{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import time\n",
    "from pprint import pprint\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import nivapy3 as nivapy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sn\n",
    "import utils\n",
    "from matplotlib import colors\n",
    "from sklearn import model_selection\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression, RidgeClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV, train_test_split\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "sn.set(style=\"ticks\")\n",
    "plt.style.use(\"ggplot\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparing models and choosing hyperparameters\n",
    "\n",
    "This notebook provides a basic framework for:\n",
    "\n",
    " 1. Tuning the hyperparameters of individual classification algorithms, and \n",
    " 2. Comparing the performance of various different algorithms (with different hyperparameters)\n",
    " \n",
    "Scikit-Learn provides a wide range of algorithms for **supervised classification** (see [here](https://scikit-learn.org/stable/supervised_learning.html) for an overview). It should be possible to use any of Sklearn's **classification** (not regression) algorithms in this notebook. I've imported seven suggested algorithms in the code above, but feel free to add others if you wish.\n",
    "\n",
    "**Tip:** If you're trying out a new algorithm, start off with a **small training dataset** (maybe 10,000-ish rows) and, if it works, scale things up. If you go straight for millions of rows, you'll likely get lots of crashes (plus 5 to 10 minute delays as the cluster recovers before you can restart).\n",
    "\n",
    "**Note:** To run this notebook in its present form, you will need to **sign in to the JupyterHub on one of the larger machines**: either \"High memory\" (48 GB RAM; 8 CPUs) or \"High memory & high CPU\" (60 GB RAM; 16 CPUs). For long-running computations, please remember to **check progress periodically and shut down your server when you're finished**. (This doesn't mean you need to be tied to your computer; you can shut down your server pretty easily from your phone)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Set user options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify area(s) from which to build train/test dataset\n",
    "area_list = [1, 3, 6]\n",
    "\n",
    "# Specify area for 'final' test image (should NOT be in the list above)\n",
    "pred_area = 2\n",
    "\n",
    "# Number of samples to use for training and testing\n",
    "train_size = 1e4\n",
    "test_size = 1e4\n",
    "\n",
    "# For repeatability of random numbers\n",
    "seed = 42\n",
    "\n",
    "# Scoring metric for model comparison\n",
    "metric = \"accuracy\"\n",
    "\n",
    "# Number of folds for CV\n",
    "n_folds = 10\n",
    "\n",
    "# Whether to equalise images using linear histogram stretch\n",
    "equalise = False\n",
    "\n",
    "assert (\n",
    "    pred_area not in area_list\n",
    "), \"'pred_area' should be an independent test i.e. not included in 'area_list'.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define colourbar\n",
    "# Class codes for \"truth\" datasets\n",
    "class_codes = {\n",
    "    -1: \"Other\",\n",
    "    0: \"No data\",\n",
    "    1: \"Brown algae\",\n",
    "    2: \"Green algae\",\n",
    "    3: \"Red algae\",\n",
    "    4: \"Eelgrass\",\n",
    "    5: \"Rock\",\n",
    "    6: \"Sand\",\n",
    "    7: \"Lichen\",\n",
    "    8: \"Lichen (2)\",\n",
    "    9: \"Terrestrial vegetation\",\n",
    "    10: \"Beach/shingle\",\n",
    "}\n",
    "\n",
    "# Define colours for classes. Ordered -1 to 10 (i.e. same as in 'class_codes', above)\n",
    "cmap = colors.ListedColormap(\n",
    "    [\n",
    "        \"lightcyan\",\n",
    "        \"black\",\n",
    "        \"tan\",\n",
    "        \"lawngreen\",\n",
    "        \"red\",\n",
    "        \"none\",\n",
    "        \"lightgrey\",\n",
    "        \"gold\",\n",
    "        \"magenta\",\n",
    "        \"none\",\n",
    "        \"mediumseagreen\",\n",
    "        \"orange\",\n",
    "    ]\n",
    ")\n",
    "bounds = np.arange(-1.5, 11.5)\n",
    "norm = colors.BoundaryNorm(bounds, cmap.N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Build dataset for training and evaluation\n",
    "\n",
    "We begin by reading all the data from several different areas, so that our training dataset has a mixture of pixels from different parts of the study region. The three areas chosen above together have ~19 million pixels, which is too large and slow for the kind of experimentation we want to do here. I've therefore set both `train_size` and `test_size` to 2 million rows. This should be more manageable, while still providing a realistic impression of performance.\n",
    "\n",
    "We also read in a fourth image, which is kept separately and used for final testing and visualisation.\n",
    "\n",
    "You are welcome to **use data from other areas** and **choose different scoring metrics** (see Sklearn's documentation). Also **consider setting `equalise=True`** in the options above. This should have no effect on \"non-parametric\" methods (like random forest) but could affect some of the other classifiers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of samples in dataset:      18.87 million.\n",
      "Number of samples in training dataset:   0.01 million.\n",
      "Number of samples in evaluation dataset: 0.01 million.\n"
     ]
    }
   ],
   "source": [
    "# Read train/test image data\n",
    "df_list = []\n",
    "for area in area_list:\n",
    "    df = utils.image_to_sample_df(area, equalise=equalise)\n",
    "    df_list.append(df)\n",
    "\n",
    "df = pd.concat(df_list, axis=\"rows\")\n",
    "del df_list\n",
    "\n",
    "# Split into training and evaluation\n",
    "cols = [str(i) for i in range(1, 9)]\n",
    "X_train, X_eval, y_train, y_eval = train_test_split(\n",
    "    df[cols],\n",
    "    df[\"y\"],\n",
    "    train_size=int(train_size),\n",
    "    test_size=int(test_size),\n",
    "    random_state=seed,\n",
    "    shuffle=True,\n",
    ")\n",
    "\n",
    "assert len(X_train) == len(y_train)\n",
    "assert len(X_eval) == len(y_eval)\n",
    "\n",
    "print(f\"Total number of samples in dataset:      {(len(df) / 1E6):.2f} million.\")\n",
    "print(f\"Number of samples in training dataset:   {(len(X_train) / 1E6):.2f} million.\")\n",
    "print(f\"Number of samples in evaluation dataset: {(len(X_eval) / 1E6):.2f} million.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of pixels in test image: 13.32 million.\n"
     ]
    }
   ],
   "source": [
    "# Read bands for 'final' test image\n",
    "pred_df = utils.image_to_sample_df(pred_area, equalise=equalise, dropna=False)\n",
    "del pred_df[\"y\"]\n",
    "\n",
    "# Read manually classified \"truth\" datset\n",
    "man_path = f\"/home/jovyan/shared/drones/frisk_oslofjord/raster/ne_akeroya_5cm_area_{pred_area}_man_class.tif\"\n",
    "man_img, ndv, man_epsg, extent = nivapy.spatial.read_raster(man_path, band_no=1)\n",
    "\n",
    "print(f\"Total number of pixels in test image: {(len(pred_df) / 1E6):.2f} million.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Explore hyperparameters for an individual model\n",
    "\n",
    "At the top of this notebook I've imported seven classifiers as a starting point (feel free to change them if you like):\n",
    "\n",
    " * LogisticRegression\n",
    " * LinearDiscriminantAnalysis\n",
    " * RidgeClassifier\n",
    " * GaussianNB\n",
    " * KNeighborsClassifier\n",
    " * DecisionTreeClassifier\n",
    " * RandomForestClassifier\n",
    "\n",
    "The first of these is essentially the same as the method you implemented with Guri (which I think was multinomial logistic regression?). This is a linear approach, as is `LinearDiscriminantAnalysis` and the `RidgeClassifier`. `GaussianNB` is a very simple method, but it can be effective in some circumstances. The `KNeighborsClassifier` is also conceptually simple, but often surprisingly powerful. The last two are tree-based classifiers, where the `RandomForestClassifier` is just an ensemble of `DecisionTreeClassifiers`. These two - together with KNN - are non-parametric methods, which makes them both flexible and powerful.\n",
    "\n",
    "As a starting point, I recommend reading the online documentation for each of these models. Most of the algorithms will have a general introduction (linked from [here](https://scikit-learn.org/stable/supervised_learning.html)) plus a more detailed page describing the API and hyperparameter options (e.g. [here](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html) for the `RandomForestClassifier`). For each algorithm, aim to:\n",
    "\n",
    " 1. Get a rough understanding of what it does and what assumptions it makes, and\n",
    " \n",
    " 2. Write down which hyperparameters you think might be sensible to tune\n",
    " \n",
    "Then, for each of the models in turn..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1. Select the base model\n",
    "\n",
    "Change the code below to match the model you want to work with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the base model to tune\n",
    "#model = RandomForestClassifier(n_jobs=-1)\n",
    "\n",
    "model = SVC(kernel='rbf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2. Choose hyperparameters to tune\n",
    "\n",
    "Change the code below to create a \"grid\" of hyperparameters to search. These hyperparameters must match the options documented in the API for each algorithm (see above; the code below applies only to the `RandomForestClassifier`). \n",
    "\n",
    "Be conservative with the number of combinations you choose to begin with until you get an idea of how long each model takes to fit (e.g. start with a grid of just one or two parameter combinations and work from there). Bear in mind that the combinations multiply quickly and runtimes can become large."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': [10, 100, 200], 'gamma': [5e-05, 0.0001, 'auto', 'scale']}\n"
     ]
    }
   ],
   "source": [
    "## Number of trees in random forest\n",
    "#n_estimators = [10]\n",
    "#\n",
    "## Number of features to consider at every split\n",
    "#max_features = [\"auto\"]  # \"sqrt\"\n",
    "#\n",
    "## Maximum number of levels in tree\n",
    "#max_depth = [2, 6, 10, 20]\n",
    "#\n",
    "## Create the random grid\n",
    "#random_grid = {\n",
    "#    \"max_features\": max_features,\n",
    "#    \"max_depth\": max_depth,\n",
    "#    \"n_estimators\": n_estimators,\n",
    "#}\n",
    "\n",
    "C = [10, 100, 200]\n",
    "gamma = [0.00005, 0.0001, 'auto', 'scale']\n",
    "random_grid = {\n",
    "    \"C\": C,\n",
    "    \"gamma\": gamma,\n",
    "}\n",
    "\n",
    "pprint(random_grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3. Train model\n",
    "\n",
    "The code below trains the model multiple times, exploring the hyperparameter grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 12 candidates, totalling 120 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.8/site-packages/sklearn/model_selection/_search.py:278: UserWarning: The total space of parameters 12 is smaller than n_iter=50. Running 12 iterations. For exhaustive searches, use GridSearchCV.\n",
      "  warnings.warn(\n",
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  25 tasks      | elapsed:   27.4s\n",
      "[Parallel(n_jobs=-1)]: Done 120 out of 120 | elapsed:  1.8min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2.16 s, sys: 121 ms, total: 2.28 s\n",
      "Wall time: 1min 52s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RandomizedSearchCV(cv=10, estimator=SVC(), n_iter=50, n_jobs=-1,\n",
       "                   param_distributions={'C': [10, 100, 200],\n",
       "                                        'gamma': [5e-05, 0.0001, 'auto',\n",
       "                                                  'scale']},\n",
       "                   random_state=42, verbose=2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Random search of parameters, using cross-validation,\n",
    "model_random = RandomizedSearchCV(\n",
    "    estimator=model,\n",
    "    param_distributions=random_grid,\n",
    "    n_iter=50,\n",
    "    cv=n_folds,\n",
    "    verbose=2,\n",
    "    random_state=seed,\n",
    "    n_jobs=-1,\n",
    ")\n",
    "\n",
    "# Fit the random search model\n",
    "model_random.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4. Evaluate model\n",
    "\n",
    "The code below picks the \"best\" model from among the ones specified in your hyperparameter grid and makes predictions for the testing dataset. **Make a note of the \"best\" hyperparameter values for each model**, so you can use them again later.\n",
    "\n",
    "The code also prints model skill statistics. It's probably a good idea to modify this to **save the output for each model**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 'best' model identified has the following parameters:\n",
      "\n",
      "SVC(C=200, gamma=5e-05) \n",
      "\n",
      "CPU times: user 791 ms, sys: 1.12 ms, total: 792 ms\n",
      "Wall time: 791 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Predict classes for the evaluation data using the 'best' model found\n",
    "best = model_random.best_estimator_\n",
    "best_preds = best.predict(X_eval)\n",
    "\n",
    "print(\"The 'best' model identified has the following parameters:\\n\")\n",
    "print(best, \"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report:\n",
      "                        precision    recall  f1-score   support\n",
      "\n",
      "           Brown algae       0.94      0.95      0.95      3921\n",
      "           Green algae       0.54      0.35      0.42        84\n",
      "             Red algae       0.82      0.20      0.33        44\n",
      "                  Rock       0.86      0.94      0.90      3416\n",
      "                  Sand       0.86      0.88      0.87      1234\n",
      "                Lichen       0.71      0.41      0.52        58\n",
      "Terrestrial vegetation       0.87      0.80      0.83       652\n",
      "         Beach/shingle       0.82      0.54      0.65       591\n",
      "\n",
      "              accuracy                           0.89     10000\n",
      "             macro avg       0.80      0.63      0.68     10000\n",
      "          weighted avg       0.89      0.89      0.89     10000\n",
      "\n",
      "Classification accuracy: 0.892400\n"
     ]
    }
   ],
   "source": [
    "# Skill summary\n",
    "# Only use relevant labels from the training dataset\n",
    "class_labels = [1, 2, 3, 5, 6, 7, 9, 10]\n",
    "class_names = [class_codes[i] for i in class_labels]\n",
    "\n",
    "utils.classification_report(\n",
    "    y_eval,\n",
    "    best_preds,\n",
    "    class_labels,\n",
    "    class_names,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tidy up to save memory\n",
    "del model, model_random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Compare multiple models\n",
    "\n",
    "Section 3 should give a good idea of which hyperparameters work best for each algorithm. In this section, you can take the best model of each kind and compare them against one another.\n",
    "\n",
    "At present, the code below uses the **default** hyperparameters for each model (except for the random forest, which we've already worked with and therefore know something about). Where possible, I've setup **parallel processing** (by setting `n_jobs=1`), but note that not all algorithms support this.\n",
    "\n",
    "Ideally, you should set the hyperparameters for each of the models below in a similar way, based on your results above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting RandomForestClassifier(max_depth=20, n_estimators=10, n_jobs=-1)\n",
      "    Cross-validating...\n",
      "    Refitting and predicting test image...\n",
      "Fitting SVC(C=200, gamma=5e-05)\n",
      "    Cross-validating...\n",
      "    Refitting and predicting test image...\n",
      "Done.\n"
     ]
    },
    {
     "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>accuracy</th>\n",
       "      <th>train_time_per_fold_s</th>\n",
       "      <th>pred_time_s</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>SVC</th>\n",
       "      <td>0.8894</td>\n",
       "      <td>0.414523</td>\n",
       "      <td>1050.339782</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RF</th>\n",
       "      <td>0.8644</td>\n",
       "      <td>0.037790</td>\n",
       "      <td>7.524469</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       accuracy  train_time_per_fold_s  pred_time_s\n",
       "model                                              \n",
       "SVC      0.8894               0.414523  1050.339782\n",
       "RF       0.8644               0.037790     7.524469"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Prepare models\n",
    "models = []\n",
    "#models.append((\"LogReg\", LogisticRegression(n_jobs=-1)))\n",
    "#models.append((\"RidReg\", RidgeClassifier()))\n",
    "#models.append((\"LDA\", LinearDiscriminantAnalysis()))\n",
    "#models.append((\"KNN\", KNeighborsClassifier(n_jobs=-1)))\n",
    "#models.append((\"CART\", DecisionTreeClassifier()))\n",
    "models.append((\"RF\", RandomForestClassifier(max_depth=20, n_estimators=10, n_jobs=-1)))\n",
    "#models.append((\"NB\", GaussianNB()))\n",
    "models.append(('SVC', SVC(C=200, gamma=5e-05)))\n",
    "\n",
    "# Containers for results\n",
    "df_list = []\n",
    "pred_img_dict = {\"Manual\": man_img}\n",
    "\n",
    "# Evaluate each model in turn\n",
    "for name, model in models:\n",
    "    print(f\"Fitting {model}\")\n",
    "    print(\"    Cross-validating...\")\n",
    "    start = time.time()\n",
    "    kfold = model_selection.KFold(\n",
    "        n_splits=n_folds,\n",
    "        random_state=seed,\n",
    "        shuffle=True,\n",
    "    )\n",
    "    cv_results = model_selection.cross_val_score(\n",
    "        model, X_train, y_train, cv=kfold, scoring=metric, n_jobs=-1\n",
    "    )\n",
    "    mid = time.time()\n",
    "\n",
    "    # Fit the model to the full training dataset and then predict 'final' test image\n",
    "    print(\"    Refitting and predicting test image...\")\n",
    "    model.fit(X_train, y_train)\n",
    "    pred_img = model.predict(pred_df).reshape(man_img.shape)\n",
    "    pred_img[man_img == 0] = 0\n",
    "    pred_img_dict[name] = pred_img\n",
    "    end = time.time()\n",
    "\n",
    "    # Build results dataframe\n",
    "    res_df = pd.DataFrame(\n",
    "        {\n",
    "            \"model\": name,\n",
    "            \"fold\": range(1, n_folds + 1),\n",
    "            metric: cv_results,\n",
    "            \"train_time_per_fold_s\": (mid - start) / n_folds,\n",
    "            \"pred_time_s\": (end - mid),\n",
    "        }\n",
    "    )\n",
    "    df_list.append(res_df)\n",
    "\n",
    "print(\"Done.\")\n",
    "\n",
    "res_df = pd.concat(df_list, axis=\"rows\")\n",
    "avg_df = (\n",
    "    res_df.groupby(\"model\")\n",
    "    .mean()\n",
    "    .sort_values(metric, ascending=False)[\n",
    "        [\"accuracy\", \"train_time_per_fold_s\", \"pred_time_s\"]\n",
    "    ]\n",
    ")\n",
    "avg_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Boxplots of skill\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n",
    "sn.boxplot(data=res_df, x=\"model\", y=metric, ax=ax, order=avg_df.index)\n",
    "_ = ax.set_title(\"Algorithm skill comparison\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note the log y-axis on the bar plot below - KNN is *very* slow to predict!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Prediction speed\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n",
    "sn.barplot(\n",
    "    data=avg_df,\n",
    "    x=avg_df.index,\n",
    "    y=\"pred_time_s\",\n",
    "    ax=ax,\n",
    "    order=avg_df.sort_values(\"pred_time_s\").index,\n",
    ")\n",
    "_ = ax.set_title(\"Algorithm prediciton speed\")\n",
    "ax.set_yscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare images predicted by each algorithm\n",
    "fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(15, 15))\n",
    "axes = axes.flatten()\n",
    "fig.delaxes(axes[-1])\n",
    "\n",
    "for idx, name in enumerate([\"Manual\"] + list(avg_df.index)):\n",
    "    img = axes[idx].imshow(\n",
    "        pred_img_dict[name], cmap=cmap, norm=norm, interpolation=\"none\"\n",
    "    )\n",
    "    axes[idx].set_title(name, fontsize=12)\n",
    "    axes[idx].axis(\"off\")\n",
    "    \n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output above compares the performance of the seven different models. It is also interesting to note **how long it takes to fit each model** (see the table above). This is important because we have a lot of data available in the full images (tens of millions of pixels) and we want to be able to use it effectively. If an algorithm is already slow here fitting just two million samples, it is unlikely to scale well to the larger dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Time versus performance\n",
    "\n",
    "We can view performance in two ways: model skill (e.g. accuracy) and computational speed. Different algorithms scale differently with the number of data samples, so it's worth exploring this further. The code below repeats the analysis above but for a range of different dataset sizes.\n",
    "\n",
    "**This will take a long time to run (several hours)!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train size: 50000.0\n",
      "    Fitting LogisticRegression(n_jobs=-1)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-2792da6ecec9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     40\u001b[0m             \u001b[0mshuffle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m         )\n\u001b[0;32m---> 42\u001b[0;31m         cv_results = model_selection.cross_val_score(\n\u001b[0m\u001b[1;32m     43\u001b[0m             \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkfold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     44\u001b[0m         )\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36minner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     70\u001b[0m                           FutureWarning)\n\u001b[1;32m     71\u001b[0m         \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     73\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0minner_f\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/sklearn/model_selection/_validation.py\u001b[0m in \u001b[0;36mcross_val_score\u001b[0;34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, error_score)\u001b[0m\n\u001b[1;32m    399\u001b[0m     \u001b[0mscorer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_scoring\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mscoring\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    400\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 401\u001b[0;31m     cv_results = cross_validate(estimator=estimator, X=X, y=y, groups=groups,\n\u001b[0m\u001b[1;32m    402\u001b[0m                                 \u001b[0mscoring\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'score'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mscorer\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcv\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    403\u001b[0m                                 \u001b[0mn_jobs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mn_jobs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36minner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     70\u001b[0m                           FutureWarning)\n\u001b[1;32m     71\u001b[0m         \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0marg\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     73\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0minner_f\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/sklearn/model_selection/_validation.py\u001b[0m in \u001b[0;36mcross_validate\u001b[0;34m(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, return_train_score, return_estimator, error_score)\u001b[0m\n\u001b[1;32m    240\u001b[0m     parallel = Parallel(n_jobs=n_jobs, verbose=verbose,\n\u001b[1;32m    241\u001b[0m                         pre_dispatch=pre_dispatch)\n\u001b[0;32m--> 242\u001b[0;31m     scores = parallel(\n\u001b[0m\u001b[1;32m    243\u001b[0m         delayed(_fit_and_score)(\n\u001b[1;32m    244\u001b[0m             \u001b[0mclone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscorers\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/joblib/parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1040\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1041\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretrieval_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1042\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mretrieve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1043\u001b[0m             \u001b[0;31m# Make sure that we get a last message telling us we are done\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1044\u001b[0m             \u001b[0melapsed_time\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_start_time\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/joblib/parallel.py\u001b[0m in \u001b[0;36mretrieve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    919\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    920\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'supports_timeout'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 921\u001b[0;31m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    922\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    923\u001b[0m                     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_output\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/site-packages/joblib/_parallel_backends.py\u001b[0m in \u001b[0;36mwrap_future_result\u001b[0;34m(future, timeout)\u001b[0m\n\u001b[1;32m    540\u001b[0m         AsyncResults.get from multiprocessing.\"\"\"\n\u001b[1;32m    541\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 542\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfuture\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    543\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mCfTimeoutError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    544\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/concurrent/futures/_base.py\u001b[0m in \u001b[0;36mresult\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    432\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__get_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    433\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 434\u001b[0;31m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_condition\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    435\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    436\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mCANCELLED\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCANCELLED_AND_NOTIFIED\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.8/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    300\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    301\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 302\u001b[0;31m                 \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    303\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    304\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Number of CV folds\n",
    "n_folds = 50\n",
    "\n",
    "# Train sizes\n",
    "train_sizes = [50e3, 200e3, 500e3, 1e6, 1.5e6, 2e6, 3e6]\n",
    "\n",
    "# Container for results\n",
    "df_list = []\n",
    "\n",
    "# Prepare models\n",
    "models = []\n",
    "models.append((\"LogReg\", LogisticRegression(n_jobs=-1)))\n",
    "models.append((\"RidReg\", RidgeClassifier()))\n",
    "models.append((\"LDA\", LinearDiscriminantAnalysis()))\n",
    "models.append((\"KNN\", KNeighborsClassifier(n_jobs=-1)))\n",
    "models.append((\"CART\", DecisionTreeClassifier()))\n",
    "models.append((\"RF\", RandomForestClassifier(max_depth=20, n_estimators=10, n_jobs=-1)))\n",
    "models.append((\"NB\", GaussianNB()))\n",
    "\n",
    "for train_size in train_sizes:\n",
    "    print(f\"Train size: {train_size}\")\n",
    "    # Split into training and evaluation\n",
    "    cols = [str(i) for i in range(1, 9)]\n",
    "    X_train, X_eval, y_train, y_eval = train_test_split(\n",
    "        df[cols],\n",
    "        df[\"y\"],\n",
    "        train_size=int(train_size),\n",
    "        test_size=int(train_size),\n",
    "        random_state=seed,\n",
    "        shuffle=True,\n",
    "    )\n",
    "\n",
    "    # Evaluate each model in turn\n",
    "    for name, model in models:\n",
    "        print(f\"    Fitting {model}\")\n",
    "        start = time.time()\n",
    "        kfold = model_selection.KFold(\n",
    "            n_splits=n_folds,\n",
    "            random_state=seed,\n",
    "            shuffle=True,\n",
    "        )\n",
    "        cv_results = model_selection.cross_val_score(\n",
    "            model, X_train, y_train, cv=kfold, scoring=metric, n_jobs=-1\n",
    "        )\n",
    "        end = time.time()\n",
    "\n",
    "        # Build results dataframe\n",
    "        res_df = pd.DataFrame(\n",
    "            {\n",
    "                \"model\": name,\n",
    "                \"n_samples\": len(X_train),\n",
    "                \"fold\": range(1, n_folds + 1),\n",
    "                metric: cv_results,\n",
    "                \"train_time_per_fold_s\": (end - start) / n_folds,\n",
    "            }\n",
    "        )\n",
    "        df_list.append(res_df)\n",
    "\n",
    "print(\"Done.\")\n",
    "\n",
    "res_df = pd.concat(df_list, axis=\"rows\")\n",
    "res_df.to_csv(r\"../results/model_comparison.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_df = res_df.groupby([\"model\", \"n_samples\"]).mean().reset_index()\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n",
    "sn.lineplot(\n",
    "    data=time_df,\n",
    "    x=\"n_samples\",\n",
    "    y=\"train_time_per_fold_s\",\n",
    "    hue=\"model\",\n",
    "    marker=\"o\",\n",
    "    markersize=10,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the average scores for the largest training dataset\n",
    "max_n_samples = res_df[\"n_samples\"].max()\n",
    "avg_df = res_df.query(\"n_samples == @max_n_samples\")\n",
    "avg_df = (\n",
    "    avg_df.groupby(\"model\")\n",
    "    .mean()[[metric, \"train_time_per_fold_s\"]]\n",
    "    .sort_values(metric, ascending=False)\n",
    ")\n",
    "avg_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boxplots over all training dataset sizes\n",
    "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n",
    "sn.boxplot(data=res_df, x=\"model\", y=metric, ax=ax, order=avg_df.index)\n",
    "_ = ax.set_title(\"Algorithm Comparison\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I haven't done much experimenting with this myself yet, but my inital impression is that the `RandomForestClassifier` and the `KNeighborsClassifier` consistently provide good accuracy and computational performance. As the dataset size grows, I would expect the performance of the random forest to scale better than the KNN algorithm, but it will be interesting to see what you find.\n",
    "\n",
    "**Good luck! :-)**"
   ]
  }
 ],
 "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": 4
}