notebooks/Locust-Prediction-Modelling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Locust Prediction Modelling\n",
    "\n",
    "Notes:\n",
    "\n",
    "- `observation_date` is already encoded as `year`, `month`, `day`, separately\n",
    "- The `dekad` variables are used for pseudo-absence generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>Unnamed: 0.1</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>presence</th>\n",
       "      <th>method</th>\n",
       "      <th>year</th>\n",
       "      <th>month</th>\n",
       "      <th>day</th>\n",
       "      <th>clay_0.5cm_mean</th>\n",
       "      <th>clay_5.15cm_mean</th>\n",
       "      <th>...</th>\n",
       "      <th>SoilMoi0_10cm_inst_95</th>\n",
       "      <th>SoilMoi10_40cm_inst_95</th>\n",
       "      <th>SoilTMP0_10cm_inst_95</th>\n",
       "      <th>SoilTMP10_40cm_inst_95</th>\n",
       "      <th>Tveg_tavg_95</th>\n",
       "      <th>Wind_f_inst_95</th>\n",
       "      <th>Rainf_f_tavg_95</th>\n",
       "      <th>Tair_f_inst_95</th>\n",
       "      <th>Qair_f_inst_95</th>\n",
       "      <th>Psurf_f_inst_95</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>-13.899444</td>\n",
       "      <td>19.156944</td>\n",
       "      <td>1</td>\n",
       "      <td>random</td>\n",
       "      <td>2000</td>\n",
       "      <td>11</td>\n",
       "      <td>27</td>\n",
       "      <td>213.0</td>\n",
       "      <td>218.0</td>\n",
       "      <td>...</td>\n",
       "      <td>21.949375</td>\n",
       "      <td>72.536621</td>\n",
       "      <td>309.327972</td>\n",
       "      <td>308.586700</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.366373</td>\n",
       "      <td>0.0</td>\n",
       "      <td>308.427795</td>\n",
       "      <td>0.006704</td>\n",
       "      <td>98936.21875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>-13.910278</td>\n",
       "      <td>19.144444</td>\n",
       "      <td>1</td>\n",
       "      <td>random</td>\n",
       "      <td>2000</td>\n",
       "      <td>11</td>\n",
       "      <td>27</td>\n",
       "      <td>212.0</td>\n",
       "      <td>217.0</td>\n",
       "      <td>...</td>\n",
       "      <td>21.949375</td>\n",
       "      <td>72.536621</td>\n",
       "      <td>309.327972</td>\n",
       "      <td>308.586700</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.366373</td>\n",
       "      <td>0.0</td>\n",
       "      <td>308.427795</td>\n",
       "      <td>0.006704</td>\n",
       "      <td>98936.21875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>-13.923056</td>\n",
       "      <td>19.146667</td>\n",
       "      <td>1</td>\n",
       "      <td>random</td>\n",
       "      <td>2000</td>\n",
       "      <td>11</td>\n",
       "      <td>27</td>\n",
       "      <td>210.0</td>\n",
       "      <td>215.0</td>\n",
       "      <td>...</td>\n",
       "      <td>21.949375</td>\n",
       "      <td>72.536621</td>\n",
       "      <td>309.327972</td>\n",
       "      <td>308.586700</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.366373</td>\n",
       "      <td>0.0</td>\n",
       "      <td>308.427795</td>\n",
       "      <td>0.006704</td>\n",
       "      <td>98936.21875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>-12.945833</td>\n",
       "      <td>19.146389</td>\n",
       "      <td>1</td>\n",
       "      <td>random</td>\n",
       "      <td>2000</td>\n",
       "      <td>11</td>\n",
       "      <td>28</td>\n",
       "      <td>175.0</td>\n",
       "      <td>190.0</td>\n",
       "      <td>...</td>\n",
       "      <td>21.541126</td>\n",
       "      <td>71.466125</td>\n",
       "      <td>308.702087</td>\n",
       "      <td>309.064667</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.542690</td>\n",
       "      <td>0.0</td>\n",
       "      <td>307.616486</td>\n",
       "      <td>0.010070</td>\n",
       "      <td>99162.62500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>-12.949722</td>\n",
       "      <td>19.133056</td>\n",
       "      <td>1</td>\n",
       "      <td>random</td>\n",
       "      <td>2000</td>\n",
       "      <td>11</td>\n",
       "      <td>28</td>\n",
       "      <td>180.0</td>\n",
       "      <td>191.0</td>\n",
       "      <td>...</td>\n",
       "      <td>21.541126</td>\n",
       "      <td>71.466125</td>\n",
       "      <td>308.702087</td>\n",
       "      <td>309.064667</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.542690</td>\n",
       "      <td>0.0</td>\n",
       "      <td>307.616486</td>\n",
       "      <td>0.010070</td>\n",
       "      <td>99162.62500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 1167 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Unnamed: 0.1          x          y  presence  method  year  month  day  \\\n",
       "0             0 -13.899444  19.156944         1  random  2000     11   27   \n",
       "1             1 -13.910278  19.144444         1  random  2000     11   27   \n",
       "2             2 -13.923056  19.146667         1  random  2000     11   27   \n",
       "3             3 -12.945833  19.146389         1  random  2000     11   28   \n",
       "4             4 -12.949722  19.133056         1  random  2000     11   28   \n",
       "\n",
       "   clay_0.5cm_mean  clay_5.15cm_mean  ...  SoilMoi0_10cm_inst_95  \\\n",
       "0            213.0             218.0  ...              21.949375   \n",
       "1            212.0             217.0  ...              21.949375   \n",
       "2            210.0             215.0  ...              21.949375   \n",
       "3            175.0             190.0  ...              21.541126   \n",
       "4            180.0             191.0  ...              21.541126   \n",
       "\n",
       "   SoilMoi10_40cm_inst_95  SoilTMP0_10cm_inst_95  SoilTMP10_40cm_inst_95  \\\n",
       "0               72.536621             309.327972              308.586700   \n",
       "1               72.536621             309.327972              308.586700   \n",
       "2               72.536621             309.327972              308.586700   \n",
       "3               71.466125             308.702087              309.064667   \n",
       "4               71.466125             308.702087              309.064667   \n",
       "\n",
       "  Tveg_tavg_95  Wind_f_inst_95  Rainf_f_tavg_95  Tair_f_inst_95  \\\n",
       "0          0.0        2.366373              0.0      308.427795   \n",
       "1          0.0        2.366373              0.0      308.427795   \n",
       "2          0.0        2.366373              0.0      308.427795   \n",
       "3          0.0        3.542690              0.0      307.616486   \n",
       "4          0.0        3.542690              0.0      307.616486   \n",
       "\n",
       "   Qair_f_inst_95  Psurf_f_inst_95  \n",
       "0        0.006704      98936.21875  \n",
       "1        0.006704      98936.21875  \n",
       "2        0.006704      98936.21875  \n",
       "3        0.010070      99162.62500  \n",
       "4        0.010070      99162.62500  \n",
       "\n",
       "[5 rows x 1167 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_train = pd.read_csv(\"../data/train_val_random.csv\", index_col=0)\n",
    "data_test = pd.read_csv(\"../data/test_random.csv\", index_col=0)\n",
    "data_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train missing 0 columns\n",
      "Test missing 0 columns\n"
     ]
    }
   ],
   "source": [
    "# assert len(data_train.drop(columns=\"presence\").columns), len(data_test.columns)\n",
    "missing_in_train = [n for n in data_test.columns if n not in data_train.columns]\n",
    "missing_in_test = [n for n in data_train.columns if n not in data_test.columns]\n",
    "\n",
    "print(f\"Train missing {len(missing_in_train)} columns\")\n",
    "print(f\"Test missing {len(missing_in_test)} columns\")\n",
    "\n",
    "data_test = data_test.drop(columns=missing_in_train)\n",
    "data_train = data_train.drop(columns=missing_in_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objects: ['method', 'observation_date']\n",
      "Categoricals: ['Unnamed: 0.1', 'presence', 'year', 'month', 'day']\n",
      "Floats: ['x', 'y', 'clay_0.5cm_mean', 'clay_5.15cm_mean', 'sand_0.5cm_mean', 'sand_5.15cm_mean', 'silt_0.5cm_mean', 'silt_5.15cm_mean', 'AvgSurfT_inst_0', 'Albedo_inst_0']\n"
     ]
    }
   ],
   "source": [
    "cats = data_train.select_dtypes(np.integer).columns.tolist()\n",
    "objects = data_train.select_dtypes(np.object).columns.tolist()\n",
    "floats = data_train.select_dtypes(np.float).columns.tolist()\n",
    "assert len(cats) + len(objects) + len(floats) == len(data_train.columns)\n",
    "\n",
    "print(\"Objects:\", objects)\n",
    "print(\"Categoricals:\", cats)\n",
    "print(\"Floats:\", floats[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 33246 entries, 0 to 76512\n",
      "Columns: 1167 entries, Unnamed: 0.1 to Psurf_f_inst_95\n",
      "dtypes: float64(1160), int64(5), object(2)\n",
      "memory usage: 296.3+ MB\n"
     ]
    }
   ],
   "source": [
    "data_train.info(verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check for NAN values\n",
    "nans = data_train.isnull().sum()\n",
    "# [(k,v,d) for k,v,d in zip(nans.keys(), nans.values, data_train.dtypes) if v>0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill NAN values with median\n",
    "# for col in data_train.columns:\n",
    "#     n_train_nans = pd.isnull(data_train[col]).sum()\n",
    "#     n_test_nans = pd.isnull(data_test[col]).sum()\n",
    "#     if data_train[col].dtype == np.float:\n",
    "#         m = data_train[col].median()\n",
    "#         if n_train_nans:\n",
    "#             data_train[col] = data_train[col].fillna(m)\n",
    "#         if n_test_nans:\n",
    "#             data_test[col] = data_test[col].fillna(m)\n",
    "\n",
    "data_train.dropna(inplace=True)\n",
    "data_test.dropna(inplace=True)\n",
    "\n",
    "assert not data_train.isnull().sum().sum()\n",
    "assert not data_test.isnull().sum().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "non_temporal_columns = ['sand_0.5cm_mean', 'sand_5.15cm_mean']\n",
    "temporal_variables = [\n",
    "    'AvgSurfT_inst', \n",
    "    # 'Albedo_inst', \n",
    "    'SoilMoi0_10cm_inst', \n",
    "    'SoilMoi10_40cm_inst', \n",
    "    'SoilTMP0_10cm_inst', \n",
    "    'SoilTMP10_40cm_inst', \n",
    "    'Tveg_tavg', \n",
    "    'Wind_f_inst', \n",
    "    'Rainf_f_tavg', \n",
    "    'Tair_f_inst',\n",
    "    'Qair_f_inst', \n",
    "    'Psurf_f_inst'\n",
    "]\n",
    "\n",
    "def grouplen(sequence, chunk_size):\n",
    "    return list(zip(*[iter(sequence)] * chunk_size))\n",
    "\n",
    "def preprocess_data(data, days=6, drop_true_absence=True):\n",
    "    \"\"\"Bucketize temporal columns\"\"\"\n",
    "    if drop_true_absence:\n",
    "        data = data[data['presence'] != 2]\n",
    "    dfs = []\n",
    "    for temp_variable in temporal_variables:\n",
    "        chunks = grouplen([col for col in data.columns if temp_variable in col], days)\n",
    "        agg_list = list(map(lambda x: data[list(x)].mean(axis=1), chunks))\n",
    "        df = pd.concat(agg_list, axis=1)\n",
    "        df.columns = [f\"{temp_variable}_bucket_{i}\" for i in range(1, df.shape[1]+1)]\n",
    "        dfs.append(df)\n",
    "    dfs.append(data[non_temporal_columns])\n",
    "    return pd.concat(dfs, axis=1), data['presence']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drops = [\"observation_date\", \"date\", \"Unnamed: 0.1\", \"presence\"]\n",
    "\n",
    "# def process_targets(data):\n",
    "#     target = data.presence.copy()\n",
    "#     data = data.drop(columns=drops)\n",
    "#     counts = list(zip(*np.unique(target, return_counts=True)))\n",
    "#     print(\"Counts:\", counts)\n",
    "    \n",
    "#     # merge pseudo-absence and true absence\n",
    "#     target.loc[target == 2] = 0\n",
    "#     return data, target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train features: (32823, 178), Train labels: (32823,)\n",
      "Test features: (6885, 178), Test labels: (6885,)\n"
     ]
    }
   ],
   "source": [
    "data_train, train_target = preprocess_data(data_train)\n",
    "data_test, test_target = preprocess_data(data_test)\n",
    "\n",
    "print(f\"Train features: {data_train.shape}, Train labels: {train_target.shape}\")\n",
    "print(f\"Test features: {data_test.shape}, Test labels: {test_target.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing, metrics\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(trues, preds, probs):\n",
    "    labels = ['absence', 'presence']\n",
    "    results = {}\n",
    "    results['accuracy'] = metrics.accuracy_score(trues, preds)\n",
    "    results['confusion_matrix'] = metrics.confusion_matrix(trues, preds)\n",
    "    results['kappa'] = metrics.cohen_kappa_score(trues, preds)\n",
    "    results['f1'] = metrics.f1_score(trues, preds)\n",
    "    results['auc'] = metrics.roc_auc_score(trues, probs)\n",
    "    \n",
    "    print(metrics.classification_report(trues, preds, target_names=labels))\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Probably should split data sooner\n",
    "seed = 111\n",
    "train_x, val_x, train_y, val_y = train_test_split(\n",
    "    data_train, train_target, test_size=0.2, random_state=seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scale the dataset\n",
    "scaler = preprocessing.StandardScaler()\n",
    "train_x_scaled = scaler.fit_transform(train_x)\n",
    "val_x_scaled = scaler.transform(val_x)\n",
    "test_x_scaled = scaler.transform(data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/sklearn/linear_model/_logistic.py:938: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "model = LogisticRegression()\n",
    "model.fit(train_x_scaled, train_y);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.66      0.40      0.50      2359\n",
      "    presence       0.72      0.89      0.80      4206\n",
      "\n",
      "    accuracy                           0.71      6565\n",
      "   macro avg       0.69      0.64      0.65      6565\n",
      "weighted avg       0.70      0.71      0.69      6565\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_preds = model.predict(val_x_scaled)\n",
    "y_probs = model.predict_proba(val_x_scaled)[:, 1]\n",
    "logistic_val_results = evaluate(val_y, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.49      0.52      0.50      1232\n",
      "    presence       0.89      0.88      0.89      5653\n",
      "\n",
      "    accuracy                           0.82      6885\n",
      "   macro avg       0.69      0.70      0.70      6885\n",
      "weighted avg       0.82      0.82      0.82      6885\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_preds = model.predict(test_x_scaled)\n",
    "y_probs = model.predict_proba(test_x_scaled)[:, 1]\n",
    "logistic_test_results = evaluate(test_target, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-1.5817677782900852, 'Tair_f_inst_bucket_16'),\n",
       " (1.4095284713943972, 'SoilTMP10_40cm_inst_bucket_16'),\n",
       " (1.2249959374559176, 'sand_0.5cm_mean'),\n",
       " (-1.149305523201153, 'Tair_f_inst_bucket_2'),\n",
       " (-1.1325072029398453, 'Tair_f_inst_bucket_1'),\n",
       " (-1.042188801310214, 'sand_5.15cm_mean'),\n",
       " (-1.006401287019596, 'Tair_f_inst_bucket_3'),\n",
       " (-0.9745902109473867, 'Tair_f_inst_bucket_14'),\n",
       " (-0.9349365050001243, 'Tair_f_inst_bucket_15'),\n",
       " (-0.8802094437176424, 'Psurf_f_inst_bucket_11')]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Feature importance\n",
    "weights = model.coef_[0].tolist()\n",
    "features = list(zip(weights, data_train.columns))\n",
    "list(sorted(features, key=lambda x: abs(x[0]), reverse=True))[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_xgb = xgb.DMatrix(train_x, label=train_y)\n",
    "val_xgb = xgb.DMatrix(val_x, label=val_y)\n",
    "test_xgb = xgb.DMatrix(data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[18:52:50] WARNING: ../src/learner.cc:1095: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.75      0.56      0.65      2359\n",
      "    presence       0.79      0.90      0.84      4206\n",
      "\n",
      "    accuracy                           0.78      6565\n",
      "   macro avg       0.77      0.73      0.74      6565\n",
      "weighted avg       0.77      0.78      0.77      6565\n",
      "\n"
     ]
    }
   ],
   "source": [
    "params = {'max_depth': 5, 'eta': 0.3, 'objective': 'binary:logistic', 'subsample': 0.7}\n",
    "model = xgb.train(params, train_xgb)\n",
    "y_probs = model.predict(val_xgb)\n",
    "y_preds = y_probs.round()\n",
    "xgb_val_results = evaluate(val_y, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.39      0.40      0.39      1232\n",
      "    presence       0.87      0.86      0.86      5653\n",
      "\n",
      "    accuracy                           0.78      6885\n",
      "   macro avg       0.63      0.63      0.63      6885\n",
      "weighted avg       0.78      0.78      0.78      6885\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_probs = model.predict(test_xgb)\n",
    "y_preds = y_probs.round()\n",
    "xgb_test_results = evaluate(test_target, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Feature Importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f,a = plt.subplots(figsize=(12,12))\n",
    "xgb.plot_importance(model, height=0.5, figure=f, ax=a, max_num_features=15);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=5, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=50, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=500,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = RandomForestClassifier(n_estimators=500, max_depth=5, min_samples_leaf=50)\n",
    "model.fit(train_x, train_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.68      0.49      0.57      2359\n",
      "    presence       0.75      0.87      0.81      4206\n",
      "\n",
      "    accuracy                           0.73      6565\n",
      "   macro avg       0.72      0.68      0.69      6565\n",
      "weighted avg       0.73      0.73      0.72      6565\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_preds = model.predict(val_x)\n",
    "y_probs = model.predict_proba(val_x)[:, 1]\n",
    "rf_val_results = evaluate(val_y, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "     absence       0.04      0.02      0.02      1232\n",
      "    presence       0.81      0.92      0.86      5653\n",
      "\n",
      "    accuracy                           0.75      6885\n",
      "   macro avg       0.42      0.47      0.44      6885\n",
      "weighted avg       0.67      0.75      0.71      6885\n",
      "\n"
     ]
    }
   ],
   "source": [
    "y_preds = model.predict(data_test)\n",
    "y_probs = model.predict_proba(data_test)[:, 1]\n",
    "rf_test_results = evaluate(test_target, y_preds, y_probs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>Logistic</th>\n",
       "      <th>XGBoost</th>\n",
       "      <th>Random Forest</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>accuracy</th>\n",
       "      <td>0.711196</td>\n",
       "      <td>0.777304</td>\n",
       "      <td>0.73374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>confusion_matrix</th>\n",
       "      <td>[[941, 1418], [478, 3728]]</td>\n",
       "      <td>[[1331, 1028], [434, 3772]]</td>\n",
       "      <td>[[1159, 1200], [548, 3658]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>kappa</th>\n",
       "      <td>0.312601</td>\n",
       "      <td>0.488017</td>\n",
       "      <td>0.384344</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>f1</th>\n",
       "      <td>0.797263</td>\n",
       "      <td>0.837664</td>\n",
       "      <td>0.807149</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>auc</th>\n",
       "      <td>0.738416</td>\n",
       "      <td>0.851092</td>\n",
       "      <td>0.808497</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                    Logistic                      XGBoost  \\\n",
       "accuracy                            0.711196                     0.777304   \n",
       "confusion_matrix  [[941, 1418], [478, 3728]]  [[1331, 1028], [434, 3772]]   \n",
       "kappa                               0.312601                     0.488017   \n",
       "f1                                  0.797263                     0.837664   \n",
       "auc                                 0.738416                     0.851092   \n",
       "\n",
       "                                Random Forest  \n",
       "accuracy                              0.73374  \n",
       "confusion_matrix  [[1159, 1200], [548, 3658]]  \n",
       "kappa                                0.384344  \n",
       "f1                                   0.807149  \n",
       "auc                                  0.808497  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val_results = pd.DataFrame({\n",
    "    \"Logistic\": logistic_val_results, \n",
    "    \"XGBoost\": xgb_val_results, \n",
    "    \"Random Forest\": rf_val_results,\n",
    "})\n",
    "val_results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>Logistic</th>\n",
       "      <th>XGBoost</th>\n",
       "      <th>Random Forest</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>accuracy</th>\n",
       "      <td>0.818301</td>\n",
       "      <td>0.77894</td>\n",
       "      <td>0.754103</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>confusion_matrix</th>\n",
       "      <td>[[636, 596], [655, 4998]]</td>\n",
       "      <td>[[490, 742], [780, 4873]]</td>\n",
       "      <td>[[19, 1213], [480, 5173]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>kappa</th>\n",
       "      <td>0.393007</td>\n",
       "      <td>0.256652</td>\n",
       "      <td>-0.0905567</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>f1</th>\n",
       "      <td>0.88877</td>\n",
       "      <td>0.864927</td>\n",
       "      <td>0.859374</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>auc</th>\n",
       "      <td>0.716195</td>\n",
       "      <td>0.714422</td>\n",
       "      <td>0.692537</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   Logistic                    XGBoost  \\\n",
       "accuracy                           0.818301                    0.77894   \n",
       "confusion_matrix  [[636, 596], [655, 4998]]  [[490, 742], [780, 4873]]   \n",
       "kappa                              0.393007                   0.256652   \n",
       "f1                                  0.88877                   0.864927   \n",
       "auc                                0.716195                   0.714422   \n",
       "\n",
       "                              Random Forest  \n",
       "accuracy                           0.754103  \n",
       "confusion_matrix  [[19, 1213], [480, 5173]]  \n",
       "kappa                            -0.0905567  \n",
       "f1                                 0.859374  \n",
       "auc                                0.692537  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_results = pd.DataFrame({\n",
    "    \"Logistic\": logistic_test_results, \n",
    "    \"XGBoost\": xgb_test_results, \n",
    "    \"Random Forest\": rf_test_results,\n",
    "})\n",
    "test_results"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "dca0ade3e726a953b501b15e8e990130d2b7799f14cfd9f4271676035ebe5511"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('base': conda)",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}