Dropout.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dropout\n",
    "Dropout [1] is a technique for regularizing neural networks by randomly setting some features 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "\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",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\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))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_val:  (1000, 3, 32, 32)\n",
      "X_train:  (49000, 3, 32, 32)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "y_train:  (49000,)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.iteritems():\n",
    "  print '%s: ' % k, v.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running tests with p =  0.3\n",
      "Mean of input:  10.000451354289595\n",
      "Mean of train-time output:  9.996442029138572\n",
      "Mean of test-time output:  10.000451354289595\n",
      "Fraction of train-time output set to zero:  0.70022\n",
      "Fraction of test-time output set to zero:  0.0\n",
      "\n",
      "Running tests with p =  0.6\n",
      "Mean of input:  10.000451354289595\n",
      "Mean of train-time output:  10.00370589519869\n",
      "Mean of test-time output:  10.000451354289595\n",
      "Fraction of train-time output set to zero:  0.399736\n",
      "Fraction of test-time output set to zero:  0.0\n",
      "\n",
      "Running tests with p =  0.75\n",
      "Mean of input:  10.000451354289595\n",
      "Mean of train-time output:  9.998207613028512\n",
      "Mean of test-time output:  10.000451354289595\n",
      "Fraction of train-time output set to zero:  0.250308\n",
      "Fraction of test-time output set to zero:  0.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randn(500, 500) + 10\n",
    "\n",
    "for p in [0.3, 0.6, 0.75]:\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx relative error:  5.445608358982094e-11\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randn(10, 10) + 10\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dropout_param = {'mode': 'train', 'p': 0.8, '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",
    "print 'dx relative error: ', rel_error(dx, dx_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully-connected nets with Dropout\n",
    "In the file `cs231n/classifiers/fc_net.py`, modify your implementation to use dropout. Specificially, if the constructor the the net receives a nonzero value for the `dropout` parameter, then the net should add dropout immediately after every ReLU nonlinearity. After doing so, run the following to numerically gradient-check your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with dropout =  0\n",
      "Initial loss:  2.3078297897356985\n",
      "W1 relative error: 1.24e-07\n",
      "W2 relative error: 1.11e-06\n",
      "W3 relative error: 5.92e-08\n",
      "b1 relative error: 9.69e-09\n",
      "b2 relative error: 2.54e-08\n",
      "b3 relative error: 1.11e-10\n",
      "\n",
      "Running check with dropout =  0.25\n",
      "Initial loss:  2.307606889331005\n",
      "W1 relative error: 5.00e-07\n",
      "W2 relative error: 5.05e-07\n",
      "W3 relative error: 1.06e-06\n",
      "b1 relative error: 5.09e-08\n",
      "b2 relative error: 4.41e-09\n",
      "b3 relative error: 1.32e-10\n",
      "\n",
      "Running check with dropout =  0.5\n",
      "Initial loss:  2.3015134122864844\n",
      "W1 relative error: 2.04e-07\n",
      "W2 relative error: 8.19e-08\n",
      "W3 relative error: 1.18e-07\n",
      "b1 relative error: 1.54e-08\n",
      "b2 relative error: 1.66e-09\n",
      "b3 relative error: 9.09e-11\n",
      "\n"
     ]
    }
   ],
   "source": [
    "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 in [0, 0.25, 0.5]:\n",
    "  print 'Running check with dropout = ', dropout\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            weight_scale=5e-2, dtype=np.float64,\n",
    "                            dropout=dropout, seed=123)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print 'Initial loss: ', loss\n",
    "\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 dropout probability of 0.75. We will then visualize the training and validation accuracies of the two networks over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "(Iteration 1 / 125) loss: 7.626699\n",
      "(Epoch 0 / 25) train acc: 0.188000; val_acc: 0.136000\n",
      "(Epoch 1 / 25) train acc: 0.368000; val_acc: 0.225000\n",
      "(Epoch 2 / 25) train acc: 0.476000; val_acc: 0.216000\n",
      "(Epoch 3 / 25) train acc: 0.606000; val_acc: 0.286000\n",
      "(Epoch 4 / 25) train acc: 0.682000; val_acc: 0.293000\n",
      "(Epoch 5 / 25) train acc: 0.752000; val_acc: 0.283000\n",
      "(Epoch 6 / 25) train acc: 0.774000; val_acc: 0.280000\n",
      "(Epoch 7 / 25) train acc: 0.826000; val_acc: 0.274000\n",
      "(Epoch 8 / 25) train acc: 0.844000; val_acc: 0.289000\n",
      "(Epoch 9 / 25) train acc: 0.862000; val_acc: 0.302000\n",
      "(Epoch 10 / 25) train acc: 0.928000; val_acc: 0.291000\n",
      "(Epoch 11 / 25) train acc: 0.936000; val_acc: 0.305000\n",
      "(Epoch 12 / 25) train acc: 0.948000; val_acc: 0.288000\n",
      "(Epoch 13 / 25) train acc: 0.924000; val_acc: 0.255000\n",
      "(Epoch 14 / 25) train acc: 0.954000; val_acc: 0.284000\n",
      "(Epoch 15 / 25) train acc: 0.958000; val_acc: 0.295000\n",
      "(Epoch 16 / 25) train acc: 0.980000; val_acc: 0.278000\n",
      "(Epoch 17 / 25) train acc: 0.974000; val_acc: 0.283000\n",
      "(Epoch 18 / 25) train acc: 0.982000; val_acc: 0.302000\n",
      "(Epoch 19 / 25) train acc: 0.980000; val_acc: 0.292000\n",
      "(Epoch 20 / 25) train acc: 0.982000; val_acc: 0.282000\n",
      "(Iteration 101 / 125) loss: 0.054130\n",
      "(Epoch 21 / 25) train acc: 0.968000; val_acc: 0.306000\n",
      "(Epoch 22 / 25) train acc: 0.992000; val_acc: 0.316000\n",
      "(Epoch 23 / 25) train acc: 0.976000; val_acc: 0.298000\n",
      "(Epoch 24 / 25) train acc: 0.960000; val_acc: 0.287000\n",
      "(Epoch 25 / 25) train acc: 0.964000; val_acc: 0.292000\n",
      "0.75\n",
      "(Iteration 1 / 125) loss: 9.483494\n",
      "(Epoch 0 / 25) train acc: 0.212000; val_acc: 0.170000\n",
      "(Epoch 1 / 25) train acc: 0.388000; val_acc: 0.242000\n",
      "(Epoch 2 / 25) train acc: 0.496000; val_acc: 0.231000\n",
      "(Epoch 3 / 25) train acc: 0.590000; val_acc: 0.262000\n",
      "(Epoch 4 / 25) train acc: 0.672000; val_acc: 0.260000\n",
      "(Epoch 5 / 25) train acc: 0.704000; val_acc: 0.314000\n",
      "(Epoch 6 / 25) train acc: 0.782000; val_acc: 0.285000\n",
      "(Epoch 7 / 25) train acc: 0.814000; val_acc: 0.274000\n",
      "(Epoch 8 / 25) train acc: 0.850000; val_acc: 0.294000\n",
      "(Epoch 9 / 25) train acc: 0.876000; val_acc: 0.285000\n",
      "(Epoch 10 / 25) train acc: 0.916000; val_acc: 0.300000\n",
      "(Epoch 11 / 25) train acc: 0.916000; val_acc: 0.285000\n",
      "(Epoch 12 / 25) train acc: 0.958000; val_acc: 0.299000\n",
      "(Epoch 13 / 25) train acc: 0.968000; val_acc: 0.299000\n",
      "(Epoch 14 / 25) train acc: 0.970000; val_acc: 0.311000\n",
      "(Epoch 15 / 25) train acc: 0.980000; val_acc: 0.316000\n",
      "(Epoch 16 / 25) train acc: 0.982000; val_acc: 0.309000\n",
      "(Epoch 17 / 25) train acc: 0.988000; val_acc: 0.290000\n",
      "(Epoch 18 / 25) train acc: 0.996000; val_acc: 0.311000\n",
      "(Epoch 19 / 25) train acc: 0.990000; val_acc: 0.313000\n",
      "(Epoch 20 / 25) train acc: 0.992000; val_acc: 0.314000\n",
      "(Iteration 101 / 125) loss: 0.003505\n",
      "(Epoch 21 / 25) train acc: 0.998000; val_acc: 0.302000\n",
      "(Epoch 22 / 25) train acc: 0.996000; val_acc: 0.294000\n",
      "(Epoch 23 / 25) train acc: 0.998000; val_acc: 0.303000\n",
      "(Epoch 24 / 25) train acc: 0.996000; val_acc: 0.306000\n",
      "(Epoch 25 / 25) train acc: 1.000000; val_acc: 0.300000\n"
     ]
    }
   ],
   "source": [
    "# Train two identical nets, one with dropout and one without\n",
    "\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 = [0, 0.75]\n",
    "for dropout in dropout_choices:\n",
    "  model = FullyConnectedNet([500], dropout=dropout)\n",
    "  print dropout\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=25, batch_size=100,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-4,\n",
    "                  },\n",
    "                  verbose=True, print_every=100)\n",
    "  solver.train()\n",
    "  solvers[dropout] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot train and validation accuracies of the two models\n",
    "\n",
    "train_accs = []\n",
    "val_accs = []\n",
    "for dropout in dropout_choices:\n",
    "  solver = solvers[dropout]\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 in dropout_choices:\n",
    "  plt.plot(solvers[dropout].train_acc_history, 'o', label='%.2f dropout' % dropout)\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 in dropout_choices:\n",
    "  plt.plot(solvers[dropout].val_acc_history, 'o', label='%.2f dropout' % dropout)\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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question\n",
    "Explain what you see in this experiment. What does it suggest about dropout?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}