diff --git a/Apply_Rate.ipynb b/Apply_Rate.ipynb new file mode 100644 index 0000000..a81f4dd --- /dev/null +++ b/Apply_Rate.ipynb @@ -0,0 +1,2003 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Apply_Rate.ipynb", + "version": "0.3.2", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "accelerator": "TPU" + }, + "cells": [ + { + "metadata": { + "colab_type": "code", + "id": "y_s5rbXeIduB", + "colab": {} + }, + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.metrics import classification_report, confusion_matrix, precision_recall_fscore_support, accuracy_score, roc_auc_score" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "ISco9swtpr0G", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "Nj1l0nzcIsV4", + "outputId": "f2e04170-ff43-4fa6-b88a-7c385026b504", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + } + }, + "cell_type": "code", + "source": [ + "df = pd.read_csv('./Apply_Rate_2019.csv')\n", + "df.shape" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1200890, 10)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 2 + } + ] + }, + { + "metadata": { + "id": "FP85NcoV742h", + "colab_type": "code", + "outputId": "e0a8f02b-b9c7-43f1-e29f-e788aa946adf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 85 + } + }, + "cell_type": "code", + "source": [ + "df.columns" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Index(['title_proximity_tfidf', 'description_proximity_tfidf',\n", + " 'main_query_tfidf', 'query_jl_score', 'query_title_score', 'city_match',\n", + " 'job_age_days', 'apply', 'search_date_pacific', 'class_id'],\n", + " dtype='object')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "metadata": { + "id": "75VbG78-79Ro", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "not_cat_cols = ['title_proximity_tfidf', 'description_proximity_tfidf', 'main_query_tfidf', 'query_jl_score', 'query_title_score', 'job_age_days']" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "MSCrtPkiNSmL", + "outputId": "6b8da50e-68a8-44a6-daeb-26f9d3ac40a3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 359 + } + }, + "cell_type": "code", + "source": [ + "df.head().T" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " 0 1 \\\n", + "title_proximity_tfidf 0 11.874 \n", + "description_proximity_tfidf 0 0.043637 \n", + "main_query_tfidf 0 2.52708 \n", + "query_jl_score 0.00482431 0.0119353 \n", + "query_title_score 0.00662807 0.011208 \n", + "city_match 0 0 \n", + "job_age_days 5 5 \n", + "apply 0 0 \n", + "search_date_pacific 2018-01-21 2018-01-21 \n", + "class_id -7613806991329176388 -1361819269400927213 \n", + "\n", + " 2 3 \\\n", + "title_proximity_tfidf 11.874 0 \n", + "description_proximity_tfidf 0.043637 0 \n", + "main_query_tfidf 2.52708 3.69581 \n", + "query_jl_score 0.0119353 0.0130464 \n", + "query_title_score 0.011208 0.0333403 \n", + "city_match 0 0 \n", + "job_age_days 5 5 \n", + "apply 1 0 \n", + "search_date_pacific 2018-01-21 2018-01-23 \n", + "class_id -1361819269400927213 -3623880078591607667 \n", + "\n", + " 4 \n", + "title_proximity_tfidf NaN \n", + "description_proximity_tfidf NaN \n", + "main_query_tfidf 7.8689 \n", + "query_jl_score 0.00806452 \n", + "query_title_score 0.00877193 \n", + "city_match 0 \n", + "job_age_days 7 \n", + "apply 0 \n", + "search_date_pacific 2018-01-24 \n", + "class_id -7054510112423797411 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
01234
title_proximity_tfidf011.87411.8740NaN
description_proximity_tfidf00.0436370.0436370NaN
main_query_tfidf02.527082.527083.695817.8689
query_jl_score0.004824310.01193530.01193530.01304640.00806452
query_title_score0.006628070.0112080.0112080.03334030.00877193
city_match00000
job_age_days55557
apply00100
search_date_pacific2018-01-212018-01-212018-01-212018-01-232018-01-24
class_id-7613806991329176388-1361819269400927213-1361819269400927213-3623880078591607667-7054510112423797411
\n", + "
" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 5 + } + ] + }, + { + "metadata": { + "colab_type": "code", + "id": "fZNz52RpL1fh", + "outputId": "1288bf15-1fd8-4be6-a948-a0c0df4863c2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + } + }, + "cell_type": "code", + "source": [ + "df.describe()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " title_proximity_tfidf description_proximity_tfidf main_query_tfidf \\\n", + "count 948319.000000 948319.000000 1.200890e+06 \n", + "mean 5.889800 0.096119 1.770301e+00 \n", + "std 9.749672 0.284249 2.237259e+00 \n", + "min 0.000000 0.000000 0.000000e+00 \n", + "25% 0.000000 0.000000 0.000000e+00 \n", + "50% 0.000000 0.000000 2.509947e-01 \n", + "75% 11.642839 0.063633 3.423265e+00 \n", + "max 93.516720 7.301161 1.774189e+01 \n", + "\n", + " query_jl_score query_title_score city_match job_age_days \\\n", + "count 1.200890e+06 1.200890e+06 944335.000000 1.200890e+06 \n", + "mean 1.711024e-02 3.580456e-02 0.563676 1.010130e+01 \n", + "std 1.220871e-02 4.886690e-02 0.495929 1.738912e+01 \n", + "min 1.000000e-06 9.998021e-07 0.000000 0.000000e+00 \n", + "25% 1.063830e-02 1.256780e-02 0.000000 2.000000e+00 \n", + "50% 1.578868e-02 2.066189e-02 1.000000 6.000000e+00 \n", + "75% 2.043710e-02 3.760018e-02 1.000000 1.400000e+01 \n", + "max 2.556893e-01 1.294088e+00 1.000000 1.340000e+03 \n", + "\n", + " apply class_id \n", + "count 1.200890e+06 1.200890e+06 \n", + "mean 8.993580e-02 -3.956263e+17 \n", + "std 2.860899e-01 5.664017e+18 \n", + "min 0.000000e+00 -9.049388e+18 \n", + "25% 0.000000e+00 -4.593390e+18 \n", + "50% 0.000000e+00 -1.614083e+18 \n", + "75% 0.000000e+00 4.315422e+18 \n", + "max 1.000000e+00 9.204124e+18 " + ], + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
title_proximity_tfidfdescription_proximity_tfidfmain_query_tfidfquery_jl_scorequery_title_scorecity_matchjob_age_daysapplyclass_id
count948319.000000948319.0000001.200890e+061.200890e+061.200890e+06944335.0000001.200890e+061.200890e+061.200890e+06
mean5.8898000.0961191.770301e+001.711024e-023.580456e-020.5636761.010130e+018.993580e-02-3.956263e+17
std9.7496720.2842492.237259e+001.220871e-024.886690e-020.4959291.738912e+012.860899e-015.664017e+18
min0.0000000.0000000.000000e+001.000000e-069.998021e-070.0000000.000000e+000.000000e+00-9.049388e+18
25%0.0000000.0000000.000000e+001.063830e-021.256780e-020.0000002.000000e+000.000000e+00-4.593390e+18
50%0.0000000.0000002.509947e-011.578868e-022.066189e-021.0000006.000000e+000.000000e+00-1.614083e+18
75%11.6428390.0636333.423265e+002.043710e-023.760018e-021.0000001.400000e+010.000000e+004.315422e+18
max93.5167207.3011611.774189e+012.556893e-011.294088e+001.0000001.340000e+031.000000e+009.204124e+18
\n", + "
" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "metadata": { + "colab_type": "code", + "id": "-03F32bhK3sM", + "outputId": "de1356d3-7f18-4db9-e2fa-400cc2782fb8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 204 + } + }, + "cell_type": "code", + "source": [ + "# Number of unique entries\n", + "df.astype(object).describe(include='all').loc['unique', :]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "title_proximity_tfidf 225538\n", + "description_proximity_tfidf 342918\n", + "main_query_tfidf 517282\n", + "query_jl_score 181318\n", + "query_title_score 343323\n", + "city_match 2\n", + "job_age_days 491\n", + "apply 2\n", + "search_date_pacific 7\n", + "class_id 157\n", + "Name: unique, dtype: object" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 7 + } + ] + }, + { + "metadata": { + "colab_type": "code", + "id": "jkXL6FOEIsVP", + "outputId": "1fd059ba-6e2a-41ff-c9b0-888190287617", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 204 + } + }, + "cell_type": "code", + "source": [ + "# Number of Null Entries\n", + "df.isnull().sum(axis=0)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "title_proximity_tfidf 252571\n", + "description_proximity_tfidf 252571\n", + "main_query_tfidf 0\n", + "query_jl_score 0\n", + "query_title_score 0\n", + "city_match 256555\n", + "job_age_days 0\n", + "apply 0\n", + "search_date_pacific 0\n", + "class_id 0\n", + "dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 8 + } + ] + }, + { + "metadata": { + "colab_type": "code", + "id": "Hdpth4B3K3u9", + "outputId": "1960176d-9950-4922-de9c-e755f2331827", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 229 + } + }, + "cell_type": "code", + "source": [ + "# Correlation Matrix\n", + "df.corr().style.background_gradient()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
title_proximity_tfidf description_proximity_tfidf main_query_tfidf query_jl_score query_title_score city_match job_age_days apply class_id
title_proximity_tfidf10.1078180.7045790.2081320.371528-0.06069270.04313870.04824170.01719
description_proximity_tfidf0.10781810.02266450.09599290.00358764-0.01020310.0114363-0.003290660.00566131
main_query_tfidf0.7045790.022664510.01073820.209315-0.07738820.08754670.03905010.0185585
query_jl_score0.2081320.09599290.010738210.387003-0.01813720.01713820.05744310.0778891
query_title_score0.3715280.003587640.2093150.3870031-0.04222430.01698770.06383220.0618706
city_match-0.0606927-0.0102031-0.0773882-0.0181372-0.04222431-0.000613780.00308262-0.00458481
job_age_days0.04313870.01143630.08754670.01713820.0169877-0.000613781-0.01182860.00395271
apply0.0482417-0.003290660.03905010.05744310.06383220.00308262-0.011828610.0116747
class_id0.017190.005661310.01855850.07788910.0618706-0.004584810.003952710.01167471
" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 9 + } + ] + }, + { + "metadata": { + "id": "mLXEQ_VMpr0u", + "colab_type": "code", + "outputId": "13a6fa0c-0a71-4e46-af41-2ac58f479210", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1321 + } + }, + "cell_type": "code", + "source": [ + "df.hist(figsize=(20,20))" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[,\n", + " ,\n", + " ],\n", + " [,\n", + " ,\n", + " ],\n", + " [,\n", + " ,\n", + " ]],\n", + " dtype=object)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 10 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "metadata": { + "id": "gjZp5GCFpr00", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "avzys-1vpr03", + "colab_type": "code", + "outputId": "e6d9eeac-dcf9-4bfa-9d35-28553ba6f71f", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 102 + } + }, + "cell_type": "code", + "source": [ + "print(df['apply'].value_counts())\n", + "print(df['apply'].value_counts()[0] / len(df) * 100)\n", + "print(df['apply'].value_counts()[1] / len(df) * 100)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "0 1092887\n", + "1 108003\n", + "Name: apply, dtype: int64\n", + "91.00642023832324\n", + "8.993579761676756\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "VwxCMX4ppr07", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "df.fillna(0, inplace=True)\n", + "df['class_id'] = df['class_id'].astype('category').cat.codes" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "PtnbSobGK3yA", + "colab": {} + }, + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "# Preprocessing\n", + "def preprocess(to_remove, normalize=False):\n", + " #Normalization\n", + " df[not_cat_cols] = (df[not_cat_cols] - df[not_cat_cols].mean()) / (df[not_cat_cols].max() - df[not_cat_cols].min())\n", + " \n", + " df_train = df[df.search_date_pacific != '2018-01-27']\n", + " df_test = df[df.search_date_pacific == '2018-01-27']\n", + " \n", + " global X_train\n", + " X_train = df_train.drop(columns=to_remove).values\n", + " global y_train \n", + " y_train = df_train['apply'].values\n", + " global X_test \n", + " X_test = df_test.drop(columns=to_remove).values\n", + " global y_test \n", + " y_test = df_test['apply'].values\n", + " \n", + " #Normalization\n", + "# if normalize: \n", + "# scaler = StandardScaler()\n", + "# scaler.fit(X_train)\n", + "# X_train = scaler.transform(X_train)\n", + "# X_test = scaler.transform(X_test)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "u1bgS9EBZTvx", + "colab": {} + }, + "cell_type": "code", + "source": [ + "def classify(clf):\n", + " clf.fit(X_train, y_train)\n", + " y_pred = clf.predict_proba(X_test)\n", + " print(clf)\n", + " print(\"ROC AUC:\", roc_auc_score(y_test, y_pred[:,1]))\n", + " y_pred = clf.predict(X_test)\n", + " print(classification_report(y_test, y_pred))\n", + " print(\"Detailed confusion matrix:\")\n", + " print(confusion_matrix(y_test, y_pred))\n", + " print(\"Accuracy Score:\", accuracy_score(y_test, y_pred))\n", + " \n", + " \n", + "from imblearn.over_sampling import SMOTE\n", + "\n", + "def classify_with_smote(clf):\n", + " smote = SMOTE(random_state=0, n_jobs=-1, sampling_strategy=4/6)\n", + " global X_train, y_train \n", + " X_train, y_train = smote.fit_resample(X_train, y_train)\n", + " classify(clf)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "UoK60GcGZT61", + "colab": {} + }, + "cell_type": "code", + "source": [ + "to_remove = ['apply', 'search_date_pacific', 'class_id']\n", + "preprocess(to_remove)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "ply2Gwi-DNZX", + "colab_type": "code", + "outputId": "6aa4d57a-e73c-4dd0-fdfd-045fe4fd993b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n", + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:1300: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 4.\n", + " \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n", + " fit_intercept=True, intercept_scaling=1, max_iter=100,\n", + " multi_class='warn', n_jobs=-1, penalty='l2', random_state=0,\n", + " solver='warn', tol=0.0001, verbose=0, warm_start=False)\n", + "ROC AUC: 0.5883860726501579\n", + " precision recall f1-score support\n", + "\n", + " 0 0.93 0.66 0.77 105940\n", + " 1 0.12 0.47 0.19 10586\n", + "\n", + " micro avg 0.64 0.64 0.64 116526\n", + " macro avg 0.52 0.56 0.48 116526\n", + "weighted avg 0.85 0.64 0.72 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[69921 36019]\n", + " [ 5658 4928]]\n", + "Accuracy Score: 0.6423373324408287\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "_v-XzpYeDSMh", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "dtty4IbnDR8s", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "ysIqx5ELKIlV", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "iR1UKr8vpr1J", + "colab_type": "code", + "outputId": "6c9927e4-9c19-4004-d15c-e3aaf4f50fef", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + } + }, + "cell_type": "code", + "source": [ + "from xgboost import XGBClassifier\n", + "\n", + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, scale_pos_weight=6)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=6,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.605199221682646\n", + " precision recall f1-score support\n", + "\n", + " 0 0.92 0.95 0.93 105940\n", + " 1 0.20 0.13 0.16 10586\n", + "\n", + " micro avg 0.87 0.87 0.87 116526\n", + " macro avg 0.56 0.54 0.54 116526\n", + "weighted avg 0.85 0.87 0.86 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[100476 5464]\n", + " [ 9217 1369]]\n", + "Accuracy Score: 0.8740109503458455\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "n86ejPSp5lcQ", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "xtQ3D4CGpr1M", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "p54c6Dk6pr1Q", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "to_remove = ['apply', 'search_date_pacific', 'class_id']\n", + "preprocess(to_remove, normalize=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "dT2lBa4mpr1T", + "colab_type": "code", + "outputId": "106e4d82-bd76-4391-9e43-a8b39be06bd8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.6068051184895856\n", + " precision recall f1-score support\n", + "\n", + " 0 0.91 1.00 0.95 105940\n", + " 1 0.00 0.00 0.00 10586\n", + "\n", + " micro avg 0.91 0.91 0.91 116526\n", + " macro avg 0.45 0.50 0.48 116526\n", + "weighted avg 0.83 0.91 0.87 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[105940 0]\n", + " [ 10586 0]]\n", + "Accuracy Score: 0.9091533220053893\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\metrics\\classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n", + " 'precision', 'predicted', average, warn_for)\n" + ], + "name": "stderr" + } + ] + }, + { + "metadata": { + "id": "b4XwOKjEpr1X", + "colab_type": "code", + "outputId": "59747b3d-a31f-46ec-88f8-f57286319bc0", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + } + }, + "cell_type": "code", + "source": [ + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, scale_pos_weight=6)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=6,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.605199221682646\n", + " precision recall f1-score support\n", + "\n", + " 0 0.92 0.95 0.93 105940\n", + " 1 0.20 0.13 0.16 10586\n", + "\n", + " micro avg 0.87 0.87 0.87 116526\n", + " macro avg 0.56 0.54 0.54 116526\n", + "weighted avg 0.85 0.87 0.86 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[100476 5464]\n", + " [ 9217 1369]]\n", + "Accuracy Score: 0.8740109503458455\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "tt2x67Z9upui", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "wcVOSenYuprC", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + }, + "outputId": "781cf3ca-c275-4ff3-b818-1365f59ede8d" + }, + "cell_type": "code", + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1)\n", + "classify_with_smote(clf)" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n", + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:1300: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 4.\n", + " \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n", + " fit_intercept=True, intercept_scaling=1, max_iter=100,\n", + " multi_class='warn', n_jobs=-1, penalty='l2', random_state=0,\n", + " solver='warn', tol=0.0001, verbose=0, warm_start=False)\n", + "ROC AUC: 0.5886791449776352\n", + " precision recall f1-score support\n", + "\n", + " 0 0.93 0.65 0.76 105940\n", + " 1 0.12 0.48 0.19 10586\n", + "\n", + " micro avg 0.64 0.64 0.64 116526\n", + " macro avg 0.52 0.56 0.48 116526\n", + "weighted avg 0.85 0.64 0.71 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[68991 36949]\n", + " [ 5555 5031]]\n", + "Accuracy Score: 0.6352402039029916\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "O1Ri7Qrppr1a", + "colab_type": "code", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + }, + "outputId": "5713e2a4-c311-47f0-d663-fb02455397db" + }, + "cell_type": "code", + "source": [ + "from xgboost import XGBClassifier\n", + "\n", + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1)\n", + "classify_with_smote(clf)" + ], + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.5579752325505624\n", + " precision recall f1-score support\n", + "\n", + " 0 0.91 1.00 0.95 105940\n", + " 1 0.21 0.00 0.01 10586\n", + "\n", + " micro avg 0.91 0.91 0.91 116526\n", + " macro avg 0.56 0.50 0.48 116526\n", + "weighted avg 0.85 0.91 0.87 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[105835 105]\n", + " [ 10558 28]]\n", + "Accuracy Score: 0.9084925252733296\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "_Wtlbu4cpr1e", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "qGpFL24Dpr1g", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "54TQ-BPdCnAO", + "colab": {} + }, + "cell_type": "code", + "source": [ + "to_remove = ['apply', 'search_date_pacific']\n", + "preprocess(to_remove)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "colab_type": "code", + "id": "fUd-4KTGCm6D", + "outputId": "12f27aaa-8de7-4b63-b748-3c7acb7bfbe6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=1, scale_pos_weight=1,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.622422824896411\n", + " precision recall f1-score support\n", + "\n", + " 0 0.91 1.00 0.95 105940\n", + " 1 0.00 0.00 0.00 10586\n", + "\n", + " micro avg 0.91 0.91 0.91 116526\n", + " macro avg 0.45 0.50 0.48 116526\n", + "weighted avg 0.83 0.91 0.87 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[105940 0]\n", + " [ 10586 0]]\n", + "Accuracy Score: 0.9091533220053893\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\metrics\\classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n", + " 'precision', 'predicted', average, warn_for)\n" + ], + "name": "stderr" + } + ] + }, + { + "metadata": { + "id": "7NQSHkahpr1u", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "Q0FRcPUHpr1x", + "colab_type": "code", + "outputId": "aa544c0b-2b2a-4bdf-cd38-e31f3da2607c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n", + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:1300: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 4.\n", + " \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n", + " fit_intercept=True, intercept_scaling=1, max_iter=100,\n", + " multi_class='warn', n_jobs=-1, penalty='l2', random_state=0,\n", + " solver='warn', tol=0.0001, verbose=0, warm_start=False)\n", + "ROC AUC: 0.5880638495794542\n", + " precision recall f1-score support\n", + "\n", + " 0 0.93 0.66 0.77 105940\n", + " 1 0.12 0.47 0.19 10586\n", + "\n", + " micro avg 0.64 0.64 0.64 116526\n", + " macro avg 0.52 0.56 0.48 116526\n", + "weighted avg 0.85 0.64 0.72 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[69888 36052]\n", + " [ 5657 4929]]\n", + "Accuracy Score: 0.6420627156171155\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "eMhUBEHFpr1z", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "QPukJmg1pr15", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "to_remove = ['apply', 'search_date_pacific']\n", + "preprocess(to_remove, normalize=True)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "R8kBQxyQpr19", + "colab_type": "code", + "outputId": "69aefcf7-df86-4a24-df94-1aa9f458bf5c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, reg_lambda=6)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=6, scale_pos_weight=1,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.6235080462899393\n", + " precision recall f1-score support\n", + "\n", + " 0 0.91 1.00 0.95 105940\n", + " 1 0.00 0.00 0.00 10586\n", + "\n", + " micro avg 0.91 0.91 0.91 116526\n", + " macro avg 0.45 0.50 0.48 116526\n", + "weighted avg 0.83 0.91 0.87 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[105940 0]\n", + " [ 10586 0]]\n", + "Accuracy Score: 0.9091533220053893\n" + ], + "name": "stdout" + }, + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\metrics\\classification.py:1143: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples.\n", + " 'precision', 'predicted', average, warn_for)\n" + ], + "name": "stderr" + } + ] + }, + { + "metadata": { + "id": "GrVxrMi9pr2B", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "NZbA-F7Dpr2D", + "colab_type": "code", + "outputId": "23484e5f-f88d-4ac5-a0e2-0bfb85831aac", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = LogisticRegression(C= 0.001, random_state=0, class_weight='balanced', n_jobs=-1)\n", + "classify(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n", + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:1300: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 4.\n", + " \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "LogisticRegression(C=0.001, class_weight='balanced', dual=False,\n", + " fit_intercept=True, intercept_scaling=1, max_iter=100,\n", + " multi_class='warn', n_jobs=-1, penalty='l2', random_state=0,\n", + " solver='warn', tol=0.0001, verbose=0, warm_start=False)\n", + "ROC AUC: 0.5797081134261731\n", + " precision recall f1-score support\n", + "\n", + " 0 0.92 0.69 0.79 105940\n", + " 1 0.12 0.43 0.19 10586\n", + "\n", + " micro avg 0.66 0.66 0.66 116526\n", + " macro avg 0.52 0.56 0.49 116526\n", + "weighted avg 0.85 0.66 0.73 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[72615 33325]\n", + " [ 6034 4552]]\n", + "Accuracy Score: 0.6622298886085509\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "8fmipsQ8pr2I", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "5wl0o0wYpr2K", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "#Took forever to run\n", + "\n", + "# from sklearn.svm import SVC\n", + "\n", + "# clf = SVC(probability=True, C=0.01)\n", + "# classify(clf)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "NnCEPM1upr2M", + "colab_type": "code", + "outputId": "d0de354f-be06-4e67-f428-471749bb6121", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 357 + } + }, + "cell_type": "code", + "source": [ + "clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, reg_lambda=6)\n", + "classify_with_smote(clf)\n" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=8, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=-1, nthread=None, objective='binary:logistic',\n", + " random_state=0, reg_alpha=0, reg_lambda=6, scale_pos_weight=1,\n", + " seed=None, silent=True, subsample=1)\n", + "ROC AUC: 0.5835380348539883\n", + " precision recall f1-score support\n", + "\n", + " 0 0.91 1.00 0.95 105940\n", + " 1 0.25 0.00 0.01 10586\n", + "\n", + " micro avg 0.91 0.91 0.91 116526\n", + " macro avg 0.58 0.50 0.48 116526\n", + "weighted avg 0.85 0.91 0.87 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[105827 113]\n", + " [ 10548 38]]\n", + "Accuracy Score: 0.9085096888248116\n" + ], + "name": "stdout" + } + ] + }, + { + "metadata": { + "id": "WsVIUdsXpr2R", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "XWuApdaVOeN9", + "colab_type": "code", + "colab": {} + }, + "cell_type": "code", + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "metadata": { + "id": "uWAE7UW2OeJt", + "colab_type": "code", + "outputId": "77142bf7-7ce2-406d-cdb5-f4276959319e", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391 + } + }, + "cell_type": "code", + "source": [ + "clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1)\n", + "classify_with_smote(clf)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n", + "c:\\python36\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:1300: UserWarning: 'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = 4.\n", + " \" = {}.\".format(effective_n_jobs(self.n_jobs)))\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "LogisticRegression(C=1.0, class_weight='balanced', dual=False,\n", + " fit_intercept=True, intercept_scaling=1, max_iter=100,\n", + " multi_class='warn', n_jobs=-1, penalty='l2', random_state=0,\n", + " solver='warn', tol=0.0001, verbose=0, warm_start=False)\n", + "ROC AUC: 0.5876126158339006\n", + " precision recall f1-score support\n", + "\n", + " 0 0.93 0.63 0.75 105940\n", + " 1 0.12 0.49 0.19 10586\n", + "\n", + " micro avg 0.62 0.62 0.62 116526\n", + " macro avg 0.52 0.56 0.47 116526\n", + "weighted avg 0.85 0.62 0.70 116526\n", + "\n", + "Detailed confusion matrix:\n", + "[[66972 38968]\n", + " [ 5376 5210]]\n", + "Accuracy Score: 0.6194497365394848\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file diff --git a/Report.pdf b/Report.pdf new file mode 100644 index 0000000..81d94dc Binary files /dev/null and b/Report.pdf differ diff --git a/apply_rate.py b/apply_rate.py new file mode 100644 index 0000000..d9ae7a6 --- /dev/null +++ b/apply_rate.py @@ -0,0 +1,182 @@ +# -*- coding: utf-8 -*- +"""Apply_Rate.ipynb + +Automatically generated by Colaboratory. + +Original file is located at + https://colab.research.google.com/drive/1RyVVT1F9WtI2PnKwhQgprOh6CSdjRVzm +""" + +import pandas as pd +import numpy as np +import matplotlib.pyplot as plt +from sklearn.model_selection import GridSearchCV +from sklearn.metrics import classification_report, confusion_matrix, precision_recall_fscore_support, accuracy_score, roc_auc_score + + + +df = pd.read_csv('./Apply_Rate_2019.csv') +df.shape + +df.columns + +not_cat_cols = ['title_proximity_tfidf', 'description_proximity_tfidf', 'main_query_tfidf', 'query_jl_score', 'query_title_score', 'job_age_days'] + +df.head().T + +df.describe() + +# Number of unique entries +df.astype(object).describe(include='all').loc['unique', :] + +# Number of Null Entries +df.isnull().sum(axis=0) + +# Correlation Matrix +df.corr().style.background_gradient() + +df.hist(figsize=(20,20)) + + + +print(df['apply'].value_counts()) +print(df['apply'].value_counts()[0] / len(df) * 100) +print(df['apply'].value_counts()[1] / len(df) * 100) + +df.fillna(0, inplace=True) +df['class_id'] = df['class_id'].astype('category').cat.codes + +from sklearn.preprocessing import StandardScaler +# Preprocessing +def preprocess(to_remove, normalize=False): + #Normalization + df[not_cat_cols] = (df[not_cat_cols] - df[not_cat_cols].mean()) / (df[not_cat_cols].max() - df[not_cat_cols].min()) + + df_train = df[df.search_date_pacific != '2018-01-27'] + df_test = df[df.search_date_pacific == '2018-01-27'] + + global X_train + X_train = df_train.drop(columns=to_remove).values + global y_train + y_train = df_train['apply'].values + global X_test + X_test = df_test.drop(columns=to_remove).values + global y_test + y_test = df_test['apply'].values + + #Normalization +# if normalize: +# scaler = StandardScaler() +# scaler.fit(X_train) +# X_train = scaler.transform(X_train) +# X_test = scaler.transform(X_test) + +def classify(clf): + clf.fit(X_train, y_train) + y_pred = clf.predict_proba(X_test) + print(clf) + print("ROC AUC:", roc_auc_score(y_test, y_pred[:,1])) + y_pred = clf.predict(X_test) + print(classification_report(y_test, y_pred)) + print("Detailed confusion matrix:") + print(confusion_matrix(y_test, y_pred)) + print("Accuracy Score:", accuracy_score(y_test, y_pred)) + + +from imblearn.over_sampling import SMOTE + +def classify_with_smote(clf): + smote = SMOTE(random_state=0, n_jobs=-1, sampling_strategy=4/6) + global X_train, y_train + X_train, y_train = smote.fit_resample(X_train, y_train) + classify(clf) + +to_remove = ['apply', 'search_date_pacific', 'class_id'] +preprocess(to_remove) + +from sklearn.linear_model import LogisticRegression + +clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1) +classify(clf) + + + + + + + +from xgboost import XGBClassifier + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, scale_pos_weight=6) +classify(clf) + + + + + +to_remove = ['apply', 'search_date_pacific', 'class_id'] +preprocess(to_remove, normalize=True) + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1) +classify(clf) + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, scale_pos_weight=6) +classify(clf) + + + +from sklearn.linear_model import LogisticRegression +clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1) +classify_with_smote(clf) + +from xgboost import XGBClassifier + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1) +classify_with_smote(clf) + + + + + +to_remove = ['apply', 'search_date_pacific'] +preprocess(to_remove) + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1) +classify(clf) + + + +clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1) +classify(clf) + + + +to_remove = ['apply', 'search_date_pacific'] +preprocess(to_remove, normalize=True) + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, reg_lambda=6) +classify(clf) + + + +clf = LogisticRegression(C= 0.001, random_state=0, class_weight='balanced', n_jobs=-1) +classify(clf) + + + +#Took forever to run + +# from sklearn.svm import SVC + +# clf = SVC(probability=True, C=0.01) +# classify(clf) + +clf = XGBClassifier(random_state=0, max_depth=8, n_jobs=-1, reg_lambda=6) +classify_with_smote(clf) + + + + + +clf = LogisticRegression(random_state=0, class_weight='balanced', n_jobs=-1) +classify_with_smote(clf) \ No newline at end of file