notebooks/deep-learning/3.train-test-diabetes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training vs validation loss\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/parrt/fundamentals-of-deep-learning/blob/main/notebooks/3.train-test-diabetes.ipynb)\n",
    "\n",
    "By [Terence Parr](https://explained.ai).\n",
    "\n",
    "This notebook explores how to use a validation set to estimate how well a model generalizes from its training data to unknown test vectors. We will see that deep learning models often have so many parameters that we can drive training loss to zero, but unfortunately the validation loss usually grows as the model overfits. We will also compare how deep learning performs compared to a random forest model as a baseline.  Instead of the cars data set, we will use the [diabetes data set](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) loaded via sklearn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Support code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import torch\n",
    "import copy\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import load_diabetes\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import colors\n",
    "\n",
    "! pip install -q -U colour\n",
    "import colour\n",
    "\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import tsensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history, ax=None, maxy=None, file=None):\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots(1,1, figsize=(3.5,3))\n",
    "    ax.set_ylabel(\"Loss\")\n",
    "    ax.set_xlabel(\"Epochs\")\n",
    "    loss = history[:,0]\n",
    "    val_loss = history[:,1]\n",
    "    if maxy:\n",
    "        ax.set_ylim(0,maxy)\n",
    "    else:\n",
    "        ax.set_ylim(0,torch.max(val_loss))\n",
    "    ax.spines['top'].set_visible(False)    # turns off the top \"spine\" completely\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_linewidth(.5)\n",
    "    ax.spines['bottom'].set_linewidth(.5)\n",
    "    ax.plot(loss, label='train_loss')\n",
    "    ax.plot(val_loss, label='val_loss')\n",
    "    ax.legend(loc='upper right')\n",
    "    plt.tight_layout()\n",
    "    if file:\n",
    "#         plt.savefig(f\"/Users/{os.environ['USER']}/Desktop/{file}.pdf\")\n",
    "        plt.savefig(f\"{os.environ['HOME']}/{file}.pdf\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load diabetes data set\n",
    "\n",
    "From [sklearn diabetes data set](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset):\n",
    "\"<i>Ten baseline variables, age, sex, body mass index, average blood pressure, and six blood serum measurements were obtained for each of n = 442 diabetes patients, as well as the response of interest, a quantitative measure of disease progression one year after baseline.</i>\"\n",
    "\n",
    "So, the goal is to predict disease progression based upon all of these features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "442"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = load_diabetes()\n",
    "len(d.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>age</th>\n",
       "      <th>sex</th>\n",
       "      <th>bmi</th>\n",
       "      <th>bp</th>\n",
       "      <th>s1</th>\n",
       "      <th>s2</th>\n",
       "      <th>s3</th>\n",
       "      <th>s4</th>\n",
       "      <th>s5</th>\n",
       "      <th>s6</th>\n",
       "      <th>disease</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.038076</td>\n",
       "      <td>0.050680</td>\n",
       "      <td>0.061696</td>\n",
       "      <td>0.021872</td>\n",
       "      <td>-0.044223</td>\n",
       "      <td>-0.034821</td>\n",
       "      <td>-0.043401</td>\n",
       "      <td>-0.002592</td>\n",
       "      <td>0.019908</td>\n",
       "      <td>-0.017646</td>\n",
       "      <td>151.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.001882</td>\n",
       "      <td>-0.044642</td>\n",
       "      <td>-0.051474</td>\n",
       "      <td>-0.026328</td>\n",
       "      <td>-0.008449</td>\n",
       "      <td>-0.019163</td>\n",
       "      <td>0.074412</td>\n",
       "      <td>-0.039493</td>\n",
       "      <td>-0.068330</td>\n",
       "      <td>-0.092204</td>\n",
       "      <td>75.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.085299</td>\n",
       "      <td>0.050680</td>\n",
       "      <td>0.044451</td>\n",
       "      <td>-0.005671</td>\n",
       "      <td>-0.045599</td>\n",
       "      <td>-0.034194</td>\n",
       "      <td>-0.032356</td>\n",
       "      <td>-0.002592</td>\n",
       "      <td>0.002864</td>\n",
       "      <td>-0.025930</td>\n",
       "      <td>141.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        age       sex       bmi        bp        s1        s2        s3  \\\n",
       "0  0.038076  0.050680  0.061696  0.021872 -0.044223 -0.034821 -0.043401   \n",
       "1 -0.001882 -0.044642 -0.051474 -0.026328 -0.008449 -0.019163  0.074412   \n",
       "2  0.085299  0.050680  0.044451 -0.005671 -0.045599 -0.034194 -0.032356   \n",
       "\n",
       "         s4        s5        s6  disease  \n",
       "0 -0.002592  0.019908 -0.017646    151.0  \n",
       "1 -0.039493 -0.068330 -0.092204     75.0  \n",
       "2 -0.002592  0.002864 -0.025930    141.0  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame(d.data, columns=d.feature_names)\n",
    "df['disease'] = d.target # \"quantitative measure of disease progression one year after baseline\"\n",
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split data into train, validation sets\n",
    "\n",
    "Any sufficiently powerful model is able to effectively drive down the training loss (error). What we really care about, though, is how well the model generalizes. That means we have to look at the validation or test error, computed from records the model was not trained on. (We'll use \"test\" as shorthand for \"validation\" often, but technically they are not the same.)  For non-time-sensitive data sets, we can simply randomize and hold out 20% of our data as our validation set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1) # set a random seed for consistency across runs\n",
    "n = len(df)\n",
    "X = df.drop('disease',axis=1).values\n",
    "y = df['disease'].values\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20) # hold out 20%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(442, 353, 89)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X), len(X_train), len(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also make sure to normalize the data to make training easier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = np.mean(X_train,axis=0)\n",
    "std = np.std(X_train,axis=0)\n",
    "X_train = (X_train-m)/std\n",
    "X_test = (X_test-m)/std       # use training data only when prepping test sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline with random forest\n",
    "\n",
    "When building machine learning models, it's always important to ask how good your model is. One of the best ways is to choose a baseline model, such as a random forest or a linear regression model, and compare your new model to make sure it can beat the old model.  Random forests are easy to use, understand, and train so they are a good baseline.  Training the model is as simple as calling `fit()` (`min_samples_leaf=20` gives a bit more generality):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestRegressor(min_samples_leaf=20, n_jobs=-1)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, min_samples_leaf=20)\n",
    "rf.fit(X_train, y_train.reshape(-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To evaluate our models, let's compute the mean squared error (MSE) for both training and validation sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training MSE 2533.91 validation MSE 3473.22\n"
     ]
    }
   ],
   "source": [
    "y_pred = rf.predict(X_train)\n",
    "mse = np.mean((y_pred - y_train.reshape(-1))**2)\n",
    "\n",
    "y_pred_test = rf.predict(X_test)\n",
    "mse_test = np.mean((y_pred_test - y_test.reshape(-1))**2)\n",
    "\n",
    "print(f\"Training MSE {mse:.2f} validation MSE {mse_test:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check $R^2$ as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5828071244691921, 0.34823877952411497)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf.score(X_train, y_train), rf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Why is the validation error much larger than the training error?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    Because the model was trained on the training set, one would expect it to generally perform better on it than any other data set.  The more the validation error diverges from the training error, the less general you should assume your model is.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train neural network model\n",
    "\n",
    "Ok, so now we have a baseline and an understanding of how well a decent model performs on this data set. Let's see if we can beat that baseline with a neural network. First we will see how easy it is to drive the training error down and then show how the validation error is not usually very good in that case.  We will finish by considering ways to get better validation errors, which means more general models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Most basic network training\n",
    "\n",
    "A basic training loop for a neural network model simply measures and tracks the training loss or error/metric. (In this case, our loss and metric are the same.)  The following function embodies such a training loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train0(model, X_train, y_train,\n",
    "          learning_rate = .5, nepochs=2000):\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "    for epoch in range(nepochs+1):\n",
    "        y_pred = model(X_train)\n",
    "        loss = torch.mean((y_pred - y_train)**2)\n",
    "        if epoch % (nepochs//10) == 0:\n",
    "            print(f\"Epoch {epoch:4d} MSE train loss {loss:12.3f}\")\n",
    "            \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward() # autograd computes w1.grad, b1.grad, ...\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use this method, we have to convert the training and validation data sets to pytorch tensors from numpy (they are already normalized):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = torch.tensor(X_train).float()\n",
    "X_test = torch.tensor(X_test).float()\n",
    "y_train = torch.tensor(y_train).float().reshape(-1,1) # column vector\n",
    "y_test = torch.tensor(y_test).float().reshape(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a model with one hidden layer and an output layer, glued together with a ReLU nonlinearity.  The network looks something like the following except of course we have many more input features and neurons than shown here:\n",
    "\n",
    "<img src=\"images/diabetes-relu.png\" width=\"300\">\n",
    "\n",
    "There is an implied input layer which is really just the input vector of features. The output layer takes the output of the hidden layer and generates a single output, our $\\hat{y}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29693.615\n",
      "Epoch  500 MSE train loss      552.236\n",
      "Epoch 1000 MSE train loss       85.343\n",
      "Epoch 1500 MSE train loss       25.167\n",
      "Epoch 2000 MSE train loss      120.147\n",
      "Epoch 2500 MSE train loss        9.741\n",
      "Epoch 3000 MSE train loss       14.483\n",
      "Epoch 3500 MSE train loss        3.674\n",
      "Epoch 4000 MSE train loss       13.071\n",
      "Epoch 4500 MSE train loss        1.539\n",
      "Epoch 5000 MSE train loss        1.087\n"
     ]
    }
   ],
   "source": [
    "ncols = X.shape[1]\n",
    "n_neurons = 150\n",
    "\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(ncols, n_neurons), # hidden layer\n",
    "    nn.ReLU(),                   # nonlinearity\n",
    "    nn.Linear(n_neurons, 1)      # output layer\n",
    ")\n",
    "\n",
    "train0(model, X_train, y_train, learning_rate=.08, nepochs=5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this a few times and you'll see that we can drive the training error very close to zero with 150 neurons and many iterations (epochs).  Compare this to the RF training MSE which is orders of magnitude bigger (partly due to the `min_samples_leaf` hyperparameter)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Why does the training loss sometimes pop up and then go back down? Why is it not monotonically decreasing?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "    The only source of randomness is the initialization of the model parameters, but that does not explain the lack of monotonicity. In this situation, it is likely that the learning rate is too high and therefore, as we approach the minimum of the lost function, our steps are too big. We are jumping back and forth across the location of the minimum in parameter space.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Change the learning rate from 0.08 to 0.001 and rerun the example.  What happens to the training loss?  Is it better or worse than the baseline random forest and the model trained with learning rate 0.08?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "     The training loss continues to decrease but much lower than before and stops long before reaching a loss near zero. On the other hand, it is better than the training error from the baseline random forest.\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Reducing the learning rate to zero in on the minimum\n",
    "\n",
    "In one of the above exercises we discussed that the learning rate was probably too high in the vicinity of the lost function minimum.  There are ways to throttle the learning rate down as we approach the minimum, but we are using a fixed learning rate here. In order to get a smooth, monotonic reduction in loss function let's start with a smaller learning rate, but that means increasing the number of epochs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29626.404\n",
      "Epoch 1500 MSE train loss     1588.800\n",
      "Epoch 3000 MSE train loss      264.717\n",
      "Epoch 4500 MSE train loss       64.575\n",
      "Epoch 6000 MSE train loss       17.353\n",
      "Epoch 7500 MSE train loss        6.367\n",
      "Epoch 9000 MSE train loss        2.682\n",
      "Epoch 10500 MSE train loss        0.691\n",
      "Epoch 12000 MSE train loss        0.700\n",
      "Epoch 13500 MSE train loss        0.190\n",
      "Epoch 15000 MSE train loss        0.067\n"
     ]
    }
   ],
   "source": [
    "ncols = X.shape[1]\n",
    "n_neurons = 150\n",
    "\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(ncols, n_neurons), # hidden layer\n",
    "    nn.ReLU(),                   # nonlinearity\n",
    "    nn.Linear(n_neurons, 1)      # output layer\n",
    ")\n",
    "\n",
    "train0(model, X_train, y_train, learning_rate=.017, nepochs=15000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice now that we can reliably drive that training error down to zero without bouncing around, although it takes longer with the smaller learning rate."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Play around with the learning rate and nepochs to see how fast you can reliably get MSE down to 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tracking validation loss\n",
    "\n",
    "A low training error doesn't really tell us that much, other than the model is able to capture the relationship between the features and the target variable. What we really want is a general model, which means evaluating the model's performance on a validation set. We have both sets, so let's now track the training and validation error in the loop. We will see that our model performs much worse on the records in the validation set (on which the model was not trained)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train1(model, X_train, X_test, y_train, y_test,\n",
    "           learning_rate = .5, nepochs=2000):\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "    history = [] # track training and validation loss\n",
    "    for epoch in range(nepochs+1):\n",
    "        y_pred = model(X_train)\n",
    "        loss = torch.mean((y_pred - y_train)**2)\n",
    "        y_pred_test = model(X_test)\n",
    "        loss_test = torch.mean((y_pred_test - y_test)**2)\n",
    "        history.append((loss, loss_test))\n",
    "        if epoch % (nepochs//10) == 0:\n",
    "            print(f\"Epoch {epoch:4d} MSE train loss {loss:12.3f}   test loss {loss_test:12.3f}\")\n",
    "            \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward() # autograd computes w1.grad, b1.grad, ...\n",
    "        optimizer.step()\n",
    "    return torch.tensor(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create the exact same model that we had before but plot train/validation errors against the number of epochs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29654.730   test loss    27063.545\n",
      "Epoch  800 MSE train loss     1841.183   test loss     3583.445\n",
      "Epoch 1600 MSE train loss      806.315   test loss     5304.467\n",
      "Epoch 2400 MSE train loss      286.301   test loss     7847.571\n",
      "Epoch 3200 MSE train loss       98.467   test loss     9669.961\n",
      "Epoch 4000 MSE train loss       29.252   test loss    11196.380\n",
      "Epoch 4800 MSE train loss        9.511   test loss    11814.456\n",
      "Epoch 5600 MSE train loss        4.533   test loss    12238.104\n",
      "Epoch 6400 MSE train loss        1.763   test loss    12479.471\n",
      "Epoch 7200 MSE train loss       16.615   test loss    12586.157\n",
      "Epoch 8000 MSE train loss        0.282   test loss    12712.996\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 207,
       "width": 245
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ncols = X.shape[1]\n",
    "n_neurons = 150\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(ncols, n_neurons),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(n_neurons, 1)\n",
    ")\n",
    "\n",
    "history = train1(model, X_train, X_test, y_train, y_test,\n",
    "                 learning_rate=.02, nepochs=8000)\n",
    "\n",
    "plot_history(torch.clamp(history, 0, 12000), file=\"train-test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow. The validation error is much much worse than the training error, which is almost 0. That tells us that the model is severely overfit to the training data and is not general at all. Well, the validation error actually makes a lot of progress initially but then after a few thousand epochs immediately starts to grow (we'll use this fact later).  Unless we do something fancier, the best solution can be obtained by selecting the model parameters that gives us the lowest validation loss."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Track best loss and choose best model\n",
    "\n",
    "We saw in the previous section that the most general model appears fairly soon in the training cycle. So, despite being able to drive the training error to zero if we keep going long enough, the most general model actually is known very early in the training process. This is not always the case, but it certainly is here for this data. Let's exploit this by tracking the best model, the one with the lowest validation error. There is [some indication](https://moultano.wordpress.com/2020/10/18/why-deep-learning-works-even-though-it-shouldnt/) that a good approach is to (sometimes crank up the power of the model and then) just stop early, or at least pick the model with the lowest validation error. The following function embodies that by making a copy of our neural net model when it finds an improved version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train2(model, X_train, X_test, y_train, y_test,\n",
    "           learning_rate = .5, nepochs=2000, weight_decay=0):\n",
    "    optimizer = torch.optim.Adam(model.parameters(),\n",
    "                                 lr=learning_rate, weight_decay=weight_decay)\n",
    "    history = [] # track training and validation loss\n",
    "    best_loss = 1e10\n",
    "    best_model = None\n",
    "    for epoch in range(nepochs+1):\n",
    "        y_pred = model(X_train)\n",
    "        loss = torch.mean((y_pred - y_train)**2)\n",
    "\n",
    "        y_pred_test = model(X_test)\n",
    "        loss_test = torch.mean((y_pred_test - y_test)**2)\n",
    "        history.append((loss, loss_test))\n",
    "        if loss_test < best_loss:\n",
    "            best_loss = loss_test\n",
    "            best_model = copy.deepcopy(model)\n",
    "            best_epoch = epoch\n",
    "        if epoch % (nepochs//10) == 0:\n",
    "            print(f\"Epoch {epoch:4d} MSE train loss {loss:12.3f}   test loss {loss_test:12.3f}\")\n",
    "            \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward() # autograd computes w1.grad, b1.grad, ...\n",
    "        optimizer.step()\n",
    "    print(f\"BEST MSE test loss {best_loss:.3f} at epoch {best_epoch}\")\n",
    "    return torch.tensor(history), best_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the exact same model and learning rate with no weight decay and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29607.461   test loss    27006.693\n",
      "Epoch  100 MSE train loss     2629.585   test loss     3087.739\n",
      "Epoch  200 MSE train loss     2384.102   test loss     3186.564\n",
      "Epoch  300 MSE train loss     2285.357   test loss     3230.039\n",
      "Epoch  400 MSE train loss     2208.642   test loss     3257.470\n",
      "Epoch  500 MSE train loss     2133.422   test loss     3275.208\n",
      "Epoch  600 MSE train loss     2077.234   test loss     3265.872\n",
      "Epoch  700 MSE train loss     2031.759   test loss     3267.592\n",
      "Epoch  800 MSE train loss     1977.212   test loss     3271.320\n",
      "Epoch  900 MSE train loss     1920.043   test loss     3249.735\n",
      "Epoch 1000 MSE train loss     1870.694   test loss     3281.241\n",
      "BEST MSE test loss 3071.237 at epoch 90\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 252x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 207,
       "width": 245
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ncols = X.shape[1]\n",
    "n_neurons = 150\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(ncols, n_neurons),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(n_neurons, 1)\n",
    ")\n",
    "\n",
    "history, best_model = train2(model, X_train, X_test, y_train, y_test,\n",
    "                             learning_rate=.02, nepochs=1000,\n",
    "                             weight_decay=0)\n",
    "\n",
    "# verify we got the best model out\n",
    "y_pred = best_model(X_test)\n",
    "loss_test = torch.mean((y_pred - y_test)**2)\n",
    "\n",
    "plot_history(torch.clamp(history, 0, 12000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also look at $R^2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5560047640093306, 0.42367165211276536)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = best_model(X_train).detach().numpy()\n",
    "y_pred_test = best_model(X_test).detach().numpy()\n",
    "\n",
    "r2_score(y_train, y_pred), r2_score(y_test, y_pred_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best MSE bounces around a loss value of 3000 from run to run, a bit above it or a bit below, depending on the run.  And this decent result occurs without having to understand or use weight decay (more on this next).  Compare the validation R^2 to that of the RF; the network does much better!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weight decay to reduce overfitting\n",
    "\n",
    "Other than stopping early, one of the most common ways to reduce model overfitting is to use weight decay, otherwise known as L2 (Ridge) regression, to constrain the model parameters. Without constraints, model parameters can get very large, which typically leads to a lack of generality.  Using the `Adam` optimizer, we turn on weight decay with parameter `weight_decay`, but otherwise the training loop is the same:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train3(model, X_train, X_test, y_train, y_test,\n",
    "           learning_rate = .5, nepochs=2000, weight_decay=0, trace=True):\n",
    "    optimizer = torch.optim.Adam(model.parameters(),\n",
    "                                 lr=learning_rate, weight_decay=weight_decay)\n",
    "    history = [] # track training and validation loss\n",
    "    for epoch in range(nepochs+1):\n",
    "        y_pred = model(X_train)\n",
    "        loss = torch.mean((y_pred - y_train)**2)\n",
    "\n",
    "        y_pred_test = model(X_test)\n",
    "        loss_test = torch.mean((y_pred_test - y_test)**2)\n",
    "        history.append((loss, loss_test))\n",
    "        if trace and epoch % (nepochs//10) == 0:\n",
    "            print(f\"Epoch {epoch:4d} MSE train loss {loss:12.3f}   test loss {loss_test:12.3f}\")\n",
    "            \n",
    "        optimizer.zero_grad()\n",
    "        loss.backward() # autograd computes w1.grad, b1.grad, ...\n",
    "        optimizer.step()\n",
    "    return torch.tensor(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we know what the right value of the weight decay is?  Typically we try a variety of weight decay values and then see which one gives us the best validation error, so let's do that using a grid of images.  The following loop uses the same network and learning rate for each run but varies the weight decay:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x180 with 4 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 171,
       "width": 892
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ncols = X.shape[1]\n",
    "n_neurons = 150\n",
    "\n",
    "fig, axes = plt.subplots(1, 4, figsize=(12.5,2.5))\n",
    "\n",
    "for wd,ax in zip([0,.3,.6,1.5],axes):\n",
    "    model = nn.Sequential(\n",
    "        nn.Linear(ncols, n_neurons),\n",
    "        nn.ReLU(),\n",
    "        nn.Linear(n_neurons, 1)\n",
    "    )\n",
    "    history = train3(model, X_train, X_test, y_train, y_test,\n",
    "                     learning_rate=.05, nepochs=1000, weight_decay=wd,\n",
    "                     trace=False)\n",
    "    mse_valid = history[-1][1]\n",
    "    ax.set_title(f\"wd={wd:.1f}, valid MSE {mse_valid:.0f}\")\n",
    "    plot_history(torch.clamp(history, 0, 10000), ax=ax, maxy=10_000)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From this experiment, we can conclude that a weight decay of 1.5 gives the best final mean squared error. But, the experiment is reporting the final MSE all the way on the right side of the graph. \n",
    "\n",
    "The minimum MSE in the above experiment (of four side-by-side graphs), however, appears before the right edge and the validation error simply gets worse after that. That tells us that we should not pick the parameters simply as the parameters where the training leaves off. We should pick the model parameters that give the minimum loss, as we did before."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "Set the weight decay to something huge like 100. What do you observe about the training and validation curves?\n",
    "\n",
    "<details>\n",
    "<summary>Solution</summary>\n",
    "\n",
    "The two curves are flat, and about the same level.  The minimum validation error is about 6000 so much worse than with more reasonable weight decay. We have seriously biased the model because we cannot even drive the training error downwards. The bias comes from the extreme constraint we've placed on the model parameters.\n",
    "    \n",
    "<pre>\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(ncols, n_neurons),\n",
    "    nn.ReLU(),\n",
    "    nn.Linear(n_neurons, 1)\n",
    ")\n",
    "history = train2(model, X_train, X_test, y_train, y_test,\n",
    "                 learning_rate=.05, nepochs=1000, weight_decay=100,\n",
    "                 trace=False)\n",
    "mse_valid = history[-1][1]\n",
    "ax.set_title(f\"wd={wd:.1f}, valid MSE {mse_valid:.0f}\")\n",
    "plot_history(torch.clamp(history, 0, 10000), ax=ax, maxy=10_000)\n",
    "</pre>\n",
    "</details>"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}