assignment2/Dropout.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "language_info": {
      "name": "python"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jJZyS84WrH3M",
        "outputId": "9bda24d6-4138-4977-92e0-0e0e74d112dc"
      },
      "source": [
        "# This mounts your Google Drive to the Colab VM.\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# TODO: Enter the foldername in your Drive where you have saved the unzipped\n",
        "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
        "FOLDERNAME = 'cs231n/assignments/assignment2/'\n",
        "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
        "\n",
        "# Now that we've mounted your Drive, this ensures that\n",
        "# the Python interpreter of the Colab VM can load\n",
        "# python files from within it.\n",
        "import sys\n",
        "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
        "\n",
        "# This downloads the CIFAR-10 dataset to your Drive\n",
        "# if it doesn't already exist.\n",
        "%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
        "!bash get_datasets.sh\n",
        "%cd /content/drive/My\\ Drive/$FOLDERNAME"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "/content/drive/My Drive/cs231n/assignments/assignment2/cs231n/datasets\n",
            "/content/drive/My Drive/cs231n/assignments/assignment2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "tags": [
          "pdf-title"
        ],
        "id": "o0y5G_rNrH3T"
      },
      "source": [
        "# Dropout\n",
        "Dropout [1] is a technique for regularizing neural networks by randomly setting some output activations to zero during the forward pass. In this exercise, you will implement a dropout layer and modify your fully connected network to optionally use dropout.\n",
        "\n",
        "[1] [Geoffrey E. Hinton et al, \"Improving neural networks by preventing co-adaptation of feature detectors\", arXiv 2012](https://arxiv.org/abs/1207.0580)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [
          "pdf-ignore"
        ],
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BdtROBuKrH3V",
        "outputId": "261dd691-0ba3-4842-c809-5e9ae75ee460"
      },
      "source": [
        "# Setup cell.\n",
        "import time\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from cs231n.classifiers.fc_net import *\n",
        "from cs231n.data_utils import get_CIFAR10_data\n",
        "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
        "from cs231n.solver import Solver\n",
        "\n",
        "%matplotlib inline\n",
        "plt.rcParams[\"figure.figsize\"] = (10.0, 8.0)  # Set default size of plots.\n",
        "plt.rcParams[\"image.interpolation\"] = \"nearest\"\n",
        "plt.rcParams[\"image.cmap\"] = \"gray\"\n",
        "\n",
        "%load_ext autoreload\n",
        "%autoreload 2\n",
        "\n",
        "def rel_error(x, y):\n",
        "    \"\"\"Returns relative error.\"\"\"\n",
        "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
            "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
            "\tThe instructions to do this will be given in a section of the notebook below.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [
          "pdf-ignore"
        ],
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pIGIcY0TrH3X",
        "outputId": "31597849-f372-4886-ef6f-73dd6cd0afb8"
      },
      "source": [
        "# Load the (preprocessed) CIFAR-10 data.\n",
        "data = get_CIFAR10_data()\n",
        "for k, v in list(data.items()):\n",
        "    print(f\"{k}: {v.shape}\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X_train: (49000, 3, 32, 32)\n",
            "y_train: (49000,)\n",
            "X_val: (1000, 3, 32, 32)\n",
            "y_val: (1000,)\n",
            "X_test: (1000, 3, 32, 32)\n",
            "y_test: (1000,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TIZldpDLrH3Y"
      },
      "source": [
        "# Dropout: Forward Pass\n",
        "In the file `cs231n/layers.py`, implement the forward pass for dropout. Since dropout behaves differently during training and testing, make sure to implement the operation for both modes.\n",
        "\n",
        "Once you have done so, run the cell below to test your implementation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tw--7XQxrH3Z",
        "outputId": "7978c391-556b-432a-9dea-30d84b446ad4"
      },
      "source": [
        "np.random.seed(231)\n",
        "x = np.random.randn(500, 500) + 10\n",
        "\n",
        "for p in [0.25, 0.4, 0.7]:\n",
        "    out, _ = dropout_forward(x, {'mode': 'train', 'p': p})\n",
        "    out_test, _ = dropout_forward(x, {'mode': 'test', 'p': p})\n",
        "\n",
        "    print('Running tests with p = ', p)\n",
        "    print('Mean of input: ', x.mean())\n",
        "    print('Mean of train-time output: ', out.mean())\n",
        "    print('Mean of test-time output: ', out_test.mean())\n",
        "    print('Fraction of train-time output set to zero: ', (out == 0).mean())\n",
        "    print('Fraction of test-time output set to zero: ', (out_test == 0).mean())\n",
        "    print()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running tests with p =  0.25\n",
            "Mean of input:  10.000207878477502\n",
            "Mean of train-time output:  10.014059116977283\n",
            "Mean of test-time output:  10.000207878477502\n",
            "Fraction of train-time output set to zero:  0.749784\n",
            "Fraction of test-time output set to zero:  0.0\n",
            "\n",
            "Running tests with p =  0.4\n",
            "Mean of input:  10.000207878477502\n",
            "Mean of train-time output:  9.977917658761159\n",
            "Mean of test-time output:  10.000207878477502\n",
            "Fraction of train-time output set to zero:  0.600796\n",
            "Fraction of test-time output set to zero:  0.0\n",
            "\n",
            "Running tests with p =  0.7\n",
            "Mean of input:  10.000207878477502\n",
            "Mean of train-time output:  9.987811912159426\n",
            "Mean of test-time output:  10.000207878477502\n",
            "Fraction of train-time output set to zero:  0.30074\n",
            "Fraction of test-time output set to zero:  0.0\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ht3kWsH-rH3a"
      },
      "source": [
        "# Dropout: Backward Pass\n",
        "In the file `cs231n/layers.py`, implement the backward pass for dropout. After doing so, run the following cell to numerically gradient-check your implementation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4sBLi-w9rH3b",
        "outputId": "0a6a90df-95ae-48f5-93b2-9358482ecedf"
      },
      "source": [
        "np.random.seed(231)\n",
        "x = np.random.randn(10, 10) + 10\n",
        "dout = np.random.randn(*x.shape)\n",
        "\n",
        "dropout_param = {'mode': 'train', 'p': 0.2, 'seed': 123}\n",
        "out, cache = dropout_forward(x, dropout_param)\n",
        "dx = dropout_backward(dout, cache)\n",
        "dx_num = eval_numerical_gradient_array(lambda xx: dropout_forward(xx, dropout_param)[0], x, dout)\n",
        "\n",
        "# Error should be around e-10 or less.\n",
        "print('dx relative error: ', rel_error(dx, dx_num))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dx relative error:  5.44560814873387e-11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "tags": [
          "pdf-inline"
        ],
        "id": "Fr6o-ErQrH3d"
      },
      "source": [
        "## Inline Question 1:\n",
        "What happens if we do not divide the values being passed through inverse dropout by `p` in the dropout layer? Why does that happen?\n",
        "\n",
        "## Answer:\n",
        "### What happens when we don't divide by `p`\n",
        "If we do not divide values by `p`, then during test time we will get wrong predictions because the network during test time will get the wrong scale of outputs than it got during training.\n",
        "\n",
        "Without scaling the expected output of any neuron producing $\\hat y$ becomes:\n",
        "\n",
        "$$E[\\hat y]=p\\hat y+(1-p)0=p\\hat y$$\n",
        "\n",
        "where:\n",
        "* $p\\hat y$ - probability of getting the output\n",
        "* $(1-p)0$ - probability of not getting the output\n",
        "\n",
        "### What happens when we divide by `p`\n",
        "Therefore, we need to scale output activations by `1/p` to ensure that the scale of outputs at test time is identical to the scale of the expected outputs at training time. I.e., when dividing by `p`, the expectation becomes:\n",
        "\n",
        "$$E[\\hat y]=\\frac{p}{p}\\hat y+\\frac{(1-p)}{p}0=\\hat y$$\n",
        "\n",
        "Which means during test time we don't need to do anything."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qxJS8FOprH3f"
      },
      "source": [
        "# Fully Connected Networks with Dropout\n",
        "In the file `cs231n/classifiers/fc_net.py`, modify your implementation to use dropout. Specifically, if the constructor of the network receives a value that is not 1 for the `dropout_keep_ratio` parameter, then the net should add a dropout layer immediately after every ReLU nonlinearity. After doing so, run the following to numerically gradient-check your implementation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C_ErJCS-rH3h",
        "outputId": "92177314-20a2-4acb-ce3b-9274edf35a04"
      },
      "source": [
        "np.random.seed(231)\n",
        "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
        "X = np.random.randn(N, D)\n",
        "y = np.random.randint(C, size=(N,))\n",
        "\n",
        "for dropout_keep_ratio in [1, 0.75, 0.5]:\n",
        "    print('Running check with dropout = ', dropout_keep_ratio)\n",
        "    model = FullyConnectedNet(\n",
        "        [H1, H2],\n",
        "        input_dim=D,\n",
        "        num_classes=C,\n",
        "        weight_scale=5e-2,\n",
        "        dtype=np.float64,\n",
        "        dropout_keep_ratio=dropout_keep_ratio,\n",
        "        seed=123\n",
        "    )\n",
        "\n",
        "    loss, grads = model.loss(X, y)\n",
        "    print('Initial loss: ', loss)\n",
        "\n",
        "    # Relative errors should be around e-6 or less.\n",
        "    # Note that it's fine if for dropout_keep_ratio=1 you have W2 error be on the order of e-5.\n",
        "    for name in sorted(grads):\n",
        "        f = lambda _: model.loss(X, y)[0]\n",
        "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
        "        print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
        "    print()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running check with dropout =  1\n",
            "Initial loss:  2.300479089768492\n",
            "W1 relative error: 1.03e-07\n",
            "W2 relative error: 2.21e-05\n",
            "W3 relative error: 4.56e-07\n",
            "b1 relative error: 4.66e-09\n",
            "b2 relative error: 2.09e-09\n",
            "b3 relative error: 1.69e-10\n",
            "\n",
            "Running check with dropout =  0.75\n",
            "Initial loss:  2.302371489704412\n",
            "W1 relative error: 1.85e-07\n",
            "W2 relative error: 2.15e-06\n",
            "W3 relative error: 4.56e-08\n",
            "b1 relative error: 1.16e-08\n",
            "b2 relative error: 1.82e-09\n",
            "b3 relative error: 1.48e-10\n",
            "\n",
            "Running check with dropout =  0.5\n",
            "Initial loss:  2.30427592207859\n",
            "W1 relative error: 3.11e-07\n",
            "W2 relative error: 2.48e-08\n",
            "W3 relative error: 6.43e-08\n",
            "b1 relative error: 5.37e-09\n",
            "b2 relative error: 1.91e-09\n",
            "b3 relative error: 1.85e-10\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5bkJUFuOrH3i"
      },
      "source": [
        "# Regularization Experiment\n",
        "As an experiment, we will train a pair of two-layer networks on 500 training examples: one will use no dropout, and one will use a keep probability of 0.25. We will then visualize the training and validation accuracies of the two networks over time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ToM5yrjPrH3j",
        "outputId": "267711b1-b55e-41f0-d310-835fb556d694"
      },
      "source": [
        "# Train two identical nets, one with dropout and one without.\n",
        "np.random.seed(231)\n",
        "num_train = 500\n",
        "small_data = {\n",
        "    'X_train': data['X_train'][:num_train],\n",
        "    'y_train': data['y_train'][:num_train],\n",
        "    'X_val': data['X_val'],\n",
        "    'y_val': data['y_val'],\n",
        "}\n",
        "\n",
        "solvers = {}\n",
        "dropout_choices = [1, 0.25]\n",
        "for dropout_keep_ratio in dropout_choices:\n",
        "    model = FullyConnectedNet(\n",
        "        [500],\n",
        "        dropout_keep_ratio=dropout_keep_ratio\n",
        "    )\n",
        "    print(dropout_keep_ratio)\n",
        "\n",
        "    solver = Solver(\n",
        "        model,\n",
        "        small_data,\n",
        "        num_epochs=25,\n",
        "        batch_size=100,\n",
        "        update_rule='adam',\n",
        "        optim_config={'learning_rate': 5e-4,},\n",
        "        verbose=True,\n",
        "        print_every=100\n",
        "    )\n",
        "    solver.train()\n",
        "    solvers[dropout_keep_ratio] = solver\n",
        "    print()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "(Iteration 1 / 125) loss: 7.856643\n",
            "(Epoch 0 / 25) train acc: 0.260000; val_acc: 0.184000\n",
            "(Epoch 1 / 25) train acc: 0.416000; val_acc: 0.258000\n",
            "(Epoch 2 / 25) train acc: 0.482000; val_acc: 0.276000\n",
            "(Epoch 3 / 25) train acc: 0.532000; val_acc: 0.277000\n",
            "(Epoch 4 / 25) train acc: 0.600000; val_acc: 0.271000\n",
            "(Epoch 5 / 25) train acc: 0.708000; val_acc: 0.299000\n",
            "(Epoch 6 / 25) train acc: 0.722000; val_acc: 0.282000\n",
            "(Epoch 7 / 25) train acc: 0.832000; val_acc: 0.255000\n",
            "(Epoch 8 / 25) train acc: 0.880000; val_acc: 0.268000\n",
            "(Epoch 9 / 25) train acc: 0.902000; val_acc: 0.277000\n",
            "(Epoch 10 / 25) train acc: 0.898000; val_acc: 0.261000\n",
            "(Epoch 11 / 25) train acc: 0.924000; val_acc: 0.263000\n",
            "(Epoch 12 / 25) train acc: 0.960000; val_acc: 0.300000\n",
            "(Epoch 13 / 25) train acc: 0.972000; val_acc: 0.314000\n",
            "(Epoch 14 / 25) train acc: 0.972000; val_acc: 0.310000\n",
            "(Epoch 15 / 25) train acc: 0.974000; val_acc: 0.314000\n",
            "(Epoch 16 / 25) train acc: 0.994000; val_acc: 0.303000\n",
            "(Epoch 17 / 25) train acc: 0.970000; val_acc: 0.306000\n",
            "(Epoch 18 / 25) train acc: 0.992000; val_acc: 0.312000\n",
            "(Epoch 19 / 25) train acc: 0.990000; val_acc: 0.311000\n",
            "(Epoch 20 / 25) train acc: 0.990000; val_acc: 0.287000\n",
            "(Iteration 101 / 125) loss: 0.001695\n",
            "(Epoch 21 / 25) train acc: 0.994000; val_acc: 0.289000\n",
            "(Epoch 22 / 25) train acc: 0.998000; val_acc: 0.307000\n",
            "(Epoch 23 / 25) train acc: 0.994000; val_acc: 0.308000\n",
            "(Epoch 24 / 25) train acc: 0.998000; val_acc: 0.311000\n",
            "(Epoch 25 / 25) train acc: 0.992000; val_acc: 0.310000\n",
            "\n",
            "0.25\n",
            "(Iteration 1 / 125) loss: 17.318478\n",
            "(Epoch 0 / 25) train acc: 0.230000; val_acc: 0.177000\n",
            "(Epoch 1 / 25) train acc: 0.378000; val_acc: 0.243000\n",
            "(Epoch 2 / 25) train acc: 0.402000; val_acc: 0.254000\n",
            "(Epoch 3 / 25) train acc: 0.502000; val_acc: 0.276000\n",
            "(Epoch 4 / 25) train acc: 0.528000; val_acc: 0.298000\n",
            "(Epoch 5 / 25) train acc: 0.562000; val_acc: 0.296000\n",
            "(Epoch 6 / 25) train acc: 0.626000; val_acc: 0.291000\n",
            "(Epoch 7 / 25) train acc: 0.622000; val_acc: 0.297000\n",
            "(Epoch 8 / 25) train acc: 0.688000; val_acc: 0.313000\n",
            "(Epoch 9 / 25) train acc: 0.712000; val_acc: 0.297000\n",
            "(Epoch 10 / 25) train acc: 0.724000; val_acc: 0.306000\n",
            "(Epoch 11 / 25) train acc: 0.768000; val_acc: 0.307000\n",
            "(Epoch 12 / 25) train acc: 0.774000; val_acc: 0.284000\n",
            "(Epoch 13 / 25) train acc: 0.828000; val_acc: 0.308000\n",
            "(Epoch 14 / 25) train acc: 0.812000; val_acc: 0.346000\n",
            "(Epoch 15 / 25) train acc: 0.848000; val_acc: 0.338000\n",
            "(Epoch 16 / 25) train acc: 0.842000; val_acc: 0.306000\n",
            "(Epoch 17 / 25) train acc: 0.856000; val_acc: 0.301000\n",
            "(Epoch 18 / 25) train acc: 0.860000; val_acc: 0.317000\n",
            "(Epoch 19 / 25) train acc: 0.882000; val_acc: 0.313000\n",
            "(Epoch 20 / 25) train acc: 0.866000; val_acc: 0.312000\n",
            "(Iteration 101 / 125) loss: 4.185203\n",
            "(Epoch 21 / 25) train acc: 0.894000; val_acc: 0.332000\n",
            "(Epoch 22 / 25) train acc: 0.898000; val_acc: 0.313000\n",
            "(Epoch 23 / 25) train acc: 0.928000; val_acc: 0.314000\n",
            "(Epoch 24 / 25) train acc: 0.922000; val_acc: 0.315000\n",
            "(Epoch 25 / 25) train acc: 0.926000; val_acc: 0.330000\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 849
        },
        "id": "vMJfUIzjrH3k",
        "outputId": "b2865cf2-fbff-45c4-ec28-a904332f9514"
      },
      "source": [
        "# Plot train and validation accuracies of the two models.\n",
        "train_accs = []\n",
        "val_accs = []\n",
        "for dropout_keep_ratio in dropout_choices:\n",
        "    solver = solvers[dropout_keep_ratio]\n",
        "    train_accs.append(solver.train_acc_history[-1])\n",
        "    val_accs.append(solver.val_acc_history[-1])\n",
        "\n",
        "plt.subplot(3, 1, 1)\n",
        "for dropout_keep_ratio in dropout_choices:\n",
        "    plt.plot(\n",
        "        solvers[dropout_keep_ratio].train_acc_history, 'o', label='%.2f dropout_keep_ratio' % dropout_keep_ratio)\n",
        "plt.title('Train accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend(ncol=2, loc='lower right')\n",
        "\n",
        "plt.subplot(3, 1, 2)\n",
        "for dropout_keep_ratio in dropout_choices:\n",
        "    plt.plot(\n",
        "        solvers[dropout_keep_ratio].val_acc_history, 'o', label='%.2f dropout_keep_ratio' % dropout_keep_ratio)\n",
        "plt.title('Val accuracy')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend(ncol=2, loc='lower right')\n",
        "\n",
        "plt.gcf().set_size_inches(15, 15)\n",
        "plt.show()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "tags": [
          "pdf-inline"
        ],
        "id": "wvmgutXirH3m"
      },
      "source": [
        "## Inline Question 2:\n",
        "Compare the validation and training accuracies with and without dropout -- what do your results suggest about dropout as a regularizer?\n",
        "\n",
        "## Answer:\n",
        "**Training**: during training, not using _dropout_ allowed the model to achieve higher accuracies. The model was unrestricted to learn all the tiny features with all the neurons it was cabale. However, it can be interpreded as a slight overfit compared to the model using _dropout_.\n",
        "\n",
        "**Validation**: during validation, the use of _dropout_ allowed the model produce slightly better results overall, therefore, _dropout_ is a good regularizer to conrol overfitting - it increases network robustness because the model can't rely too much on some specific neurons.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "tags": [
          "pdf-inline"
        ],
        "id": "OoIZ3pjHrH3m"
      },
      "source": [
        "## Inline Question 3:\n",
        "Suppose we are training a deep fully connected network for image classification, with dropout after hidden layers (parameterized by keep probability `p`). If we are concerned about overfitting, how should we modify `p` (if at all) when we decide to decrease the size of the hidden layers (that is, the number of nodes in each layer)?\n",
        "\n",
        "## Answer:\n",
        "\n",
        "**Modification during**: there is no need to modify `p` when we are decreasing the size of the hidden layers. A simpler model won't learn all the tiny patterns and possible artifacts, therefore, _simpler architecture_ already deals with overfitting.\n",
        "\n",
        "**Modification after**: after we decide on the complexity of the layers, we could then fine tune the model with _dropout_ - if we reduced the layers too much, we coud increase _keep_ probability and if we could simplify the model further - we could decrease it.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g--G0B3trH3n"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ]
}