assignment2/FullyConnectedNets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\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": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "    print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "Sigmoid, when |x| >= 10, grad is almost 0. ReLU doesn't saturate in positive area at all, but has a zero-gradient in the negative one (but with right initialization it's not a cause for concern). Leaky ReLU as an ordinary ReLU is fine in positive area and has slightly better grad in the negative one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "    print('Running numeric gradient check with reg = ', reg)\n",
    "    model.reg = reg\n",
    "    loss, grads = model.loss(X, y)\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)\n",
    "        print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 2450) loss: 2.305965\n",
      "(Epoch 0 / 10) train acc: 0.114000; val_acc: 0.096000\n",
      "(Iteration 201 / 2450) loss: 1.598619\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.416000\n",
      "(Iteration 401 / 2450) loss: 1.661861\n",
      "(Epoch 2 / 10) train acc: 0.491000; val_acc: 0.462000\n",
      "(Iteration 601 / 2450) loss: 1.665413\n",
      "(Epoch 3 / 10) train acc: 0.485000; val_acc: 0.461000\n",
      "(Iteration 801 / 2450) loss: 1.393038\n",
      "(Epoch 4 / 10) train acc: 0.533000; val_acc: 0.499000\n",
      "(Iteration 1001 / 2450) loss: 1.449278\n",
      "(Iteration 1201 / 2450) loss: 1.207275\n",
      "(Epoch 5 / 10) train acc: 0.520000; val_acc: 0.516000\n",
      "(Iteration 1401 / 2450) loss: 1.430487\n",
      "(Epoch 6 / 10) train acc: 0.534000; val_acc: 0.507000\n",
      "(Iteration 1601 / 2450) loss: 1.167146\n",
      "(Epoch 7 / 10) train acc: 0.558000; val_acc: 0.511000\n",
      "(Iteration 1801 / 2450) loss: 1.225039\n",
      "(Epoch 8 / 10) train acc: 0.567000; val_acc: 0.505000\n",
      "(Iteration 2001 / 2450) loss: 1.271719\n",
      "(Iteration 2201 / 2450) loss: 1.279429\n",
      "(Epoch 9 / 10) train acc: 0.580000; val_acc: 0.514000\n",
      "(Iteration 2401 / 2450) loss: 1.104043\n",
      "(Epoch 10 / 10) train acc: 0.597000; val_acc: 0.518000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.518"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data, print_every=200, optim_config={'learning_rate':1e-3}, lr_decay=0.95, num_epochs=10, \n",
    "                batch_size=200)\n",
    "solver.train()\n",
    "solver.check_accuracy(data['X_val'], data['y_val'])\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.302097302967627\n",
      "W1 relative error: 8.20e-04\n",
      "W2 relative error: 9.94e-07\n",
      "W3 relative error: 3.14e-07\n",
      "b1 relative error: 1.93e-04\n",
      "b2 relative error: 1.33e-09\n",
      "b3 relative error: 1.78e-10\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052442290138278\n",
      "W1 relative error: 2.02e-08\n",
      "W2 relative error: 1.64e-08\n",
      "W3 relative error: 2.02e-07\n",
      "b1 relative error: 6.00e-08\n",
      "b2 relative error: 8.71e-09\n",
      "b3 relative error: 1.16e-10\n"
     ]
    }
   ],
   "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 reg in [0, 3.14]:\n",
    "    print('Running check with reg = ', reg)\n",
    "    model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "    loss, grads = model.loss(X, y)\n",
    "    print('Initial loss: ', loss)\n",
    "\n",
    "    # Most of the errors should be on the order of e-7 or smaller.   \n",
    "    # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "    # for the check when reg = 0.0\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])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.817092\n",
      "(Epoch 0 / 20) train acc: 0.300000; val_acc: 0.128000\n",
      "(Epoch 1 / 20) train acc: 0.460000; val_acc: 0.174000\n",
      "(Epoch 2 / 20) train acc: 0.700000; val_acc: 0.172000\n",
      "(Epoch 3 / 20) train acc: 0.740000; val_acc: 0.188000\n",
      "(Epoch 4 / 20) train acc: 0.920000; val_acc: 0.186000\n",
      "(Epoch 5 / 20) train acc: 0.900000; val_acc: 0.190000\n",
      "(Iteration 11 / 40) loss: 0.293863\n",
      "(Epoch 6 / 20) train acc: 0.920000; val_acc: 0.195000\n",
      "(Epoch 7 / 20) train acc: 0.940000; val_acc: 0.186000\n",
      "(Epoch 8 / 20) train acc: 0.920000; val_acc: 0.182000\n",
      "(Epoch 9 / 20) train acc: 1.000000; val_acc: 0.184000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.191000\n",
      "(Iteration 21 / 40) loss: 0.098852\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.186000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.189000\n",
      "(Iteration 31 / 40) loss: 0.047165\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.189000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\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",
    "weight_scale = 2e-2 # Experiment with this!\n",
    "learning_rate = 5e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 5.713474\n",
      "(Epoch 0 / 20) train acc: 0.200000; val_acc: 0.126000\n",
      "(Epoch 1 / 20) train acc: 0.220000; val_acc: 0.081000\n",
      "(Epoch 2 / 20) train acc: 0.460000; val_acc: 0.117000\n",
      "(Epoch 3 / 20) train acc: 0.760000; val_acc: 0.143000\n",
      "(Epoch 4 / 20) train acc: 0.820000; val_acc: 0.141000\n",
      "(Epoch 5 / 20) train acc: 0.900000; val_acc: 0.149000\n",
      "(Iteration 11 / 40) loss: 0.574323\n",
      "(Epoch 6 / 20) train acc: 0.900000; val_acc: 0.154000\n",
      "(Epoch 7 / 20) train acc: 1.000000; val_acc: 0.148000\n",
      "(Epoch 8 / 20) train acc: 1.000000; val_acc: 0.154000\n",
      "(Epoch 9 / 20) train acc: 0.980000; val_acc: 0.154000\n",
      "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.155000\n",
      "(Iteration 21 / 40) loss: 0.242696\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.153000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.157000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.149000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.155000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.156000\n",
      "(Iteration 31 / 40) loss: 0.120374\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.153000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.157000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.153000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.154000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.147000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\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",
    "learning_rate = 5e-3  # Experiment with this!\n",
    "weight_scale = 5e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "The five layer net is more sensitive to the initialization scale, probably because of washing gradient effect.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.406122\n",
      "(Epoch 0 / 5) train acc: 0.118000; val_acc: 0.104000\n",
      "(Iteration 11 / 200) loss: 2.253021\n",
      "(Iteration 21 / 200) loss: 2.198018\n",
      "(Iteration 31 / 200) loss: 2.165732\n",
      "(Epoch 1 / 5) train acc: 0.217000; val_acc: 0.206000\n",
      "(Iteration 41 / 200) loss: 2.139461\n",
      "(Iteration 51 / 200) loss: 2.094174\n",
      "(Iteration 61 / 200) loss: 2.044474\n",
      "(Iteration 71 / 200) loss: 2.085293\n",
      "(Epoch 2 / 5) train acc: 0.312000; val_acc: 0.262000\n",
      "(Iteration 81 / 200) loss: 1.928688\n",
      "(Iteration 91 / 200) loss: 2.053501\n",
      "(Iteration 101 / 200) loss: 2.082303\n",
      "(Iteration 111 / 200) loss: 1.948948\n",
      "(Epoch 3 / 5) train acc: 0.336000; val_acc: 0.281000\n",
      "(Iteration 121 / 200) loss: 1.850955\n",
      "(Iteration 131 / 200) loss: 1.888997\n",
      "(Iteration 141 / 200) loss: 1.942303\n",
      "(Iteration 151 / 200) loss: 1.891277\n",
      "(Epoch 4 / 5) train acc: 0.337000; val_acc: 0.298000\n",
      "(Iteration 161 / 200) loss: 1.818936\n",
      "(Iteration 171 / 200) loss: 1.893548\n",
      "(Iteration 181 / 200) loss: 1.764046\n",
      "(Iteration 191 / 200) loss: 1.943643\n",
      "(Epoch 5 / 5) train acc: 0.355000; val_acc: 0.294000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.567393\n",
      "(Epoch 0 / 5) train acc: 0.100000; val_acc: 0.086000\n",
      "(Iteration 11 / 200) loss: 2.086529\n",
      "(Iteration 21 / 200) loss: 1.986413\n",
      "(Iteration 31 / 200) loss: 1.868583\n",
      "(Epoch 1 / 5) train acc: 0.342000; val_acc: 0.301000\n",
      "(Iteration 41 / 200) loss: 1.981484\n",
      "(Iteration 51 / 200) loss: 1.664619\n",
      "(Iteration 61 / 200) loss: 1.656482\n",
      "(Iteration 71 / 200) loss: 1.830942\n",
      "(Epoch 2 / 5) train acc: 0.392000; val_acc: 0.314000\n",
      "(Iteration 81 / 200) loss: 1.822012\n",
      "(Iteration 91 / 200) loss: 1.632368\n",
      "(Iteration 101 / 200) loss: 1.445682\n",
      "(Iteration 111 / 200) loss: 1.419704\n",
      "(Epoch 3 / 5) train acc: 0.490000; val_acc: 0.333000\n",
      "(Iteration 121 / 200) loss: 1.709680\n",
      "(Iteration 131 / 200) loss: 1.559145\n",
      "(Iteration 141 / 200) loss: 1.503049\n",
      "(Iteration 151 / 200) loss: 1.650793\n",
      "(Epoch 4 / 5) train acc: 0.516000; val_acc: 0.338000\n",
      "(Iteration 161 / 200) loss: 1.391171\n",
      "(Iteration 171 / 200) loss: 1.466306\n",
      "(Iteration 181 / 200) loss: 1.414331\n",
      "(Iteration 191 / 200) loss: 1.275019\n",
      "(Epoch 5 / 5) train acc: 0.568000; val_acc: 0.346000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:39: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:42: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:49: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\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",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.127899\n",
      "(Epoch 0 / 5) train acc: 0.101000; val_acc: 0.086000\n",
      "(Iteration 11 / 200) loss: 2.112590\n",
      "(Iteration 21 / 200) loss: 2.271643\n",
      "(Iteration 31 / 200) loss: 1.849840\n",
      "(Epoch 1 / 5) train acc: 0.385000; val_acc: 0.310000\n",
      "(Iteration 41 / 200) loss: 1.723654\n",
      "(Iteration 51 / 200) loss: 1.794711\n",
      "(Iteration 61 / 200) loss: 1.921361\n",
      "(Iteration 71 / 200) loss: 1.481937\n",
      "(Epoch 2 / 5) train acc: 0.424000; val_acc: 0.335000\n",
      "(Iteration 81 / 200) loss: 1.586227\n",
      "(Iteration 91 / 200) loss: 1.481025\n",
      "(Iteration 101 / 200) loss: 1.429454\n",
      "(Iteration 111 / 200) loss: 1.526017\n",
      "(Epoch 3 / 5) train acc: 0.491000; val_acc: 0.385000\n",
      "(Iteration 121 / 200) loss: 1.291797\n",
      "(Iteration 131 / 200) loss: 1.578226\n",
      "(Iteration 141 / 200) loss: 1.406855\n",
      "(Iteration 151 / 200) loss: 1.295022\n",
      "(Epoch 4 / 5) train acc: 0.545000; val_acc: 0.361000\n",
      "(Iteration 161 / 200) loss: 1.357491\n",
      "(Iteration 171 / 200) loss: 1.271353\n",
      "(Iteration 181 / 200) loss: 1.176019\n",
      "(Iteration 191 / 200) loss: 1.186534\n",
      "(Epoch 5 / 5) train acc: 0.557000; val_acc: 0.355000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.819742\n",
      "(Epoch 0 / 5) train acc: 0.161000; val_acc: 0.158000\n",
      "(Iteration 11 / 200) loss: 2.066583\n",
      "(Iteration 21 / 200) loss: 1.962698\n",
      "(Iteration 31 / 200) loss: 1.746210\n",
      "(Epoch 1 / 5) train acc: 0.360000; val_acc: 0.313000\n",
      "(Iteration 41 / 200) loss: 1.919487\n",
      "(Iteration 51 / 200) loss: 1.820685\n",
      "(Iteration 61 / 200) loss: 1.561909\n",
      "(Iteration 71 / 200) loss: 1.659426\n",
      "(Epoch 2 / 5) train acc: 0.430000; val_acc: 0.330000\n",
      "(Iteration 81 / 200) loss: 1.628831\n",
      "(Iteration 91 / 200) loss: 1.609865\n",
      "(Iteration 101 / 200) loss: 1.544479\n",
      "(Iteration 111 / 200) loss: 1.522880\n",
      "(Epoch 3 / 5) train acc: 0.467000; val_acc: 0.335000\n",
      "(Iteration 121 / 200) loss: 1.540743\n",
      "(Iteration 131 / 200) loss: 1.490188\n",
      "(Iteration 141 / 200) loss: 1.535558\n",
      "(Iteration 151 / 200) loss: 1.561205\n",
      "(Epoch 4 / 5) train acc: 0.513000; val_acc: 0.363000\n",
      "(Iteration 161 / 200) loss: 1.545316\n",
      "(Iteration 171 / 200) loss: 1.540540\n",
      "(Iteration 181 / 200) loss: 1.592574\n",
      "(Iteration 191 / 200) loss: 1.315832\n",
      "(Epoch 5 / 5) train acc: 0.534000; val_acc: 0.350000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:30: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:33: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:36: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "/home/andreybocharnikov/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:40: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "Since dw^2 is always positive, cache will only increase, so we will divide by more and more scalar, so each step will be less. \n",
    "Adam doesn't have this issue, because like in RMSprop, adam has a decay_rate so 'v' and 'm' won't monotonically increase. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 0.000457, reg 0.000073, weight_scale 0.011072, val_accuracy 0.543000\n",
      "lr 0.003985, reg 0.004033, weight_scale 0.097666, val_accuracy 0.439000\n",
      "lr 0.005041, reg 0.000282, weight_scale 0.074111, val_accuracy 0.424000\n",
      "lr 0.000189, reg 0.000152, weight_scale 0.014961, val_accuracy 0.540000\n",
      "lr 0.002133, reg 0.000241, weight_scale 0.085611, val_accuracy 0.477000\n",
      "lr 0.000330, reg 0.000543, weight_scale 0.060372, val_accuracy 0.465000\n",
      "lr 0.000119, reg 0.000078, weight_scale 0.010121, val_accuracy 0.532000\n",
      "lr 0.000241, reg 0.000106, weight_scale 0.018837, val_accuracy 0.533000\n",
      "lr 0.000629, reg 0.000054, weight_scale 0.063009, val_accuracy 0.489000\n",
      "lr 0.000372, reg 0.000200, weight_scale 0.053480, val_accuracy 0.507000\n",
      "lr 0.001802, reg 0.003679, weight_scale 0.014966, val_accuracy 0.468000\n",
      "lr 0.000172, reg 0.009550, weight_scale 0.020643, val_accuracy 0.530000\n",
      "lr 0.004492, reg 0.000094, weight_scale 0.040155, val_accuracy 0.440000\n",
      "lr 0.007983, reg 0.000108, weight_scale 0.013864, val_accuracy 0.107000\n",
      "lr 0.000461, reg 0.007706, weight_scale 0.056254, val_accuracy 0.501000\n",
      "best val score - 0.543000\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "best_val_score = 0\n",
    "for i in range(15):\n",
    "    lr = 10 ** np.random.uniform(-4, -2)\n",
    "    reg = 10 ** np.random.uniform(-5, -2)\n",
    "    weight_scale = 10 ** np.random.uniform(-2, -1)\n",
    "    model = FullyConnectedNet([100, 100, 100], weight_scale=weight_scale, reg=reg)\n",
    "\n",
    "    solver = Solver(model, data,\n",
    "                  num_epochs=10, batch_size=100,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': lr,\n",
    "                  },\n",
    "                  verbose=False,\n",
    "                  lr_decay=0.95)\n",
    "    solver.train()\n",
    "    val_accuracy = solver.best_val_acc\n",
    "    if val_accuracy > best_val_score:\n",
    "        best_val_score = val_accuracy\n",
    "        best_model = model\n",
    "    print('lr %f, reg %f, weight_scale %f, val_accuracy %f' % (lr, reg, weight_scale, val_accuracy))\n",
    "print('best val score - %f' % best_val_score)\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.543\n",
      "Test set accuracy:  0.541\n"
     ]
    }
   ],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}