v_appoutcomemodels.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7885167e-959e-4ea9-95ad-17caeaaa027c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(36461, 29)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import model_selection, preprocessing, linear_model, naive_bayes, metrics, svm, decomposition, ensemble\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer, TfidfTransformer\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, ConfusionMatrixDisplay\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import StratifiedKFold,StratifiedShuffleSplit,KFold,ShuffleSplit,train_test_split\n",
    "from sklearn.feature_selection import SelectKBest, chi2\n",
    "from collections import Counter\n",
    "from nltk import ngrams\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import multiprocessing as mp\n",
    "from joblib import Parallel, delayed\n",
    "from tqdm import tqdm\n",
    "from datetime import date, timedelta\n",
    "from IPython.core.display import display, HTML\n",
    "import requests, json, os, time, datetime, random, glob, re, csv, urllib, nltk, collections, pickle, random\n",
    "from bs4 import BeautifulSoup as bs\n",
    "from bs4.element import Tag\n",
    "from dateutil.parser import parse\n",
    "from stop_words import get_stop_words\n",
    "from string import digits\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer, PorterStemmer\n",
    "from nltk.util import everygrams\n",
    "from nltk.tokenize import sent_tokenize, RegexpTokenizer\n",
    "\n",
    "def rmnl(t):\n",
    "    return re.sub('\\s+',' ',t).strip()\n",
    "\n",
    "def map_filenolocs(x,filelocdict):\n",
    "    cleanjl = []\n",
    "    for k,v in filelocdict.items():\n",
    "        prfxs = [i for i in v if i in x]\n",
    "        if len(prfxs) >0:\n",
    "            cleanjl.append(v[0])\n",
    "        else:\n",
    "            continue\n",
    "    return '|'.join(list(set(cleanjl)))\n",
    "\n",
    "def get_wordcount(x):\n",
    "    return len(x.split())\n",
    "\n",
    "mainpath = str(os.getcwd())+'/'\n",
    "\n",
    "df = pd.read_csv(mainpath +'output/4_traindataplus.csv',sep='\\t')\n",
    "print(df.shape)\n",
    "\n",
    "dftraintest = df[df['outcome']!= 'nottrainingsample']\n",
    "dftraintest = dftraintest.copy()\n",
    "df0 = df[df['outcome']== 'nottrainingsample']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b4befa2c-409f-4725-b1f1-39951bd32735",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dftrain = dftraintest.sample(1100)\n",
    "# dftrain.to_csv(mainpath + 'output/5_dftrain.csv',sep='\\t',index=False,quoting=csv.QUOTE_ALL)\n",
    "dftrain = pd.read_csv(mainpath +'output/5_dftrain.csv',sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1dc28df6-5620-4691-b1c9-1ef39ea0b45a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1636, 29)\n",
      "(1100, 29)\n",
      "(536, 29)\n",
      "(34825, 29)\n",
      "train    1100\n",
      "test      536\n",
      "Name: traintest, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "dftest = dftraintest[~dftraintest['cid'].isin(dftrain['cid'].tolist())]\n",
    "print(dftraintest.shape)\n",
    "print(dftrain.shape)\n",
    "print(dftest.shape)\n",
    "print(df0.shape)\n",
    "\n",
    "dftraintest['traintest'] = np.where(dftraintest['cid'].isin(dftrain['cid'].tolist()),'train','test')\n",
    "print(dftraintest['traintest'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expensive-anniversary",
   "metadata": {
    "tags": []
   },
   "source": [
    "<h2> APPLICANTS </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "52ac3a8a-b62d-45dd-8dfe-3365b7a6ce0a",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=StratifiedShuffleSplit(n_splits=5, random_state=0, test_size=0.3,\n",
       "            train_size=0.7),\n",
       "             estimator=SVC(probability=True), n_jobs=8,\n",
       "             param_grid={'C': [100, 10, 1, 0.5, 0.1],\n",
       "                         'class_weight': ['balanced', None],\n",
       "                         'gamma': [10, 1, 0.1, 0.01, 0.001],\n",
       "                         'kernel': ['rbf', 'poly', 'sigmoid', 'linear']})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ssp = StratifiedShuffleSplit(n_splits = 5, test_size=0.3, train_size=0.7,random_state=0)\n",
    "svmmodel = svm.SVC(probability=True)\n",
    "cvectorizera = CountVectorizer(ngram_range=(2,3))\n",
    "\n",
    "paramgrid = {'C': [100,10,1,0.5,0.1],\n",
    "                  'gamma': [10,1, 0.1, 0.01,0.001], \n",
    "                  'kernel': ['rbf','poly','sigmoid','linear'],\n",
    "                 \"class_weight\":[\"balanced\",None]}\n",
    "\n",
    "xa = dftrain['appcleantext'].tolist()\n",
    "ya = dftrain['applicant'].tolist()\n",
    "\n",
    "cvectorizera.fit(xa)\n",
    "xa = cvectorizera.transform(xa)\n",
    "\n",
    "selectora = SelectKBest(chi2, k=1000)\n",
    "selectora.fit(xa, ya)\n",
    "xa = selectora.transform(xa)\n",
    "\n",
    "grida = GridSearchCV(svmmodel, paramgrid, cv=ssp, refit = True, verbose = 0, n_jobs=8) # cv=10, refit = True,\n",
    "grida.fit(xa, ya)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0700dcae-e4b2-45eb-a62b-20046e955125",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 100, 'class_weight': 'balanced', 'gamma': 10, 'kernel': 'linear'}\n",
      "SVC(C=100, class_weight='balanced', gamma=10, kernel='linear', probability=True)\n"
     ]
    }
   ],
   "source": [
    "print(grida.best_params_)  \n",
    "print(grida.best_estimator_) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "03d207fb-bae3-4384-b1aa-4b07b31b48d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           l       0.99      0.99      0.99       379\n",
      "           t       0.98      0.99      0.98       157\n",
      "\n",
      "    accuracy                           0.99       536\n",
      "   macro avg       0.99      0.99      0.99       536\n",
      "weighted avg       0.99      0.99      0.99       536\n",
      "\n"
     ]
    }
   ],
   "source": [
    "xat = dftest['appcleantext'].tolist()\n",
    "yat = dftest['applicant'].tolist()\n",
    "\n",
    "xat = cvectorizera.transform(xat)\n",
    "xat = selectora.transform(xat)\n",
    "\n",
    "predictionsa = grida.best_estimator_.predict(xat)\n",
    "\n",
    "print(classification_report(yat, predictionsa)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "adequate-liability",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=100, class_weight='balanced', gamma=10, kernel='linear', probability=True)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvectorizera = CountVectorizer(ngram_range=(2,3))\n",
    "selectora = SelectKBest(chi2,k=1000)\n",
    "\n",
    "xao = dftraintest['appcleantext'].tolist()\n",
    "yao = dftraintest['applicant'].tolist()\n",
    "\n",
    "cvectorizera.fit(xao)\n",
    "xao = cvectorizera.transform(xao)\n",
    "selectora.fit(xao,yao)\n",
    "xao = selectora.transform(xao)\n",
    "\n",
    "svm_model_applicant = svm.SVC(C= 100, class_weight= 'balanced', gamma= 10, kernel = 'linear', probability=True)\n",
    "\n",
    "svm_model_applicant.fit(xao, yao)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "sunset-charles",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l    30427\n",
      "t     6034\n",
      "Name: applicant, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "\"\"\" predict \"\"\"\n",
    "\n",
    "Xa = df['appcleantext'].tolist()\n",
    "Xa = cvectorizera.transform(Xa)\n",
    "applicant_vect = selectora.transform(Xa)\n",
    "\n",
    "y_applicant = svm_model_applicant.predict(applicant_vect)\n",
    "df['applicant'] = y_applicant \n",
    "\n",
    "print(df['applicant'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "retained-arena",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# tsamp = random.sample(df[df['applicant']=='t']['text'].tolist(),1)[0][:1000]\n",
    "# print(tsamp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ad0120ff-b01d-4ce7-ab34-16748fb38c9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(mainpath +'models/applicant.pkl', 'wb') as f:\n",
    "    pickle.dump((cvectorizera, selectora, grida, svm_model_applicant), f)\n",
    "\n",
    "# with open(mainpath +'models/applicant.pkl', \"rb\") as f:\n",
    "#      cvectorizera, selectora, grida, svm_model_applicant = pickle.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "challenging-latest",
   "metadata": {},
   "source": [
    "<h2> OUTCOMES </h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "fe25143e-5287-4268-a439-27717abbf8e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=StratifiedShuffleSplit(n_splits=5, random_state=0, test_size=0.3,\n",
       "            train_size=0.7),\n",
       "             estimator=SVC(probability=True), n_jobs=8,\n",
       "             param_grid={'C': [100, 10, 1, 0.5, 0.1],\n",
       "                         'class_weight': ['balanced', None],\n",
       "                         'gamma': [10, 1, 0.1, 0.01, 0.001],\n",
       "                         'kernel': ['rbf', 'poly', 'sigmoid', 'linear']})"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ssp = StratifiedShuffleSplit(n_splits = 5, test_size=0.3, train_size=0.7,random_state=0)\n",
    "svmmodel = svm.SVC(probability=True)\n",
    "cvectorizerw = CountVectorizer(ngram_range=(2,3))\n",
    "\n",
    "paramgrid = {'C': [100,10,1,0.5,0.1],\n",
    "                  'gamma': [10,1, 0.1, 0.01,0.001], \n",
    "                  'kernel': ['rbf','poly','sigmoid','linear'],\n",
    "                 \"class_weight\":[\"balanced\",None]}\n",
    "\n",
    "xw = dftrain['wincleantext'].tolist()\n",
    "yw = dftrain['winner'].tolist()\n",
    "\n",
    "cvectorizerw.fit(xw)\n",
    "xw = cvectorizerw.transform(xw)\n",
    "\n",
    "selectorw = SelectKBest(chi2, k=1000)\n",
    "selectorw.fit(xw, yw)\n",
    "xw = selectorw.transform(xw)\n",
    "\n",
    "gridw = GridSearchCV(svmmodel, paramgrid, cv=ssp, refit = True, verbose = 0, n_jobs=8) # cv=10, refit = True,\n",
    "gridw.fit(xw, yw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b26150a1-e1a2-471f-8c15-222eb2105ca0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 10, 'class_weight': 'balanced', 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "SVC(C=10, class_weight='balanced', gamma=0.001, probability=True)\n"
     ]
    }
   ],
   "source": [
    "print(gridw.best_params_)  \n",
    "print(gridw.best_estimator_) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "26161b99-6caf-4584-8a9e-3eefce1a88d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           l       0.90      0.88      0.89       303\n",
      "           t       0.85      0.87      0.86       233\n",
      "\n",
      "    accuracy                           0.88       536\n",
      "   macro avg       0.88      0.88      0.88       536\n",
      "weighted avg       0.88      0.88      0.88       536\n",
      "\n"
     ]
    }
   ],
   "source": [
    "xwt = dftest['wincleantext'].tolist()\n",
    "ywt = dftest['winner'].tolist()\n",
    "\n",
    "xwt = cvectorizerw.transform(xwt)\n",
    "xwt = selectorw.transform(xwt)\n",
    "\n",
    "predictionsw = gridw.best_estimator_.predict(xwt)\n",
    "\n",
    "print(classification_report(ywt, predictionsw)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "0ee099b7-e682-4073-8049-c590a0e32063",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=10, class_weight='balanced', gamma=0.001, probability=True)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvectorizerw = CountVectorizer(ngram_range=(2,3))\n",
    "selectorw = SelectKBest(chi2,k=1000)\n",
    "\n",
    "xaw = dftraintest['wincleantext'].tolist()\n",
    "yaw = dftraintest['winner'].tolist()\n",
    "\n",
    "cvectorizerw.fit(xaw)\n",
    "xaw = cvectorizerw.transform(xaw)\n",
    "selectorw.fit(xaw,yaw)\n",
    "xaw = selectorw.transform(xaw)\n",
    "\n",
    "svm_model_outcome = svm.SVC(C= 10, class_weight= 'balanced', gamma= 0.001, kernel = 'rbf', probability=True)\n",
    "\n",
    "svm_model_outcome.fit(xaw, yaw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "2d7787e4-926d-41e1-a84f-f26b8a3a6269",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l    26136\n",
      "t    10325\n",
      "Name: winner, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "\"\"\" predict \"\"\"\n",
    "\n",
    "Xw = df['wincleantext'].tolist()\n",
    "Xw = cvectorizerw.transform(Xw)\n",
    "outcome_vect = selectorw.transform(Xw)\n",
    "\n",
    "y_outcome = svm_model_outcome.predict(outcome_vect)\n",
    "df['winner'] = y_outcome \n",
    "\n",
    "print(df['winner'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "24de800a-2c3e-4fd1-902a-0428cec4e8bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tsamp = random.sample(df[df['winner']=='t']['text'].tolist(),1)[0][-1000:]\n",
    "# print(tsamp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "different-address",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(mainpath +'models/outcome.pkl', 'wb') as f:\n",
    "    pickle.dump((cvectorizerw, selectorw, gridw, svm_model_outcome), f)\n",
    "    \n",
    "# with open(mainpath +'models/applicant.pkl', \"rb\") as f:\n",
    "#      cvectorizerw, selectorw, gridw, svm_model_outcome = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "f279383b-ec9b-419d-a1da-46fc9f1ad8e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['cid', 'date', 'member', 'memberloc', 'filenos', 'loc', 'sections',\n",
      "       'text', 'otext', 'error', 'caseurl', 'file', 'errtype', 'source',\n",
      "       'jltext', 'cleantext', 'judgeloc', 'membertype', 'fileno',\n",
      "       'fileno_clean', 'outcome', 'idxtext', 'appcleantext', 'wincleantext',\n",
      "       'applicant', 'winner', 'filenoloc', 'newloc', 'topiccleantext'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "confident-painting",
   "metadata": {},
   "outputs": [],
   "source": [
    "selectorw_scores = pd.DataFrame(list(zip(cvectorizerw.get_feature_names_out(), selectorw.scores_, selectorw.pvalues_)), columns=['ftr', 'score', 'pval'])\n",
    "selectorw_scores.sort_values(by=['score'],ascending=False, inplace= True)\n",
    "selectora_scores = pd.DataFrame(list(zip(cvectorizera.get_feature_names_out(), selectora.scores_, selectora.pvalues_)), columns=['ftr', 'score', 'pval'])\n",
    "selectora_scores.sort_values(by=['score'],ascending=False, inplace= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "eight-observer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ftr</th>\n",
       "      <th>score</th>\n",
       "      <th>pval</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>211552</th>\n",
       "      <td>pay tenant</td>\n",
       "      <td>1187.468786</td>\n",
       "      <td>3.226215e-260</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>160321</th>\n",
       "      <td>landlord shall</td>\n",
       "      <td>1009.964294</td>\n",
       "      <td>1.225740e-221</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94229</th>\n",
       "      <td>enforc offic sheriff</td>\n",
       "      <td>900.704445</td>\n",
       "      <td>6.897359e-198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198076</th>\n",
       "      <td>offic sheriff</td>\n",
       "      <td>900.704445</td>\n",
       "      <td>6.897359e-198</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69602</th>\n",
       "      <td>court enforc offic</td>\n",
       "      <td>892.562617</td>\n",
       "      <td>4.060933e-196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69601</th>\n",
       "      <td>court enforc</td>\n",
       "      <td>890.197046</td>\n",
       "      <td>1.327022e-195</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>94225</th>\n",
       "      <td>enforc offic</td>\n",
       "      <td>883.129105</td>\n",
       "      <td>4.564456e-194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>202042</th>\n",
       "      <td>order court enforc</td>\n",
       "      <td>882.263157</td>\n",
       "      <td>7.041088e-194</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>202041</th>\n",
       "      <td>order court</td>\n",
       "      <td>880.575880</td>\n",
       "      <td>1.638483e-193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>160369</th>\n",
       "      <td>landlord shall pay</td>\n",
       "      <td>586.470520</td>\n",
       "      <td>1.467656e-129</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         ftr        score           pval\n",
       "211552            pay tenant  1187.468786  3.226215e-260\n",
       "160321        landlord shall  1009.964294  1.225740e-221\n",
       "94229   enforc offic sheriff   900.704445  6.897359e-198\n",
       "198076         offic sheriff   900.704445  6.897359e-198\n",
       "69602     court enforc offic   892.562617  4.060933e-196\n",
       "69601           court enforc   890.197046  1.327022e-195\n",
       "94225           enforc offic   883.129105  4.564456e-194\n",
       "202042    order court enforc   882.263157  7.041088e-194\n",
       "202041           order court   880.575880  1.638483e-193\n",
       "160369    landlord shall pay   586.470520  1.467656e-129"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selectorw_scores.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "informational-reset",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ftr</th>\n",
       "      <th>score</th>\n",
       "      <th>pval</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>47736</th>\n",
       "      <td>order determin</td>\n",
       "      <td>1227.756556</td>\n",
       "      <td>5.663466e-269</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5106</th>\n",
       "      <td>appli order determin</td>\n",
       "      <td>1203.397657</td>\n",
       "      <td>1.114023e-263</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69786</th>\n",
       "      <td>tenant appli</td>\n",
       "      <td>992.317613</td>\n",
       "      <td>8.397428e-218</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69791</th>\n",
       "      <td>tenant appli order</td>\n",
       "      <td>969.494048</td>\n",
       "      <td>7.678266e-213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47826</th>\n",
       "      <td>order determin landlord</td>\n",
       "      <td>790.348777</td>\n",
       "      <td>6.767472e-174</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18871</th>\n",
       "      <td>determin landlord</td>\n",
       "      <td>679.481174</td>\n",
       "      <td>8.664674e-150</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55305</th>\n",
       "      <td>reason enjoy rental</td>\n",
       "      <td>559.765185</td>\n",
       "      <td>9.455819e-124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22140</th>\n",
       "      <td>enjoy rental</td>\n",
       "      <td>558.569638</td>\n",
       "      <td>1.720963e-123</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22142</th>\n",
       "      <td>enjoy rental unit</td>\n",
       "      <td>556.360392</td>\n",
       "      <td>5.204281e-123</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>71390</th>\n",
       "      <td>tenant member</td>\n",
       "      <td>489.954426</td>\n",
       "      <td>1.457902e-108</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           ftr        score           pval\n",
       "47736           order determin  1227.756556  5.663466e-269\n",
       "5106      appli order determin  1203.397657  1.114023e-263\n",
       "69786             tenant appli   992.317613  8.397428e-218\n",
       "69791       tenant appli order   969.494048  7.678266e-213\n",
       "47826  order determin landlord   790.348777  6.767472e-174\n",
       "18871        determin landlord   679.481174  8.664674e-150\n",
       "55305      reason enjoy rental   559.765185  9.455819e-124\n",
       "22140             enjoy rental   558.569638  1.720963e-123\n",
       "22142        enjoy rental unit   556.360392  5.204281e-123\n",
       "71390            tenant member   489.954426  1.457902e-108"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selectora_scores.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "developing-fault",
   "metadata": {},
   "outputs": [],
   "source": [
    "selectora_scores.to_csv(mainpath+\"models/5_applicantmodelfeatures.csv\",sep='\\t',index=False,quoting=csv.QUOTE_ALL)\n",
    "selectorw_scores.to_csv(mainpath+\"models/5_outcomemodelfeatures.csv\",sep='\\t',index=False,quoting=csv.QUOTE_ALL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "effective-dance",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv(mainpath+\"output/5_model_results.csv\",sep='\\t',index=False,quoting=csv.QUOTE_ALL)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}