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": 42,
   "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": 43,
   "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "442"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = load_diabetes()\n",
    "len(d.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "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": 45,
     "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": 46,
   "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": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(442, 353, 89)"
      ]
     },
     "execution_count": 47,
     "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": 48,
   "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": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestRegressor(min_samples_leaf=20, n_jobs=-1)"
      ]
     },
     "execution_count": 50,
     "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": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training MSE 2504.44 validation MSE 3519.29\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": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5876587105627167, 0.3395926375554863)"
      ]
     },
     "execution_count": 52,
     "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": 53,
   "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": 54,
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29523.111\n",
      "Epoch  500 MSE train loss      408.056\n",
      "Epoch 1000 MSE train loss       55.792\n",
      "Epoch 1500 MSE train loss       65.796\n",
      "Epoch 2000 MSE train loss       22.513\n",
      "Epoch 2500 MSE train loss       62.795\n",
      "Epoch 3000 MSE train loss       26.895\n",
      "Epoch 3500 MSE train loss        3.796\n",
      "Epoch 4000 MSE train loss        8.120\n",
      "Epoch 4500 MSE train loss        0.897\n",
      "Epoch 5000 MSE train loss        2.180\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": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29629.543\n",
      "Epoch 1500 MSE train loss     1147.990\n",
      "Epoch 3000 MSE train loss      255.365\n",
      "Epoch 4500 MSE train loss       32.298\n",
      "Epoch 6000 MSE train loss        6.595\n",
      "Epoch 7500 MSE train loss        1.272\n",
      "Epoch 9000 MSE train loss        0.922\n",
      "Epoch 10500 MSE train loss        0.680\n",
      "Epoch 12000 MSE train loss        1.055\n",
      "Epoch 13500 MSE train loss        0.187\n",
      "Epoch 15000 MSE train loss       18.345\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": 57,
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29548.420   test loss    26950.088\n",
      "Epoch  800 MSE train loss     2098.554   test loss     3177.844\n",
      "Epoch 1600 MSE train loss     1233.612   test loss     4570.043\n",
      "Epoch 2400 MSE train loss      213.282   test loss     6235.141\n",
      "Epoch 3200 MSE train loss       47.369   test loss     7547.466\n",
      "Epoch 4000 MSE train loss       14.170   test loss     8242.722\n",
      "Epoch 4800 MSE train loss        4.326   test loss     8422.316\n",
      "Epoch 5600 MSE train loss        2.142   test loss     8585.063\n",
      "Epoch 6400 MSE train loss        1.264   test loss     8703.910\n",
      "Epoch 7200 MSE train loss        0.660   test loss     8760.495\n",
      "Epoch 8000 MSE train loss        0.209   test loss     8813.763\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": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train2(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",
    "    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": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29648.459   test loss    27044.287\n",
      "Epoch  800 MSE train loss     2123.568   test loss     3208.119\n",
      "Epoch 1600 MSE train loss      706.206   test loss     5947.452\n",
      "Epoch 2400 MSE train loss      217.245   test loss     7589.392\n",
      "Epoch 3200 MSE train loss      103.856   test loss     8635.430\n",
      "Epoch 4000 MSE train loss       61.184   test loss     8631.894\n",
      "Epoch 4800 MSE train loss       27.290   test loss     9191.044\n",
      "Epoch 5600 MSE train loss       14.697   test loss     9428.932\n",
      "Epoch 6400 MSE train loss        7.880   test loss     9469.983\n",
      "Epoch 7200 MSE train loss        2.657   test loss     9715.653\n",
      "Epoch 8000 MSE train loss        1.879   test loss     9891.595\n",
      "BEST MSE test loss 3086.961 at epoch 115\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=8000)\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": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5788013440965045, 0.42072098442137273)"
      ]
     },
     "execution_count": 61,
     "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": 62,
   "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": 41,
   "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=8000, 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
}