{ "cells": [ { "cell_type": "markdown", "id": "thermal-syndrome", "metadata": {}, "source": [ "## DATA PREPARATION" ] }, { "cell_type": "code", "execution_count": 1, "id": "basic-ethnic", "metadata": {}, "outputs": [ { "data": { "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", "
AñoMesHora SolicitudHora IntervenciónCódigoDistritoHospital
02020ENERO0:03:210:08:49Accidente de monopatinARGANZUELANaN
12020ENERO0:04:030:14:44Patología obstétricaSAN BLASNaN
22020ENERO0:04:050:10:12Inconsciente sin filiar causaVILLA DE VALLECASNaN
32020ENERO0:05:090:13:15IncendioVALLECAS PTE.NaN
42020ENERO0:07:430:16:19Agresión sin especificarVALLECAS PTE.NaN
\n", "
" ], "text/plain": [ " Año Mes Hora Solicitud Hora Intervención \\\n", "0 2020 ENERO 0:03:21 0:08:49 \n", "1 2020 ENERO 0:04:03 0:14:44 \n", "2 2020 ENERO 0:04:05 0:10:12 \n", "3 2020 ENERO 0:05:09 0:13:15 \n", "4 2020 ENERO 0:07:43 0:16:19 \n", "\n", " Código Distrito Hospital \n", "0 Accidente de monopatin ARGANZUELA NaN \n", "1 Patología obstétrica SAN BLAS NaN \n", "2 Inconsciente sin filiar causa VILLA DE VALLECAS NaN \n", "3 Incendio VALLECAS PTE. NaN \n", "4 Agresión sin especificar VALLECAS PTE. NaN " ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "df = pd.read_csv('samur_2020.csv', sep=';')\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 2, "id": "humanitarian-austin", "metadata": {}, "outputs": [ { "data": { "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", "
YEARMONTHHOUR_REQUESTHOUR_INTERVENTIONCODEDISTRICTHOSPITAL
02020ENERO0:03:210:08:49Accidente de monopatinARGANZUELANaN
12020ENERO0:04:030:14:44Patología obstétricaSAN BLASNaN
22020ENERO0:04:050:10:12Inconsciente sin filiar causaVILLA DE VALLECASNaN
32020ENERO0:05:090:13:15IncendioVALLECAS PTE.NaN
42020ENERO0:07:430:16:19Agresión sin especificarVALLECAS PTE.NaN
\n", "
" ], "text/plain": [ " YEAR MONTH HOUR_REQUEST HOUR_INTERVENTION CODE \\\n", "0 2020 ENERO 0:03:21 0:08:49 Accidente de monopatin \n", "1 2020 ENERO 0:04:03 0:14:44 Patología obstétrica \n", "2 2020 ENERO 0:04:05 0:10:12 Inconsciente sin filiar causa \n", "3 2020 ENERO 0:05:09 0:13:15 Incendio \n", "4 2020 ENERO 0:07:43 0:16:19 Agresión sin especificar \n", "\n", " DISTRICT HOSPITAL \n", "0 ARGANZUELA NaN \n", "1 SAN BLAS NaN \n", "2 VILLA DE VALLECAS NaN \n", "3 VALLECAS PTE. NaN \n", "4 VALLECAS PTE. NaN " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.columns = ['YEAR', 'MONTH', 'HOUR_REQUEST', 'HOUR_INTERVENTION', 'CODE', 'DISTRICT', 'HOSPITAL']\n", "df = df.dropna(subset=['HOUR_REQUEST', 'HOUR_INTERVENTION'])\n", "df.head()" ] }, { "cell_type": "code", "execution_count": 3, "id": "desperate-bacteria", "metadata": {}, "outputs": [], "source": [ "def time_difference(from_date, to_date):\n", " import math\n", " from datetime import datetime \n", " FMT = '%H:%M:%S'\n", " tdelta = datetime.strptime(to_date, FMT) - datetime.strptime(from_date, FMT)\n", " solution = math.floor(tdelta.seconds / 60)\n", " return solution\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "convenient-fraud", "metadata": {}, "outputs": [], "source": [ "def fix_midnight(date):\n", " str_repr = str(date)\n", " is_wrong = str_repr.startswith('0:')\n", " \n", " if (is_wrong):\n", " hour, minutes, seconds = date.split(':')\n", " return ':'.join(['00', minutes, seconds])\n", " \n", " return date" ] }, { "cell_type": "code", "execution_count": 5, "id": "solid-candidate", "metadata": {}, "outputs": [], "source": [ "month_codes, _ = pd.factorize(df['MONTH'])\n", "code_codes, _ = pd.factorize(df['CODE'])\n", "district_codes, _ = pd.factorize(df['DISTRICT'])\n", "hospital_codes, _ = pd.factorize(df['HOSPITAL'])\n", "\n", "df['MONTH'] = month_codes\n", "df['CODE'] = code_codes\n", "df['DISTRICT'] = district_codes\n", "df['HOSPITAL'] = hospital_codes\n", "df['HOUR_REQUEST'] = df['HOUR_REQUEST'].apply(fix_midnight)\n", "df['HOUR_INTERVENTION'] = df['HOUR_INTERVENTION'].apply(fix_midnight)\n", "df['MINUTES_TO_RESPOND'] = df.\\\n", " loc[:, ['HOUR_REQUEST', 'HOUR_INTERVENTION']].\\\n", " T.\\\n", " apply(lambda x: time_difference(x[0], x[1]))" ] }, { "cell_type": "code", "execution_count": 6, "id": "latest-archives", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "average_time_to_respond = np.floor(np.average(df['MINUTES_TO_RESPOND']))\n", "average_time_to_respond" ] }, { "cell_type": "code", "execution_count": 7, "id": "ultimate-federal", "metadata": {}, "outputs": [ { "data": { "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", "
YEARMONTHHOUR_REQUESTHOUR_INTERVENTIONCODEDISTRICTHOSPITALMINUTES_TO_RESPONDHOURABOVE_AVG
02020000:03:2100:08:4900-1500
12020000:04:0300:14:4411-11001
22020000:04:0500:10:1222-1600
32020000:05:0900:13:1533-1800
42020000:07:4300:16:1943-1800
\n", "
" ], "text/plain": [ " YEAR MONTH HOUR_REQUEST HOUR_INTERVENTION CODE DISTRICT HOSPITAL \\\n", "0 2020 0 00:03:21 00:08:49 0 0 -1 \n", "1 2020 0 00:04:03 00:14:44 1 1 -1 \n", "2 2020 0 00:04:05 00:10:12 2 2 -1 \n", "3 2020 0 00:05:09 00:13:15 3 3 -1 \n", "4 2020 0 00:07:43 00:16:19 4 3 -1 \n", "\n", " MINUTES_TO_RESPOND HOUR ABOVE_AVG \n", "0 5 0 0 \n", "1 10 0 1 \n", "2 6 0 0 \n", "3 8 0 0 \n", "4 8 0 0 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df['HOUR'] = df['HOUR_REQUEST'].apply(lambda v: int(v.split(':')[0]))\n", "df['ABOVE_AVG'] = df['MINUTES_TO_RESPOND'].apply(lambda v: 1 if v > average_time_to_respond else 0)\n", "df.head()" ] }, { "cell_type": "markdown", "id": "starting-shark", "metadata": {}, "source": [ "## Feature selection" ] }, { "cell_type": "code", "execution_count": 8, "id": "adjusted-grounds", "metadata": {}, "outputs": [ { "data": { "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", "
YEARMONTHCODEDISTRICTHOSPITALHOURABOVE_AVG
02020000-100
12020011-101
22020022-100
32020033-100
42020043-100
\n", "
" ], "text/plain": [ " YEAR MONTH CODE DISTRICT HOSPITAL HOUR ABOVE_AVG\n", "0 2020 0 0 0 -1 0 0\n", "1 2020 0 1 1 -1 0 1\n", "2 2020 0 2 2 -1 0 0\n", "3 2020 0 3 3 -1 0 0\n", "4 2020 0 4 3 -1 0 0" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cols = ['YEAR', 'MONTH', 'CODE', 'DISTRICT', 'HOSPITAL', 'HOUR', 'ABOVE_AVG']\n", "samur = df[cols]\n", "samur.head()" ] }, { "cell_type": "markdown", "id": "proper-carbon", "metadata": {}, "source": [ "### Correlation Matrix" ] }, { "cell_type": "code", "execution_count": 9, "id": "differential-belle", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/numpy/lib/function_base.py:2642: RuntimeWarning: invalid value encountered in true_divide\n", " c /= stddev[:, None]\n", "/opt/conda/lib/python3.8/site-packages/numpy/lib/function_base.py:2643: RuntimeWarning: invalid value encountered in true_divide\n", " c /= stddev[None, :]\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "corr_matrix = np.corrcoef(samur.T)\n", "\n", "plt.figure(figsize=(10, 10))\n", "sns.heatmap(\n", " corr_matrix,\n", " cbar=False,\n", " annot=True,\n", " square=True,\n", " xticklabels=samur.columns,\n", " yticklabels=samur.columns)" ] }, { "cell_type": "markdown", "id": "signed-pharmaceutical", "metadata": {}, "source": [ "### Imbalance analysis" ] }, { "cell_type": "code", "execution_count": 10, "id": "psychological-morocco", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
ABOVE_AVGCOUNT
1128268
0075583
\n", "
" ], "text/plain": [ " ABOVE_AVG COUNT\n", "1 1 28268\n", "0 0 75583" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.loc[:, [\"ABOVE_AVG\", \"MONTH\"]]\\\n", " .groupby(\"ABOVE_AVG\")\\\n", " .count()\\\n", " .rename(columns={\"MONTH\": \"COUNT\"})\\\n", " .reset_index()\\\n", " .sort_values(\"ABOVE_AVG\", ascending=False)" ] }, { "cell_type": "code", "execution_count": 11, "id": "bridal-oxford", "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "columns = ['YEAR', 'MONTH', 'CODE', 'DISTRICT', 'HOSPITAL', 'HOUR']\n", "target = 'ABOVE_AVG'\n", "\n", "X = samur[columns]\n", "y = samur[target]" ] }, { "cell_type": "code", "execution_count": 12, "id": "mediterranean-louis", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: imbalanced-learn in /opt/conda/lib/python3.8/site-packages (0.8.0)\n", "Requirement already satisfied: numpy>=1.13.3 in /opt/conda/lib/python3.8/site-packages (from imbalanced-learn) (1.20.0)\n", "Requirement already satisfied: joblib>=0.11 in /opt/conda/lib/python3.8/site-packages (from imbalanced-learn) (1.0.0)\n", "Requirement already satisfied: scikit-learn>=0.24 in /opt/conda/lib/python3.8/site-packages (from imbalanced-learn) (0.24.1)\n", "Requirement already satisfied: scipy>=0.19.1 in /opt/conda/lib/python3.8/site-packages (from imbalanced-learn) (1.6.0)\n", "Requirement already satisfied: threadpoolctl>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from scikit-learn>=0.24->imbalanced-learn) (2.1.0)\n" ] } ], "source": [ "# Install a pip package in the current Jupyter kernel\n", "import sys\n", "!{sys.executable} -m pip install -U imbalanced-learn" ] }, { "cell_type": "markdown", "id": "engaging-moral", "metadata": {}, "source": [ "Because there are many samples, I think is going to be counter-productive to add more samples. I'm ok just having the same amount of positive samples than negative ones. For that I'm using an under-sampling algorithm from imlearn" ] }, { "cell_type": "code", "execution_count": 13, "id": "bacterial-deployment", "metadata": {}, "outputs": [], "source": [ "from imblearn.under_sampling import RandomUnderSampler\n", "\n", "rus = RandomUnderSampler(random_state=0)\n", "X, y = rus.fit_resample(X, y)" ] }, { "cell_type": "code", "execution_count": 14, "id": "needed-munich", "metadata": {}, "outputs": [], "source": [ "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)" ] }, { "cell_type": "code", "execution_count": 15, "id": "realistic-maryland", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BEST 5 FEATURES: ['MONTH' 'CODE' 'DISTRICT' 'HOSPITAL' 'HOUR']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/sklearn/feature_selection/_univariate_selection.py:114: UserWarning: Features [0] are constant.\n", " warnings.warn(\"Features %s are constant.\" % constant_features_idx,\n", "/opt/conda/lib/python3.8/site-packages/sklearn/feature_selection/_univariate_selection.py:116: RuntimeWarning: invalid value encountered in true_divide\n", " f = msb / msw\n" ] } ], "source": [ "from sklearn.feature_selection import SelectKBest\n", "from sklearn.feature_selection import f_classif\n", "\n", "fs = SelectKBest(f_classif, k=5)\n", "X_selected = fs.fit_transform(X, y)\n", "cols = fs.get_support(indices=True)\n", "df_best = samur.iloc[:, cols]\n", "\n", "print(\"BEST 5 FEATURES: {}\".format(samur.iloc[:, cols].columns.values))" ] }, { "cell_type": "markdown", "id": "worse-prisoner", "metadata": {}, "source": [ "## CONFUSION MATRICES" ] }, { "cell_type": "code", "execution_count": 16, "id": "respiratory-rochester", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/sklearn/svm/_base.py:985: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n", " warnings.warn(\"Liblinear failed to converge, increase \"\n" ] } ], "source": [ "from sklearn.linear_model import LogisticRegression\n", "from sklearn.svm import LinearSVC\n", "from sklearn.neighbors import KNeighborsClassifier\n", "from sklearn.tree import DecisionTreeClassifier\n", "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n", "from sklearn.dummy import DummyClassifier\n", "\n", "# different classifiers\n", "logistic = LogisticRegression().fit(X_train, y_train)\n", "svc = LinearSVC(random_state=0).fit(X_train, y_train)\n", "knn = KNeighborsClassifier(5).fit(X_train, y_train)\n", "tree = DecisionTreeClassifier(max_depth=3).fit(X_train, y_train)\n", "rff = RandomForestClassifier(max_depth=2, n_estimators=4, max_features=2).fit(X_train, y_train)\n", "ada = AdaBoostClassifier(n_estimators=100).fit(X_train, y_train)\n", "dummy = DummyClassifier(strategy = 'most_frequent').fit(X_train, y_train)\n", "classifiers = [dummy, logistic, svc, knn, tree, rff, ada]" ] }, { "cell_type": "code", "execution_count": 19, "id": "greater-formula", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DummyClassifier\n", "===========================================\n", "[[7053 0]\n", " [7081 0]]\n", "\n", "LogisticRegression\n", "===========================================\n", "[[4944 2109]\n", " [3685 3396]]\n", "\n", "LinearSVC\n", "===========================================\n", "[[ 0 7053]\n", " [ 0 7081]]\n", "\n", "KNeighborsClassifier\n", "===========================================\n", "[[4273 2780]\n", " [2732 4349]]\n", "\n", "DecisionTreeClassifier\n", "===========================================\n", "[[5825 1228]\n", " [4486 2595]]\n", "\n", "RandomForestClassifier\n", "===========================================\n", "[[4631 2422]\n", " [3381 3700]]\n", "\n", "AdaBoostClassifier\n", "===========================================\n", "[[4934 2119]\n", " [3054 4027]]\n", "\n" ] } ], "source": [ "from sklearn.metrics import confusion_matrix\n", "\n", "for clsf in classifiers:\n", " y_predicted = clsf.predict(X_test)\n", " print(clsf.__class__.__name__)\n", " print('===========================================')\n", " print(confusion_matrix(y_test, y_predicted))\n", " print()" ] }, { "cell_type": "markdown", "id": "junior-powell", "metadata": {}, "source": [ "## CLASSIFICATION REPORTS" ] }, { "cell_type": "code", "execution_count": 17, "id": "original-raleigh", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DummyClassifier\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.50 1.00 0.67 7053\n", "not_above_avg 0.00 0.00 0.00 7081\n", "\n", " accuracy 0.50 14134\n", " macro avg 0.25 0.50 0.33 14134\n", " weighted avg 0.25 0.50 0.33 14134\n", "\n", "LogisticRegression\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.57 0.70 0.63 7053\n", "not_above_avg 0.62 0.48 0.54 7081\n", "\n", " accuracy 0.59 14134\n", " macro avg 0.59 0.59 0.59 14134\n", " weighted avg 0.59 0.59 0.58 14134\n", "\n", "LinearSVC\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.00 0.00 0.00 7053\n", "not_above_avg 0.50 1.00 0.67 7081\n", "\n", " accuracy 0.50 14134\n", " macro avg 0.25 0.50 0.33 14134\n", " weighted avg 0.25 0.50 0.33 14134\n", "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n", "/opt/conda/lib/python3.8/site-packages/sklearn/metrics/_classification.py:1245: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", " _warn_prf(average, modifier, msg_start, len(result))\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "KNeighborsClassifier\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.61 0.61 0.61 7053\n", "not_above_avg 0.61 0.61 0.61 7081\n", "\n", " accuracy 0.61 14134\n", " macro avg 0.61 0.61 0.61 14134\n", " weighted avg 0.61 0.61 0.61 14134\n", "\n", "DecisionTreeClassifier\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.56 0.83 0.67 7053\n", "not_above_avg 0.68 0.37 0.48 7081\n", "\n", " accuracy 0.60 14134\n", " macro avg 0.62 0.60 0.57 14134\n", " weighted avg 0.62 0.60 0.57 14134\n", "\n", "RandomForestClassifier\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.58 0.66 0.61 7053\n", "not_above_avg 0.60 0.52 0.56 7081\n", "\n", " accuracy 0.59 14134\n", " macro avg 0.59 0.59 0.59 14134\n", " weighted avg 0.59 0.59 0.59 14134\n", "\n", "AdaBoostClassifier\n", "===========================================\n", " precision recall f1-score support\n", "\n", " above_avg 0.62 0.70 0.66 7053\n", "not_above_avg 0.66 0.57 0.61 7081\n", "\n", " accuracy 0.63 14134\n", " macro avg 0.64 0.63 0.63 14134\n", " weighted avg 0.64 0.63 0.63 14134\n", "\n" ] } ], "source": [ "from sklearn.metrics import classification_report\n", "\n", "# creating their confusion matrices\n", "for clsf in classifiers:\n", " y_predicted = clsf.predict(X_test)\n", " print(clsf.__class__.__name__)\n", " print('===========================================')\n", " print(classification_report(y_test, y_predicted, target_names = ['above_avg', 'not_above_avg']))" ] }, { "cell_type": "code", "execution_count": null, "id": "restricted-nashville", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.6" } }, "nbformat": 4, "nbformat_minor": 5 }