FullyConnectedNets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.\n",
    "\n",
    "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 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 Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "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": [
    "# 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.769847728806635e-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 1e-9.\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:  2.0238470085452315e-10\n",
      "dw error:  4.4616314327028506e-11\n",
      "db error:  1.1661958957246272e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "\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 1e-10\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 layer: 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 around 1e-8\n",
    "print 'Testing relu_forward function:'\n",
    "print 'difference: ', rel_error(out, correct_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU layer: 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.2755904605652973e-12\n"
     ]
    }
   ],
   "source": [
    "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 around 1e-12\n",
    "print 'Testing relu_backward function:'\n",
    "print 'dx error: ', rel_error(dx_num, dx)"
   ]
  },
  {
   "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:\n",
      "dx error:  2.3984974752035926e-10\n",
      "dw error:  1.2980650269467918e-10\n",
      "db error:  4.119836164147637e-11\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "\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",
    "print 'Testing affine_relu_forward:'\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:  9.000494692738734\n",
      "dx error:  8.182894472887002e-10\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.3026350606941453\n",
      "dx error:  6.9906432002479366e-09\n"
     ]
    }
   ],
   "source": [
    "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 1e-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 2.3 and dx error should be 1e-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.22e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 9.09e-10\n"
     ]
    }
   ],
   "source": [
    "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-2\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",
    "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]))"
   ]
  },
  {
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-03 rs 1.000000e+01 train accuracy: 0.372000 val accuracy: 0.404000\n",
      "lr 1.000000e-03 rs 1.000000e+00 train accuracy: 0.520000 val accuracy: 0.502000\n",
      "lr 1.000000e-03 rs 1.000000e-01 train accuracy: 0.594000 val accuracy: 0.521000\n",
      "lr 1.000000e-03 rs 1.000000e-02 train accuracy: 0.579000 val accuracy: 0.523000\n",
      "lr 1.000000e-03 rs 1.000000e-03 train accuracy: 0.594000 val accuracy: 0.517000\n",
      "lr 1.000000e-04 rs 1.000000e+01 train accuracy: 0.387000 val accuracy: 0.400000\n",
      "lr 1.000000e-04 rs 1.000000e+00 train accuracy: 0.459000 val accuracy: 0.471000\n",
      "lr 1.000000e-04 rs 1.000000e-01 train accuracy: 0.483000 val accuracy: 0.466000\n",
      "lr 1.000000e-04 rs 1.000000e-02 train accuracy: 0.515000 val accuracy: 0.473000\n",
      "lr 1.000000e-04 rs 1.000000e-03 train accuracy: 0.477000 val accuracy: 0.481000\n",
      "lr 1.000000e-05 rs 1.000000e+01 train accuracy: 0.279000 val accuracy: 0.288000\n",
      "lr 1.000000e-05 rs 1.000000e+00 train accuracy: 0.314000 val accuracy: 0.299000\n",
      "lr 1.000000e-05 rs 1.000000e-01 train accuracy: 0.290000 val accuracy: 0.304000\n",
      "lr 1.000000e-05 rs 1.000000e-02 train accuracy: 0.290000 val accuracy: 0.307000\n",
      "lr 1.000000e-05 rs 1.000000e-03 train accuracy: 0.285000 val accuracy: 0.307000\n",
      "best validation accuracy achieved during cross-validation: 0.523000\n"
     ]
    }
   ],
   "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",
    "learning_rates = np.logspace(-3, -5, 3)\n",
    "regularization_strengths = np.logspace(1, -3, 5)\n",
    "result = {}\n",
    "best_val = -1\n",
    "best_model = None\n",
    "best_lr = None\n",
    "best_rs = None\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        model = TwoLayerNet(reg=rs)\n",
    "        solver = Solver(model, data,\n",
    "                      update_rule='sgd',\n",
    "                      optim_config={\n",
    "                        'learning_rate': lr,\n",
    "                      },\n",
    "                      lr_decay=0.95,\n",
    "                      num_epochs=10, batch_size=100,\n",
    "                      verbose=False)\n",
    "        solver.train()\n",
    "        result[(lr, rs)] = (solver.train_acc_history[-1], solver.val_acc_history[-1])\n",
    "        print 'lr %e rs %e train accuracy: %f val accuracy: %f' % (\n",
    "            lr, rs, solver.train_acc_history[-1], solver.val_acc_history[-1])\n",
    "        if best_val < solver.val_acc_history[-1]:\n",
    "            best_val = solver.val_acc_history[-1]\n",
    "            best_model = model\n",
    "            best_lr = lr\n",
    "            best_rs = rs\n",
    "    \n",
    "print 'best validation accuracy achieved during cross-validation: %f' % best_val            \n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = TwoLayerNet(reg=best_rs)\n",
    "solver = Solver(model, data,\n",
    "                      update_rule='sgd',\n",
    "                      optim_config={\n",
    "                        'learning_rate': best_lr,\n",
    "                      },\n",
    "                      lr_decay=0.95,\n",
    "                      num_epochs=10, batch_size=100,\n",
    "                      verbose=False)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "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()"
   ]
  },
  {
   "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 normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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-6 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3041351384586575\n",
      "W1 relative error: 1.02e-06\n",
      "W2 relative error: 1.45e-07\n",
      "W3 relative error: 3.96e-07\n",
      "b1 relative error: 1.05e-08\n",
      "b2 relative error: 1.85e-09\n",
      "b3 relative error: 8.06e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.017172765498804\n",
      "W1 relative error: 3.09e-08\n",
      "W2 relative error: 2.94e-08\n",
      "W3 relative error: 1.85e-08\n",
      "b1 relative error: 2.71e-08\n",
      "b2 relative error: 9.29e-08\n",
      "b3 relative error: 2.42e-10\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 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",
    "  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. You will need to tweak the learning rate and initialization scale, but you should be able to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 28.494050\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.121000\n",
      "(Epoch 1 / 20) train acc: 0.200000; val_acc: 0.113000\n",
      "(Epoch 2 / 20) train acc: 0.500000; val_acc: 0.120000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.113000\n",
      "(Epoch 4 / 20) train acc: 0.740000; val_acc: 0.141000\n",
      "(Epoch 5 / 20) train acc: 0.800000; val_acc: 0.135000\n",
      "(Iteration 11 / 40) loss: 0.524520\n",
      "(Epoch 6 / 20) train acc: 0.920000; val_acc: 0.143000\n",
      "(Epoch 7 / 20) train acc: 0.960000; val_acc: 0.146000\n",
      "(Epoch 8 / 20) train acc: 0.980000; val_acc: 0.152000\n",
      "(Epoch 9 / 20) train acc: 1.000000; val_acc: 0.157000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Iteration 21 / 40) loss: 0.003718\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.157000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Iteration 31 / 40) loss: 0.001169\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.158000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.158000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAGwRJREFUeJzt3Xu4XXV95/H3pyHAqVwC5qAkgAGKAayV4CnqhDqISgAvREcfwFFpS5+gj7RamGjCqEM7OqZGYdRxqFERWi7VSgyoYKRcZGAUOLmQy8TI1ZKTkISh4VLOSBK+88f6Hdw5PWfvfS5rr3327/N6nvPsvddlr+9ZkPU56/db67cUEZiZWb5+p+oCzMysWg4CM7PMOQjMzDLnIDAzy5yDwMwscw4CM7PMOQisbUmaJOk5SUeM57KjqONzkq4a7+8dZltvk/RYnfnfknRJK2qxfOxVdQHWOSQ9V/Pxd4HfALvT5wsi4tqRfF9E7Ab2G+9lJ7KI+LNmlpO0CfhgRNxZbkXWCRwENm4i4qUDcfqr9s8i4p+GW17SXhGxqxW1WfP83yU/bhqylklNLN+VdL2kZ4EPSnqTpF9I2iFpi6SvSpqclt9LUkiakT5fk+bfIulZST+XdORIl03zz5D0K0lPS/qapHsk/XGTv8dcSetTzbdLmlkz7xJJmyU9I+mXkk5J098oaWWavlXS4gbb+KSk7em7Plwz/RpJl6b3h0i6OdXxlKS70vTrgWnALam57KIm6t4kab6ktcDzkhZK+u6gmq6Q9KVm9pFNLA4Ca7X3ANcBBwLfBXYBHwemArOB04EL6qz/AeAzwMHAPwP/daTLSjoE+B4wP233UeCkZoqXdBxwDfDnQDfwT8APJU2W9JpU+4kRcQBwRtouwNeAxWn67wHfr7OZw4AuioP5R4ArJB0wxHLzgUdSHa9MvysRcS6wGTgjIvaLiMvq1V3zfeekmg8E/h54x8B2Je0NvD9Ntw7jILBWuzsifhgRL0ZEf0TcHxH3RsSuiHgEWAL8+zrrfz8ieiNiJ3AtcMIoln0nsDoibkzzLgeebLL+c4CbIuL2tO4i4ADgDRShti/wmtS88mj6nQB2AsdIenlEPBsR99bZxv8DPhcROyPiJoq+llcPsdxOirA4IiJeiIifjbLuAV+JiE3pv8sm4OfAf0jzzgQ2R8QDdbZhE5SDwFrt8doPko6V9GNJT0h6Bvhrir/Sh/NEzfvnqd9BPNyy02rriGLkxU1N1D6w7q9r1n0xrTs9IjYCF1P8DttSE9gr06J/AhwPbJR0n6Qz62zjydT5PVTttRalWm6T9LCk+aOpu2aZxwetczXwwfT+g/hsoGM5CKzVBg93+w1gHfB7qdnks4BKrmELRfMLAJLEngfEejYDr6pZ93fSd/UBRMQ1ETEbOBKYBHwhTd8YEecAhwBfBm6QtO9YfomIeCYi/jIiZgBzgU9JGjibGryf69Y9zDpLgdenJq8zKJr0rAM5CKxq+wNPA/+a2rHr9Q+Mlx8BJ0p6l6S9KPoouptc93vAuyWdktrX5wPPAvdKOk7SWyTtA/Snn90Akj4kaWr6S/xpioPui2P5JVL9R6cgezpta+BMYitwVDN1D/f9EfE88APgeuCeiOgbblmb2BwEVrWLgfMoDkrfoOhALlVEbAXOBi4D/i9wNLCKoi2+0brrKeq9AthO0bn97tTuvg/wRYr+hieAg4BPp1XPBDakq6W+BJwdES+M8VeZCdwOPAfcQ9HGf3ea99+Av0pXCH2iQd31XA28FjcLdTT5wTSWO0mTKJpO3hcR/6vqetqJpKOANcArI+K5RsvbxOQzAsuSpNMlHZiacT5DccXPfRWX1VZSP8JFwHUOgc7mO4stVydTXFK6N7AemBsRDZuGciHpQIqO5MeAOdVWY2Vz05CZWebcNGRmlrkJ0TQ0derUmDFjRtVlmJlNKCtWrHgyIhpeGj0hgmDGjBn09vZWXYaZ2YQi6deNl3LTkJlZ9hwEZmaZcxCYmWXOQWBmljkHgZlZ5ibEVUOjsWxVH4uXb2Tzjn6mTeli/pyZzJ3V7EjDZmb56MggWLaqj4VL19K/sxiRt29HPwuXrgVwGJiZDdKRTUOLl298KQQG9O/czeLlGyuqyMysfXVkEGze0T+i6WZmOevIIJg2pWtE083MctaRQTB/zky6Jk/aY1rX5EnMnzOzoorMzNpXR3YWD3QI+6ohM7PGOjIIoAgDH/jNzBrryKYhMzNrnoPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMldaEEg6XNIdkjZIWi/p42n6pZL6JK1OP2eWVYOZmTVW5hPKdgEXR8RKSfsDKyTdmuZdHhFfKnHbZmbWpNKCICK2AFvS+2clbQD87EgzszbTkj4CSTOAWcC9adKFktZIulLSQcOsM09Sr6Te7du3t6JMM7MslR4EkvYDbgA+ERHPAFcARwMnUJwxfHmo9SJiSUT0RERPd3d32WWamWWr1CCQNJkiBK6NiKUAEbE1InZHxIvAN4GTyqzBzMzqK/OqIQHfBjZExGU10w+tWew9wLqyajAzs8bKvGpoNvAhYK2k1WnaJcC5kk4AAngMuKDEGszMrIEyrxq6G9AQs24ua5tmZjZyvrPYzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLXJmjj7a1Zav6WLx8I5t39DNtShfz58xk7iw/SdPM8pNlECxb1cfCpWvp37kbgL4d/SxcuhbAYWBm2cmyaWjx8o0vhcCA/p27Wbx8Y0UVmZlVJ8sg2Lyjf0TTzcw6WZZBMG1K14imm5l1siyDYP6cmXRNnrTHtK7Jk5g/Z2ZFFZmZVSfLzuKBDmFfNWRmlmkQQBEGPvCbmWXaNGRmZr/lIDAzy5yDwMwscw4CM7PMOQjMzDLnIDAzy1xpQSDpcEl3SNogab2kj6fpB0u6VdKD6fWgsmowM7PGyjwj2AVcHBHHAW8EPibpeGABcFtEHAPclj6bmVlFSguCiNgSESvT+2eBDcB04Czg6rTY1cDcsmowM7PGWtJHIGkGMAu4F3hFRGyBIiyAQ4ZZZ56kXkm927dvb0WZZmZZKj0IJO0H3AB8IiKeaXa9iFgSET0R0dPd3V1egWZmmSs1CCRNpgiBayNiaZq8VdKhaf6hwLYyazAzs/rKvGpIwLeBDRFxWc2sm4Dz0vvzgBvLqsHMzBorc/TR2cCHgLWSVqdplwCLgO9JOh/4Z+D9JdZgZmYNlBYEEXE3oGFmv7Ws7ZqZ2cj4zmIzs8w5CMzMMucgMDPLnIPAzCxzIwoCFV5WVjFmZtZ6DYNA0t9JOkDS7wLrgUclXVR+aWZm1grNnBG8Ng0NMRf4KXAY8MdlFmVmZq3TTBDsLWkvilFDl0XEC8CL5ZZlZmat0kwQfIviDuCDgJ9JOgJ4rtSqzMysZRoGQURcHhHTIuK0iAjgceDU8kszM7NWaKaz+EJJB6T336B4psAflV2YmZm1RjNNQ/Mi4hlJp1E8YeyjwBfLLcvMzFqlmSCI9HoG8J2IWNHkemZmNgE0c0B/QNLNwLuAW9ITx6LBOmZmNkE0Mwz1nwCvBx6KiOclTQXOL7csMzNrlYZBEBG708H/vcVDx/hZRNxSemVmZtYSzVw19Hngk8Aj6We+pM+VXZiZmbVGM01D7wJOjIhdAJKuBFYCny6zMDMza41mr/7Zf5j3ZmY2wTVzRvBFYKWk2yieQXwK8NkyizIzs9ZpprP4Gkl3AG+gCILPRkRf6ZWZmVlLDBsEkv5g0KSH0uvLJb08ItaUV1b1lq3qY/HyjWze0c+0KV3MnzOTubOmV12Wmdm4q3dG8PU68wJ48zjX0jaWrepj4dK19O/cDUDfjn4WLl0L4DAws44zbBBERLYDyy1evvGlEBjQv3M3i5dvdBCYWcfxmEFD2Lyjf0TTzcwmMgfBEKZN6RrRdDOziay0IJB0paRtktbVTLtUUp+k1ennzLK2Pxbz58yka/KkPaZ1TZ7E/DkzK6rIzKw8DS8fHeLqIYCngccjot6zi68C/gfwd4OmXx4RX2q6wgoM9APUu2rIVxWZWado5oaybwMnAOsp7iM4DlgHHChpXkTcNtRKEXGXpBnjVGfLzZ01fdgDu68qMrNO0kzT0IPA6yPihIh4HcWQ1KuBOcCXR7HNCyWtSU1HBw23kKR5knol9W7fvn0UmylPvauKzMwmmmaC4Ljam8ciYi3FIHQP1VlnOFcAR1OcYWyhTpBExJKI6ImInu7u7lFsqjy+qsjMOkkzQfCwpK9Jmp1+vgo8JGkfYNdINhYRWyNid+pb+CZw0ihqrpyvKjKzTtJMEHwY2AQsABYCm4HzKELgrSPZmKRDaz6+h6KvYcLxVUVm1kmaGXTueeBv0s9gTw+3nqTrKUYqnSppE/BfgFMknUAxRMVjwAUjL7l6zVxVZGY2USii/nPoJb2R4iD+KmqCIyJeXW5pv9XT0xO9vb2t2pyZWUeQtCIiehot18zlo9+heFTlCmB3g2XNzGyCaSYInomIH5ZeiZmZVaKZILhd0heApcBvBiZ2+vMIzMxy0UwQnDzoFTr8eQRmZjlp5qqhbJ9LYGaWg3qPqjw3Iq6X9BdDzY+Ir5ZXlpmZtUq9M4KBcYDaa3wHMzMbV/UeVfk/0+tnWleOmZm1WjPPI5gK/Ckwgz1vKJtXXllmZtYqzVw1dCPwC+BufEOZmVnHaSYIXhYRF5deiZmZVaKZ0UdvkXRa6ZWYmVklmgmCjwA/kfScpKck/Yukp8ouzMzMWqOZpqGppVdhZmaVqXdD2TER8SDwmmEW8VhDZmYdoN4ZwQLgfODrQ8zzWENmZh2i3g1l56dXjzVkZtbBmukjQNKxwPHAvgPTIuK6sooyM7PWaebO4k8DpwHHAsuBORQ3lzkIzMw6QDOXj54NvAXYEhEfAl5Hk2cSZmbW/poJgv6I2A3skrQ/8ARwVLllmZlZqzTzl/0qSVOAK4Fe4BlgZalVmZlZy9QNAkkCLo2IHcDXJS0HDogIB4GZWYeo2zQUEQH8qObzQw4BM7PO0kwfwX2STiy9EjMzq8SwQSBpoNnoZIow2ChppaRVkhqeFUi6UtI2Setqph0s6VZJD6bXg+p9h5mZla/eGcF96XUuMBM4E3g/8L702shVwOmDpi0AbouIY4Db0mczM6tQvc5iAUTEw6P54oi4S9KMQZPPAk5J768G7gQ+NZrvNzOz8VEvCLolXTTczIi4bBTbe0VEbEnrb5F0yCi+w8zMxlG9IJgE7Ec6M2g1SfOAeQBHHHFEFSWYmWWhXhBsiYi/HuftbZV0aDobOBTYNtyCEbEEWALQ09MT41yHmZkl9TqLyzgTuAk4L70/D7ixhG2YmdkI1AuCt47liyVdD/wcmClpk6TzgUXA2yU9CLw9fTYzswrVezDNmB5QHxHnDjNrTAFjZmbjq5k7i83MrIM5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMucgMDPLnIPAzCxzDgIzs8w5CMzMMrdXFRuV9BjwLLAb2BURPVXUYWZmFQVB8paIeLLC7ZuZGW4aMjPLXlVBEMBPJa2QNG+oBSTNk9QrqXf79u0tLs/MLB9VBcHsiDgROAP4mKQ3D14gIpZERE9E9HR3d7e+QjOzTFTSRxARm9PrNkk/AE4C7qqiljIsW9XH4uUb2byjn2lTupg/ZyZzZ02vuiwzsyG1/IxA0ssk7T/wHjgNWNfqOsqybFUfC5eupW9HPwH07ehn4dK1LFvVV3VpZmZDqqJp6BXA3ZIeAO4DfhwRP6mgjlIsXr6R/p2795jWv3M3i5dvrKgiM7P6Wt40FBGPAK9r9XZbZfOO/obT3XRkZu3El4+Os2lTuupOd9ORmbUbB8E4mz9nJl2TJ+0xrWvyJObPmQm46cjM2k+VdxZ3pIEmnuGafpppOjIzayUHQQnmzpo+bJv/tCld9A1x0B+uScnMrGxuGmqxRk1HzVi2qo/Zi27nyAU/Zvai292/YGZj4jOCFmvUdNTIQGfzQD/DQGdz7XebmY2Eg6AC9ZqOGqnX2ewgMLPRcBC0oXr3Gbiz2czGm/sI2kyj+wwa3adgZjZSDoI20+g+g/HobDYzq+WmoTbTqOmnmc5mD2FhZiPhIGgzzdxnUK+z2VcVmdlIuWmozYy16cdDWJjZSPmMoM2M9T4DX1VkZiPlIGhDY7nPwENYmNlIuWmow/iqIjMbKZ8RdJixNi2ZWX4cBB1oLE1LZpYfNw2ZmWXOZwSZ8c1mZjaYgyAjrbjZzEFjNvG4aSgjZd9s1mjAPDNrTz4jyEgzN5uN5S96PyvBbGLyGUFGGg1hPda/6H1Xs9nE5CDISKObzZppOqr3vGQ/K8FsYnLTUEYa3WzW6C/6Rp3N8+fM3GM+jOyu5rF2NLuj2mx0KgkCSacDXwEmAd+KiEVV1JGjejebNRqnqFEfwFieldDMFU31DvRjXb+Z7x/LMyDKnO/a8qx9PCkiSvniYTcoTQJ+Bbwd2ATcD5wbEf9nuHV6enqit7e3RRXma/DBFIq/6L/w3tcyd9Z0jlzwY4b6v0XAo4veMabvX7x845AhNH1KF/csOLVhbbMX3T6m9evNB0a9btnzXVuetTdL0oqI6Gm0XBV9BCcBD0XEIxHxAvAPwFkV1GGDzJ01nS+897VMn9KFKA6itf/jjbUPoN4ZRaNmqUb9F2Ndv978saxb9nzXlmft462KpqHpwOM1nzcBbxi8kKR5wDyAI444ojWVWd2mo7H2AdQ7WDdqlmp0oB/r+qO54qnZdcue79rKmT/RahuLKs4INMS0f9PiEBFLIqInInq6u7tbUJY10uiMoZF6ZxSNrmhqdDYy1vXrzR/LumXPd23lzG/n2spQRRBsAg6v+XwYsLmCOmwU5s6azj0LTuXRRe/gngWnjqi9st7BulHINDrQj3X9evPHsm7Z811bnrWPtyqahu4HjpF0JNAHnAN8oII6rMUaXVVUr1mqmSuSxrJ+M98/2nXLnu/a8qt9vLX8qiEASWcC/53i8tErI+Lz9Zb3VUNmZiPX7FVDldxHEBE3AzdXsW0zM9uTh5gwM8ucg8DMLHMOAjOzzDkIzMwyV8lVQyMlaTvw61GuPhV4chzLGU+ubXRc2+i4ttGZyLW9KiIa3pE7IYJgLCT1NnP5VBVc2+i4ttFxbaOTQ21uGjIzy5yDwMwsczkEwZKqC6jDtY2Oaxsd1zY6HV9bx/cRmJlZfTmcEZiZWR0OAjOzzHV0EEg6XdJGSQ9JWlB1PbUkPSZpraTVkiodWlXSlZK2SVpXM+1gSbdKejC9HtRGtV0qqS/tu9VpNNsqajtc0h2SNkhaL+njaXrl+65ObZXvO0n7SrpP0gOptr9K04+UdG/ab9+VtHcb1XaVpEdr9tsJra6tpsZJklZJ+lH6PPb9FhEd+UMxxPXDwFHA3sADwPFV11VT32PA1KrrSLW8GTgRWFcz7YvAgvR+AfA3bVTbpcB/aoP9dihwYnq/P/Ar4Ph22Hd1aqt831E8pXC/9H4ycC/wRuB7wDlp+t8CH22j2q4C3lf1/3OprouA64Afpc9j3m+dfEZwEvBQRDwSES8A/wCcVXFNbSki7gKeGjT5LODq9P5qYG5Li0qGqa0tRMSWiFiZ3j8LbKB4Jnfl+65ObZWLwnPp4+T0E8CpwPfT9Kr223C1tQVJhwHvAL6VPotx2G+dHATTgcdrPm+iTf4hJAH8VNIKSfOqLmYIr4iILVAcVIBDKq5nsAslrUlNR5U0W9WSNAOYRfEXZFvtu0G1QRvsu9S8sRrYBtxKcfa+IyJ2pUUq+/c6uLaIGNhvn0/77XJJ+1RRG8UDvT4JvJg+v5xx2G+dHAQaYlrbJDswOyJOBM4APibpzVUXNIFcARwNnABsAb5cZTGS9gNuAD4REc9UWctgQ9TWFvsuInZHxAkUzyw/CThuqMVaW1Xa6KDaJP0+sBA4FvhD4GDgU62uS9I7gW0RsaJ28hCLjni/dXIQbAIOr/l8GLC5olr+jYjYnF63AT+g+MfQTrZKOhQgvW6ruJ6XRMTW9I/1ReCbVLjvJE2mONBeGxFL0+S22HdD1dZO+y7VswO4k6IdfoqkgacmVv7vtaa201NTW0TEb4DvUM1+mw28W9JjFE3dp1KcIYx5v3VyENwPHJN61PcGzgFuqrgmACS9TNL+A++B04B19ddquZuA89L784AbK6xlDwMH2eQ9VLTvUvvst4ENEXFZzazK991wtbXDvpPULWlKet8FvI2iD+MO4H1psar221C1/bIm2EXRBt/y/RYRCyPisIiYQXE8uz0i/iPjsd+q7gEvuXf9TIqrJR4G/nPV9dTUdRTFVUwPAOurrg24nqKZYCfFmdT5FG2PtwEPpteD26i2vwfWAmsoDrqHVlTbyRSn4WuA1ennzHbYd3Vqq3zfAX8ArEo1rAM+m6YfBdwHPAT8I7BPG9V2e9pv64BrSFcWVfUDnMJvrxoa837zEBNmZpnr5KYhMzNrgoPAzCxzDgIzs8w5CMzMMucgMDPLnIPAsiLpufQ6Q9IHxvm7Lxn0+X+P5/eblcVBYLmaAYwoCCRNarDIHkEQEf9uhDWZVcJBYLlaBPxRGlv+L9NAY4sl3Z8GFrsAQNIpaVz/6yhuKELSsjRY4PqBAQMlLQK60vddm6YNnH0offc6Fc+gOLvmu++U9H1Jv5R0bbpz1ayl9mq8iFlHWkAxLv87AdIB/emI+MM0suQ9kn6alj0J+P2IeDR9/tOIeCoNQXC/pBsiYoGkC6MYrGyw91IM8vY6YGpa5640bxbwGorxYe6hGE/m7vH/dc2G5zMCs8JpwIfT8MP3UgwTcUyad19NCAD8haQHgF9QDGx4DPWdDFwfxWBvW4GfUYxiOfDdm6IYBG41RZOVWUv5jMCsIODPI2L5HhOlU4B/HfT5bcCbIuJ5SXcC+zbx3cP5Tc373fjfpFXAZwSWq2cpHuE4YDnw0TR0M5JenUaGHexA4F9SCBxLMXzygJ0D6w9yF3B26ofopnj85n3j8luYjQP/9WG5WgPsSk08VwFfoWiWWZk6bLcz9CP/fgJ8RNIaYCNF89CAJcAaSSujGB54wA+AN1GMNhvAJyPiiRQkZpXz6KNmZplz05CZWeYcBGZmmXMQmJllzkFgZpY5B4GZWeYcBGZmmXMQmJll7v8DremAXuuHoPIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples.\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 =5e-2\n",
    "learning_rate = 1e-3\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",
    "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, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 105.655648\n",
      "(Epoch 0 / 20) train acc: 0.120000; val_acc: 0.107000\n",
      "(Epoch 1 / 20) train acc: 0.180000; val_acc: 0.121000\n",
      "(Epoch 2 / 20) train acc: 0.300000; val_acc: 0.113000\n",
      "(Epoch 3 / 20) train acc: 0.440000; val_acc: 0.110000\n",
      "(Epoch 4 / 20) train acc: 0.720000; val_acc: 0.076000\n",
      "(Epoch 5 / 20) train acc: 0.820000; val_acc: 0.102000\n",
      "(Iteration 11 / 40) loss: 3.679207\n",
      "(Epoch 6 / 20) train acc: 0.940000; val_acc: 0.098000\n",
      "(Epoch 7 / 20) train acc: 1.000000; val_acc: 0.095000\n",
      "(Epoch 8 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 9 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Iteration 21 / 40) loss: 0.000544\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Iteration 31 / 40) loss: 0.000114\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.094000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.094000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples.\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 = 1e-3\n",
    "weight_scale = 1e-1\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()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inline question: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net?\n",
    "\n",
    "# Answer:\n",
    "[FILL THIS IN]\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 stochstic gradient descent.\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 1e-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",
    "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.960267\n",
      "(Epoch 0 / 5) train acc: 0.083000; val_acc: 0.090000\n",
      "(Iteration 11 / 200) loss: 2.209393\n",
      "(Iteration 21 / 200) loss: 1.984141\n",
      "(Iteration 31 / 200) loss: 1.965922\n",
      "(Epoch 1 / 5) train acc: 0.262000; val_acc: 0.246000\n",
      "(Iteration 41 / 200) loss: 2.028457\n",
      "(Iteration 51 / 200) loss: 1.956354\n",
      "(Iteration 61 / 200) loss: 2.064978\n",
      "(Iteration 71 / 200) loss: 1.949478\n",
      "(Epoch 2 / 5) train acc: 0.359000; val_acc: 0.288000\n",
      "(Iteration 81 / 200) loss: 1.993715\n",
      "(Iteration 91 / 200) loss: 1.877420\n",
      "(Iteration 101 / 200) loss: 1.821640\n",
      "(Iteration 111 / 200) loss: 1.804942\n",
      "(Epoch 3 / 5) train acc: 0.360000; val_acc: 0.302000\n",
      "(Iteration 121 / 200) loss: 1.842798\n",
      "(Iteration 131 / 200) loss: 1.877155\n",
      "(Iteration 141 / 200) loss: 1.782519\n",
      "(Iteration 151 / 200) loss: 1.891671\n",
      "(Epoch 4 / 5) train acc: 0.424000; val_acc: 0.320000\n",
      "(Iteration 161 / 200) loss: 1.601913\n",
      "(Iteration 171 / 200) loss: 1.794024\n",
      "(Iteration 181 / 200) loss: 1.727406\n",
      "(Iteration 191 / 200) loss: 1.596529\n",
      "(Epoch 5 / 5) train acc: 0.434000; val_acc: 0.303000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.641813\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.099000\n",
      "(Iteration 11 / 200) loss: 2.193229\n",
      "(Iteration 21 / 200) loss: 2.089414\n",
      "(Iteration 31 / 200) loss: 1.917785\n",
      "(Epoch 1 / 5) train acc: 0.327000; val_acc: 0.309000\n",
      "(Iteration 41 / 200) loss: 1.750238\n",
      "(Iteration 51 / 200) loss: 1.881908\n",
      "(Iteration 61 / 200) loss: 1.747753\n",
      "(Iteration 71 / 200) loss: 1.694604\n",
      "(Epoch 2 / 5) train acc: 0.385000; val_acc: 0.334000\n",
      "(Iteration 81 / 200) loss: 1.776605\n",
      "(Iteration 91 / 200) loss: 1.702672\n",
      "(Iteration 101 / 200) loss: 1.571863\n",
      "(Iteration 111 / 200) loss: 1.686193\n",
      "(Epoch 3 / 5) train acc: 0.434000; val_acc: 0.316000\n",
      "(Iteration 121 / 200) loss: 1.587805\n",
      "(Iteration 131 / 200) loss: 1.740698\n",
      "(Iteration 141 / 200) loss: 1.487222\n",
      "(Iteration 151 / 200) loss: 1.743433\n",
      "(Epoch 4 / 5) train acc: 0.434000; val_acc: 0.311000\n",
      "(Iteration 161 / 200) loss: 1.268242\n",
      "(Iteration 171 / 200) loss: 1.494284\n",
      "(Iteration 181 / 200) loss: 1.360006\n",
      "(Iteration 191 / 200) loss: 1.244863\n",
      "(Epoch 5 / 5) train acc: 0.499000; val_acc: 0.358000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {},
     "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': 1e-2,\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.iteritems():\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": {},
   "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",
    "[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; you should see errors less than 1e-7\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",
    "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": 19,
   "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; you should see errors around 1e-7 or less\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",
    "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.434233\n",
      "(Epoch 0 / 5) train acc: 0.097000; val_acc: 0.097000\n",
      "(Iteration 11 / 200) loss: 2.127776\n",
      "(Iteration 21 / 200) loss: 1.912481\n",
      "(Iteration 31 / 200) loss: 1.688366\n",
      "(Epoch 1 / 5) train acc: 0.356000; val_acc: 0.307000\n",
      "(Iteration 41 / 200) loss: 1.774665\n",
      "(Iteration 51 / 200) loss: 1.727765\n",
      "(Iteration 61 / 200) loss: 1.640788\n",
      "(Iteration 71 / 200) loss: 1.614419\n",
      "(Epoch 2 / 5) train acc: 0.475000; val_acc: 0.360000\n",
      "(Iteration 81 / 200) loss: 1.672347\n",
      "(Iteration 91 / 200) loss: 1.550501\n",
      "(Iteration 101 / 200) loss: 1.408855\n",
      "(Iteration 111 / 200) loss: 1.724903\n",
      "(Epoch 3 / 5) train acc: 0.476000; val_acc: 0.347000\n",
      "(Iteration 121 / 200) loss: 1.565827\n",
      "(Iteration 131 / 200) loss: 1.351655\n",
      "(Iteration 141 / 200) loss: 1.233731\n",
      "(Iteration 151 / 200) loss: 1.047642\n",
      "(Epoch 4 / 5) train acc: 0.573000; val_acc: 0.369000\n",
      "(Iteration 161 / 200) loss: 1.487394\n",
      "(Iteration 171 / 200) loss: 1.357566\n",
      "(Iteration 181 / 200) loss: 1.330408\n",
      "(Iteration 191 / 200) loss: 1.162741\n",
      "(Epoch 5 / 5) train acc: 0.580000; val_acc: 0.374000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.489735\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.113000\n",
      "(Iteration 11 / 200) loss: 1.995923\n",
      "(Iteration 21 / 200) loss: 1.859602\n",
      "(Iteration 31 / 200) loss: 1.789558\n",
      "(Epoch 1 / 5) train acc: 0.390000; val_acc: 0.315000\n",
      "(Iteration 41 / 200) loss: 1.709071\n",
      "(Iteration 51 / 200) loss: 1.724800\n",
      "(Iteration 61 / 200) loss: 1.582961\n",
      "(Iteration 71 / 200) loss: 1.712063\n",
      "(Epoch 2 / 5) train acc: 0.453000; val_acc: 0.338000\n",
      "(Iteration 81 / 200) loss: 1.736022\n",
      "(Iteration 91 / 200) loss: 1.771282\n",
      "(Iteration 101 / 200) loss: 1.709644\n",
      "(Iteration 111 / 200) loss: 1.468034\n",
      "(Epoch 3 / 5) train acc: 0.483000; val_acc: 0.359000\n",
      "(Iteration 121 / 200) loss: 1.566406\n",
      "(Iteration 131 / 200) loss: 1.460235\n",
      "(Iteration 141 / 200) loss: 1.464256\n",
      "(Iteration 151 / 200) loss: 1.443468\n",
      "(Epoch 4 / 5) train acc: 0.534000; val_acc: 0.357000\n",
      "(Iteration 161 / 200) loss: 1.256973\n",
      "(Iteration 171 / 200) loss: 1.400313\n",
      "(Iteration 181 / 200) loss: 1.147510\n",
      "(Iteration 191 / 200) loss: 1.427130\n",
      "(Epoch 5 / 5) train acc: 0.536000; val_acc: 0.376000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {},
     "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 solvers.iteritems():\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": {},
   "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": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# batch normalization and dropout useful. Store your best model in the         #\n",
    "# best_model variable.                                                         #\n",
    "################################################################################\n",
    "pass\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test you 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(X_test), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(X_val), axis=1)\n",
    "print 'Validation set accuracy: ', (y_val_pred == y_val).mean()\n",
    "print 'Test set accuracy: ', (y_test_pred == y_test).mean()"
   ]
  }
 ],
 "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
}