From 2e170ccfa70f37ce07e2df14d6bad2906a1c2d4b Mon Sep 17 00:00:00 2001 From: Sam Date: Tue, 7 May 2024 18:53:49 -0700 Subject: [PATCH] Upload Colab-debugged deep double descent notebook --- notebooks/6. deep_double_descent.ipynb | 1358 ++++++++++++------------ 1 file changed, 706 insertions(+), 652 deletions(-) diff --git a/notebooks/6. deep_double_descent.ipynb b/notebooks/6. deep_double_descent.ipynb index a605a0d..e3f011b 100644 --- a/notebooks/6. deep_double_descent.ipynb +++ b/notebooks/6. deep_double_descent.ipynb @@ -1,665 +1,719 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "L6chybAVFJW2" - }, - "source": [ - "# **MNIST-1D**: Observing deep double descent\n", - "\n", - "This notebook investigates double descent as described in section 8.4 of the [\"Understanding Deep Learning\"](https://udlbook.github.io/udlbook/) textbook.\n", - "\n", - "The deep double descent phenomenon was [originally described here](https://arxiv.org/abs/1812.11118) and later extended to modern architectures and large datasets in an [OpenAI research project](https://openai.com/blog/deep-double-descent/).\n", - "\n", - "This case study is meant to show the convenience and computational savings of working with the low-dimensional MNIST-1D dataset. You can find more details at https://github.com/greydanus/mnist1d." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "L6chybAVFJW2" + }, + "source": [ + "# **MNIST-1D**: Observing deep double descent\n", + "\n", + "This notebook investigates double descent as described in section 8.4 of the [\"Understanding Deep Learning\"](https://udlbook.github.io/udlbook/) textbook.\n", + "\n", + "The deep double descent phenomenon was [originally described here](https://arxiv.org/abs/1812.11118) and later extended to modern architectures and large datasets in an [OpenAI research project](https://openai.com/blog/deep-double-descent/).\n", + "\n", + "This case study is meant to show the convenience and computational savings of working with the low-dimensional MNIST-1D dataset. You can find more details at https://github.com/greydanus/mnist1d." + ] }, - "id": "fn9BP5N5TguP", - "outputId": "b08d5e28-46e4-4c89-d17e-9b3e178d2e2a" - }, - "outputs": [], - "source": [ - "!python -m pip install git+https://github.com/greydanus/mnist1d.git@master\n", - " \n", - "# Download repo directly (gives access to notebooks/models.py and notebooks/train.py)\n", - "!git clone https://github.com/greydanus/mnist1d" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fn9BP5N5TguP", + "outputId": "6ad96253-0334-4eb8-da7f-bb21ed96b705" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/greydanus/mnist1d.git@master\n", + " Cloning https://github.com/greydanus/mnist1d.git (to revision master) to /tmp/pip-req-build-15yo7ijy\n", + " Running command git clone --filter=blob:none --quiet https://github.com/greydanus/mnist1d.git /tmp/pip-req-build-15yo7ijy\n", + " Resolved https://github.com/greydanus/mnist1d.git to commit ad53e36d4c2d74174fd90b68d1284f024d286acb\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from mnist1d==0.0.0) (2.31.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from mnist1d==0.0.0) (1.25.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from mnist1d==0.0.0) (3.7.1)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from mnist1d==0.0.0) (1.11.4)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (4.51.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (24.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mnist1d==0.0.0) (2.8.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->mnist1d==0.0.0) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->mnist1d==0.0.0) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->mnist1d==0.0.0) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->mnist1d==0.0.0) (2024.2.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->mnist1d==0.0.0) (1.16.0)\n", + "fatal: destination path 'mnist1d' already exists and is not an empty directory.\n" + ] + } + ], + "source": [ + "!python -m pip install git+https://github.com/greydanus/mnist1d.git@master\n", + "\n", + "# Download repo directly (gives access to notebooks/models.py and notebooks/train.py)\n", + "!git clone https://github.com/greydanus/mnist1d" + ] }, - "id": "hFxuHpRqTgri", - "outputId": "8e769ed7-da9b-4a68-cb0b-6cae0be3cebe" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using: cpu\n" - ] - } - ], - "source": [ - "import torch, torch.nn as nn\n", - "from torch.utils.data import TensorDataset, DataLoader\n", - "from torch.optim.lr_scheduler import StepLR\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import mnist1d\n", - "import random\n", - "random.seed(0)\n", - "\n", - "# Try attaching to GPU -- Use \"Change Runtime Type to change to GPUT\"\n", - "DEVICE = str(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))\n", - "print('Using:', DEVICE)\n", - "\n", - "plt.style.use('https://github.com/greydanus/mnist1d/raw/master/notebooks/mpl_style.txt')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Only run this if you're in Google Colab" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "if False:\n", - " # Only run this in Colab\n", - " from google.colab import drive\n", - " drive.mount('/content/gdrive')\n", - " project_dir = \"/content/gdrive/My Drive/Research/mnist1d/\"\n", - "else:\n", - " project_dir = './'" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up hyperparameters" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hFxuHpRqTgri", + "outputId": "d207a6c5-3ffe-4dab-e734-27e8d540f841" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using: cuda\n" + ] + } + ], + "source": [ + "import torch, torch.nn as nn\n", + "from torch.utils.data import TensorDataset, DataLoader\n", + "from torch.optim.lr_scheduler import StepLR\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import mnist1d\n", + "import random, os\n", + "random.seed(0)\n", + "\n", + "# Try attaching to GPU -- Use \"Change Runtime Type to change to GPUT\"\n", + "DEVICE = str(torch.device('cuda' if torch.cuda.is_available() else 'cpu'))\n", + "print('Using:', DEVICE)\n", + "\n", + "plt.style.use('https://github.com/greydanus/mnist1d/raw/master/notebooks/mpl_style.txt')" + ] }, - "id": "PW2gyXL5UkLU", - "outputId": "d52d2497-d27f-4a84-d822-51babe0bf0ad" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Did or could not load data from ./mnist1d_data.pkl. Rebuilding dataset...\n", - "Examples in training set: 4000\n", - "Examples in test set: 4000\n", - "Length of each example: 40\n" - ] - } - ], - "source": [ - "args = mnist1d.data.get_dataset_args()\n", - "args.num_samples = 8000\n", - "args.train_split = 0.5\n", - "args.corr_noise_scale = 0.25\n", - "args.iid_noise_scale=2e-2\n", - "data = mnist1d.data.get_dataset(args, path='./mnist1d_data.pkl', download=False, regenerate=True)\n", - "\n", - "# Add 15% noise to training labels\n", - "for c_y in range(len(data['y'])):\n", - " random_number = random.random()\n", - " if random_number < 0.15 :\n", - " random_int = int(random.random() * 10)\n", - " data['y'][c_y] = random_int\n", - "\n", - "# The training and test input and outputs are in\n", - "# data['x'], data['y'], data['x_test'], and data['y_test']\n", - "print(\"Examples in training set: {}\".format(len(data['y'])))\n", - "print(\"Examples in test set: {}\".format(len(data['y_test'])))\n", - "print(\"Length of each example: {}\".format(data['x'].shape[-1]))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "hAIvZOAlTnk9" - }, - "outputs": [], - "source": [ - "# Initialize the parameters with He initialization\n", - "def weights_init(layer_in):\n", - " if isinstance(layer_in, nn.Linear):\n", - " nn.init.kaiming_uniform_(layer_in.weight)\n", - " layer_in.bias.data.fill_(0.0)\n", - "\n", - "# Return an initialized model with two hidden layers and n_hidden hidden units at each\n", - "def get_model(n_hidden):\n", - "\n", - " D_i = 40 # Input dimensions\n", - " D_k = n_hidden # Hidden dimensions\n", - " D_o = 10 # Output dimensions\n", - "\n", - " # Define a model with two hidden layers of size 100\n", - " # And ReLU activations between them\n", - " model = nn.Sequential(\n", - " nn.Linear(D_i, D_k),\n", - " nn.ReLU(),\n", - " nn.Linear(D_k, D_k),\n", - " nn.ReLU(),\n", - " nn.Linear(D_k, D_o))\n", - "\n", - " # Call the function you just defined\n", - " model.apply(weights_init)\n", - "\n", - " # Return the model\n", - " return model ;" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "AazlQhheWmHk" - }, - "outputs": [], - "source": [ - "def fit_model(model, data):\n", - "\n", - " # choose cross entropy loss function (equation 5.24)\n", - " loss_function = torch.nn.CrossEntropyLoss()\n", - " # construct SGD optimizer and initialize learning rate and momentum\n", - " # optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n", - " optimizer = torch.optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)\n", - "\n", - "\n", - " # create 100 dummy data points and store in data loader class\n", - " x_train = torch.tensor(data['x'].astype('float32'))\n", - " y_train = torch.tensor(data['y'].transpose().astype('long'))\n", - " x_test= torch.tensor(data['x_test'].astype('float32'))\n", - " y_test = torch.tensor(data['y_test'].astype('long'))\n", - "\n", - " # load the data into a class that creates the batches\n", - " data_loader = DataLoader(TensorDataset(x_train,y_train), batch_size=100, shuffle=True, worker_init_fn=np.random.seed(1))\n", - "\n", - " # loop over the dataset n_epoch times\n", - " n_epoch = 1000\n", - "\n", - " for epoch in range(n_epoch):\n", - " # loop over batches\n", - " for i, batch in enumerate(data_loader):\n", - " # retrieve inputs and labels for this batch\n", - " x_batch, y_batch = batch\n", - " # zero the parameter gradients\n", - " optimizer.zero_grad()\n", - " # forward pass -- calculate model output\n", - " pred = model(x_batch)\n", - " # compute the loss\n", - " loss = loss_function(pred, y_batch)\n", - " # backward pass\n", - " loss.backward()\n", - " # SGD update\n", - " optimizer.step()\n", - "\n", - " # Run whole dataset to get statistics -- normally wouldn't do this\n", - " pred_train = model(x_train)\n", - " pred_test = model(x_test)\n", - " _, predicted_train_class = torch.max(pred_train.data, 1)\n", - " _, predicted_test_class = torch.max(pred_test.data, 1)\n", - " errors_train = 100 - 100 * (predicted_train_class == y_train).float().sum() / len(y_train)\n", - " errors_test= 100 - 100 * (predicted_test_class == y_test).float().sum() / len(y_test)\n", - " losses_train = loss_function(pred_train, y_train).item()\n", - " losses_test= loss_function(pred_test, y_test).item()\n", - " if epoch%100 ==0 :\n", - " print(f'Epoch {epoch:5d}, train loss {losses_train:.6f}, train error {errors_train:3.2f}, test loss {losses_test:.6f}, test error {errors_test:3.2f}')\n", - "\n", - " return errors_train, errors_test\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "IcP4UPMudxPS" - }, - "source": [ - "## The following code produces the double descent curve by training the model with different numbers of hidden units and plotting the test error." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" + "cell_type": "markdown", + "metadata": { + "id": "P39h-h6tszXs" + }, + "source": [ + "## Only run this if you're in Google Colab" + ] }, - "id": "K4OmBZGHWXpk", - "outputId": "35d86b9f-8ceb-4d8b-b07b-51fbe04dbcf3" - }, - "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training model with 2 hidden variables\n", - "Epoch 0, train loss 2.302392, train error 89.78, test loss 2.302779, test error 90.18\n", - "Epoch 100, train loss 2.302209, train error 89.57, test loss 2.303445, test error 90.30\n", - "Epoch 200, train loss 2.302207, train error 89.57, test loss 2.303366, test error 90.30\n", - "Epoch 300, train loss 2.302209, train error 89.57, test loss 2.303377, test error 90.30\n", - "Epoch 400, train loss 2.302216, train error 89.57, test loss 2.303575, test error 90.30\n", - "Epoch 500, train loss 2.302210, train error 89.57, test loss 2.303383, test error 90.30\n", - "Epoch 600, train loss 2.302215, train error 89.57, test loss 2.303501, test error 90.30\n", - "Epoch 700, train loss 2.302213, train error 89.57, test loss 2.303368, test error 90.30\n", - "Epoch 800, train loss 2.302217, train error 89.57, test loss 2.303529, test error 90.30\n", - "Epoch 900, train loss 2.302226, train error 89.57, test loss 2.303560, test error 90.30\n", - "Training model with 4 hidden variables\n", - "Epoch 0, train loss 2.250851, train error 85.15, test loss 2.233320, test error 84.05\n", - "Epoch 100, train loss 1.816823, train error 68.03, test loss 1.671895, test error 66.03\n", - "Epoch 200, train loss 1.805447, train error 67.68, test loss 1.659775, test error 65.75\n", - "Epoch 300, train loss 1.805674, train error 68.25, test loss 1.664179, test error 66.18\n", - "Epoch 400, train loss 1.802919, train error 67.28, test loss 1.650813, test error 65.82\n", - "Epoch 500, train loss 1.798811, train error 67.72, test loss 1.654510, test error 65.70\n", - "Epoch 600, train loss 1.797068, train error 67.10, test loss 1.652466, test error 65.95\n", - "Epoch 700, train loss 1.797401, train error 67.35, test loss 1.657384, test error 65.85\n", - "Epoch 800, train loss 1.794392, train error 67.18, test loss 1.661046, test error 65.57\n", - "Epoch 900, train loss 1.792606, train error 66.93, test loss 1.656063, test error 65.22\n", - "Training model with 6 hidden variables\n", - "Epoch 0, train loss 2.157780, train error 78.85, test loss 2.112093, test error 77.50\n", - "Epoch 100, train loss 1.711605, train error 61.55, test loss 1.557814, test error 61.35\n", - "Epoch 200, train loss 1.660365, train error 59.30, test loss 1.482511, test error 57.38\n", - "Epoch 300, train loss 1.640397, train error 57.85, test loss 1.467646, test error 58.08\n", - "Epoch 400, train loss 1.636314, train error 58.80, test loss 1.480724, test error 59.15\n", - "Epoch 500, train loss 1.626414, train error 57.72, test loss 1.471985, test error 57.70\n", - "Epoch 600, train loss 1.624055, train error 57.62, test loss 1.483606, test error 57.47\n", - "Epoch 700, train loss 1.621565, train error 57.22, test loss 1.476077, test error 57.53\n", - "Epoch 800, train loss 1.614165, train error 57.00, test loss 1.478664, test error 57.05\n", - "Epoch 900, train loss 1.615926, train error 57.25, test loss 1.477551, test error 56.60\n", - "Training model with 8 hidden variables\n", - "Epoch 0, train loss 2.207131, train error 82.20, test loss 2.175218, test error 81.25\n", - "Epoch 100, train loss 1.562333, train error 54.42, test loss 1.371664, test error 50.90\n", - "Epoch 200, train loss 1.502774, train error 51.10, test loss 1.336490, test error 49.78\n", - "Epoch 300, train loss 1.482883, train error 50.03, test loss 1.319196, test error 47.95\n", - "Epoch 400, train loss 1.476818, train error 50.42, test loss 1.324280, test error 48.92\n", - "Epoch 500, train loss 1.476231, train error 50.00, test loss 1.341571, test error 48.88\n", - "Epoch 600, train loss 1.470834, train error 50.05, test loss 1.339733, test error 48.92\n", - "Epoch 700, train loss 1.466901, train error 49.78, test loss 1.340641, test error 48.53\n", - "Epoch 800, train loss 1.470004, train error 49.58, test loss 1.360699, test error 49.28\n", - "Epoch 900, train loss 1.464413, train error 49.62, test loss 1.344246, test error 49.20\n", - "Training model with 10 hidden variables\n", - "Epoch 0, train loss 2.230791, train error 83.10, test loss 2.219962, test error 82.57\n", - "Epoch 100, train loss 1.624031, train error 55.40, test loss 1.483665, test error 57.30\n", - "Epoch 200, train loss 1.573270, train error 53.55, test loss 1.473368, test error 55.70\n", - "Epoch 300, train loss 1.532066, train error 51.75, test loss 1.456869, test error 54.42\n", - "Epoch 400, train loss 1.517440, train error 51.25, test loss 1.455229, test error 53.95\n", - "Epoch 500, train loss 1.494027, train error 49.47, test loss 1.446776, test error 52.60\n", - "Epoch 600, train loss 1.489535, train error 50.15, test loss 1.445012, test error 52.42\n", - "Epoch 700, train loss 1.481718, train error 49.80, test loss 1.455935, test error 53.53\n", - "Epoch 800, train loss 1.472508, train error 49.05, test loss 1.440699, test error 52.60\n", - "Epoch 900, train loss 1.468138, train error 49.25, test loss 1.438105, test error 52.58\n", - "Training model with 14 hidden variables\n", - "Epoch 0, train loss 2.194987, train error 82.38, test loss 2.157802, test error 82.18\n", - "Epoch 100, train loss 1.432727, train error 46.45, test loss 1.298154, test error 47.20\n", - "Epoch 200, train loss 1.371660, train error 45.62, test loss 1.288553, test error 47.75\n", - "Epoch 300, train loss 1.342002, train error 44.33, test loss 1.298116, test error 48.22\n", - "Epoch 400, train loss 1.324692, train error 44.38, test loss 1.310549, test error 48.42\n", - "Epoch 500, train loss 1.311786, train error 44.03, test loss 1.332682, test error 49.28\n", - "Epoch 600, train loss 1.296012, train error 42.42, test loss 1.334784, test error 48.70\n", - "Epoch 700, train loss 1.284480, train error 42.35, test loss 1.345621, test error 48.83\n", - "Epoch 800, train loss 1.280150, train error 41.97, test loss 1.354114, test error 48.30\n", - "Epoch 900, train loss 1.279138, train error 42.83, test loss 1.360159, test error 48.50\n", - "Training model with 18 hidden variables\n", - "Epoch 0, train loss 2.208465, train error 82.88, test loss 2.175686, test error 82.05\n", - "Epoch 100, train loss 1.363582, train error 44.50, test loss 1.272581, test error 46.72\n", - "Epoch 200, train loss 1.270183, train error 41.92, test loss 1.264062, test error 46.33\n", - "Epoch 300, train loss 1.214964, train error 40.65, test loss 1.299780, test error 46.92\n", - "Epoch 400, train loss 1.189231, train error 39.67, test loss 1.338635, test error 47.42\n", - "Epoch 500, train loss 1.156629, train error 38.45, test loss 1.366682, test error 48.03\n", - "Epoch 600, train loss 1.138318, train error 38.08, test loss 1.387562, test error 47.83\n", - "Epoch 700, train loss 1.133006, train error 37.88, test loss 1.411109, test error 48.00\n", - "Epoch 800, train loss 1.132416, train error 38.28, test loss 1.446937, test error 49.62\n", - "Epoch 900, train loss 1.119343, train error 37.88, test loss 1.460641, test error 49.62\n", - "Training model with 22 hidden variables\n", - "Epoch 0, train loss 2.226865, train error 81.88, test loss 2.182973, test error 80.05\n", - "Epoch 100, train loss 1.288200, train error 40.83, test loss 1.306713, test error 48.30\n", - "Epoch 200, train loss 1.175445, train error 38.58, test loss 1.406979, test error 50.33\n", - "Epoch 300, train loss 1.117835, train error 36.70, test loss 1.517466, test error 51.42\n", - "Epoch 400, train loss 1.070894, train error 35.32, test loss 1.558678, test error 50.95\n", - "Epoch 500, train loss 1.050902, train error 34.90, test loss 1.607843, test error 51.67\n", - "Epoch 600, train loss 1.016922, train error 33.62, test loss 1.628765, test error 52.08\n", - "Epoch 700, train loss 1.016387, train error 33.80, test loss 1.695786, test error 53.35\n", - "Epoch 800, train loss 1.007088, train error 33.72, test loss 1.727620, test error 53.10\n", - "Epoch 900, train loss 0.995803, train error 33.05, test loss 1.753152, test error 53.17\n", - "Training model with 26 hidden variables\n", - "Epoch 0, train loss 2.163288, train error 79.97, test loss 2.124022, test error 78.25\n", - "Epoch 100, train loss 1.196717, train error 38.62, test loss 1.322258, test error 49.58\n", - "Epoch 200, train loss 1.068718, train error 34.55, test loss 1.431815, test error 51.42\n", - "Epoch 300, train loss 0.985991, train error 33.12, test loss 1.567818, test error 52.08\n", - "Epoch 400, train loss 0.936697, train error 31.97, test loss 1.684496, test error 53.75\n", - "Epoch 500, train loss 0.911425, train error 31.55, test loss 1.790007, test error 53.70\n", - "Epoch 600, train loss 0.886706, train error 30.57, test loss 1.856272, test error 53.78\n", - "Epoch 700, train loss 0.875984, train error 30.35, test loss 1.946271, test error 54.90\n", - "Epoch 800, train loss 0.871701, train error 30.00, test loss 2.001556, test error 55.60\n", - "Epoch 900, train loss 0.854498, train error 29.88, test loss 2.053360, test error 55.70\n", - "Training model with 30 hidden variables\n", - "Epoch 0, train loss 2.092851, train error 79.00, test loss 2.032718, test error 78.07\n", - "Epoch 100, train loss 1.143900, train error 36.65, test loss 1.357492, test error 50.17\n", - "Epoch 200, train loss 0.956724, train error 32.12, test loss 1.534423, test error 50.38\n", - "Epoch 300, train loss 0.857389, train error 28.85, test loss 1.714931, test error 51.95\n", - "Epoch 400, train loss 0.809718, train error 26.90, test loss 1.910003, test error 53.45\n", - "Epoch 500, train loss 0.751300, train error 25.30, test loss 2.055625, test error 53.10\n", - "Epoch 600, train loss 0.731607, train error 24.97, test loss 2.271353, test error 55.30\n", - "Epoch 700, train loss 0.700835, train error 23.55, test loss 2.379167, test error 54.40\n", - "Epoch 800, train loss 0.700877, train error 25.38, test loss 2.558042, test error 54.78\n", - "Epoch 900, train loss 0.657081, train error 22.75, test loss 2.653164, test error 55.17\n", - "Training model with 35 hidden variables\n", - "Epoch 0, train loss 2.132697, train error 80.20, test loss 2.099225, test error 80.15\n", - "Epoch 100, train loss 1.007896, train error 31.80, test loss 1.374517, test error 48.53\n", - "Epoch 200, train loss 0.779573, train error 25.60, test loss 1.700892, test error 51.20\n", - "Epoch 300, train loss 0.658741, train error 21.50, test loss 2.019543, test error 52.78\n", - "Epoch 400, train loss 0.600679, train error 19.35, test loss 2.384401, test error 53.50\n", - "Epoch 500, train loss 0.563982, train error 18.88, test loss 2.715812, test error 54.40\n", - "Epoch 600, train loss 0.537495, train error 18.22, test loss 3.025938, test error 54.50\n", - "Epoch 700, train loss 0.513099, train error 17.70, test loss 3.332701, test error 54.67\n", - "Epoch 800, train loss 0.472061, train error 15.93, test loss 3.504873, test error 54.80\n", - "Epoch 900, train loss 0.461231, train error 15.85, test loss 3.800179, test error 55.22\n", - "Training model with 40 hidden variables\n", - "Epoch 0, train loss 2.138055, train error 80.12, test loss 2.107509, test error 79.10\n", - "Epoch 100, train loss 0.918194, train error 29.28, test loss 1.442799, test error 50.22\n", - "Epoch 200, train loss 0.635553, train error 20.62, test loss 1.934060, test error 52.90\n", - "Epoch 300, train loss 0.504686, train error 17.20, test loss 2.566078, test error 55.30\n", - "Epoch 400, train loss 0.424505, train error 14.47, test loss 3.141229, test error 54.60\n", - "Epoch 500, train loss 0.353525, train error 12.22, test loss 3.840992, test error 57.03\n", - "Epoch 600, train loss 0.402119, train error 14.57, test loss 4.390154, test error 56.55\n", - "Epoch 700, train loss 0.333216, train error 11.68, test loss 5.103640, test error 58.03\n", - "Epoch 800, train loss 0.299515, train error 10.93, test loss 5.603264, test error 57.08\n", - "Epoch 900, train loss 0.350713, train error 12.85, test loss 6.311297, test error 56.90\n", - "Training model with 45 hidden variables\n", - "Epoch 0, train loss 2.098883, train error 77.80, test loss 2.063929, test error 77.15\n", - "Epoch 100, train loss 0.855755, train error 27.50, test loss 1.568584, test error 51.78\n", - "Epoch 200, train loss 0.538689, train error 17.57, test loss 2.297779, test error 54.12\n", - "Epoch 300, train loss 0.318577, train error 9.85, test loss 3.308709, test error 56.33\n", - "Epoch 400, train loss 0.201060, train error 6.15, test loss 4.522632, test error 55.65\n", - "Epoch 500, train loss 0.184482, train error 6.12, test loss 5.796445, test error 56.45\n", - "Epoch 600, train loss 0.159223, train error 5.55, test loss 7.017427, test error 56.30\n", - "Epoch 700, train loss 0.181304, train error 6.25, test loss 8.060752, test error 56.22\n", - "Epoch 800, train loss 0.007479, train error 0.00, test loss 8.816522, test error 56.47\n", - "Epoch 900, train loss 0.005266, train error 0.00, test loss 9.326012, test error 56.70\n", - "Training model with 50 hidden variables\n", - "Epoch 0, train loss 2.115768, train error 78.47, test loss 2.063965, test error 77.30\n", - "Epoch 100, train loss 0.745307, train error 23.88, test loss 1.575308, test error 51.47\n", - "Epoch 200, train loss 0.385711, train error 12.05, test loss 2.666324, test error 53.60\n", - "Epoch 300, train loss 0.229571, train error 7.68, test loss 4.189817, test error 55.17\n", - "Epoch 400, train loss 0.086696, train error 2.38, test loss 5.827739, test error 55.80\n", - "Epoch 500, train loss 0.010698, train error 0.00, test loss 6.764512, test error 55.88\n", - "Epoch 600, train loss 0.006887, train error 0.00, test loss 7.352395, test error 56.10\n", - "Epoch 700, train loss 0.005042, train error 0.00, test loss 7.798390, test error 56.33\n", - "Epoch 800, train loss 0.003959, train error 0.00, test loss 8.149263, test error 56.38\n", - "Epoch 900, train loss 0.003218, train error 0.00, test loss 8.435203, test error 56.30\n", - "Training model with 55 hidden variables\n", - "Epoch 0, train loss 2.070678, train error 78.28, test loss 1.980998, test error 75.97\n", - "Epoch 100, train loss 0.652201, train error 20.12, test loss 1.713133, test error 51.05\n", - "Epoch 200, train loss 0.219332, train error 4.97, test loss 3.128451, test error 54.67\n", - "Epoch 300, train loss 0.044860, train error 0.05, test loss 4.984075, test error 55.92\n", - "Epoch 400, train loss 0.014124, train error 0.00, test loss 6.120574, test error 55.55\n", - "Epoch 500, train loss 0.008292, train error 0.00, test loss 6.788756, test error 55.88\n", - "Epoch 600, train loss 0.005544, train error 0.00, test loss 7.276557, test error 56.12\n", - "Epoch 700, train loss 0.004151, train error 0.00, test loss 7.653577, test error 56.22\n", - "Epoch 800, train loss 0.003301, train error 0.00, test loss 7.957417, test error 56.33\n", - "Epoch 900, train loss 0.002704, train error 0.00, test loss 8.212501, test error 56.22\n", - "Training model with 60 hidden variables\n", - "Epoch 0, train loss 2.075572, train error 76.93, test loss 2.040101, test error 77.50\n", - "Epoch 100, train loss 0.538120, train error 16.05, test loss 1.755384, test error 52.40\n", - "Epoch 200, train loss 0.108896, train error 1.40, test loss 3.457802, test error 55.20\n", - "Epoch 300, train loss 0.019101, train error 0.00, test loss 4.733725, test error 54.65\n", - "Epoch 400, train loss 0.009264, train error 0.00, test loss 5.386252, test error 54.58\n", - "Epoch 500, train loss 0.005851, train error 0.00, test loss 5.812413, test error 54.75\n", - "Epoch 600, train loss 0.004207, train error 0.00, test loss 6.138036, test error 54.95\n", - "Epoch 700, train loss 0.003242, train error 0.00, test loss 6.389002, test error 55.10\n", - "Epoch 800, train loss 0.002605, train error 0.00, test loss 6.604166, test error 55.12\n", - "Epoch 900, train loss 0.002167, train error 0.00, test loss 6.782824, test error 55.00\n", - "Training model with 70 hidden variables\n", - "Epoch 0, train loss 2.061579, train error 77.38, test loss 2.009555, test error 76.70\n", - "Epoch 100, train loss 0.372350, train error 10.35, test loss 1.977640, test error 51.60\n", - "Epoch 200, train loss 0.033212, train error 0.00, test loss 3.540529, test error 52.60\n", - "Epoch 300, train loss 0.011224, train error 0.00, test loss 4.311882, test error 53.22\n", - "Epoch 400, train loss 0.006188, train error 0.00, test loss 4.746296, test error 53.05\n", - "Epoch 500, train loss 0.004167, train error 0.00, test loss 5.049072, test error 53.30\n", - "Epoch 600, train loss 0.003077, train error 0.00, test loss 5.276596, test error 53.33\n", - "Epoch 700, train loss 0.002414, train error 0.00, test loss 5.461852, test error 53.45\n", - "Epoch 800, train loss 0.001974, train error 0.00, test loss 5.615400, test error 53.47\n", - "Epoch 900, train loss 0.001658, train error 0.00, test loss 5.747221, test error 53.47\n", - "Training model with 80 hidden variables\n", - "Epoch 0, train loss 2.013625, train error 75.03, test loss 1.967258, test error 75.07\n", - "Epoch 100, train loss 0.198255, train error 2.72, test loss 2.162482, test error 51.70\n", - "Epoch 200, train loss 0.017640, train error 0.00, test loss 3.331854, test error 51.35\n", - "Epoch 300, train loss 0.007404, train error 0.00, test loss 3.823162, test error 51.53\n", - "Epoch 400, train loss 0.004471, train error 0.00, test loss 4.123217, test error 51.42\n", - "Epoch 500, train loss 0.003124, train error 0.00, test loss 4.336044, test error 51.45\n", - "Epoch 600, train loss 0.002364, train error 0.00, test loss 4.503454, test error 51.45\n", - "Epoch 700, train loss 0.001882, train error 0.00, test loss 4.639870, test error 51.42\n", - "Epoch 800, train loss 0.001553, train error 0.00, test loss 4.755078, test error 51.50\n", - "Epoch 900, train loss 0.001317, train error 0.00, test loss 4.855614, test error 51.55\n", - "Training model with 90 hidden variables\n", - "Epoch 0, train loss 2.008511, train error 74.40, test loss 1.927014, test error 75.75\n", - "Epoch 100, train loss 0.164169, train error 1.88, test loss 2.238531, test error 52.53\n", - "Epoch 200, train loss 0.015319, train error 0.00, test loss 3.449536, test error 53.38\n", - "Epoch 300, train loss 0.006647, train error 0.00, test loss 3.922795, test error 53.05\n", - "Epoch 400, train loss 0.004047, train error 0.00, test loss 4.215492, test error 53.35\n", - "Epoch 500, train loss 0.002834, train error 0.00, test loss 4.422700, test error 53.25\n", - "Epoch 600, train loss 0.002148, train error 0.00, test loss 4.584569, test error 53.15\n", - "Epoch 700, train loss 0.001715, train error 0.00, test loss 4.716221, test error 53.20\n", - "Epoch 800, train loss 0.001418, train error 0.00, test loss 4.829510, test error 53.22\n", - "Epoch 900, train loss 0.001204, train error 0.00, test loss 4.927960, test error 53.22\n", - "Training model with 100 hidden variables\n", - "Epoch 0, train loss 1.997642, train error 74.65, test loss 1.917644, test error 75.68\n", - "Epoch 100, train loss 0.109920, train error 0.45, test loss 2.326162, test error 51.88\n", - "Epoch 200, train loss 0.012435, train error 0.00, test loss 3.261668, test error 51.88\n", - "Epoch 300, train loss 0.005718, train error 0.00, test loss 3.648452, test error 52.10\n", - "Epoch 400, train loss 0.003553, train error 0.00, test loss 3.895045, test error 52.20\n", - "Epoch 500, train loss 0.002519, train error 0.00, test loss 4.071107, test error 52.20\n", - "Epoch 600, train loss 0.001927, train error 0.00, test loss 4.210408, test error 52.35\n", - "Epoch 700, train loss 0.001548, train error 0.00, test loss 4.323563, test error 52.33\n", - "Epoch 800, train loss 0.001285, train error 0.00, test loss 4.422837, test error 52.25\n", - "Epoch 900, train loss 0.001094, train error 0.00, test loss 4.506187, test error 52.20\n", - "Training model with 120 hidden variables\n", - "Epoch 0, train loss 1.986796, train error 73.93, test loss 1.916073, test error 74.15\n", - "Epoch 100, train loss 0.052036, train error 0.00, test loss 2.240527, test error 50.47\n", - "Epoch 200, train loss 0.009687, train error 0.00, test loss 2.878947, test error 50.95\n", - "Epoch 300, train loss 0.004754, train error 0.00, test loss 3.163424, test error 51.08\n", - "Epoch 400, train loss 0.003041, train error 0.00, test loss 3.344830, test error 51.28\n", - "Epoch 500, train loss 0.002187, train error 0.00, test loss 3.480298, test error 51.25\n", - "Epoch 600, train loss 0.001688, train error 0.00, test loss 3.586750, test error 51.25\n", - "Epoch 700, train loss 0.001363, train error 0.00, test loss 3.674964, test error 51.30\n", - "Epoch 800, train loss 0.001136, train error 0.00, test loss 3.749809, test error 51.35\n", - "Epoch 900, train loss 0.000970, train error 0.00, test loss 3.816431, test error 51.38\n", - "Training model with 140 hidden variables\n", - "Epoch 0, train loss 1.972830, train error 74.05, test loss 1.902861, test error 73.90\n", - "Epoch 100, train loss 0.035940, train error 0.00, test loss 2.201971, test error 49.62\n", - "Epoch 200, train loss 0.008159, train error 0.00, test loss 2.700946, test error 49.97\n", - "Epoch 300, train loss 0.004193, train error 0.00, test loss 2.935437, test error 50.25\n", - "Epoch 400, train loss 0.002727, train error 0.00, test loss 3.090166, test error 50.40\n", - "Epoch 500, train loss 0.001985, train error 0.00, test loss 3.205765, test error 50.45\n", - "Epoch 600, train loss 0.001543, train error 0.00, test loss 3.297369, test error 50.38\n", - "Epoch 700, train loss 0.001254, train error 0.00, test loss 3.373976, test error 50.47\n", - "Epoch 800, train loss 0.001051, train error 0.00, test loss 3.438622, test error 50.55\n", - "Epoch 900, train loss 0.000901, train error 0.00, test loss 3.495601, test error 50.65\n", - "Training model with 160 hidden variables\n", - "Epoch 0, train loss 1.954547, train error 72.38, test loss 1.881418, test error 74.03\n", - "Epoch 100, train loss 0.027367, train error 0.00, test loss 2.192432, test error 49.33\n", - "Epoch 200, train loss 0.006922, train error 0.00, test loss 2.595632, test error 49.45\n", - "Epoch 300, train loss 0.003672, train error 0.00, test loss 2.795458, test error 49.47\n", - "Epoch 400, train loss 0.002422, train error 0.00, test loss 2.931873, test error 49.50\n", - "Epoch 500, train loss 0.001777, train error 0.00, test loss 3.031744, test error 49.62\n", - "Epoch 600, train loss 0.001389, train error 0.00, test loss 3.111899, test error 49.70\n", - "Epoch 700, train loss 0.001133, train error 0.00, test loss 3.179173, test error 49.67\n", - "Epoch 800, train loss 0.000952, train error 0.00, test loss 3.237365, test error 49.75\n", - "Epoch 900, train loss 0.000818, train error 0.00, test loss 3.287590, test error 49.75\n", - "Training model with 180 hidden variables\n", - "Epoch 0, train loss 1.911722, train error 70.70, test loss 1.859951, test error 73.47\n", - "Epoch 100, train loss 0.023744, train error 0.00, test loss 2.141875, test error 50.30\n", - "Epoch 200, train loss 0.006522, train error 0.00, test loss 2.517111, test error 50.25\n", - "Epoch 300, train loss 0.003506, train error 0.00, test loss 2.702383, test error 50.35\n", - "Epoch 400, train loss 0.002326, train error 0.00, test loss 2.825993, test error 50.33\n", - "Epoch 500, train loss 0.001714, train error 0.00, test loss 2.919655, test error 50.30\n", - "Epoch 600, train loss 0.001344, train error 0.00, test loss 2.994997, test error 50.30\n", - "Epoch 700, train loss 0.001098, train error 0.00, test loss 3.057640, test error 50.33\n", - "Epoch 800, train loss 0.000924, train error 0.00, test loss 3.110366, test error 50.20\n", - "Epoch 900, train loss 0.000795, train error 0.00, test loss 3.157181, test error 50.25\n", - "Training model with 200 hidden variables\n", - "Epoch 0, train loss 1.935183, train error 70.32, test loss 1.860099, test error 72.15\n", - "Epoch 100, train loss 0.021110, train error 0.00, test loss 2.097157, test error 49.95\n", - "Epoch 200, train loss 0.006083, train error 0.00, test loss 2.430903, test error 49.97\n", - "Epoch 300, train loss 0.003299, train error 0.00, test loss 2.602134, test error 49.67\n", - "Epoch 400, train loss 0.002203, train error 0.00, test loss 2.716572, test error 49.60\n", - "Epoch 500, train loss 0.001627, train error 0.00, test loss 2.802333, test error 49.50\n", - "Epoch 600, train loss 0.001278, train error 0.00, test loss 2.872474, test error 49.38\n", - "Epoch 700, train loss 0.001046, train error 0.00, test loss 2.930250, test error 49.38\n", - "Epoch 800, train loss 0.000881, train error 0.00, test loss 2.979946, test error 49.33\n", - "Epoch 900, train loss 0.000758, train error 0.00, test loss 3.023744, test error 49.38\n", - "Training model with 250 hidden variables\n", - "Epoch 0, train loss 1.890159, train error 68.22, test loss 1.832332, test error 71.40\n", - "Epoch 100, train loss 0.016685, train error 0.00, test loss 1.968000, test error 48.22\n", - "Epoch 200, train loss 0.005257, train error 0.00, test loss 2.231468, test error 47.85\n", - "Epoch 300, train loss 0.002929, train error 0.00, test loss 2.368432, test error 47.88\n", - "Epoch 400, train loss 0.001981, train error 0.00, test loss 2.465126, test error 47.75\n", - "Epoch 500, train loss 0.001476, train error 0.00, test loss 2.537093, test error 47.72\n", - "Epoch 600, train loss 0.001166, train error 0.00, test loss 2.595000, test error 47.70\n", - "Epoch 700, train loss 0.000958, train error 0.00, test loss 2.644549, test error 47.75\n", - "Epoch 800, train loss 0.000809, train error 0.00, test loss 2.686273, test error 47.58\n", - "Epoch 900, train loss 0.000698, train error 0.00, test loss 2.723091, test error 47.60\n", - "Training model with 300 hidden variables\n", - "Epoch 0, train loss 1.868014, train error 67.85, test loss 1.782235, test error 69.80\n", - "Epoch 100, train loss 0.013968, train error 0.00, test loss 1.921103, test error 47.92\n", - "Epoch 200, train loss 0.004723, train error 0.00, test loss 2.139918, test error 47.80\n", - "Epoch 300, train loss 0.002682, train error 0.00, test loss 2.255778, test error 47.38\n", - "Epoch 400, train loss 0.001830, train error 0.00, test loss 2.338202, test error 47.45\n", - "Epoch 500, train loss 0.001371, train error 0.00, test loss 2.401059, test error 47.38\n", - "Epoch 600, train loss 0.001086, train error 0.00, test loss 2.451458, test error 47.12\n", - "Epoch 700, train loss 0.000895, train error 0.00, test loss 2.494015, test error 47.15\n", - "Epoch 800, train loss 0.000757, train error 0.00, test loss 2.531076, test error 47.10\n", - "Epoch 900, train loss 0.000655, train error 0.00, test loss 2.563121, test error 47.03\n", - "Training model with 400 hidden variables\n", - "Epoch 0, train loss 1.906025, train error 69.03, test loss 1.813143, test error 70.03\n", - "Epoch 100, train loss 0.011582, train error 0.00, test loss 1.779863, test error 45.75\n", - "Epoch 200, train loss 0.004120, train error 0.00, test loss 1.948928, test error 45.55\n", - "Epoch 300, train loss 0.002390, train error 0.00, test loss 2.046339, test error 45.47\n", - "Epoch 400, train loss 0.001647, train error 0.00, test loss 2.114718, test error 45.35\n", - "Epoch 500, train loss 0.001242, train error 0.00, test loss 2.166928, test error 45.30\n", - "Epoch 600, train loss 0.000990, train error 0.00, test loss 2.209104, test error 45.15\n", - "Epoch 700, train loss 0.000818, train error 0.00, test loss 2.244647, test error 45.03\n", - "Epoch 800, train loss 0.000694, train error 0.00, test loss 2.275772, test error 45.10\n", - "Epoch 900, train loss 0.000602, train error 0.00, test loss 2.302584, test error 45.08\n" - ] - } - ], - "source": [ - "# This code will take a while (~30 mins on GPU) to run! Go and make a cup of coffee!\n", - "\n", - "hidden_variables = np.array([2,4,6,8,10,14,18,22,26,30,35,40,45,50,55,60,70,80,90,100,120,140,160,180,200,250,300,400]) ;\n", - "errors_train_all = np.zeros_like(hidden_variables)\n", - "errors_test_all = np.zeros_like(hidden_variables)\n", - "\n", - "# For each hidden variable size\n", - "for c_hidden in range(len(hidden_variables)):\n", - " print(f'Training model with {hidden_variables[c_hidden]:3d} hidden variables')\n", - " # Get a model\n", - " model = get_model(hidden_variables[c_hidden]) ;\n", - " # Train the model\n", - " errors_train, errors_test = fit_model(model, data)\n", - " # Store the results\n", - " errors_train_all[c_hidden] = errors_train\n", - " errors_test_all[c_hidden]= errors_test" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 667 + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "84K-7oU2szXs", + "outputId": "1298d651-273b-4c93-a114-0337b0779353", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n" + ] + } + ], + "source": [ + "if True:\n", + " # Only run this in Colab\n", + " from google.colab import drive\n", + " drive.mount('/content/gdrive')\n", + " project_dir = \"/content/gdrive/My Drive/Research/mnist1d/\"\n", + "else:\n", + " project_dir = './'" + ] }, - "id": "LHcrh7Ik0yuS", - "outputId": "37ddd07d-aeeb-4a9e-b576-fc5fd51c8508" - }, - "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "id": "8HwKO9tpszXs" + }, + "source": [ + "## Set up hyperparameters" ] - }, - "metadata": {}, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PW2gyXL5UkLU", + "outputId": "e6efc855-a742-47f3-b95c-13e526dac1bd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Did or could not load data from ./mnist1d_data.pkl. Rebuilding dataset...\n", + "Examples in training set: 4000\n", + "Examples in test set: 4000\n", + "Length of each example: 40\n" + ] + } + ], + "source": [ + "args = mnist1d.data.get_dataset_args()\n", + "args.num_samples = 8000\n", + "args.train_split = 0.5\n", + "args.corr_noise_scale = 0.25\n", + "args.iid_noise_scale=2e-2\n", + "data = mnist1d.data.get_dataset(args, path='./mnist1d_data.pkl', download=False, regenerate=True)\n", + "\n", + "# Add 15% noise to training labels\n", + "for c_y in range(len(data['y'])):\n", + " random_number = random.random()\n", + " if random_number < 0.15 :\n", + " random_int = int(random.random() * 10)\n", + " data['y'][c_y] = random_int\n", + "\n", + "# The training and test input and outputs are in\n", + "# data['x'], data['y'], data['x_test'], and data['y_test']\n", + "print(\"Examples in training set: {}\".format(len(data['y'])))\n", + "print(\"Examples in test set: {}\".format(len(data['y_test'])))\n", + "print(\"Length of each example: {}\".format(data['x'].shape[-1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "hAIvZOAlTnk9" + }, + "outputs": [], + "source": [ + "# Initialize the parameters with He initialization\n", + "def weights_init(layer_in):\n", + " if isinstance(layer_in, nn.Linear):\n", + " nn.init.kaiming_uniform_(layer_in.weight)\n", + " layer_in.bias.data.fill_(0.0)\n", + "\n", + "# Return an initialized model with two hidden layers and n_hidden hidden units at each\n", + "def get_model(n_hidden):\n", + "\n", + " D_i = 40 # Input dimensions\n", + " D_k = n_hidden # Hidden dimensions\n", + " D_o = 10 # Output dimensions\n", + "\n", + " # Define a model with two hidden layers of size 100\n", + " # And ReLU activations between them\n", + " model = nn.Sequential(\n", + " nn.Linear(D_i, D_k),\n", + " nn.ReLU(),\n", + " nn.Linear(D_k, D_k),\n", + " nn.ReLU(),\n", + " nn.Linear(D_k, D_o))\n", + "\n", + " # Call the function you just defined\n", + " model.apply(weights_init)\n", + "\n", + " # Return the model\n", + " return model ;" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "AazlQhheWmHk" + }, + "outputs": [], + "source": [ + "def fit_model(model, data):\n", + "\n", + " # choose cross entropy loss function (equation 5.24)\n", + " loss_function = torch.nn.CrossEntropyLoss()\n", + " # construct SGD optimizer and initialize learning rate and momentum\n", + " # optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n", + " optimizer = torch.optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)\n", + "\n", + "\n", + " # create 100 dummy data points and store in data loader class\n", + " x_train = torch.tensor(data['x'].astype('float32'))\n", + " y_train = torch.tensor(data['y'].transpose().astype('long'))\n", + " x_test= torch.tensor(data['x_test'].astype('float32'))\n", + " y_test = torch.tensor(data['y_test'].astype('long'))\n", + "\n", + " # load the data into a class that creates the batches\n", + " data_loader = DataLoader(TensorDataset(x_train,y_train), batch_size=100, shuffle=True, worker_init_fn=np.random.seed(1))\n", + "\n", + " # loop over the dataset n_epoch times\n", + " n_epoch = 1000\n", + "\n", + " for epoch in range(n_epoch):\n", + " # loop over batches\n", + " for i, batch in enumerate(data_loader):\n", + " # retrieve inputs and labels for this batch\n", + " x_batch, y_batch = batch\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + " # forward pass -- calculate model output\n", + " pred = model(x_batch)\n", + " # compute the loss\n", + " loss = loss_function(pred, y_batch)\n", + " # backward pass\n", + " loss.backward()\n", + " # SGD update\n", + " optimizer.step()\n", + "\n", + " # Run whole dataset to get statistics -- normally wouldn't do this\n", + " pred_train = model(x_train)\n", + " pred_test = model(x_test)\n", + " _, predicted_train_class = torch.max(pred_train.data, 1)\n", + " _, predicted_test_class = torch.max(pred_test.data, 1)\n", + " errors_train = 100 - 100 * (predicted_train_class == y_train).float().sum() / len(y_train)\n", + " errors_test= 100 - 100 * (predicted_test_class == y_test).float().sum() / len(y_test)\n", + " losses_train = loss_function(pred_train, y_train).item()\n", + " losses_test= loss_function(pred_test, y_test).item()\n", + " if epoch%100 ==0 :\n", + " print(f'Epoch {epoch:5d}, train loss {losses_train:.6f}, train error {errors_train:3.2f}, test loss {losses_test:.6f}, test error {errors_test:3.2f}')\n", + "\n", + " return errors_train, errors_test\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IcP4UPMudxPS" + }, + "source": [ + "## The following code produces the double descent curve by training the model with different numbers of hidden units and plotting the test error." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K4OmBZGHWXpk", + "outputId": "805c4bac-1d07-4862-cee9-4324f2530c9c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training model with 2 hidden variables\n", + "Epoch 0, train loss 2.277798, train error 85.95, test loss 2.278397, test error 86.47\n", + "Epoch 100, train loss 1.929422, train error 73.53, test loss 1.759784, test error 70.10\n", + "Epoch 200, train loss 1.911519, train error 70.95, test loss 1.762149, test error 69.47\n", + "Epoch 300, train loss 1.904752, train error 70.93, test loss 1.750811, test error 67.88\n", + "Epoch 400, train loss 1.902335, train error 72.22, test loss 1.733160, test error 68.28\n", + "Epoch 500, train loss 1.899587, train error 71.32, test loss 1.730040, test error 67.85\n", + "Epoch 600, train loss 1.898971, train error 70.25, test loss 1.748773, test error 68.62\n", + "Epoch 700, train loss 1.901459, train error 70.97, test loss 1.744638, test error 68.70\n", + "Epoch 800, train loss 1.907022, train error 71.90, test loss 1.726579, test error 68.60\n", + "Epoch 900, train loss 1.899073, train error 71.30, test loss 1.728388, test error 68.20\n", + "Training model with 4 hidden variables\n", + "Epoch 0, train loss 2.305642, train error 89.22, test loss 2.306927, test error 89.38\n", + "Epoch 100, train loss 1.851166, train error 68.93, test loss 1.721395, test error 67.45\n", + "Epoch 200, train loss 1.842221, train error 68.95, test loss 1.713934, test error 67.93\n", + "Epoch 300, train loss 1.840521, train error 68.68, test loss 1.724285, test error 67.53\n", + "Epoch 400, train loss 1.843446, train error 69.18, test loss 1.718536, test error 68.22\n", + "Epoch 500, train loss 1.837805, train error 68.70, test loss 1.724053, test error 68.40\n", + "Epoch 600, train loss 1.836774, train error 68.35, test loss 1.722682, test error 67.78\n", + "Epoch 700, train loss 1.839800, train error 69.00, test loss 1.725044, test error 68.68\n", + "Epoch 800, train loss 1.837812, train error 68.70, test loss 1.720145, test error 68.45\n", + "Epoch 900, train loss 1.836510, train error 68.25, test loss 1.731109, test error 68.28\n", + "Training model with 6 hidden variables\n", + "Epoch 0, train loss 2.296063, train error 87.80, test loss 2.289008, test error 87.12\n", + "Epoch 100, train loss 1.782382, train error 66.60, test loss 1.657886, test error 67.12\n", + "Epoch 200, train loss 1.769995, train error 65.70, test loss 1.654014, test error 65.80\n", + "Epoch 300, train loss 1.766263, train error 65.72, test loss 1.665794, test error 66.32\n", + "Epoch 400, train loss 1.732158, train error 64.55, test loss 1.628523, test error 63.95\n", + "Epoch 500, train loss 1.727116, train error 63.72, test loss 1.619467, test error 63.38\n", + "Epoch 600, train loss 1.718737, train error 62.53, test loss 1.622113, test error 64.60\n", + "Epoch 700, train loss 1.712936, train error 62.62, test loss 1.622989, test error 63.47\n", + "Epoch 800, train loss 1.717998, train error 63.38, test loss 1.641411, test error 64.68\n", + "Epoch 900, train loss 1.712761, train error 62.75, test loss 1.633255, test error 63.92\n", + "Training model with 8 hidden variables\n", + "Epoch 0, train loss 2.305267, train error 87.38, test loss 2.311470, test error 88.28\n", + "Epoch 100, train loss 1.730496, train error 61.15, test loss 1.615144, test error 61.75\n", + "Epoch 200, train loss 1.534971, train error 52.33, test loss 1.373511, test error 51.03\n", + "Epoch 300, train loss 1.499398, train error 51.03, test loss 1.353365, test error 50.65\n", + "Epoch 400, train loss 1.498065, train error 51.90, test loss 1.355931, test error 51.40\n", + "Epoch 500, train loss 1.480597, train error 51.20, test loss 1.346169, test error 50.75\n", + "Epoch 600, train loss 1.475865, train error 50.58, test loss 1.342336, test error 49.95\n", + "Epoch 700, train loss 1.469683, train error 50.15, test loss 1.342557, test error 50.88\n", + "Epoch 800, train loss 1.467087, train error 50.62, test loss 1.340699, test error 50.35\n", + "Epoch 900, train loss 1.469405, train error 51.00, test loss 1.351334, test error 50.05\n", + "Training model with 10 hidden variables\n", + "Epoch 0, train loss 2.234534, train error 84.80, test loss 2.224005, test error 84.22\n", + "Epoch 100, train loss 1.594883, train error 56.70, test loss 1.466902, test error 57.28\n", + "Epoch 200, train loss 1.527535, train error 53.75, test loss 1.437089, test error 55.40\n", + "Epoch 300, train loss 1.498228, train error 51.85, test loss 1.436568, test error 55.28\n", + "Epoch 400, train loss 1.480634, train error 52.47, test loss 1.441888, test error 55.20\n", + "Epoch 500, train loss 1.470844, train error 52.00, test loss 1.458117, test error 55.25\n", + "Epoch 600, train loss 1.464356, train error 51.42, test loss 1.453825, test error 55.53\n", + "Epoch 700, train loss 1.466169, train error 51.83, test loss 1.464509, test error 55.62\n", + "Epoch 800, train loss 1.459520, train error 51.10, test loss 1.466022, test error 55.38\n", + "Epoch 900, train loss 1.452488, train error 51.30, test loss 1.462659, test error 54.20\n", + "Training model with 14 hidden variables\n", + "Epoch 0, train loss 2.146217, train error 81.07, test loss 2.126280, test error 81.00\n", + "Epoch 100, train loss 1.477179, train error 51.17, test loss 1.410910, test error 53.35\n", + "Epoch 200, train loss 1.403087, train error 48.53, test loss 1.402029, test error 52.78\n", + "Epoch 300, train loss 1.370836, train error 47.45, test loss 1.410461, test error 52.90\n", + "Epoch 400, train loss 1.348348, train error 45.62, test loss 1.411001, test error 52.80\n", + "Epoch 500, train loss 1.324302, train error 45.65, test loss 1.390860, test error 52.88\n", + "Epoch 600, train loss 1.314746, train error 45.20, test loss 1.393942, test error 52.58\n", + "Epoch 700, train loss 1.308699, train error 44.95, test loss 1.416470, test error 52.22\n", + "Epoch 800, train loss 1.307101, train error 44.75, test loss 1.422840, test error 52.28\n", + "Epoch 900, train loss 1.301498, train error 45.03, test loss 1.426830, test error 51.80\n", + "Training model with 18 hidden variables\n", + "Epoch 0, train loss 2.142181, train error 79.82, test loss 2.103149, test error 79.72\n", + "Epoch 100, train loss 1.364448, train error 46.20, test loss 1.287756, test error 48.35\n", + "Epoch 200, train loss 1.253487, train error 42.35, test loss 1.283555, test error 47.30\n", + "Epoch 300, train loss 1.203104, train error 40.38, test loss 1.316006, test error 46.97\n", + "Epoch 400, train loss 1.176826, train error 39.58, test loss 1.359188, test error 47.80\n", + "Epoch 500, train loss 1.162791, train error 39.17, test loss 1.397180, test error 48.22\n", + "Epoch 600, train loss 1.148493, train error 38.75, test loss 1.405104, test error 48.15\n", + "Epoch 700, train loss 1.136651, train error 37.33, test loss 1.432554, test error 49.20\n", + "Epoch 800, train loss 1.129435, train error 37.92, test loss 1.453079, test error 49.03\n", + "Epoch 900, train loss 1.123817, train error 37.78, test loss 1.478313, test error 49.92\n", + "Training model with 22 hidden variables\n", + "Epoch 0, train loss 2.208354, train error 80.93, test loss 2.179399, test error 79.75\n", + "Epoch 100, train loss 1.265390, train error 42.60, test loss 1.315378, test error 47.05\n", + "Epoch 200, train loss 1.144453, train error 38.72, test loss 1.416743, test error 49.12\n", + "Epoch 300, train loss 1.078853, train error 37.15, test loss 1.522008, test error 50.53\n", + "Epoch 400, train loss 1.044330, train error 34.47, test loss 1.610976, test error 51.53\n", + "Epoch 500, train loss 1.026177, train error 35.35, test loss 1.661785, test error 51.35\n", + "Epoch 600, train loss 1.007766, train error 34.90, test loss 1.745563, test error 52.10\n", + "Epoch 700, train loss 0.996448, train error 34.47, test loss 1.797653, test error 52.12\n", + "Epoch 800, train loss 0.986775, train error 34.25, test loss 1.883572, test error 52.67\n", + "Epoch 900, train loss 0.974680, train error 33.47, test loss 1.932562, test error 53.08\n", + "Training model with 26 hidden variables\n", + "Epoch 0, train loss 2.104259, train error 78.15, test loss 2.053929, test error 77.07\n", + "Epoch 100, train loss 1.189821, train error 39.53, test loss 1.256541, test error 46.72\n", + "Epoch 200, train loss 1.038548, train error 34.35, test loss 1.332605, test error 47.80\n", + "Epoch 300, train loss 0.952429, train error 32.10, test loss 1.450068, test error 49.33\n", + "Epoch 400, train loss 0.898211, train error 31.07, test loss 1.577021, test error 50.20\n", + "Epoch 500, train loss 0.858215, train error 28.75, test loss 1.683115, test error 50.83\n", + "Epoch 600, train loss 0.828292, train error 28.68, test loss 1.805334, test error 51.62\n", + "Epoch 700, train loss 0.801849, train error 27.25, test loss 1.878300, test error 51.70\n", + "Epoch 800, train loss 0.791768, train error 27.82, test loss 1.955360, test error 52.12\n", + "Epoch 900, train loss 0.797058, train error 27.72, test loss 2.071712, test error 52.45\n", + "Training model with 30 hidden variables\n", + "Epoch 0, train loss 2.173317, train error 79.57, test loss 2.154406, test error 80.07\n", + "Epoch 100, train loss 1.113931, train error 37.50, test loss 1.376841, test error 50.50\n", + "Epoch 200, train loss 0.950208, train error 31.88, test loss 1.542872, test error 51.00\n", + "Epoch 300, train loss 0.860230, train error 28.57, test loss 1.763987, test error 53.40\n", + "Epoch 400, train loss 0.792413, train error 25.78, test loss 1.963454, test error 54.38\n", + "Epoch 500, train loss 0.755384, train error 25.82, test loss 2.147870, test error 54.78\n", + "Epoch 600, train loss 0.720875, train error 24.57, test loss 2.297896, test error 54.50\n", + "Epoch 700, train loss 0.708125, train error 23.90, test loss 2.407183, test error 55.08\n", + "Epoch 800, train loss 0.706724, train error 24.07, test loss 2.529273, test error 55.80\n", + "Epoch 900, train loss 0.681161, train error 22.97, test loss 2.551394, test error 55.53\n", + "Training model with 35 hidden variables\n", + "Epoch 0, train loss 2.091297, train error 76.95, test loss 2.040095, test error 76.10\n", + "Epoch 100, train loss 1.009840, train error 33.72, test loss 1.455501, test error 50.88\n", + "Epoch 200, train loss 0.776223, train error 26.22, test loss 1.843668, test error 52.58\n", + "Epoch 300, train loss 0.667015, train error 22.53, test loss 2.266239, test error 55.08\n", + "Epoch 400, train loss 0.596252, train error 20.15, test loss 2.630574, test error 54.35\n", + "Epoch 500, train loss 0.555517, train error 19.57, test loss 3.066689, test error 56.38\n", + "Epoch 600, train loss 0.508091, train error 17.90, test loss 3.507661, test error 56.92\n", + "Epoch 700, train loss 0.459423, train error 15.93, test loss 3.901947, test error 57.35\n", + "Epoch 800, train loss 0.460926, train error 16.72, test loss 4.213217, test error 57.30\n", + "Epoch 900, train loss 0.454525, train error 16.43, test loss 4.511256, test error 56.62\n", + "Training model with 40 hidden variables\n", + "Epoch 0, train loss 2.112535, train error 77.45, test loss 2.110076, test error 78.05\n", + "Epoch 100, train loss 0.927038, train error 29.03, test loss 1.472567, test error 51.25\n", + "Epoch 200, train loss 0.675030, train error 21.72, test loss 1.957363, test error 53.80\n", + "Epoch 300, train loss 0.514380, train error 16.22, test loss 2.608608, test error 56.38\n", + "Epoch 400, train loss 0.403386, train error 12.32, test loss 3.201011, test error 55.88\n", + "Epoch 500, train loss 0.337224, train error 10.88, test loss 3.906964, test error 56.28\n", + "Epoch 600, train loss 0.320731, train error 10.47, test loss 4.684555, test error 56.97\n", + "Epoch 700, train loss 0.260660, train error 8.53, test loss 5.368700, test error 57.60\n", + "Epoch 800, train loss 0.273061, train error 9.50, test loss 6.093386, test error 57.97\n", + "Epoch 900, train loss 0.217861, train error 8.00, test loss 6.882625, test error 58.08\n", + "Training model with 45 hidden variables\n", + "Epoch 0, train loss 2.125701, train error 78.32, test loss 2.093323, test error 77.90\n", + "Epoch 100, train loss 0.823193, train error 26.50, test loss 1.454006, test error 49.15\n", + "Epoch 200, train loss 0.483560, train error 15.75, test loss 2.161387, test error 52.88\n", + "Epoch 300, train loss 0.318699, train error 10.28, test loss 3.112746, test error 53.97\n", + "Epoch 400, train loss 0.216546, train error 7.28, test loss 4.249859, test error 55.35\n", + "Epoch 500, train loss 0.261341, train error 9.38, test loss 5.473794, test error 54.60\n", + "Epoch 600, train loss 0.114566, train error 3.50, test loss 6.637478, test error 55.60\n", + "Epoch 700, train loss 0.021248, train error 0.00, test loss 7.606625, test error 55.47\n", + "Epoch 800, train loss 0.011991, train error 0.00, test loss 8.434978, test error 55.50\n", + "Epoch 900, train loss 0.008384, train error 0.00, test loss 9.053809, test error 55.55\n", + "Training model with 50 hidden variables\n", + "Epoch 0, train loss 2.068581, train error 77.05, test loss 2.011443, test error 76.78\n", + "Epoch 100, train loss 0.710207, train error 21.68, test loss 1.590943, test error 50.78\n", + "Epoch 200, train loss 0.331485, train error 9.78, test loss 2.717822, test error 53.28\n", + "Epoch 300, train loss 0.152775, train error 3.68, test loss 4.292100, test error 55.65\n", + "Epoch 400, train loss 0.031117, train error 0.03, test loss 5.680546, test error 54.92\n", + "Epoch 500, train loss 0.013629, train error 0.00, test loss 6.633136, test error 55.05\n", + "Epoch 600, train loss 0.008529, train error 0.00, test loss 7.260022, test error 55.17\n", + "Epoch 700, train loss 0.006064, train error 0.00, test loss 7.714928, test error 55.15\n", + "Epoch 800, train loss 0.004673, train error 0.00, test loss 8.102780, test error 55.25\n", + "Epoch 900, train loss 0.003773, train error 0.00, test loss 8.405490, test error 55.28\n", + "Training model with 55 hidden variables\n", + "Epoch 0, train loss 2.057113, train error 77.88, test loss 1.986622, test error 75.95\n", + "Epoch 100, train loss 0.579253, train error 17.30, test loss 1.660998, test error 51.58\n", + "Epoch 200, train loss 0.191182, train error 4.90, test loss 3.165936, test error 54.85\n", + "Epoch 300, train loss 0.029577, train error 0.00, test loss 4.815818, test error 55.40\n", + "Epoch 400, train loss 0.012224, train error 0.00, test loss 5.730045, test error 55.17\n", + "Epoch 500, train loss 0.007409, train error 0.00, test loss 6.301328, test error 55.12\n", + "Epoch 600, train loss 0.005215, train error 0.00, test loss 6.721978, test error 55.30\n", + "Epoch 700, train loss 0.003948, train error 0.00, test loss 7.047026, test error 55.28\n", + "Epoch 800, train loss 0.003139, train error 0.00, test loss 7.322274, test error 55.15\n", + "Epoch 900, train loss 0.002599, train error 0.00, test loss 7.553209, test error 55.30\n", + "Training model with 60 hidden variables\n", + "Epoch 0, train loss 2.068582, train error 76.18, test loss 2.007226, test error 76.25\n", + "Epoch 100, train loss 0.533304, train error 15.53, test loss 1.742298, test error 51.92\n", + "Epoch 200, train loss 0.122812, train error 1.97, test loss 3.303282, test error 54.10\n", + "Epoch 300, train loss 0.021038, train error 0.03, test loss 4.671144, test error 54.38\n", + "Epoch 400, train loss 0.009639, train error 0.00, test loss 5.351838, test error 54.15\n", + "Epoch 500, train loss 0.006082, train error 0.00, test loss 5.799342, test error 54.28\n", + "Epoch 600, train loss 0.004322, train error 0.00, test loss 6.126484, test error 54.45\n", + "Epoch 700, train loss 0.003307, train error 0.00, test loss 6.388663, test error 54.45\n", + "Epoch 800, train loss 0.002661, train error 0.00, test loss 6.606226, test error 54.53\n", + "Epoch 900, train loss 0.002208, train error 0.00, test loss 6.791449, test error 54.62\n", + "Training model with 70 hidden variables\n", + "Epoch 0, train loss 2.045562, train error 75.90, test loss 1.999222, test error 75.62\n", + "Epoch 100, train loss 0.362263, train error 8.85, test loss 1.909161, test error 51.50\n", + "Epoch 200, train loss 0.032422, train error 0.00, test loss 3.479482, test error 52.17\n", + "Epoch 300, train loss 0.011008, train error 0.00, test loss 4.242747, test error 52.40\n", + "Epoch 400, train loss 0.006122, train error 0.00, test loss 4.679764, test error 52.35\n", + "Epoch 500, train loss 0.004145, train error 0.00, test loss 4.979578, test error 52.65\n", + "Epoch 600, train loss 0.003054, train error 0.00, test loss 5.203156, test error 52.42\n", + "Epoch 700, train loss 0.002396, train error 0.00, test loss 5.388821, test error 52.62\n", + "Epoch 800, train loss 0.001957, train error 0.00, test loss 5.540919, test error 52.65\n", + "Epoch 900, train loss 0.001646, train error 0.00, test loss 5.674027, test error 52.67\n", + "Training model with 80 hidden variables\n", + "Epoch 0, train loss 2.012289, train error 75.57, test loss 1.935207, test error 75.10\n", + "Epoch 100, train loss 0.223808, train error 3.15, test loss 2.030555, test error 52.00\n", + "Epoch 200, train loss 0.019970, train error 0.00, test loss 3.356064, test error 53.00\n", + "Epoch 300, train loss 0.007981, train error 0.00, test loss 3.890963, test error 53.25\n", + "Epoch 400, train loss 0.004739, train error 0.00, test loss 4.209256, test error 53.38\n", + "Epoch 500, train loss 0.003287, train error 0.00, test loss 4.436763, test error 53.45\n", + "Epoch 600, train loss 0.002479, train error 0.00, test loss 4.615886, test error 53.47\n", + "Epoch 700, train loss 0.001971, train error 0.00, test loss 4.762332, test error 53.65\n", + "Epoch 800, train loss 0.001624, train error 0.00, test loss 4.883774, test error 53.62\n", + "Epoch 900, train loss 0.001374, train error 0.00, test loss 4.989693, test error 53.67\n", + "Training model with 90 hidden variables\n", + "Epoch 0, train loss 2.011843, train error 74.57, test loss 1.920866, test error 74.22\n", + "Epoch 100, train loss 0.147898, train error 1.15, test loss 2.236695, test error 52.00\n", + "Epoch 200, train loss 0.015235, train error 0.00, test loss 3.386966, test error 52.97\n", + "Epoch 300, train loss 0.006678, train error 0.00, test loss 3.855526, test error 53.10\n", + "Epoch 400, train loss 0.004074, train error 0.00, test loss 4.146383, test error 53.25\n", + "Epoch 500, train loss 0.002863, train error 0.00, test loss 4.353124, test error 53.10\n", + "Epoch 600, train loss 0.002175, train error 0.00, test loss 4.515549, test error 53.12\n", + "Epoch 700, train loss 0.001738, train error 0.00, test loss 4.648784, test error 53.00\n", + "Epoch 800, train loss 0.001438, train error 0.00, test loss 4.761609, test error 53.15\n", + "Epoch 900, train loss 0.001221, train error 0.00, test loss 4.858825, test error 53.20\n", + "Training model with 100 hidden variables\n", + "Epoch 0, train loss 1.980510, train error 73.03, test loss 1.922574, test error 74.07\n", + "Epoch 100, train loss 0.085691, train error 0.18, test loss 2.267983, test error 51.25\n", + "Epoch 200, train loss 0.012223, train error 0.00, test loss 3.129498, test error 51.28\n", + "Epoch 300, train loss 0.005662, train error 0.00, test loss 3.494441, test error 51.12\n", + "Epoch 400, train loss 0.003526, train error 0.00, test loss 3.724051, test error 51.12\n", + "Epoch 500, train loss 0.002506, train error 0.00, test loss 3.891907, test error 51.20\n", + "Epoch 600, train loss 0.001920, train error 0.00, test loss 4.022094, test error 51.25\n", + "Epoch 700, train loss 0.001542, train error 0.00, test loss 4.130742, test error 51.20\n", + "Epoch 800, train loss 0.001281, train error 0.00, test loss 4.222344, test error 51.20\n", + "Epoch 900, train loss 0.001091, train error 0.00, test loss 4.301238, test error 51.28\n", + "Training model with 120 hidden variables\n", + "Epoch 0, train loss 1.943708, train error 70.85, test loss 1.866282, test error 71.62\n", + "Epoch 100, train loss 0.050664, train error 0.00, test loss 2.186416, test error 50.05\n", + "Epoch 200, train loss 0.009387, train error 0.00, test loss 2.795197, test error 50.15\n", + "Epoch 300, train loss 0.004621, train error 0.00, test loss 3.068460, test error 50.35\n", + "Epoch 400, train loss 0.002968, train error 0.00, test loss 3.245287, test error 50.38\n", + "Epoch 500, train loss 0.002140, train error 0.00, test loss 3.376844, test error 50.40\n", + "Epoch 600, train loss 0.001657, train error 0.00, test loss 3.481111, test error 50.60\n", + "Epoch 700, train loss 0.001341, train error 0.00, test loss 3.567583, test error 50.50\n", + "Epoch 800, train loss 0.001119, train error 0.00, test loss 3.640468, test error 50.40\n", + "Epoch 900, train loss 0.000958, train error 0.00, test loss 3.704510, test error 50.45\n", + "Training model with 140 hidden variables\n", + "Epoch 0, train loss 1.942865, train error 71.62, test loss 1.865268, test error 72.45\n", + "Epoch 100, train loss 0.036812, train error 0.00, test loss 2.168292, test error 49.88\n", + "Epoch 200, train loss 0.008186, train error 0.00, test loss 2.652970, test error 49.88\n", + "Epoch 300, train loss 0.004203, train error 0.00, test loss 2.884356, test error 50.35\n", + "Epoch 400, train loss 0.002725, train error 0.00, test loss 3.039208, test error 50.47\n", + "Epoch 500, train loss 0.001981, train error 0.00, test loss 3.152171, test error 50.38\n", + "Epoch 600, train loss 0.001540, train error 0.00, test loss 3.241005, test error 50.38\n", + "Epoch 700, train loss 0.001250, train error 0.00, test loss 3.316286, test error 50.38\n", + "Epoch 800, train loss 0.001046, train error 0.00, test loss 3.379523, test error 50.40\n", + "Epoch 900, train loss 0.000896, train error 0.00, test loss 3.434940, test error 50.40\n", + "Training model with 160 hidden variables\n", + "Epoch 0, train loss 1.957147, train error 72.15, test loss 1.887318, test error 74.07\n", + "Epoch 100, train loss 0.028162, train error 0.00, test loss 2.163814, test error 49.75\n", + "Epoch 200, train loss 0.007050, train error 0.00, test loss 2.569677, test error 49.47\n", + "Epoch 300, train loss 0.003709, train error 0.00, test loss 2.770983, test error 49.45\n", + "Epoch 400, train loss 0.002438, train error 0.00, test loss 2.905585, test error 49.55\n", + "Epoch 500, train loss 0.001786, train error 0.00, test loss 3.003768, test error 49.47\n", + "Epoch 600, train loss 0.001393, train error 0.00, test loss 3.083718, test error 49.60\n", + "Epoch 700, train loss 0.001135, train error 0.00, test loss 3.149890, test error 49.60\n", + "Epoch 800, train loss 0.000953, train error 0.00, test loss 3.207501, test error 49.60\n", + "Epoch 900, train loss 0.000818, train error 0.00, test loss 3.256952, test error 49.55\n", + "Training model with 180 hidden variables\n", + "Epoch 0, train loss 1.932707, train error 71.57, test loss 1.855839, test error 72.03\n", + "Epoch 100, train loss 0.023571, train error 0.00, test loss 2.108888, test error 48.97\n", + "Epoch 200, train loss 0.006491, train error 0.00, test loss 2.470407, test error 49.38\n", + "Epoch 300, train loss 0.003482, train error 0.00, test loss 2.654031, test error 49.30\n", + "Epoch 400, train loss 0.002311, train error 0.00, test loss 2.774333, test error 49.33\n", + "Epoch 500, train loss 0.001702, train error 0.00, test loss 2.864647, test error 49.50\n", + "Epoch 600, train loss 0.001334, train error 0.00, test loss 2.938636, test error 49.47\n", + "Epoch 700, train loss 0.001089, train error 0.00, test loss 3.000289, test error 49.50\n", + "Epoch 800, train loss 0.000916, train error 0.00, test loss 3.052549, test error 49.40\n", + "Epoch 900, train loss 0.000788, train error 0.00, test loss 3.098409, test error 49.42\n", + "Training model with 200 hidden variables\n", + "Epoch 0, train loss 1.924386, train error 70.97, test loss 1.850654, test error 71.35\n", + "Epoch 100, train loss 0.021921, train error 0.00, test loss 1.969747, test error 48.00\n", + "Epoch 200, train loss 0.006208, train error 0.00, test loss 2.279866, test error 48.10\n", + "Epoch 300, train loss 0.003361, train error 0.00, test loss 2.440256, test error 48.08\n", + "Epoch 400, train loss 0.002236, train error 0.00, test loss 2.548698, test error 48.10\n", + "Epoch 500, train loss 0.001651, train error 0.00, test loss 2.628224, test error 47.90\n", + "Epoch 600, train loss 0.001296, train error 0.00, test loss 2.693671, test error 47.80\n", + "Epoch 700, train loss 0.001060, train error 0.00, test loss 2.747444, test error 47.88\n", + "Epoch 800, train loss 0.000892, train error 0.00, test loss 2.794039, test error 47.90\n", + "Epoch 900, train loss 0.000767, train error 0.00, test loss 2.834373, test error 47.70\n", + "Training model with 250 hidden variables\n", + "Epoch 0, train loss 1.900808, train error 68.32, test loss 1.812863, test error 69.80\n", + "Epoch 100, train loss 0.017362, train error 0.00, test loss 1.916260, test error 47.22\n", + "Epoch 200, train loss 0.005418, train error 0.00, test loss 2.176876, test error 47.50\n", + "Epoch 300, train loss 0.003008, train error 0.00, test loss 2.312958, test error 47.53\n", + "Epoch 400, train loss 0.002028, train error 0.00, test loss 2.405332, test error 47.53\n", + "Epoch 500, train loss 0.001509, train error 0.00, test loss 2.476225, test error 47.47\n", + "Epoch 600, train loss 0.001191, train error 0.00, test loss 2.532754, test error 47.42\n", + "Epoch 700, train loss 0.000977, train error 0.00, test loss 2.580711, test error 47.30\n", + "Epoch 800, train loss 0.000825, train error 0.00, test loss 2.621753, test error 47.22\n", + "Epoch 900, train loss 0.000712, train error 0.00, test loss 2.657163, test error 47.15\n", + "Training model with 300 hidden variables\n", + "Epoch 0, train loss 1.877477, train error 67.97, test loss 1.789489, test error 69.50\n", + "Epoch 100, train loss 0.014561, train error 0.00, test loss 1.874937, test error 47.15\n", + "Epoch 200, train loss 0.004836, train error 0.00, test loss 2.100475, test error 47.15\n", + "Epoch 300, train loss 0.002740, train error 0.00, test loss 2.219764, test error 47.15\n", + "Epoch 400, train loss 0.001866, train error 0.00, test loss 2.303527, test error 47.25\n", + "Epoch 500, train loss 0.001396, train error 0.00, test loss 2.366918, test error 47.42\n", + "Epoch 600, train loss 0.001106, train error 0.00, test loss 2.418468, test error 47.40\n", + "Epoch 700, train loss 0.000910, train error 0.00, test loss 2.461385, test error 47.58\n", + "Epoch 800, train loss 0.000771, train error 0.00, test loss 2.498425, test error 47.58\n", + "Epoch 900, train loss 0.000666, train error 0.00, test loss 2.530921, test error 47.58\n", + "Training model with 400 hidden variables\n", + "Epoch 0, train loss 1.832919, train error 65.55, test loss 1.745499, test error 66.75\n", + "Epoch 100, train loss 0.011636, train error 0.00, test loss 1.691945, test error 44.50\n", + "Epoch 200, train loss 0.004143, train error 0.00, test loss 1.859708, test error 44.30\n", + "Epoch 300, train loss 0.002399, train error 0.00, test loss 1.952566, test error 44.40\n", + "Epoch 400, train loss 0.001654, train error 0.00, test loss 2.018919, test error 44.30\n", + "Epoch 500, train loss 0.001246, train error 0.00, test loss 2.068805, test error 44.08\n", + "Epoch 600, train loss 0.000993, train error 0.00, test loss 2.109763, test error 43.97\n", + "Epoch 700, train loss 0.000821, train error 0.00, test loss 2.144062, test error 44.08\n", + "Epoch 800, train loss 0.000697, train error 0.00, test loss 2.173550, test error 44.03\n", + "Epoch 900, train loss 0.000604, train error 0.00, test loss 2.199606, test error 44.15\n" + ] + } + ], + "source": [ + "# This code will take a while (~30 mins on GPU) to run! Go and make a cup of coffee!\n", + "\n", + "hidden_variables = np.array([2,4,6,8,10,14,18,22,26,30,35,40,45,50,55,60,70,80,90,100,120,140,160,180,200,250,300,400]) ;\n", + "errors_train_all = np.zeros_like(hidden_variables)\n", + "errors_test_all = np.zeros_like(hidden_variables)\n", + "\n", + "# For each hidden variable size\n", + "for c_hidden in range(len(hidden_variables)):\n", + " print(f'Training model with {hidden_variables[c_hidden]:3d} hidden variables')\n", + " # Get a model\n", + " model = get_model(hidden_variables[c_hidden]) ;\n", + " # Train the model\n", + " errors_train, errors_test = fit_model(model, data)\n", + " # Store the results\n", + " errors_train_all[c_hidden] = errors_train\n", + " errors_test_all[c_hidden]= errors_test" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 671 + }, + "id": "LHcrh7Ik0yuS", + "outputId": "64c7f7de-4369-470d-bcbb-6ccead7d61a8" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "fig = plt.figure(dpi=250, figsize=[4,2.5])\n", + "plt.plot(hidden_variables, errors_train_all,'r.-', label='train', alpha=0.33, linewidth=2.5)\n", + "plt.plot(hidden_variables, errors_test_all,'b.-', label='test', linewidth=2.5)\n", + "plt.ylim(-5,80);\n", + "plt.xlabel('Size of hidden layer'); plt.ylabel('Test error')\n", + "plt.legend(ncols=2)\n", + "plt.show()\n", + "\n", + "os.makedirs(project_dir + 'figures/', exist_ok=True)\n", + "fig.savefig(project_dir + 'figures/deep_double_descent.png')\n", + "fig.savefig(project_dir + 'figures/deep_double_descent.pdf')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "hhvnAJ2F0r15" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "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.9.18" } - ], - "source": [ - "plt.figure(dpi=250, figsize=[4,2.5])\n", - "plt.plot(hidden_variables, errors_train_all,'r.-', label='train', alpha=0.33, linewidth=2.5)\n", - "plt.plot(hidden_variables, errors_test_all,'b.-', label='test', linewidth=2.5)\n", - "plt.ylim(-5,80);\n", - "plt.xlabel('Size of hidden layer'); plt.ylabel('Test error')\n", - "plt.legend(ncols=2)\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "hhvnAJ2F0r15" - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "gpuType": "T4", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.18" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file