notebooks/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 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": 65,
   "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",
    "import colour\n",
    "\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import tsensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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\")"
   ]
  },
  {
   "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": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "442"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = load_diabetes()\n",
    "len(d.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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": 36,
     "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": 37,
   "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": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(442, 353, 89)"
      ]
     },
     "execution_count": 38,
     "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": 39,
   "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.  Don't worry about the details of using sklearn to train the random forest regressor, just assume it is a powerful and efficient model. Training the model is as simple as calling `fit()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestRegressor(n_estimators=500)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf = RandomForestRegressor(n_estimators=500)#, min_samples_leaf=2, max_features=1)\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": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training MSE 443.77 validation MSE 3745.30\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": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9269354185671265, 0.297181470721385)"
      ]
     },
     "execution_count": 43,
     "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": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train0(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",
    "    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": 45,
   "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 then 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": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29584.062\n",
      "Epoch  500 MSE train loss      492.858\n",
      "Epoch 1000 MSE train loss      159.819\n",
      "Epoch 1500 MSE train loss       75.240\n",
      "Epoch 2000 MSE train loss       39.704\n",
      "Epoch 2500 MSE train loss      213.632\n",
      "Epoch 3000 MSE train loss       12.191\n",
      "Epoch 3500 MSE train loss       20.866\n",
      "Epoch 4000 MSE train loss        7.563\n",
      "Epoch 4500 MSE train loss        3.197\n",
      "Epoch 5000 MSE train loss        2.332\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, X_test, y_train, y_test, 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)."
   ]
  },
  {
   "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": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29548.352\n",
      "Epoch  800 MSE train loss     2101.343\n",
      "Epoch 1600 MSE train loss     1091.825\n",
      "Epoch 2400 MSE train loss      308.611\n",
      "Epoch 3200 MSE train loss       70.748\n",
      "Epoch 4000 MSE train loss       26.113\n",
      "Epoch 4800 MSE train loss       10.978\n",
      "Epoch 5600 MSE train loss        4.934\n",
      "Epoch 6400 MSE train loss        2.993\n",
      "Epoch 7200 MSE train loss        4.263\n",
      "Epoch 8000 MSE train loss        1.385\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, X_test, y_train, y_test, learning_rate=.02, nepochs=8000)"
   ]
  },
  {
   "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": [
    "### 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": 63,
   "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:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29603.037   test loss    26998.922\n",
      "Epoch  800 MSE train loss     2133.840   test loss     3174.325\n",
      "Epoch 1600 MSE train loss     1423.420   test loss     4316.454\n",
      "Epoch 2400 MSE train loss      375.720   test loss     7257.883\n",
      "Epoch 3200 MSE train loss      120.477   test loss     9051.368\n",
      "Epoch 4000 MSE train loss       57.527   test loss    10240.634\n",
      "Epoch 4800 MSE train loss       31.486   test loss    10784.966\n",
      "Epoch 5600 MSE train loss       16.044   test loss    11113.780\n",
      "Epoch 6400 MSE train loss        8.490   test loss    11283.872\n",
      "Epoch 7200 MSE train loss        6.594   test loss    11503.454\n",
      "Epoch 8000 MSE train loss        3.513   test loss    11644.484\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 some indication 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": 15,
   "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": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch    0 MSE train loss    29565.133   test loss    26969.477\n",
      "Epoch  100 MSE train loss     2626.783   test loss     3094.345\n",
      "Epoch  200 MSE train loss     2373.439   test loss     3144.432\n",
      "Epoch  300 MSE train loss     2289.213   test loss     3189.719\n",
      "Epoch  400 MSE train loss     2234.759   test loss     3224.917\n",
      "Epoch  500 MSE train loss     2191.735   test loss     3252.248\n",
      "Epoch  600 MSE train loss     2160.511   test loss     3270.010\n",
      "Epoch  700 MSE train loss     2137.964   test loss     3254.622\n",
      "Epoch  800 MSE train loss     2120.482   test loss     3231.413\n",
      "Epoch  900 MSE train loss     2089.598   test loss     3249.099\n",
      "Epoch 1000 MSE train loss     1962.712   test loss     3460.817\n",
      "BEST MSE test loss 3085.759 at epoch 117\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAGfCAYAAACQgpFIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAABYlAAAWJQFJUiTwAABSJklEQVR4nO3deZyVZf3/8dfnnFkZGGBABBFF3NHKNRVcEK2fuW+FaYqZ3/JbVqbftNQCy/ayMivb3DKXotTcTQUBMRWXNEHcwAVBRLZh9pnz+f1x32fmnsOZ5cycM+fMzPv5eJzHfc51X9e9HA7zPte9XMfcHRERESlMsXxvgIiIiHRMQS0iIlLAFNQiIiIFTEEtIiJSwBTUIiIiBUxBLSIiUsAU1CIiIgVMQS0iIlLAFNQiIiIFTEEtIiJSwBTUIiIiBUxBLSIiUsAU1CIiIgVMQS0iIlLA+l1Qm9mpZvYrM1tgZpvMzM3s5g7q7mxml5jZo2b2tpk1mtl7ZnaXmR3exXpmmtlTZrbZzDaa2TwzO7aT+uVmdoWZLTOzejNbY2Z/NbPdO2mzrZldZ2bvmlmDma0ws1+Y2cjuvyMiIjKQWX/7PWozex74CLAZeAfYDfiLu38mTd3bgBnAEmAhsA7YFTgeiANfdfer07T7KXBRuPw5QAlwGlAFfNndr0mpXwo8AkwFFgOPAhOATwKNwHR3fzKlzY7AImAMcBfwMvBR4HBgGTDV3T/I6M0REZEBpz8G9eEEAfoacBgwl46D+mzgP+7+XEr5YcC/AAcmuvuqyLwpwOPA68D+7r4+LJ8IPANUALu5+4pIm28C3ycI9RnungjLTwDuJPii8KFkeTjvQeDjwFfc/VeR8quArwG/c/fzMn6DRERkQOl3h77dfa67v+rd+Ibh7jekhnRY/hgwj6CnPCVldjIcv5cM6bDNCuDXQCnw2WS5mVmkzcXRMHb3u4AFwGSCLxXJNpMIQjq5zKhZQA1wpplVdLWPIiIysPW7oM6ipnDanFI+PZw+kKbN/Sl1AHYEtgNecffl3WyTfP5QNNgB3L2aoEc/BDiww60XEZFBYVAGtZltDxwB1ALzI+UVwHhgc/RweMSr4XSXSNmu4fSVDlaXrTYiIjIIFeV7A/paeOHXXwgOYV8cPbwNDA+nGztoniwfkYc2aZnZMx3Nc/d9u2ovIiKFbVAFtZnFgT8TXJ19O/DTHi4qkyvwrI/abLkQs+6cyt/Cv3/zPxy45q+d1rl16Fl8+v9+1WkdEZFBwrqu0nODJqjDkL6Z4JapvwKfSZNiyZ7scNJL1xPuqk1lltqk1Vmv2cx6FPRbT/s8z787fYvystfuZbfVdwfPEzU9WbSIiGRoUAS1mRUBtxCE9C3AWe7eklrP3WvMbCUw3szGpTlPvXM4jZ5bXhZOOzqfnK02fWaHyfvD5P23KH+r5X0Ig7o8UdvXmyUiMigN+IvJzKyE4P7mTwI3AWemC+mIR8PpUWnmfSKlDgT3W78F7GJmO3Szzdxw+nEza/dvYGbDCA7N1wH/7mQ7+5yXVrY+H6IetYhInxjQQR1eOHYHcALwJ+CzqbdDpXFtOL0sOpRnOODJl4AG4PpkeXj4PNnmx9HgDQc8OYRgwJPHIm1eBx4CksuMuoJgUJWb3L2g0lBBLSLS9/rdoW8zOxE4MXw5NpweZGY3hM/Xuvv/hc+vBY4G1gIrgW8H45O0M8/d5yVfuPuicHSwC4EXzCw5hOgM2oYQXZGyjKuAY4FTgSfN7BGCe6s/SXAL2DlpviB8kWAI0avN7AhgKXAAwRCirwCXdf1u9LHitvFXSrw+jxsiIjJ49LugBvYCZqaUTQofAG8CyaBOHooeDXy7k2XOi75w94vM7AXgfODzQAJ4FviJu9+T2tjdG8zsSOAbwOkEQ4BuIhg+dJa7L0nT5nUz2w/4DsFh9qOBVcDVwBXuvq6T7c2LeDze+jxGVwcmREQkG/rdWN/SfT29Pasj77wwj23/cQIAS2K7MPnbT2dt2SIi/VhOb88a0OeoJbss3nYARj1qEZG+0R8PfUuexGJth76ty2vyRLonkUiwbt06qquraWhoQEf5JF/MjNLSUoYNG0ZVVRWxWGH0ZRXU0m2xdueoO7vDTaR7EokEb7/9NrW1ui9f8s/dqa+vp76+npqaGiZMmFAQYa2glm6L6dC3ZNm6deuora2lqKiIsWPHUlFRURB/GGVwSiQS1NTUsHr1ampra1m3bh2jR4/O92bpHLV0XzSo452OGSPSPdXV1QCMHTuWYcOGKaQlr2KxGMOGDWPs2ODO3+TnM9/0v0K6LRZTj1qyq6GhAYCKioouaor0neTnMfn5zDcFtXSb7qOWbEteOKaetBSS5MBYhXJho/53SLe1uz1LV32LyACVZgTLvFJQS7fFdTGZiEifU1BLt7W7mEy3Z4mI9AkFtXRbvCga1OpRi/RXs2fPxsyYN29en6xvxYoVmBlnn312n6xvoFFQS7fFddW3SE4oyKQzCmrptljKVd+JRGFcESkimTn//PNZunQpH/3oR/O9KdINGplMui8y1ncRCVrcieX2R2NEJAdGjx5dECNuSfeoRy3dF2t/jrpFPWqRXps9ezY77LADADfeeCNm1vq44YYbmDdvHmbG7NmzeeqppzjmmGOoqqrCzFixYgUAc+fO5fOf/zyTJ0+msrKS8vJy9txzT6644grq6+vTrjPdOWozY9q0aaxdu5bPf/7zjBs3jtLSUvbYYw+uv/76nOz/qlWr+NKXvsTEiRMpKSlhq6224uSTT+aZZ57Zom5jYyNXX301++yzDyNHjmTIkCFMnDiRE044gYcffrhd3QULFnDcccex7bbbUlpaytixYznwwAO54oorcrIfuaQetXSftT/03VQggwGI9GfTpk1jw4YN/PKXv+QjH/kIJ554Yuu8vfbaiw0bNgDwxBNP8IMf/ICDDz6Yc845h7Vr11JSUgLAj370I15++WWmTJnCMcccQ319PY8//jizZ89m3rx5PPzww+0GLOrMhg0bmDp1KiUlJZx66qnU19czZ84czjnnHGKxGDNnzszavi9fvpyDDz6Yd999l+nTp/PpT3+at99+m7/97W/ce++9/P3vf+fYY49trX/22Wdz6623sueee3LWWWdRXl7Ou+++y8KFC3nggQc48sgjAXjggQc45phjqKys5Pjjj2f8+PGsW7eOpUuX8pvf/IZZs2ZlbR/6hLvrMUAfwT9vFrU0u8+qdJ9V6S3fHu6b6hqzu3wZdJYsWeJLlizJ92bk3fLlyx3wmTNnbjFv7ty5Djjg1157bdr2r7/+uicSiS3KL7/8cgf8tttua1c+a9YsB3zu3LntypPr+dznPufNzc2t5S+99JLH43HffffdM98573j/Pv7xjzvgV155Zbvyxx9/3OPxuFdVVXl1dbW7u2/YsMHNzPfdd99225a0du3a1ucnn3yyA/78889vUe/999/v1jZn+NnM6d9y9ail+6ztTEnMnJaWFqA4f9sjA97Eb9yb703othU/PCany99rr734whe+kHbepEmT0pZfcMEFXHnllTz44IPMmDGjW+sZMmQIV111Vbse+OTJk5k6dSrz58+nurqaYcOGZb4DKd555x0eeughtttuOy6++OJ286ZMmcKnP/1pbr75Zv7xj39w1llnYWa4O6WlpWmHnB01atQWZeXl5VuU9cdz8zpHLd1nRkvk4rGW5uY8bozI4NLZFdo1NTV8//vfZ//992f48OHEYjHMrDWUVq5c2e317LzzzlRWVm5RPmHCBIDWQ/G99dxzzwFwyCGHUFy85Rf+6dOnt6tXWVnJcccdx6JFi9hrr734zne+w9y5c9P+lvkZZ5wBwAEHHMB5553H7bffzjvvvJOV7c4HBbVkpIW2b9ktCQW1SF9J/vRiqqamJqZPn85ll11GfX09M2bM4Jvf/CazZs1qPRebya9AjRgxIm15UTjgUXAkrfc2btwIwLhx49LOT5ZHvxjcfvvtzJo1i7q6OmbNmsX06dMZNWoUZ555Ju+9915rvZNPPpl77rmHvffem+uuu47TTjuNCRMmsN9++/Gvf/0rK9vfl3ToWzKSiHy38yz9hxXpSK4PJ/cnHf1QxF133cVTTz3FzJkzueGGG9rNW7VqVcFe5Tx8+HAAVq9enXb+qlWr2tWD4FD27NmzmT17Nm+//Tbz58/nhhtu4Oabb2bFihUsWLCgte4xxxzDMcccQ01NDU8++ST33HMPv/3tbzn22GN57rnnmDx5cg73LrvUo5aMtEQ+Mtn6Zi0y2CXPB/fk/9Rrr70GwCmnnLLFvMcee6x3G5ZDe++9NwALFy6kOc1ptLlz5wKwzz77pG0/YcIEzjjjDB588EF23nlnFi5cyAcffLBFvYqKCqZPn85VV13FpZdeSmNjI/fff38W9yT3FNSSkWiPOtGiQ98i2TBy5EjMjLfeeivjthMnTgTY4p7oN954g0suuSQLW5cb2267LR/72MdYsWIFv/jFL9rNe/LJJ7nlllsYOXIkJ510EgDvv/8+Tz755BbLqampobq6mqKiotbb1R555BHq6uq2qJs8PD5kyJAs701u6dC3ZCQRPUetoBbJiqFDh3LAAQewYMECzjjjDHbZZRfi8TjHH398l22PO+44dtppJ6666ipefPFF9t57b9566y3uuecejjnmmB6Ff1+59tprmTp1Kl//+td56KGH2G+//Vrvo47FYlx//fWtV5ivXLmSAw88kN1335199tmHCRMmsGnTJu655x5Wr17NV77ylda6F110EStWrGDatGmtA6k888wzPProo2y//facdtpp+dztjCmoJSMtFgvutEQ9apFs+vOf/8zXvvY1HnjgAW699VbcnW233ba1x9yRiooKHn30Ub7xjW8wb948FixYwKRJk/jWt77FhRdeyO233943O9ADkyZNYvHixVx55ZXcd999zJs3j8rKSo466iguu+wy9t9//9a6EydO5IorrmDevHnMnTuXtWvXUlVVxa677soPf/jDduF76aWXcscdd7B48WIefvhhYrEY2223HZdeeikXXHABI0eOzMfu9pi5a3SpgcrMPNv/vmuv2IHRvg6AN858mkk77pLV5cvgsnTpUgB23333PG+JSHsZfjZz+qMHOkctGXFdTCYi0qcU1JKRhOliMhGRvqRz1JKRdvdRa8ATkUFpxYoVW9yz3ZELLrigw0FUpHsU1JKRhOmqb5HBbsWKFd0eSOXss89WUPeSgloyopHJRGTatGnoQuS+o3PUkhGP9KgTOvQtIpJzCmrJSPtz1OpRi4jkmoJaMuKmQ98iIn1JQS0ZSejQt4hIn1JQS0aiQe266ltEJOcU1JKR6MhkiUQij1siIjI4KKglI64etYhIn1JQS0aih77ROWoRkZzrd0FtZqea2a/MbIGZbTIzN7Obu2gzxczuM7N1ZlZrZi+Y2QVm0dTZos1MM3vKzDab2UYzm2dmx3ZSv9zMrjCzZWZWb2ZrzOyvZtbhT6+Y2bZmdp2ZvWtmDWa2wsx+YWYF+xts0au+E7o9S0Qk5/pdUAOXA+cDewEru6psZicA84FDgTuAXwMlwM+B2zpo81PgBmAc8AfgZuBDwN1mdn6a+qXAv4BvA5uAXwIPAycBi83sgDRtdgSeAT4LPBVuzxvAV4EnzGxUV/uWD96uR62gFukvJk6c2OVvW3dk3rx5mBmzZ8/O6jZJ9/THIUS/BrwDvAYcBsztqKKZVRIEbQswzd0Xh+XfAh4FTjWz09z9tkibKcBFwOvA/u6+Piz/CUGw/tTM7nH3FZFVXQhMBeYAM9w9Eba5HbgTuM7MPpQsD/0GGAN8xd1/FVn/VeE+fg84L7O3pg/o17NERPpUv+tRu/tcd3/VuzfQ7KnAVsBtyZAOl1FP0DMH+N+UNslw/F4ypMM2Kwh646UEvWAAzMwibS6OhrG73wUsACYTfKlItpkEfBxILjNqFlADnGlmFd3Yxz7V7mIy9ahFRHKu3wV1hqaH0wfSzJsP1AJTwkPX3Wlzf0odgB2B7YBX3H15N9sknz+U0svG3auBx4EhwIFplpdXuphMRKRvDfSg3jWcvpI6w92bgeUEh/8nAYQ92PHAZndflWZ5r4bTXbqzjiy3ScvMnuno0VXbHlGPWiTrnnjiCcyMk08+ucM6u+++O6Wlpaxbt47GxkauueYajj76aLbffntKS0upqqriyCOP5P777+9wGbnw6quvctZZZzF+/HhKSkrYZpttOOuss3j11Ve3qFtdXc13v/td9txzTyorKxk2bBg77rgjM2bM4Jln2v/J+uc//8kRRxzBuHHjKC0tZZtttuGwww7jN7/5TV/tWsHoj+eoMzE8nG7sYH6yfEQP6/dlm4LQbqxvBbVIVhx00EHsuuuu3HPPPXzwwQeMGtX+WtKnnnqKl19+mVNOOYWqqipWr17NV7/6VaZMmcLHPvYxttpqK1atWsXdd9/N0UcfzR/+8AfOPffcnG/3008/zZFHHkl1dTXHH388kydP5uWXX+Yvf/kLd911F4888gj77bcfAO7OUUcdxaJFizjooIM499xzKSoq4u2332bevHkccsgh7LvvvgD8/ve/5wtf+AJjx47luOOOY/To0axZs4YXXniB66+/ni9+8Ys537dCMtCDuisWTjP9YdVM6vdkHd1u4+77drgQs+z/YKx61CI5MXPmTC699FJuvfVWzj+//c0lN954Y2sdgJEjR/Lmm2+y7bbbtqu3ceNGpk6dysUXX8wZZ5xBeXl5zrbX3TnrrLPYtGkTN998M2eccUbrvNtvv53TTjuNz3zmMyxZsoRYLMZ///tfFi1axIknnsgdd9zRblmJRIKNG9v6Lb/73e8oKSnhP//5D2PGjGlXd+3atTnbp0I10IM6+S8/vIP5lSn1uqqfriec6Tp62qYgeExBLX1odkf/RQrQ7N79dz3zzDO5/PLLufHGG9sFdWNjI7fddhtjxozhE5/4BAClpaVbhDTA8OHDOeecc7jooot4+umnOfTQQ3u1TZ1ZtGgRL7/8MgcddFC7kAaYMWMG11xzDQsXLmThwoXttiPdl4dYLMbIke2HjygqKqK4uHiLuqNHj87SHvQfA/0c9bJwusW5XjMrAnYAmgnuX8bdawjuzR5qZuPSLG/ncBo9t9zhOrLcpjDoYjKRnNh222054ogjWLx4MUuWLGktv/vuu1m3bh1nnHEGRUVtfauXXnqJs88+m0mTJlFeXo6ZYWZcdNFFAKxc2eUwE73y7LPPAjB9+vS085Plzz33HACTJ09mr7324tZbb2Xq1Kn8+Mc/ZtGiRTQ2Nm7R9owzzqC2tpY99tiDr33ta9x55528//77OdqTwjfQg/rRcHpUmnmHElxZvcjdG7rZ5hMpdSC43/otYBcz26GbbZL3fn/czNr9G5jZMIJ7suuAf6dZXl5Fe9Qa8EQku84++2yg7VB39HnysDfAv//9b/bff39uueUWdt11V77whS/wrW99i1mzZnHCCScA0NAQ/bOWfclD1ePGpevTtJVv2LABgHg8zqOPPsoFF1zAW2+9xSWXXMLUqVMZPXo0X/7yl9m8eXNr2wsvvJAbb7yR7bbbjquvvpqTTjqJrbfemsMPP5zFixenW93A5u799gFMIziPe3MH8yuB94EGYL9IeRmwKGx7WkqbKWH5a8DISPlE4AOgHpiY0uabYZu/AbFI+Qlh+UvR8nDeg+G8L6eUXxWWX5uF98ez7dnffNZ9VqX7rEqf9+crs758GVyWLFniS5YsyfdmFIza2lqvrKz0bbbZxpubm33NmjVeVFTkH/nIR9rVO+aYYxzwuXPnbrGM73//+w749ddf3658++239+23375H2zV37lwHfNasWa1lV199tQN++eWXp23z7W9/2wH/+c9/nnb+q6++6n/84x99//33d8A/85nPpK23fv16v/fee/3cc8/1WCzmVVVV/t577/VoPzKR4Wczp1nX785Rm9mJwInhy7Hh9CAzuyF8vtbd/w/A3TeZ2f8QjBg2z8xuA9YBxxPcIjUHuD26fHdfFI4OdiHwgpnNIRhydAZQRRCsK1I26yrgWIIBVp40s0cI7q3+JMG92ud4yv3SwBcJvixcbWZHAEuBA4DDCQ55X5bRG9NXdNW3SM6Ul5fzqU99ij/+8Y88/PDDLF26lObm5na9aYDXXnuNqqoqpk2btsUyHnvssT7Z1r333hsIhhdNJ1m+zz77pJ2/0047sdNOO3H66aczZswY7rrrrrT1RowYwdFHH83RRx9NIpHguuuuY8GCBZxyyim93of+oj8e+t4LmBk+/l9YNilSdmq0srvfSTAq2HzgFODLQBNBEJ/mvuUIZ+5+EXA2sBr4PHAWQa/4OHe/Jk39BuBI4DsEt1R9DfgYwfCh+7v7k2navA7sRzCm+AEEw5buCFwNHOTuH3T9VuSBDn2L5FTy8PdNN93ETTfdRFFR0RYXa02cOJF169bxwgsvtCv/05/+xIMPPtgn2zl16lR23XVXFi5cyJw5c9rNmzNnDvPnz2eXXXbh4IMPBmD58uW89NJLWyxn/fr1NDQ0tLvI7IEHHqC5ectrYNasWQPAkCFDsrkrBa/f9ajdfTYwO8M2jwNHZ9jmRuDGLiu21a8jGP5zVgZt3iYyHGl/4Bb5yOhiMpGsmzp1KjvttBN/+9vfaGpq4rjjjtviFqULLriABx98kIMPPphPfepTDB8+nMWLF7Nw4UJOPfXULYIzF8yMG2+8kY997GPMmDGDE044gd12241ly5Zx5513MmzYMG666SZisaA/+J///IeTTjqJfffdlz333JNtttmG999/n7vuuoumpiYuueSS1mWfdtpplJWVcfDBBzNx4kTcnQULFvD000+z7777cuSRR+Z8/wpJf+xRSz5Fb8/a4mi+iGTDzJkzaWpqan2e6qijjuLuu+9m8uTJ3H777fzpT3+itLSUuXPncswxx/TZdh5wwAE8/fTTnH766TzxxBP85Cc/YdGiRXz605/m6aef5oAD2n44cL/99uOb3/wmpaWlPPDAA/zsZz/j/vvvZ9999+W+++7jwgsvbK37wx/+kIMOOohnn32W3/zmN1x//fU0NTXxox/9iLlz56a9bWsgszRHfmWAMLN0R/Z75bnrLmDvt64HYN74LzDtf36c1eXL4LJ06VIgGB5TpJBk+Nm0rqv0nHrUkhmdoxYR6VMKaslMNKhdQS0ikmv97mIyybNY5CPjuphMpD96/vnnufPOO7tVd/bs2TndFumagloy024IUV1MJtIfPf/881xxxRXdqqugzj8d+paMWOTQt+nQt0i/dPbZZ2cywqHkmYJaMhNTj1pEpC8pqCUj6lGLiPQtBbVkxOLRi8kU1CIy8BTaIX8FtWQmcjGZ6T5q6SWzYJyIhE6jSAFJBnXy85lvCmrJiA59SzaVlpYCUFNTk+ctEWmT/DwmP5/5pqCWjFg8OuCJekHSO8OGDQNg9erVVFdXk0gkCu6wowwO7k4ikaC6uprVq1cDbZ/PfNN91JIRi/x6lnrU0ltVVVXU1NRQW1vLO++8k+/NEWk1ZMgQqqqq8r0ZgIJaMhS9mExBLb0Vi8WYMGEC69ato7q6moaGBvWoJW/MjNLSUoYNG0ZVVVXrT3Tmm4JaMqJz1JJtsViM0aNHM3r06HxvikhBKoyvC9JvRM9Rm85Ri4jknIJaMmKmHrWISF9SUEtGYpFz1DEFtYhIzimoJSPtLiZDh75FRHJNQS0ZsXhx63P1qEVEck9BLRmJHvqOe3Met0REZHBQUEtG1KMWEelbCmrJSLugRkEtIpJrCmrJiA59i4j0LQW1ZCRW1NajjqtHLSKScwpqyUgspnPUIiJ9SUEtGYkVtx36LlKPWkQk5xTUkpFYvKTtuXrUIiI5p6CWjER/lEPnqEVEck9BLRmJF7X1qIvQVd8iIrmmoJaMxOPRq7411reISK4pqCUjVhS9j1qHvkVEck1BLRkpanfoW0EtIpJrCmrJSCzao1ZQi4jknIJaMtL+HLWCWkQk1xTUkpF4ZAjREmvBE7qgTEQklxTUkhGLxWlxa33d0qJetYhILg2aoDazY8zsITN7x8zqzOwNM/ubmR3UQf0pZnafma0zs1oze8HMLjCzeLr6YZuZZvaUmW02s41mNs/Mju2kfrmZXWFmy8ys3szWmNlfzWz3bOxzrrTQ9hY0NzflcUtERAa+QRHUZvYj4B5gH+AB4JfAs8AJwONm9pmU+icA84FDgTuAXwMlwM+B2zpYx0+BG4BxwB+Am4EPAXeb2flp6pcC/wK+DWwKt+lh4CRgsZkd0Jt9zqXmSFA3NTXkcUtERAY+c/d8b0NOmdlYYCXwPvBhd18TmXc48Ciw3N0nhWWVwGvAcGCquy8Oy8vCugcBn3b32yLLmQI8DrwO7O/u68PyicAzQAWwm7uviLT5JvB9YA4ww90TYfkJwJ3AEuBDyfIe7rvn4t930+xxVFILwMavvMbwqq2yvg4RkX7Euq7Sc4OhR709wX4+GQ1pAHefC1QD0aQ5NXx9WzKkw7r1wOXhy/9NWcd54fR7yZAO26wg6I2XAp9NlpuZRdpcHA1jd78LWABMBg7LZEf7SqJdj1qHvkVEcmkwBPWrQCPwUTMbHZ1hZocCwwgOOSdND6cPpFnWfKAWmBIeuu5Om/tT6gDsCGwHvOLuy7vZpmBED323NDfmcUtERAa+oq6r9G/uvs7MLgGuApaY2Z3ABwRheTzBeeIvRJrsGk5fSbOsZjNbDuwBTAKWmlkFMB7Y7O6r0mzCq+F0l+6so5M2aZnZM13VybaWdkGtHrWISC4N+KAGcPdfmNkK4DrgfyKzXgNuSDkkPjycbuxgccnyET2s39M2BSNhcQhPfeuqbxGR3BoUQW1mFxNcuHU1cA2wGtgN+AHwFzPby90v7u7iwmmmV2llUr/b63D3fTtciFlOrhRssaLWLVOPWkQktwb8OWozmwb8CPinu1/o7m+4e627P0twK9RK4CIzmxQ2SfZmh2+xsEBlSr2u6qfrPWe6joKiQ98iIn1nwAc1kBxwZG7qDHevBZ4ieB/2DouXhdMtzg+bWRGwA9AMvBEuo4Yg7Iea2bg06985nEbPR3e4jk7aFIxEZMyXhIJaRCSnBkNQJ6/O7uhm32R58vLlR8PpUWnqHgoMARa5e3Skj87afCKlDgT3W78F7GJmO3SzTcFIWNsZE/WoRURyazAE9YJw+nkzGx+dYWafAKYC9cCisHgOsBY4zcz2i9QtA64MX/42ZR3XhtPLzGxkpM1E4EtAA3B9sjwchSTZ5sdmFou0OQE4hGDAk8cy2dG+Eu1RK6hFRHJrMFxMNofgPukjCW6nuoPgYrLdCQ6LG/ANd/8AwN03mdn/hO3mmdltwDqCW7l2Dctvj67A3ReZ2VXAhcALZjaHYMjRGUAV8OXoqGShq8L1nwo8aWaPENxb/UmCe7XP6c2oZLnUEulRJ1oU1CIiuTTgg9rdE2Z2NEHP9jSCC8iGEITvfcDV7v5QSps7zeww4DLgFKCM4FauC8P6W1xN7e4XmdkLwPnA54EEwXjiP3H3e9LUbzCzI4FvAKcDXyMY8/tOYJa7L8nC7ueE6xy1iEifGfBjfQ9muRrr+6UfTmOP+ucAePaw69nn8JOzvg4RkX5EY31LYUm0O/TdnMctEREZ+BTUkrlY5NC3zlGLiOSUgloyFu1Re7N61CIiuaSglowlYsVtz1saOqkpIiK9paCWjLm1BTU69C0iklMKaslYIl7S9qJZPWoRkVxSUEvGEjEFtYhIX1FQS8ai56itpbGTmiIi0lsKasmYRw59u4JaRCSnFNSSMY+Xtj5Xj1pEJLcU1JIxj+vQt4hIX1FQS+Yih74toaAWEcklBbVkTIe+RUT6joJaMhe56jumoBYRySkFtWSuqK1HHdOhbxGRnFJQS+aK2s5RK6hFRHJLQS0Zs3i0R62xvkVEcklBLRmzdj1qBbWISC4pqCVjseK2HnVch75FRHJKQS0Zi5eUtz7XOWoRkdxSUEvGiorbDn3HXYe+RURySUEtGYsXl7U91zlqEZGcUlBLxopLIkHtOvQtIpJLCmrJWFFJ28VkRTr0LSKSUwpqyVhxaVuPusib87glIiIDn4JaMlZS2nbVt3rUIiK5ldWgNrORZjbZzEpTyj9rZneZ2S1m9tFsrlP6XnHk0HcxCmoRkVwqyvLyvg98BhiTLDCzLwO/ACwsOtHM9nP3JVlet/SRkrKK1udl3gDuYNZJCxER6alsH/qeCjzi7nWRsv8DVgKHAp8Kyy7M8nqlD5WVl9PocQCKLIE31XXRQkREeirbQT0eWJ58YWaTgQnAr9x9obvPAe4mCG3pp0qL4tTQdp66sW5THrdGRGRgy3ZQlwP1kddTAQcejpS9ThDo0o/VWltQ11VvzOOWiIgMbNkO6pXAbpHX/w/YBPwnUjYS0LHSfq4+EtT1NQpqEZFcyfbFZHOBmWZ2PkHP+njg7+6eiNTZCXg7y+uVPlYfGwItwfPGWh36FhHJlWz3qH8AbAZ+CfyeIKxnJ2ea2RjgMGBRltcrfawh1nblt4JaRCR3stqjdvflZrYHcGpY9E93fytSZXvg18At2Vyv9L2moiEkb6FuUlCLiORMtg994+6rgWs6mPc08HS21yl9L1Fc0XqlQV3Nhrxui4jIQJb1oE7HzEYDhwC1wMPu3tIX65XciZUNCy4TBBo2q0ctIpIr2R5C9H/N7Ekzq4qU7QssBeYA9wGLzKyio2VI/xAvq2x9/sTSN2lsTnRSW0REeirbF5PNANzd10XKfkJwS9b1BEG9P3BeltfbLWZ2iJn93cxWmVlDOH3IzI5OU3eKmd1nZuvMrNbMXjCzC8ws3snyZ5rZU2a22cw2mtk8Mzu2k/rlZnaFmS0zs3ozW2NmfzWz3bO1z7kyZNjw1ucVVsf371uax60RERm4sh3UOwMvJF+Eh7wPA/7k7ue6+3EE56hPz/J6u2RmlwPzCUZFewD4GcEoaSOBaSl1T4jUvYPgArgS4OfAbR0s/6fADcA44A/AzcCHgLvD29VS65cC/wK+TXAQ+ZcEA8OcBCw2swN6sbs5t924rVufD6eGu55fibvncYtERAambJ+jHgWsibyeGk7viJQtAM7O8no7ZWafBL5LEIQnu3t1yvziyPNKgqBtAaa5++Kw/FvAo8CpZnaau98WaTMFuIhg1LX93X19WP4T4Bngp2Z2j7uviKz2QoL3Zw4wI3mvuZndDtwJXGdmH0q5B71gDB09ofX5WFvP+tomVm+qZ9zw8k5aiYhIprLdo14HjI68PgxI0P6+aQfKsrzeDplZDPgRwYVsp6eGNIB7ux9VPhXYCrgtGdJhnXrg8vDl/6YsInko/3vJkA7brCDojZcCn41sk0XaXBwNY3e/i+DLzGSC968wVW7T+nSsBWc63lmvAedERLIt20G9FDjOzEaZ2QiCc9ZPu3v0suCJwOosr7czU4AdCM6PrzezY8zsEjP7qpkdlKb+9HD6QJp58wkCf0rKb2531ub+lDoAOwLbAa+4+/Itm6RtU1gqt219uo19AMB7m+o7qi0iIj2U7UPfvyQ4bPsO0AwMAS5JzgwvxDqYvh2ZbP9w+h7wLMF541ZmNh841d3fD4t2DaevpC7I3ZvNbDmwBzAJWBpewT4e2Ozuq9Ks/9VwukukrMN1dNImLTN7pqs6OVExGuIl0NJIpdVSQR2rNyqoRUSyLas9anf/J8Eh3ZeAZcD/ufvNkSpHEhz2fjCb6+3CmHB6HsGvex0JDAP2DLfjUOBvkfrJy5k7+qWJZPmIHtbvaZvCYrbF4e8NtU2dNBARkZ7IxchkvycY5zvdvAcJrrLuS8nbqYyg55z8Ja+XzOwkgl7tYWZ2kLs/0Y3lWTjN9BLnTOp3ex3uvm+HCzHL7WXYwyfA+hUAbGtr2VSvoBYRybZsn6MuRMmLu96IhDQA7l5HW+/+o+E02ZsdTnqVKfW6qp+u95zpOgrTyO1bn06wNWyqU1CLiGRbToLazA40sz+a2TNm9rqZPWtmfwhvY+pry8Lphg7mJ4M8eV9Rsv4W54fNrIjgwrRm4A0Ad68h+B3uoWY2Ls3ydw6n0fPRHa6jkzaFZ+TE1qfb2Rqq65vzty0iIgNU1oPazK4EHgfOAfYmCLa9gM8BC8zs+9leZxfmEwTrzmZWkmb+nuF0RTh9NJwelabuoQQXyC1y94ZIeWdtPpFSB4L7rd8CdjGzHbrZpvCMbNv07WyNDn2LiORAtsf6/iRwKUEInUtwZXR5OD03LL/EzD6VzfV2xt3XArcTHGb+dsr2fgz4fwSHmJO3Vs0B1gKnmdl+kbplwJXhy9+mrObacHqZmY2MtJkIfAloIBhCNblNHmnz4/Be72SbEwh+wGQJ8Fhme9vH1KMWEck5y+awj+GtTjsDHwoDMnX+aOC/wDJ377PBPMxsDEEvfyeCwUSeIvht7JMILtg63d3/Fql/IkFg1xMMGboOOJ7gtqo5wKc85Y0zs58RjDb2TlinhOA+8lHAl939mpT6pQQ95inAYuARgnurPwk0AtPd/cle7nfqZmbXplVw1W4AvO+VnFB2A4u+eUTu1iciUpis6yo9l+1D3x8B5qQLaWjt3f6N4FB4n3H3NcABBGN1TwC+QjCYyL3AIdGQDuvfSTAq2HzgFODLQBNBEJ+WLv3c/SKCoVFXA58HziK4Te241JAO6zcQ3Cr2HYLbsL4GfIzgPvT9exvSfWLIqNanVVRTU9+Yx40RERmYsn17VhHByF2dqc3BersU/qLXheGjO/UfB7b4Va0u2twI3JhB/TpgVvjof4pK8LIRWP0G4ubE6zfQknDisZx+uRQRGVSy3aN+DTg2es41Kiw/muBiKhkArGKr1uejbBObdZ5aRCSrsh3UtwK7A3eZ2c7RGWa2I8G528nALVler+RLJKhH20Zd+S0ikmXZPgR9FcEtSscAnzCzd4FVwFiC8bBjwMKwngwEFW0/ljaKTdQ0qkctIpJN2R7ru5HggqjLgOXAtgQ/ijEhfH0ZcERYTwaClEPfNQ0KahGRbMrFWN9NwA+AH5jZUIL7lze6+2YI7kc2s/KUn76U/irSo66yTWxuaMnjxoiIDDw5Hevb3Te7+8pkSId+S3BfsgwE5W2/sTKcGvWoRUSyLF8/yqH7dwaKshGtT0fYZjYrqEVEsmow/HqW5FL5iNan6lGLiGSfglp6J3ro2xTUIiLZpqCW3okc+h5OjS4mExHJMgW19I561CIiOaWglt6JnKMewWZqNDKZiEhW9fo+ajPTsc7BrKiUlngZ8ZZ6iixBU311vrdIRGRAyUaP2nrwkAGkuWR463Or35C/DRERGYB63aN2dx0+H+QSpSOg7j0AYg0b8rotIiIDjUJWes0j56njDRvztyEiIgOQglp6zSJBXdyoIdxFRLJJQS29Fh9S1fq8tFk9ahGRbFJQS68VVbTdS13WvAl3z+PWiIgMLApq6bVYpEddSQ11TbpjT0QkWxTU0nvtBj2p0S9oiYhkkYJaei863rfVUKPxvkVEskZBLb0XHe+bzRrvW0QkixTU0nvR36Q2HfoWEckmBbX0XspPXapHLSKSPQpq6b3Ioe8Rtlk9ahGRLFJQS++Vtf0oxzDq9FOXIiJZpKCW3osX0RAbAkDMnKaaDfndHhGRAURBLVlRX9zWq26pWZfHLRERGVgU1JIVTcWVrc+9bn0et0REZGBRUEtWNJe0BTX1G/K2HSIiA42CWrKipbTtyu+YglpEJGsU1JIVHrnyO96gn7oUEckWBbVkhUVGJytqUlCLiGSLglqyIlbR9lOXpU2b8rglIiIDi4JasqJoSNs56rJmBbWISLYoqCUrioe29aiHtCioRUSyRUEtWVFSNaH1+djEe3ncEhGRgWVQBrWZnWlmHj7O7aDOFDO7z8zWmVmtmb1gZheYWbyT5c40s6fMbLOZbTSzeWZ2bCf1y83sCjNbZmb1ZrbGzP5qZrtnYz/7UtnWu7Q+357VNDfrhzlERLJh0AW1mU0AfgVs7qTOCcB84FDgDuDXQAnwc+C2Dtr8FLgBGAf8AbgZ+BBwt5mdn6Z+KfAv4NvAJuCXwMPAScBiMzugRzuYJ7Gho9nAUACGWAMb3nsrz1skIjIwDKqgNjMDrgc+AK7toE4lQdC2ANPc/XPu/nVgL+AJ4FQzOy2lzRTgIuB14MPu/jV3/xKwL7AO+KmZTUxZ1YXAVGAOcIC7X+LupwOnAkOA68ysX/37vBsf3/p888qX8rglIiIDR78Kgiz4CjAd+CxQ00GdU4GtgNvcfXGy0N3rgcvDl/+b0ua8cPo9d18fabOCoDdeGq4TaP3CkGxzsbsnIm3uAhYAk4HDMti3vFtVumPr86onfwqr/5vHrRERGRgGTVCH531/CPzS3ed3UnV6OH0gzbz5QC0wJTx03Z0296fUAdgR2A54xd2Xd7NNwXut6pDW55UfPA+/OxSWd/ZWi4hIVwZFUJtZEfBn4C3g0i6q7xpOX0md4e7NwHKgCJgULrsCGA9sdvdVaZb3ajjdJVLW4To6aZOWmT3T0aOrttm2ZutDmd/yobYCb4GHZ/f1ZoiIDCiDIqgJLtjaGzjb3eu6qJsctLqjcTCT5SN6WL+nbQre6GHlfK7p61zUeF5b4cpnYP2b+dsoEZF+bsAHtZl9lKAX/TN3fyIbiwynnmG7TOp3ex3uvm9Hjwy3r9dGDy2hiSL+njiUJRUfbZux7P6OG4mISKcGdFBHDnm/Anyrm82SvdnhHcyvTKnXVf10vedM19EvbFc1pPX5Y0S+J7zzVB62RkRkYBjQQQ0MJTjPuztQHxnkxIFZYZ0/hGW/CF8vC6dbnB8Og38HoBl4A8Dda4CVwFAzG5dmG3YOp9Hz0R2uo5M2BW/HMUNbn8+tbhupjJV9frpcRGTAKMr3BuRYA/CnDubtQ3DeeiFBcCYPiz8KnAEcBdya0uZQgnuc57t7Q6T8UeDMsM31KW0+EamT9DrBhW27mNkOaa78Ttem4I2qKKGyrIhN9c0817gtXlGKtTTA+hVQsxYqRud7E0VE+p0B3aN29zp3PzfdA/hnWO3GsOz28PUcYC1wmpntl1yWmZUBV4Yvf5uyquTgKZeZ2chIm4nAlwi+MLQGuLt7pM2PowObhKOiHQIsAR7r6b7ng5m19qqbKGLTiMhIqCufzdNWiYj0bwM6qHvC3TcB/wPEgXlm9kcz+zHwPHAQQZDfntJmEXAVwf3RL5jZz83s18BioAr4v3Dwk6irgEUEA6w8aWY/NLNbwuXXAudEB0LpLz6y7YjW568URY7sv6ugFhHpCQV1Gu5+J8GoYPOBU4AvA00Ew36eFvaIU9tcBJwNrAY+D5wFvAQc5+7XpKnfABwJfIfgNqyvAR8D7gT2d/cns7tXfePgndoObz9W3TakKO8+3/cbIyIyAFiazJEBwszSfafIqc0NzezznX/R2JJgZ3uHf5VeHMwYNg4uerlPt0VEpI9Y11V6Tj1qyaqhpUUcukvQq37dt6EpVhbMqF4F1fqdahGRTCmoJeuO/fA2ACSI8YpNapux6vn8bJCISD+moJasO2L3MZQUBR+tpxoi91O/+1yetkhEpP9SUEvWDSsrbr2o7MXEDm0zdEGZiEjGBvqAJ5InU3YcxaMvr+FF16FvESkgtetg9Quw+sXg8f4yaNgEFVvBJ34M2+yV7y3cgoJacmLKjm0XlNVSxhDqgwvK1r0BVZO6aC0i0kvusOFNWBUJ5dUvwqZ30tdf9wZYTi/e7jEFteTEbmOHUVVRwrqaRp5o2Z0j4uH56dfnKqhFJPtqPgh+AOjtp+Cdp2HVf4KeciaGpfu5hvxTUEtOxGLGgZOquO/F1SxM7NkW1Mvug/0/l9+NE5H+zR02vhME8+tz4c3Hgx5xd8RLYevJMPZDMPbDsPUeMGQU1LwPQwrz9wgU1JIzB04axX0vruZfif2YxZ+DwtfnQvVqGDY2vxsnIv1D7TpYswTeWwJrXoI1S4NHd3rL5SODME6G8rgPw6idIZ4m+rbaNfvbniUKasmZgyaNAuAd34pn2J19WQreAk9cAx+/sovW0u+5Q0sTtDSGj3TPm6Cloe15ohkSLcHnJNECnkh53YPy5sZgHc3henqsh+cvLQZFJUFPLl7S9jw5jcWDZZtFpsm2lmZeytRiwXKLy6GoFIrKoagseF5cDvFisHhQr6QCSoZCLI83/LhDUy001kDj5nAaPm/YHPRs16+A98JQ3ry6e8uNl8C4j8C2H4UJH4Vt94PK8QV73jkTCmrJmZ3GDGX00BLWbm7k941H8buSpcGMf/8W9jgZxu+T3w0caBIJaK4P/gg21UJTXfAHsKkueETDqqWx7XnaaUMYcOEj0RwJ1qZOgjfyPNGU73dEOlIyDErDR0lFW5jH4mH4h8FusbAs1v4BwZciTwTB6y2R18nfErIwkKNhHD7IwtDGZSNg6z1hh0Ng0jTYZu/gy8kApLG+B7B8jPWd6ku3PMu9L6zCSPDvrX/M1htfCGYMHQtn3Qljdu+0fb/V0gxNNZGwrG37I9VUC421wfzG2rZ5zQ1BuLU0Bu0TaQKxORqGDWEIh8trrsv3XotkX1FZcFh6zB7B34utJwfPh40tpN5yTjdEQT2AFUJQ3/zvN7n8zv8CcOoOTfz0g/OhsTqYWVwBx18Ne57St//h3INv+fUbw8emMEBTvvU314ePhvbTpvq2eU11YXldUJ4MX/UmA7Hi4JBkPDnt6Hlx8IgVt/XgYvFILy/eg/JYMC1KHnIuC6Y9+az15v+Rt2x51CL6PNECeLgOj6wrtSw6jcz3RPilLfK5TH5em+qCL3WeCI6KJHu4+VZUHh6GDw/Ftz6vgIrRMGwbGLMbjJkc3CUSi+d7i7uioJaeKYSgfmd9LQf/aC4AMYNnzhrCyH+cEQRa0k5HwpQvhxd5lAR/UCwWnF8rHpL+wg/34A9R/YbgYpO6dVtO6zZEwjjl4S19sv99rqgseM+Kh0DJkLb3sDg8bxkvbn9+tDXEotPI/HRBmlxGvBshXDg9HklKtITng6uDL6lNtWGYR8/xpxzSTkQPbbcQnB9PORzeeojcgi8Sngg+g+3COJwWfvBmSkEtPVMIQQ3wqd89wVPL1wFw2dG78z+71MJfz+z+7RQWb7tQJlYc9F4ba4JAL1gW/EFqDcyKcDokUl7Rvk6yxxcrioRiUSRQ0wRiNJSLyvN7kZDI4KWglp4plKC+7am3+MY/XgRg3PAy5n19GqXNm+Hh2bD4erJyYUmmiodA2fDgUVrZ/tBbMjyTvdDoFbTJ50XlkbLStnrJtkWl6k2KDB4KaumZQgnqusYWDvnxXNZubgDg28dO5pyDwx/rWP0iPHNDMJLQplXB4bJYPJgmz/m2XkWaIlYM5SOgvCq4X3JIVfB8yMjgddmIYH5Z8jG87VFUkvP9FpFBQ0EtPVMoQQ3wp4XL+e49SwAYVlbEoxdNY6th3byVoqU5ONzdHN5eVFwenOtS2IpIYchpUOuElvSJzxy4HZNGVwBQXd/MD+5b2v3G8aLgfs+K0TB8fNBzVkiLyCChoJY+UVoU54oT9mh9/Y/nVvLQS90ccUhEZBBTUEufOWTnrTj2w22/TvP1OS/w7gYN0iEi0hkFtfSpK0/ck22GlwGwsa6JL/z5GWoaCvk2KxGR/FJQS58aMaSEqz+9N/FYcO3Fiys3cv4tz9LQPEAHIBER6SUFtfS5/SZW8d0T9mx9PXfZ+5x93dNsrNOwmyIiqRTUkhenH7AdXzp8x9bXT7zxAcf9aiHPv70hfxslIlKAdB/1AFZI91Gn4+789rHX+fEDy1rLimLG+dN34rzDdqSseMCNBywiA5MGPJGeKfSgTrr3hVV84+8vUB25qGyb4WV89cidOXHv8ZQWKbBFpKApqKVn+ktQA7y9rpYLbn+eZ95c3658zLBSzp46kVP22ZatK8vytHUiIp1SUEvP9KegBmhJOLc//TY/e2gZH9Q0tpsXMzh45604ee/xHL7bGIaXF+dpK0VEtqCglp7pb0GdVF3fxF+efIvrFi5nTXXDFvPjMWPf7Ucyfbcx7D+xij3HV+rwuIjkk4Jaeqa/BnVSQ3MLd/9nFXOeeZt/v7Guw3ol8RiTt6lkrwkjmLxNJZPHVbLTmKG6GE1E+oqCWnqmvwd11Dvra7nzuZX8a8l7/OedjV3Wj8eMHbeqYPdxlewwuoLtRw1hu6pgOqqiBNNvRYtI9iiopWcGUlBHramuZ96y9/n36x/w7FvrWfFBbUbtK0ribDOinLHDyxg3vIyxw8sZFz4fNzworywrUpiLSHcpqKVnBmpQp1pX08hzb63nvys3sXTVJpau3sSbGYZ3qiEl8dYgHzOsjFEVJVQNLWFURQmjKkqpGlrC6HBaURJXqIsMbgpq6ZnBEtTpbG5oZtnqTSxbvZk319Xw1ge1vPlBLW+tq2Vzln8EpKQoxuiKEkYMKWF4eTGV5UXBtKw4fB1Mk/Mqy4oZWlZERWkRFSVFreOei0i/paCWnhnMQd0Rd2d9bROrNtaxemM9qzbWt0031bFqQ/C8rqnvfiSkvDhORWkRw8qKqCiNU1FSxNDSMMhLixhaGmdoaTEVpfHW8ug0eB5nSEkRZcUx9e5F+p6CWnpGQd0z7s6mumZWbapj1cZ61lY38EFNI+tqGvlgcyMf1DS0e17flMj3JrdTXhxnSEmcsnBaXhKnvDiYtisvjlNeUtRaP1mntX1JunIdARBJQ0EtPaOgzj13p7axhXU1jWyobWJjXfDYVB9OW183t86rrmtic0MzNQ3N1DT2v5/3LInH2gV6eZqQD54XUV4So7w4TklRjNKiYFoSj1FanJzG27+O1CstirVOi+L6/SApaArq3jCzUcBJwDHAh4DxQCPwInA9cL27b9ElMrMpwOXAgUAZ8BpwHfArd0/719XMZgJfAiYDLcBzwE/d/Z4O6pcD3wBOA7YHNgHzgFnuvrRne9xu+QrqApdIOLVNLdQ0NFNdH4Z3Q3MQ5I3NbG5oaS1rnZ9Svjl81DW20NBcWL37bIkZbUHfLsTbQr005UtASRjwJfEYRTGjKB6jOG4Ux2MUxY3iWPA6WV4Ui1FcFKM4tW74uiTZrnUZ6evGY6bTD4OPgro3zOw84LfAKmAu8BawNXAyMBz4O/DJaKKZ2QlheT1wO7AOOA7YFZjj7p9Ms56fAhcB7wBzgBKCAK4Cvuzu16TULwUeAaYCi4FHgQnAJwm+SEx39yd7ue8K6kGmJeHUN7VQ29jSOq1raqG2sbntdVhW19g2P/m8PqybLKtLsyx9pDpnBsWxINSLYhZ8YQhfJ8O+KJbypaE15GPEY1AUixEPQz8eC5YTC6fxmBE3Ix4uP25Bu6K4EbNInUjbeCxYRzBtq18Us9Zti8eCLy9tddraJLe53bxYjJhOgyQpqHvDzKYDFcC90Z6zmY0FniIIx1Pd/e9heSVB73k4MNXdF4flZQRhehDwaXe/LbKsKcDjwOvA/u6+PiyfCDwTrn83d18RafNN4PsEoT4juW3hl4Q7gSXAh9L19jPYdwW1ZJW709CcCIK9qYW6xmbqGhOdhnt9UwuNzQkamhPhtIXGlgQNTYlgmjov8jpZltDHuCBFv5SUFMUojredwmh9HR7pKC5qm1ccN8pLggsoh5a2n44cUsLoYaWMHlran8YzUFDnipldCnwPuMbdvxyWnQP8CbjJ3Wem1J9O0Aue7+6HRcpvAs4EznH361PafAf4FvAdd58VlhmwAtgOmOTuy1PazAcOIehVz+3F/imoZUBobomGeRjiLS3UJ8O+dRp8CUiGfFPCaWpO0JxI0NTiNLUkaG5xmhLhtCUob25JBM8TwfPmFqcxnDYnEjS2tJU3JRJty2ldZriuloSOOGRR8tbH0cNKGVVRwuihpYwdXsbWlWWMrSxj7PDgUTWkJN+9+5yuvCiXC+8HmsJp9Mba6eH0gTT15wO1wBQzK3X3hm60uZ8gqKcDs8KyHQlC+pXUkI60OSRs0+OgFhkoisJzwhWl+d6SrrWEgd0chn5r4CfDP82XhMaWBC0Jb300J5yEB21aEk6LB2UtLQlaHFoSwfITYd3Utu2fJ7clWZb8ApL6PNiWlsjzZLtk3Zbwi0qwj7n/RtLYnODdjfW8u7G+03rFcWPMsLLWQYrGjyxn2xHljB9ZzvgRQxg/spyhpf037vrvlveSmRUBZ4UvowG7azh9JbWNuzeb2XJgD2ASsNTMKgguUNvs7qvSrOrVcLpLd9bRSZu0zOyZruqISN8Jzg0P/B+EcXcSTuvRitajGC3Rox7B68bI0ZDk69qmFjbXN1NdH9wFsbm+mU31TXxQ08jazQ18sLmR2m7eFdHU4qzcUMfKDXUd1hleXsz41vAuZ9uRwSMZ5COHFBfsYfZBG9TAD4E9gfvc/cFI+fBw2tEvPyTLR/Swfk/biIgUDDMjbhCPxSktAnJwtKO2sZm11Y2srWlgbXUD729u4L1NDazeWMfqTQ28t7Ge1Zvq2VjX1OWykrdHLlm1Ke388uI4fzp7P6bsODrbu9FrgzKozewrBFdov0xwbjmj5uE00+M+mdTv9jrcfd8OF2Kms2Ui0m8NKSliu1FFbDdqSKf16hpbWL2pnlUbg9EFV26oY+X6oIf9zvpa3t1QT2NL59fl1jW1UFVRks3Nz5pBF9Rm9iXglwRXVR/h7qk/dJzszQ4nvcqUel3VT9d7znQdIiLSgfKSODuMrmCH0RVp5ycSztrNDbyTEuDJ5yvX11HT2ML4EeV9vOXdM6iC2swuAH4O/JcgpNekqbYM2I/g/HC787/hee0dCC4+ewPA3WvMbCUw3szGpTlPvXM4jZ6PXhZOOzoHna6NiIj0QCxmjKksY0xlGftsN3KL+e7OxromhpUV52HrujZoxuUzs0sIQvp54PAOQhqCe6UBjkoz71BgCLAocsV3V20+kVIHgvut3wJ2MbMdutlGRERywMwYMaQwD3vDIAlqM/sWwcVjzxD0pNd2Un0OsBY4zcz2iyyjDLgyfPnblDbXhtPLzGxkpM1EgiFFGwiGKwUgvLk52ebHZhaLtDmB4NasJcBj3dxFEREZoAb8gCfh+Ns3EIy9/SvSn/dd4e43RNqcSBDY9cBtBEOIHk84hCjwqdSRRMzsZ8CFtB9CdAYwio6HEH0UmEIwhOgjBPdWawhREZH+RSOT9YaZzaZtoJGOPObu01LaTQUuIxgyNPqjHFd38aMc5xP8KEcCeBb4STd+lON0gpCO/ijHkq73rnMKahGRPqGglp5RUIuI9ImcBvWgOEctIiLSXymoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCWkREpIApqEVERAqYglpERKSAKahFREQKmIJaRESkgCmoRURECpiCOs/MbFszu87M3jWzBjNbYWa/MLOR+d42ERHJP3P3fG/DoGVmOwKLgDHAXcDLwEeBw4FlwFR3/6AXy3f9+4qI5JzlcuHqUefXbwhC+ivufqK7f8PdpwM/B3YFvpfXrRMRkbxTjzpPzGwS8DqwAtjR3RORecOAVQTf0sa4e00P16EetYhI7qlHPUBND6cPRUMawN2rgceBIcCBfb1hIiJSOBTU+bNrOH2lg/mvhtNd+mBbRESkQBXlewMGseHhdGMH85PlIzpbiJk9k60NEhGRwqOgLlzJcx69OslsltNTJyIiAu7uOftjq6DOn2SPeXgH8ytT6qXl7vtmbYsikj31XC1/INN713N673pO713PFfp7p3PU+bMsnHZ0DnrncNrROWwRERkEFNT5MzecftzM2v07hLdnTQXqgH/39YaJiEjhUFDnibu/DjwETAS+lDL7CqACuKmn91CLiMjAoHPU+fVFgiFErzazI4ClwAEEQ4i+AlyWx20TEZECoB51HoW96v2AGwgC+iJgR+Bq4KDejPMtIiIDg4YQFRERKWDqUYuIiBQwBbWIiEgBU1CLiIgUMAW1iIhIAVNQi4iIFDAFtYiISAFTUIuIiBQwBbW0Y2bbmtl1ZvaumTWY2Qoz+4WZjcz3tvUFMxtlZuea2R1m9pqZ1ZnZRjNbaGafSzMu+0Qz804et3Wyrplm9pSZbQ7XMc/Mjs39XuZO+Hnp6L1Y3UGbKWZ2n5mtM7NaM3vBzC4ws3gn6xlQ752Znd3F58jNrCVSf9B97szsVDP7lZktMLNN4X7e3EWbnH+2zKzczK4ws2VmVm9ma8zsr2a2e2/2t906NOCJJJnZjgRDmo4B7gJeBj5KMKTpMmDqQB8tzczOA34LrCL44ZS3gK2Bkwl+kvTvwCc9/I9jZhOB5cB/gDvTLPK/7j4nzXp+SjAS3TvAHKAEOA2oAr7s7tdkc7/6ipmtAEYAv0gze7O7/zSl/gkE72k9cDuwDjgO2BWY4+6fTLOOAffemdlewIkdzD4EmA7c6+7HhvUnMsg+d2b2PPARYDPB9u8G/MXdP9NB/Zx/tsysFHiE4EeUFgOPAhOATwKNwHR3f7I3+w2Au+uhB+4O8CDg4QcyWn5VWH5tvrexD96D6eF/5lhK+ViC0HbglEj5xLDshgzWMSVs8xowMmVZHxD8YZmY7/eih+/fCmBFN+tWAmuABmC/SHkZwRdGB04bLO9dJ+/TE+E+Hz+YP3cEHYadAQOmhftycz4/W8A3wzZ/i/7NAE4Iy19K/VvSk4cOfQsAZjYJ+DjBH9pfp8yeBdQAZ5pZRR9vWp9y90fd/W53T6SUrwauDV9O6+Vqzgun33P39ZF1rCB470uBz/ZyHf3BqcBWwG3uvjhZ6O71wOXhy/9NaTOo3jsz2xM4EFgJ3NvLxfXr987d57r7qx4mYRdy/tkyM4u0uTj6N8Pd7wIWAJOBw7qxvZ1SUEvS9HD6UJqQqgYeB4YQ/NEYrJrCaXOaeduY2RfM7NJw+uFOlpN8rx9IM+/+lDr9UamZfSZ8L75qZod3cE6ws/dhPlALTAkPL3anzUB471J9IZz+yd1b0szX5y69vvhs7QhsB7zi7su72aZH9DOXkrRrOH2lg/mvEvS4dyE4JzOomFkRcFb4Mt1/5I+Fj2ibecBMd38rUlYBjCc4X7sqzXJeDae79Hab82gs8OeUsuVm9ll3fyxS1uFnzt2bzWw5sAcwCVg6SN67VmZWDnwGSAB/7KCaPnfp9cVnqzt/M1Pb9Ih61JI0PJxu7GB+snxE7jelIP0Q2BO4z90fjJTXAt8F9gVGho/DCC5EmwY8knK6YKC/z9cDRxCEdQXwIeB3BOf57jezj0TqZvpeDPT3LtWnCPblfnd/O2WePned64vPVp+9pwpq6S4Lp4PuNgEz+wrBlaAvA2dG57n7Gnf/trs/6+4bwsd8gqMPTwI7Aef2YLX98n129yvC8/zvuXutu//X3c8juCCxHJidweJ6+pnrl+9dGp8Pp79LnaHPXa/1xWcra38zFdSSlPz2N7yD+ZUp9QYFM/sS8EtgCXC4u6/rTjt3b6btcOWhkVldvc9dfUvvr5IX4mXyXqR+5gbNe2dmkwmuQn4HuK+77fS5a9UXn60++5upoJakZeG0o/MpO4fTjs7HDDhmdgFwDfBfgpBOO2BHJ94Pp62HIN29huAK3qFmNi5Nm4H6Pq8Jp9HDsR1+5sJrAnYguHDvDRh0711XF5F1Rp+7vvls9dnfTAW1JM0Npx+3LUffGkZwQ38d8O++3rB8MLNLgJ8DzxOE9JrOW6SVvEL+jZTyR8PpUWnafCKlzkBxUDiNvhedvQ+HEtxlsMjdG7rZZkC8d2ZWRnCKJQH8qQeL0Oeubz5brxOMrbCLme3QzTY90xc3quvRPx5owJPk/n4r3N/FQFUXdQ8AStKUTycYIMGBKSnz+vXAE528F3uke7+A7QmugHXg0kh5JUHvTwOetN/HM8N9vFufuw73fxpdD3iS888WfTTgiYYQlVZphhBdSvAH4XCCwzdTfOAPIToTuAFoAX5F+vNLK9z9hrD+PIKAmkdwPhHgw7TdO/ktd78yzXp+BlxI+6EKZwCjKPChHDtiZrOBbxAcnVkOVBPca3oMwR/I+4CT3L0x0uZEgv2vB24jGObxeMJhHoFPecofqYH43kWZ2QLgYIKRyO7uoM48BtnnLvysnBi+HAv8P4KjBgvCsrXu/n8p9XP62Qrvw36UIOQXE9y6uh0aQlSPXD4Ixqm9nmCs60bgTYKLqTrtWQ6UB8FVyd7FY16k/ueAewhGdNtM8A3+LYKxhQ/pYl0zgacJRn2rBh4Djs33e9CL9+4w4FaCq+M3EAwQ8z7wL4J70K2DdlMJQnw9wemVF4GvAfHB8t5F9mv38DP2dhf7P+g+d934v7kiH58tgrsZriA4atQQfub/BkzO1r6rRy0iIlLAdDGZiIhIAVNQi4iIFDAFtYiISAFTUIuIiBQwBbWIiEgBU1CLiIgUMAW1iIhIAVNQi4iIFDAFtYiISAFTUIuIiBQwBbWIiEgBU1CLyIBgZrPNzM1sWr63RSSbFNQiAkAYcl09puV7O0UGm6J8b4CIFJwrOpm3oq82QkQCCmoRacfdZ+d7G0SkjQ59i0iPRM8Jm9lMM3vOzOrMbI2ZXWdmYztot7OZ3WRmK82s0czeDV/v3EH9uJmdZ2aPm9nGcB2vmdkfO2lzqpk9ZWa1ZrbOzG4zs/Fp6k0ys9+Hy6sL675oZtea2ajevUMi2aEetYj01teAjwO3Aw8ABwOfBaaZ2QHu/n6yopntDzwMDAP+CSwBdgPOAE4wsyPcfXGkfglwL3Ak8DZwC7AJmAicBCwEXk3Zni8Cx4fLfww4AJgBfMTM9nL3hnDZ44CngUrgPuDvQBmwA3AmcA3wQa/fHZFeUlCLSDtmNruDWfXu/sM05Z8ADnD35yLL+DlwAfBD4HNhmQE3EQTjZ9z9L5H6M4DbgJvNbLK7J8JZswlC+m7gk8mQDduUhstKdRSwv7u/GKl7C/Bp4ATgr2HxqUAVcIG7/zLlPagAEogUAAW1iKSa1UH5RoLgTfXnaEiHZhP0qk83sy+GATuFoPf8RDSkAdz9djM7n6A3fjAw38ziBL3jOuC8aEiHbRqA99nS1dGQDv2BIKg/SltQJ9WlLsDda9IsVyQvdI5aRNpxd+vgMaKDJo+lWcZG4HmCQ8m7h8X7hNNHO1hOsnzvcLobMBx4wd3fzWAXFqcpezucjoyU/RPYDPzazP5uZp83sz3Cnr9IwVBQi0hvvddB+epwOjxluqqD+snyESnTlRluz4Y0Zc3hNJ4scPc3CXrY/yA4vP474L/Am2b2lQzXKZIzCmoR6a2tOyhPXvW9MWWa9mpwYFxKvQ3hdIurtbPF3Ze6+wxgFLAf8A2Cv4u/NLPP5Wq9IplQUItIbx2WWmBmw4G9gHpgaVicPI89rYPlJMufDacvE4T1h81sm95vZsfcvdndn3H3HxGcywY4MZfrFOkuBbWI9NaZZrZ3StlsgkPdt0YuAnscWAYcbGanRiuHrw8FXiG45Qp3bwF+A5QD14ZXeUfblJjZVj3daDP7qJmlOxqQLKvt6bJFsklXfYtIO53cngVwp7s/n1J2P/C4mf2V4Dxz8srtFQSHkgFwdzezmcC/gNvN7C6CXvOuBL3XauCsyK1ZEAxnegBwHPCKmd0T1ptAcO/214EberCbAKcDXzKzx4DXgPXAjuG6GoBf9HC5IlmloBaRVB3dngVB+D6fUvZz4A6C+6ZnEFxJfQNwqbuviVZ09yfDQU8uJ7iA6zhgLXAr8F13X5ZSv9HMjgLOA84CZgIGvBuuc2GmOxdxK1BKcNvYPgQ995UE93P/zN3/24tli2SNuXu+t0FE+qGw5z0LONzd5+V3a0QGLp2jFhERKWAKahERkQKmoBYRESlgOkctIiJSwNSjFhERKWAKahERkQKmoBYRESlgCmoREZECpqAWEREpYApqERGRAqagFhERKWAKahERkQKmoBYRESlgCmoREZECpqAWEREpYApqERGRAqagFhERKWD/H2PA5cFki2BgAAAAAElFTkSuQmCC\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": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5812576830429843, 0.4209466241683596)"
      ]
     },
     "execution_count": 69,
     "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). You might find this article interesting: [Why Deep Learning Works Even Though It Shouldn’t](https://moultano.wordpress.com/2020/10/18/why-deep-learning-works-even-though-it-shouldnt/)."
   ]
  },
  {
   "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": 17,
   "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": 72,
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}