NumpyNN (honor).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your very own neural network\n",
    "\n",
    "In this notebook, we're going to build a neural network using naught but pure numpy and steel nerves. It's going to be fun, I promise!\n",
    "\n",
    "![img](https://s27.postimg.org/vpui4r5n7/cartoon-2029952_960_720.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ln: failed to create symbolic link '/root/.keras/datasets/cifar-10-batches-py.tar.gz': File exists\n",
      "ln: failed to create symbolic link '/root/.keras/models/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5': File exists\n"
     ]
    }
   ],
   "source": [
    "# use the preloaded keras datasets and models\n",
    "! mkdir -p ~/.keras/datasets\n",
    "! mkdir -p ~/.keras/models\n",
    "! ln -s $(realpath ../readonly/keras/datasets/*) ~/.keras/datasets/\n",
    "! ln -s $(realpath ../readonly/keras/models/*) ~/.keras/models/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here goes our main class: a layer that can .forward() and .backward()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Layer:\n",
    "    \"\"\"\n",
    "    A building block. Each layer is capable of performing two things:\n",
    "    \n",
    "    - Process input to get output:           output = layer.forward(input)\n",
    "    \n",
    "    - Propagate gradients through itself:    grad_input = layer.backward(input, grad_output)\n",
    "    \n",
    "    Some layers also have learnable parameters which they update during layer.backward.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\"Here you can initialize layer parameters (if any) and auxiliary stuff.\"\"\"\n",
    "        # A dummy layer does nothing\n",
    "        pass\n",
    "    \n",
    "    def forward(self, input):\n",
    "        \"\"\"\n",
    "        Takes input data of shape [batch, input_units], returns output data [batch, output_units]\n",
    "        \"\"\"\n",
    "        # A dummy layer just returns whatever it gets as input.\n",
    "        return input\n",
    "\n",
    "    def backward(self, input, grad_output):\n",
    "        \"\"\"\n",
    "        Performs a backpropagation step through the layer, with respect to the given input.\n",
    "        \n",
    "        To compute loss gradients w.r.t input, you need to apply chain rule (backprop):\n",
    "        \n",
    "        d loss / d x  = (d loss / d layer) * (d layer / d x)\n",
    "        \n",
    "        Luckily, you already receive d loss / d layer as input, so you only need to multiply it by d layer / d x.\n",
    "        \n",
    "        If your layer has parameters (e.g. dense layer), you also need to update them here using d loss / d layer\n",
    "        \"\"\"\n",
    "        # The gradient of a dummy layer is precisely grad_output, but we'll write it more explicitly\n",
    "        num_units = input.shape[1]\n",
    "        \n",
    "        d_layer_d_input = np.eye(num_units)\n",
    "        \n",
    "        return np.dot(grad_output, d_layer_d_input) # chain rule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The road ahead\n",
    "\n",
    "We're going to build a neural network that classifies MNIST digits. To do so, we'll need a few building blocks:\n",
    "- Dense layer - a fully-connected layer, $f(X)=W \\cdot X + \\vec{b}$\n",
    "- ReLU layer (or any other nonlinearity you want)\n",
    "- Loss function - crossentropy\n",
    "- Backprop algorithm - a stochastic gradient descent with backpropageted gradients\n",
    "\n",
    "Let's approach them one at a time.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nonlinearity layer\n",
    "\n",
    "This is the simplest layer you can get: it simply applies a nonlinearity to each element of your network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReLU(Layer):\n",
    "    def __init__(self):\n",
    "        \"\"\"ReLU layer simply applies elementwise rectified linear unit to all inputs\"\"\"\n",
    "        pass\n",
    "    \n",
    "    def forward(self, input):\n",
    "        \"\"\"Apply elementwise ReLU to [batch, input_units] matrix\"\"\"\n",
    "        return np.maximum(0,input)# <your code. Try np.maximum>\n",
    "    \n",
    "    def backward(self, input, grad_output):\n",
    "        \"\"\"Compute gradient of loss w.r.t. ReLU input\"\"\"\n",
    "        relu_grad = input > 0\n",
    "        return grad_output*relu_grad        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# some tests\n",
    "from util import eval_numerical_gradient\n",
    "x = np.linspace(-1,1,10*32).reshape([10,32])\n",
    "l = ReLU()\n",
    "grads = l.backward(x,np.ones([10,32])/(32*10))\n",
    "numeric_grads = eval_numerical_gradient(lambda x: l.forward(x).mean(), x=x)\n",
    "assert np.allclose(grads, numeric_grads, rtol=1e-3, atol=0),\\\n",
    "    \"gradient returned by your layer does not match the numerically computed gradient\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instant primer: lambda functions\n",
    "\n",
    "In python, you can define functions in one line using the `lambda` syntax: `lambda param1, param2: expression`\n",
    "\n",
    "For example: `f = lambda x, y: x+y` is equivalent to a normal function:\n",
    "\n",
    "```\n",
    "def f(x,y):\n",
    "    return x+y\n",
    "```\n",
    "For more information, click [here](http://www.secnetix.de/olli/Python/lambda_functions.hawk).    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dense layer\n",
    "\n",
    "Now let's build something more complicated. Unlike nonlinearity, a dense layer actually has something to learn.\n",
    "\n",
    "A dense layer applies affine transformation. In a vectorized form, it can be described as:\n",
    "$$f(X)= W \\cdot X + \\vec b $$\n",
    "\n",
    "Where \n",
    "* X is an object-feature matrix of shape [batch_size, num_features],\n",
    "* W is a weight matrix [num_features, num_outputs] \n",
    "* and b is a vector of num_outputs biases.\n",
    "\n",
    "Both W and b are initialized during layer creation and updated each time backward is called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dense(Layer):\n",
    "    def __init__(self, input_units, output_units, learning_rate=0.1,initialization='xavier'):\n",
    "        \"\"\"\n",
    "        A dense layer is a layer which performs a learned affine transformation:\n",
    "        f(x) = <W*x> + b\n",
    "        \"\"\"\n",
    "        self.learning_rate = learning_rate\n",
    "        \n",
    "        # initialize weights with small random numbers. We use normal initialization, \n",
    "        # but surely there is something better. Try this once you got it working: http://bit.ly/2vTlmaJ\n",
    "        if initialization == 'xavier':\n",
    "            self.weights = np.random.randn(input_units, output_units) * np.sqrt(2.0/(input_units+output_units))\n",
    "        else:\n",
    "            self.weights = np.random.randn(input_units, output_units) * 0.01\n",
    "        self.biases = np.zeros(output_units)\n",
    "        \n",
    "    def forward(self,input):\n",
    "        \"\"\"\n",
    "        Perform an affine transformation:\n",
    "        f(x) = <W*x> + b\n",
    "        \n",
    "        input shape: [batch, input_units]\n",
    "        output shape: [batch, output units]\n",
    "        \"\"\"\n",
    "        return np.dot(input,self.weights) + self.biases \n",
    "    \n",
    "    def backward(self,input,grad_output):\n",
    "        \n",
    "        # compute d f / d x = d f / d dense * d dense / d x\n",
    "        # where d dense/ d x = weights transposed\n",
    "        grad_input = np.dot(grad_output, self.weights.T) \n",
    "        \n",
    "        #compute gradient w.r.t. weights and biases\n",
    "        grad_weights = np.dot(input.T, grad_output)\n",
    "        grad_biases = np.sum(grad_output, axis=0)\n",
    "        \n",
    "        assert grad_weights.shape == self.weights.shape and grad_biases.shape == self.biases.shape\n",
    "        # Here we perform a stochastic gradient descent step. \n",
    "        # Later on, you can try replacing that with something better.\n",
    "        self.weights = self.weights - self.learning_rate * grad_weights\n",
    "        self.biases = self.biases - self.learning_rate * grad_biases\n",
    "        \n",
    "        return grad_input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the dense layer\n",
    "\n",
    "Here we have a few tests to make sure your dense layer works properly. You can just run them, get 3 \"well done\"s and forget they ever existed.\n",
    "\n",
    "... or not get 3 \"well done\"s and go fix stuff. If that is the case, here are some tips for you:\n",
    "* Make sure you compute gradients for W and b as __sum of gradients over batch__, not mean over gradients. Grad_output is already divided by batch size.\n",
    "* If you're debugging, try saving gradients in class fields, like \"self.grad_w = grad_w\" or print first 3-5 weights. This helps debugging.\n",
    "* If nothing else helps, try ignoring tests and proceed to network training. If it trains alright, you may be off by something that does not affect network training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Well done!\n"
     ]
    }
   ],
   "source": [
    "l = Dense(128, 150)\n",
    "\n",
    "assert -0.05 < l.weights.mean() < 0.05 and 1e-3 < l.weights.std() < 1e-1,\\\n",
    "    \"The initial weights must have zero mean and small variance. \"\\\n",
    "    \"If you know what you're doing, remove this assertion.\"\n",
    "assert -0.05 < l.biases.mean() < 0.05, \"Biases must be zero mean. Ignore if you have a reason to do otherwise.\"\n",
    "\n",
    "# To test the outputs, we explicitly set weights with fixed values. DO NOT DO THAT IN ACTUAL NETWORK!\n",
    "l = Dense(3,4)\n",
    "\n",
    "x = np.linspace(-1,1,2*3).reshape([2,3])\n",
    "l.weights = np.linspace(-1,1,3*4).reshape([3,4])\n",
    "l.biases = np.linspace(-1,1,4)\n",
    "\n",
    "assert np.allclose(l.forward(x),np.array([[ 0.07272727,  0.41212121,  0.75151515,  1.09090909],\n",
    "                                          [-0.90909091,  0.08484848,  1.07878788,  2.07272727]]))\n",
    "print(\"Well done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Well done!\n"
     ]
    }
   ],
   "source": [
    "# To test the grads, we use gradients obtained via finite differences\n",
    "\n",
    "from util import eval_numerical_gradient\n",
    "\n",
    "x = np.linspace(-1,1,10*32).reshape([10,32])\n",
    "l = Dense(32,64,learning_rate=0)\n",
    "\n",
    "numeric_grads = eval_numerical_gradient(lambda x: l.forward(x).sum(),x)\n",
    "grads = l.backward(x,np.ones([10,64]))\n",
    "\n",
    "assert np.allclose(grads,numeric_grads,rtol=1e-3,atol=0), \"input gradient does not match numeric grad\"\n",
    "print(\"Well done!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Well done!\n"
     ]
    }
   ],
   "source": [
    "#test gradients w.r.t. params\n",
    "def compute_out_given_wb(w,b):\n",
    "    l = Dense(32,64,learning_rate=1)\n",
    "    l.weights = np.array(w)\n",
    "    l.biases = np.array(b)\n",
    "    x = np.linspace(-1,1,10*32).reshape([10,32])\n",
    "    return l.forward(x)\n",
    "    \n",
    "def compute_grad_by_params(w,b):\n",
    "    l = Dense(32,64,learning_rate=1)\n",
    "    l.weights = np.array(w)\n",
    "    l.biases = np.array(b)\n",
    "    x = np.linspace(-1,1,10*32).reshape([10,32])\n",
    "    l.backward(x,np.ones([10,64]) / 10.)\n",
    "    return w - l.weights, b - l.biases\n",
    "    \n",
    "w,b = np.random.randn(32,64), np.linspace(-1,1,64)\n",
    "\n",
    "numeric_dw = eval_numerical_gradient(lambda w: compute_out_given_wb(w,b).mean(0).sum(),w )\n",
    "numeric_db = eval_numerical_gradient(lambda b: compute_out_given_wb(w,b).mean(0).sum(),b )\n",
    "grad_w,grad_b = compute_grad_by_params(w,b)\n",
    "\n",
    "assert np.allclose(numeric_dw,grad_w,rtol=1e-3,atol=0), \"weight gradient does not match numeric weight gradient\"\n",
    "assert np.allclose(numeric_db,grad_b,rtol=1e-3,atol=0), \"weight gradient does not match numeric weight gradient\"\n",
    "print(\"Well done!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The loss function\n",
    "\n",
    "Since we want to predict probabilities, it would be logical for us to define softmax nonlinearity on top of our network and compute loss given predicted probabilities. However, there is a better way to do so.\n",
    "\n",
    "If you write down the expression for crossentropy as a function of softmax logits (a), you'll see:\n",
    "\n",
    "$$ loss = - log \\space {e^{a_{correct}} \\over {\\underset i \\sum e^{a_i} } } $$\n",
    "\n",
    "If you take a closer look, ya'll see that it can be rewritten as:\n",
    "\n",
    "$$ loss = - a_{correct} + log {\\underset i \\sum e^{a_i} } $$\n",
    "\n",
    "It's called Log-softmax and it's better than naive log(softmax(a)) in all aspects:\n",
    "* Better numerical stability\n",
    "* Easier to get derivative right\n",
    "* Marginally faster to compute\n",
    "\n",
    "So why not just use log-softmax throughout our computation and never actually bother to estimate probabilities.\n",
    "\n",
    "Here you are! We've defined the both loss functions for you so that you could focus on neural network part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax_crossentropy_with_logits(logits,reference_answers):\n",
    "    \"\"\"Compute crossentropy from logits[batch,n_classes] and ids of correct answers\"\"\"\n",
    "    logits_for_answers = logits[np.arange(len(logits)),reference_answers]\n",
    "    \n",
    "    xentropy = - logits_for_answers + np.log(np.sum(np.exp(logits),axis=-1))\n",
    "    \n",
    "    return xentropy\n",
    "\n",
    "def grad_softmax_crossentropy_with_logits(logits,reference_answers):\n",
    "    \"\"\"Compute crossentropy gradient from logits[batch,n_classes] and ids of correct answers\"\"\"\n",
    "    ones_for_answers = np.zeros_like(logits)\n",
    "    ones_for_answers[np.arange(len(logits)),reference_answers] = 1\n",
    "    \n",
    "    softmax = np.exp(logits) / np.exp(logits).sum(axis=-1,keepdims=True)\n",
    "    \n",
    "    return (- ones_for_answers + softmax) / logits.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits = np.linspace(-1,1,500).reshape([50,10])\n",
    "answers = np.arange(50)%10\n",
    "\n",
    "softmax_crossentropy_with_logits(logits,answers)\n",
    "grads = grad_softmax_crossentropy_with_logits(logits,answers)\n",
    "numeric_grads = eval_numerical_gradient(lambda l: softmax_crossentropy_with_logits(l,answers).mean(),logits)\n",
    "\n",
    "assert np.allclose(numeric_grads,grads,rtol=1e-3,atol=0), \"The reference implementation has just failed. Someone has just changed the rules of math.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Full network\n",
    "\n",
    "Now let's combine what we've just built into a working neural network. As we announced, we're gonna use this monster to classify handwritten digits, so let's get them loaded."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f65f436d940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from preprocessed_mnist import load_dataset\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(flatten=True)\n",
    "\n",
    "plt.figure(figsize=[6,6])\n",
    "for i in range(4):\n",
    "    plt.subplot(2,2,i+1)\n",
    "    plt.title(\"Label: %i\"%y_train[i])\n",
    "    plt.imshow(X_train[i].reshape([28,28]),cmap='gray');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll define network as a list of layers, each applied on top of previous one. In this setting, computing predictions and training becomes trivial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "network = []\n",
    "network.append(Dense(X_train.shape[1],100))\n",
    "network.append(ReLU())\n",
    "network.append(Dense(100,200))\n",
    "network.append(ReLU())\n",
    "network.append(Dense(200,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward(network, X):\n",
    "    \"\"\"\n",
    "    Compute activations of all network layers by applying them sequentially.\n",
    "    Return a list of activations for each layer. \n",
    "    Make sure last activation corresponds to network logits.\n",
    "    \"\"\"\n",
    "    activations = []\n",
    "    input = X\n",
    "    \n",
    "    for layer in network:\n",
    "        activations.append(layer.forward(input))\n",
    "        input = activations[-1]\n",
    "        \n",
    "    assert len(activations) == len(network)\n",
    "    return activations\n",
    "\n",
    "\n",
    "def predict(network,X):\n",
    "    \"\"\"\n",
    "    Compute network predictions.\n",
    "    \"\"\"\n",
    "    logits = forward(network,X)[-1]\n",
    "    return logits.argmax(axis=-1)\n",
    "\n",
    "def train(network,X,y):\n",
    "    \"\"\"\n",
    "    Train your network on a given batch of X and y.\n",
    "    You first need to run forward to get all layer activations.\n",
    "    Then you can run layer.backward going from last to first layer.\n",
    "    \n",
    "    After you called backward for all layers, all Dense layers have already made one gradient step.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Get the layer activations\n",
    "    layer_activations = forward(network,X)\n",
    "    layer_inputs = [X]+layer_activations  #layer_input[i] is an input for network[i]\n",
    "    logits = layer_activations[-1]\n",
    "    \n",
    "    # Compute the loss and the initial gradient\n",
    "    loss = softmax_crossentropy_with_logits(logits,y)\n",
    "    loss_grad = grad_softmax_crossentropy_with_logits(logits,y)\n",
    "    \n",
    "    # <your code: propagate gradients through the network>\n",
    "    for layer_i in range(len(network))[::-1]:\n",
    "        layer = network[layer_i]\n",
    "        \n",
    "        loss_grad = layer.backward(layer_inputs[layer_i],loss_grad)\n",
    "        \n",
    "    return np.mean(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of tests, we provide you with a training loop that prints training and validation accuracies on every epoch.\n",
    "\n",
    "If your implementation of forward and backward are correct, your accuracy should grow from 90~93% to >97% with the default network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training loop\n",
    "\n",
    "As usual, we split data into minibatches, feed each such minibatch into the network and update weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import trange\n",
    "def iterate_minibatches(inputs, targets, batchsize, shuffle=False):\n",
    "    assert len(inputs) == len(targets)\n",
    "    if shuffle:\n",
    "        indices = np.random.permutation(len(inputs))\n",
    "    for start_idx in trange(0, len(inputs) - batchsize + 1, batchsize):\n",
    "        if shuffle:\n",
    "            excerpt = indices[start_idx:start_idx + batchsize]\n",
    "        else:\n",
    "            excerpt = slice(start_idx, start_idx + batchsize)\n",
    "        yield inputs[excerpt], targets[excerpt]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "train_log = []\n",
    "val_log = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24\n",
      "Train accuracy: 1.0\n",
      "Val accuracy: 0.9809\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f65e10ccdd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for epoch in range(25):\n",
    "\n",
    "    for x_batch,y_batch in iterate_minibatches(X_train,y_train,batchsize=32,shuffle=True):\n",
    "        train(network,x_batch,y_batch)\n",
    "    \n",
    "    train_log.append(np.mean(predict(network,X_train)==y_train))\n",
    "    val_log.append(np.mean(predict(network,X_val)==y_val))\n",
    "    \n",
    "    clear_output()\n",
    "    print(\"Epoch\",epoch)\n",
    "    print(\"Train accuracy:\",train_log[-1])\n",
    "    print(\"Val accuracy:\",val_log[-1])\n",
    "    plt.plot(train_log,label='train accuracy')\n",
    "    plt.plot(val_log,label='val accuracy')\n",
    "    plt.legend(loc='best')\n",
    "    plt.grid()\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Peer-reviewed assignment\n",
    "\n",
    "Congradulations, you managed to get this far! There is just one quest left undone, and this time you'll get to choose what to do.\n",
    "\n",
    "\n",
    "#### Option I: initialization\n",
    "* Implement Dense layer with Xavier initialization as explained [here](http://bit.ly/2vTlmaJ)\n",
    "\n",
    "To pass this assignment, you must conduct an experiment showing how xavier initialization compares to default initialization on deep networks (5+ layers).\n",
    "\n",
    "\n",
    "#### Option II: regularization\n",
    "* Implement a version of Dense layer with L2 regularization penalty: when updating Dense Layer weights, adjust gradients to minimize\n",
    "\n",
    "$$ Loss = Crossentropy + \\alpha \\cdot \\underset i \\sum {w_i}^2 $$\n",
    "\n",
    "To pass this assignment, you must conduct an experiment showing if regularization mitigates overfitting in case of abundantly large number of neurons. Consider tuning $\\alpha$ for better results.\n",
    "\n",
    "#### Option III: optimization\n",
    "* Implement a version of Dense layer that uses momentum/rmsprop or whatever method worked best for you last time.\n",
    "\n",
    "Most of those methods require persistent parameters like momentum direction or moving average grad norm, but you can easily store those params inside your layers.\n",
    "\n",
    "To pass this assignment, you must conduct an experiment showing how your chosen method performs compared to vanilla SGD.\n",
    "\n",
    "### General remarks\n",
    "_Please read the peer-review guidelines before starting this part of the assignment._\n",
    "\n",
    "In short, a good solution is one that:\n",
    "* is based on this notebook\n",
    "* runs in the default course environment with Run All\n",
    "* its code doesn't cause spontaneous eye bleeding\n",
    "* its report is easy to read.\n",
    "\n",
    "_Formally we can't ban you from writing boring reports, but if you bored your reviewer to death, there's noone left alive to give you the grade you want._\n",
    "\n",
    "\n",
    "### Bonus assignments\n",
    "\n",
    "As a bonus assignment (no points, just swag), consider implementing Batch Normalization ([guide](https://gab41.lab41.org/batch-normalization-what-the-hey-d480039a9e3b)) or Dropout ([guide](https://medium.com/@amarbudhiraja/https-medium-com-amarbudhiraja-learning-less-to-learn-better-dropout-in-deep-machine-learning-74334da4bfc5)). Note, however, that those \"layers\" behave differently when training and when predicting on test set.\n",
    "\n",
    "* Dropout:\n",
    "  * During training: drop units randomly with probability __p__ and multiply everything by __1/(1-p)__\n",
    "  * During final predicton: do nothing; pretend there's no dropout\n",
    "  \n",
    "* Batch normalization\n",
    "  * During training, it substracts mean-over-batch and divides by std-over-batch and updates mean and variance.\n",
    "  * During final prediction, it uses accumulated mean and variance.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "xavier_network = []\n",
    "xavier_network.append(Dense(X_train.shape[1],100,initialization='xavier'))\n",
    "xavier_network.append(ReLU())\n",
    "xavier_network.append(Dense(100,200,initialization='xavier'))\n",
    "xavier_network.append(ReLU())\n",
    "xavier_network.append(Dense(200,10,initialization='xavier'))\n",
    "default_network = []\n",
    "default_network.append(Dense(X_train.shape[1],100,initialization='default'))\n",
    "default_network.append(ReLU())\n",
    "default_network.append(Dense(100,200,initialization='default'))\n",
    "default_network.append(ReLU())\n",
    "default_network.append(Dense(200,10,initialization='default'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24\n",
      "xavier accuracy: 1.0\n",
      "default accuracy: 1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl8VNXd+PHPNyEhJECABMMSIKgsZUkgYXNBUUsFtFhtKe7VXy1dtMvTaoU+Pmqx1FqpbV2etjwVBatVS6uixYJLUqgkyCL7viRhwpqN7NvM+f1xb+IQssxMJjNJ5vt+veY1M+fee+45GZjv3HPOPUeMMSillFJhwS6AUkqpjkEDglJKKUADglJKKZsGBKWUUoAGBKWUUjYNCEoppQANCEoppWwaEJRSSgEaEJRSStm6BbsA3oiPjzdJSUk+HVteXk5MTIx/C9RJhHLdIbTrH8p1h9Cuv3vdt27dmm+M6d/aMZ0qICQlJbFlyxafjs3IyGDGjBn+LVAnEcp1h9CufyjXHUK7/u51F5EcT47RJiOllFKABgSllFI2DQhKKaUADQhKKaVsGhCUUkoBHgYEEVkuImdEZHcz20VEnhWRwyKyU0RS3bZ9Q0QO2Y9vuKWnicgu+5hnRUTaXh2llFK+8vQK4WVgVgvbZwMj7McC4A8AItIPeAyYCkwBHhORvvYxfwC+5XZcS/krpZRqZx7dh2CMWS8iSS3schOw0ljrcWaJSB8RGQjMAD4wxhQCiMgHwCwRyQB6G2Oy7PSVwFeA932sh+pCjDFU1DgpLK+hoLyGwvJqCspqKCyvoby6zuv8snNq2FZzoB1K6gPjIr7iMIklnxFdW9zup6s6V0zW4dXtfp6OqivVf+Tcn9DvosHteg5/3Zg2GDju9t5hp7WU7mgi/QIisgDrqoOEhAQyMjJ8KmBZWZnPx3Z2gay7yxiqnVDtNNQ4afTa2lZjP1fXGUprDaU1UFpjKK0xlNjPta7mz+F926KBI4ebTI+hin5SQhyl9JMS+kkJvajEYeI5bBLJNRfhJNzrM9YLw8UXJIepYfuYGraPKWH76SPlALhMgFpJSwJzmg6ri9R/zb8n0LP/UI/39+X/fYe/U9kYswxYBjBp0iTj612HesfijHbJu7C8hje3HOfNzcdxFFdSU9fCN3kToiLCiIvpTlzPSJLiIukXE0lcTCT9YroTFxNJXM/6tO706xlJTGQ4rXY3OWuhJA+Kc6E4l6M7s7g4oTdU5EN5/ufP5fngrG45r/BIiBsBF42G/qOh/yjrud/FEB7RxLnr4NROyP4P5HwCOZlQfc7a1u9iGHYLJF0Jw64grM8Qr/5Wvgjlf/fQtep/o5f7+1J3fwWEPMD9X3einZaH1Wzknp5hpyc2sb/qBIwxbMst5i9ZOfxz10lq6lxMGd6PL40dQI+IcKIjw4mKDCc6IpwekfbDTu8R4f6+Gz0iffj1XVcN5xzWF/654w1f/BTbr0tPgPk8MF0M4IiBmDiIjoeeAyBhHETHQUy8lRYT//nr7r2gKBvO7rcfByBvK+z+B2CsTMMiIO7SzwNEt+6QsxFys6Cm1Non7lIY+xVImg5JV0DvQW38yyvVvvwVEFYDD4jI61gdyOeMMSdFZC3wS7eO5C8Bi4wxhSJSIiLTgE3A3cBzfiqLaifl1XW8s/0Er2TlsO9kCT27d+O2yUO4Y9owRib0av8C7H0H3l8IpSdp+GIGkDDonQh9hsDw6dBnKMQOsZ77DGH9Z4e46rrrvTtXdD8YnHp+Wk055B+yAkR9sDi10yoXBuJHQfI8GHaFdRXQa0Bba6xUQHkUEETkr1i/9ONFxIE1cigCwBjzR2ANMAc4DFQA99rbCkXkCWCzndXi+g5m4HtYo5d6YHUma4dyB3XodCl/ycrhH9vyKK2uY/SAXvzy5vHcNGEQMd0D1OpoDHzwGERGw4yF9pe9/cXfe1DTzTc2V3iuf8oQGQODJlgPd7WV1iO6n3/Oo1SQeDrK6LZWthvg/ma2LQeWN5G+BRjnyfmV744XVvDMlirecGx1a5+PpF/P89vo+0VH0i3881HINXUu1u09xV+ycsg6WkhkeBg3JA/kzmlDSR3at/V2fH/L3gBFx+DmZZAyP7Dnbk1ED+uhVCfX4TuVVdv8ecNR9hQ4qQgro7C8hqKKGoxpet/YHhENASOnsIKzpdUM6deDhbNHMy8tkbie3QNbeHfbVkL3WBgzN3hlUKqL04DQhZVV1/H3bXlMGRjOX39wNQBOl6G4osZtjH8NBWXVn78ur6GwrIbUoX24dfJQrhrZn/CwIN9EXlEIe1dD6t36S1ypdqQBoQt767M8yqrruG5oVENaeJgQ17M7cT27MyKIZfPKrr9Zw0PTvtH6vkopn+nkdl2UMYZXMrMZN7g3l8R24o/ZGNi6AgZNhAHjg10apbq0TvxNoVqy6VghB0+Xcfe0pMB3APvTiW1wZo/VXKSUalcaELqoVzJziO0RwZdTOvnNUNtWQkQ0jPtasEuiVJenAaELOl1Sxdo9p/j6pETf7gT2Vm0lvHwjbPqTf/OtLoNdq2DszRDV2795K6UuoAGhC3ptUy5OY7hz2rDAnPDfT1n3CXz4OJSe9l++e96CmjJtLlIqQDQgdDG1Thd//TSXq0f2Z1hcTPuf8NQu+ORZuHQmOGus4OAv21ZC/EgYMtV/eSqlmqUBoYtZu+cUZ0qrufuyAFwduJyw+vvWlA23LIO0e2Hry5Df1FTTXjqzDxyfWlcHnblTXKlORANCF7MyM4eh/aK5euRF7X+yTX+EE5/B7KesoHD1T6FbFHz8RNvz3vaKNaNoSouzpiil/EgDQhey/1QJnx4r5M5pQ9v/7uKibPj4FzDiehh7i5XW8yK4/AHY+zY4tvqed1017PgrjL7BmpJaKRUQGhC6kFcyc+jeLYyvT2rnhVeMgfd+bE07fcNvzm/SuewBa02BDx+j2UmTWrP/n1BZqJ3JSgWYBoQuoqSqlrc+y2NuyiD6REe278l2/Q2OfATXPWqtQeAuqrfVdJS9AQ5/5Fv+21ZC7FC4+Jq2l1Up5TENCF3E37c6qKhxcvdlSe17ovIC+NdCGDwJJt/X9D5p90KfYdZVgsu7JTUpyoaj6TDxTgjTf55KBZL+j+sCjDG8kpXDhCF9GJ8Y274nW/szqDoHc5+DsGZueusWaV09nN5tXU1447O/AAIT72hzUZVS3tGA0AV8criAo2fL23+o6eEPYefrcOV/QcKYlvcdewsMSLY6nutaWci+nrMOPnsVLv0ixCa2vr9Syq88CggiMktEDojIYRFZ2MT2YSLykYjsFJEMEUl02/aUiOy2H/Pd0q8VkW12+goR0am4fbQyM5t+MZHMGT+w/U5SUw7v/RfEjYDpD7a+f1gYzPw5nMuFzS96do4jH0HpCZ3mWqkgaTUgiEg48AIwGxgD3CYijX8eLgVWGmOSgcXAk/axNwCpwARgKvCgiPQWkTBgBXCrMWYckAPot4AP8oor+XDfaeZPHkJURDvOW5T+SyjOhS//HiKiWt8f4JJr4eIZsP5pq5mpNdtWQkx/GDmrLSVVSvnIkyuEKcBhY8xRY0wN8DpwU6N9xgAf26/T3baPAdYbY+qMMeXATmAWEAfUGGMO2vt9AHzV92qErtc25QBwx9Sh7XeSvG2Q9b+Qdg8kXeHdsV983BpC+smzLe9XehoOvA8TbofwCB8LqpRqC0+aaQYDx93eO7B+7bvbAdwC/B64GeglInF2+mMi8hsgGrgG2AvkA91EZJIxZgvwNaDJwfMisgBYAJCQkEBGRoZnNWukrKzM52M7qlqXYeUnFaT0D+fwjk9pbsKIttRdXHWkbnuQyIhYNkfNpM6HfL5w0XTiP3mWTXVjqener8l9huT+nUuMk021o6j08+fUFT97T4Vy3SG06+9T3Y0xLT6wvqz/7Pb+LuD5RvsMAv4BfIYVFBxAH3vbfwPbsa4CXgV+ZKdfBmwAPgV+AWxvrSxpaWnGV+np6T4f21G9tc1hhj38nvn3gTMt7temum94xpjHehuz5x3f8yg4YszP+xmz+odNb3e5jPn9BGOWz/b9HC3oip+9p0K57saEdv3d6w5sMa18vxpjPGoyyuP8X++Jdpp7UDlhjLnFGDPRDgAYY4rt5yXGmAnGmJmAAAft9ExjzHRjzBRgfX268tzKzGyGx8dw5aXtNL1DwRHI+BWMvhHGzPU9n34Xw6T/Z/UR5B+6cHvOJ1B4VO9MVirIPAkIm4ERIjJcRCKBW4HV7juISLzdUQywCFhup4fbTUeISDKQDKyz319kP3cHHgb+2PbqhI7deefYllvMndOGEdYe8xYZA+/9CMIjYc7Tbc/vqp9CRA/4aPGF27augO6x8IU2BB2lVJu1GhCMMXXAA8BaYB/wpjFmj4gsFpH6/8EzgAMichBIAJbY6RHABhHZCywD7rTzA3hIRPZhdTS/a4yp75RWHnglM4ceEeF8La2dxutvfxWOrbc6hXv7YRnOnv3h8u/DvtVwfPPn6ZVFsPcdSJ4HkdFtP49Symcejf03xqwB1jRKe9Tt9SpgVRPHVWGNNGoqz4eAh7wprLKcq6jlnR153DxxMLE92mFETtkZWPvfMPQyaxoKf7nsfvj0/6wpLe75pzUp3s6/gbMaUnXUsVLBpncqd0J/23qcqloXd01Lap8TZPwKaiusew78OZ9Q915w9cNWn8GhD6xmqW0rYOAEGJjsv/MopXyiAaGTcbmseYsmDevLmEHtsPC8y2k14Yy+EfqP8n/+afdA3yRr/eW8rdZ8R9qZrFSHoAGhk1l/6Cw5BRXc1V7zFuVmQUU+fOHL7ZN/t0i49n/gzB74+zehWw8Y/7X2OZdSyisaEDqRyhonL/7nGPE9uzN7XDvNW7TvXQjvDiNmtk/+YE18NzDFmup67M0Q1c4ztCqlPKITynUCx/LLeTUrh79tdXCuspafzhpFZLd2iOXGwP734JJrrPb+9hIWBl/6Bbw6r/k1FZRSAacBoYOqc7r4cN8ZXt2Uw4ZD+XQLE64fN4C7pg1j6vCmp39os5Pb4dxxmHHBhLb+N/wqWJQH4fpPUKmOQv83djBnSqr466fH+eunuZwqqWJQbBQ/mTmS+VOGcFEvD2cZ9dW+d0HCYeTs9j1PPQ0GSnUo+j+yAzDGkHm0gL9k5bBuz2nqXIarRvZn8U1juXb0RXQLD1BXz773YNjlEBMXmPMppToUDQhBVF5dx5tbjvOXrByOnC2nT3QE916RxB1Th5EUHxPYwpw9APkHtE1fqRCmASGI/ued3fxjWx4ThvRh6bwUbkwe2L6L3LRk37vW8+gbgnN+pVTQaUAIEpfLkL7/DDdPHMxv508IdnGs0UWD0yB2cLBLopQKEr0PIUgOnC6lqKKWK9pr6mpvFB+HE5+1381oSqlOQQNCkGQdLQDgsks6QAfu/ves59EaEJQKZRoQgiTzSAFD+0UzuE+PYBfFGl3U/wsQf2mwS6KUCiINCEHgchk2HStk2sXtdIOZN8rOQu5GbS5SSmlACIZ9p0o4V1nbMZqLDqwB49KAoJTSgBAMmUes/oNpF3eAgLDvXegzDAaMD3ZJlFJB5lFAEJFZInJARA6LyAUT3YjIMBH5SER2ikiGiCS6bXtKRHbbj/lu6deJyDYR2S4i/xGRkGnAzjpaQFJcNANjg9x/UHUOjv3bujqQdliXWSnVqbQaEEQkHHgBmI21HOZtItJ4WcylwEpjTDKwGHjSPvYGIBWYAEwFHhSR+lVd/gDcYYyZALwGPNL26nR8Trv/oEM0Fx36AJw12lyklAI8u0KYAhw2xhw1xtQArwM3NdpnDPCx/TrdbfsYYL0xps4YUw7sBGbZ2wxQHxxigRO+VaFz2XuihNKqug7SXLQaeiZA4pRgl0Qp1QF4EhAGA8fd3jvsNHc7gFvs1zcDvUQkzk6fJSLRIhIPXAMMsfe7D1gjIg7gLuBXvlWhc8k8mg/AZcEOCLWVcOhDGDXHv+smK6U6LX9NXfEg8LyI3AOsB/IApzFmnYhMBjYCZ4FMwGkf81/AHGPMJhF5CHgGK0icR0QWAAsAEhISyMjI8KmAZWVlPh/rT//cWsWAGGHvtiz2BuicTdU9Ln8T42vL2VE7jKIO8HdpTx3lsw+GUK47hHb9faq7MabFB3AZsNbt/SJgUQv79wQczWx7DZgD9AeOuKUPBfa2Vpa0tDTjq/T0dJ+P9ZfaOqcZ++i/zM/+sTOg522y7v/4jjFPDjGmtjqgZQmGjvDZB0so192Y0K6/e92BLaaV71djjEdNRpuBESIyXEQigVuB1e47iEi8iNTntQhYbqeH201HiEgykAysA4qAWBEZaR8zE9jnXSjrfHafKKGsugP0Hzhr4eD7MHKWtei9UkrhQZORMaZORB4A1gLhwHJjzB4RWYwVdVYDM4AnRcRgNRndbx8eAWwQa0hjCXCnMaYOQES+BfxdRFxYAeL/+bVmHVD9/EVBDwg5n0BlkY4uUkqdx6M+BGPMGmBNo7RH3V6vAlY1cVwV1kijpvJ8C3jLm8J2dplHChhxUU/69+oe3ILsexe69YBLrgtuOZRSHYoOLwmQWqeLzdmFwb86cLlg/z/h0usgMjq4ZVFKdSgaEAJkV945Kmqcwb8hLW8rlJ6EL8wNbjmUUh2OBoQAqZ+/aOrwIM9wum81hHWDkdcHtxxKqQ5HA0KAZB0tYFRCL+J6BrH/wBhrMZzhV0OPPsErh1KqQ9KAEAA1dS62ZBcFv7nozF4oPApfuDG45VBKdUgaEAJgp6OYylpn8DuU970LCIy6IbjlUEp1SBoQAiDzSAEiHaH/4D0YOg16JQS3HEqpDkkDQgBkHi1g9IDe9I0J4l3BhUfh9C4Yrc1FSqmmaUBoZ9V1TrbmFAV/dtN971nP2n+glGqGBoR2tj23mOo6F9MuDnJz0f73YEAy9E0KbjmUUh2WBoR2lnm0vv8geFcIkdWFcHyTzl2klGqRBoR2lnW0gLGDehMbHRG0MsTnb7JeaEBQSrVAA0I7qqp1si23OOj9B/H5WRB3KfQfHdRyKKU6Ng0I7WhbbhE1da7g3n9QUUifYnt0kTUNuVJKNUkDQjvKOlpImMDkYN5/sOOvhBknjLkpeGVQSnUKGhDaUdaRAsYPjqV3VJD6D6rLYMMzFPZNgcGpwSmDUqrT0IDQTiprnHx2vCi4zUWf/gkq8slOuiN4ZVBKdRoeBQQRmSUiB0TksIgsbGL7MBH5SER2ikiGiCS6bXtKRHbbj/lu6RtEZLv9OCEib/unSh3Dttwiap2GacGa0K6yGD75PYycRUnsqOCUQSnVqbQaEEQkHHgBmI21HOZtItJ4WcylwEpjTDKwGHjSPvYGIBWYAEwFHhSR3gDGmOnGmAnGmAlAJvAP/1SpY8g8UkB4mDA5KUj9B1n/C1Xn4JqfBef8SqlOx5MrhCnAYWPMUWNMDfA60LiHcgzwsf063W37GGC9MabOGFMO7ARmuR9oB4hrgS51hZB51Oo/6Nndo2Wr/au8ADL/1+pIHpgS+PMrpTolTwLCYOC423uHneZuB3CL/fpmoJeIxNnps0QkWkTigWuAIY2O/QrwkTGmxNvCd1QVNXXsOF4cvPUPNv4easpghl4dKKU856+frw8Cz4vIPcB6IA9wGmPWichkYCNwFqtpyNno2NuAPzeXsYgsABYAJCQkkJGR4VMBy8rKfD7WW7vz66hzGWLKHGRknArIOetFVhcxddMfOJtwNfv3noK9pwJa944olOsfynWH0K6/T3U3xrT4AC4D1rq9XwQsamH/noCjmW2vAXPc3scDBUBUa+UwxpCWlmZ8lZ6e7vOx3vrV+/vMJYv+acqqagN2zgZrfmrM432NyT/ckBTIundEoVz/UK67MaFdf/e6A1uMB9+xnjQZbQZGiMhwEYkEbgVWu+8gIvEiUp/XImC5nR5uNx0hIslAMrDO7dCvAe8ZY6q8imIdXOaRAlKG9CEm0P0H5xywZTlMvAPiLgnsuZVSnV6rAcEYUwc8AKwF9gFvGmP2iMhiEZlr7zYDOCAiB4EEYImdHgFsEJG9wDLgTju/ercCf/VLTTqIsuo6duWdC878Reuftp6v+mngz62U6vQ8+glrjFkDrGmU9qjb61XAqiaOq8IaadRcvjM8LWhnsTm7EKfLBP6GtMKj8NlfYNI3oU/jfnullGqd3qnsZ1lHCogIF9KG9Q3siTOegrAImP7jwJ5XKdVlaEDws6yjBUwc0pcekeGBO+mZ/bDzDZjyLeg1IHDnVUp1KRoQ/KikqpZdeecCv1xmxpMQGQNX/Ciw51VKdSkaEPxo87FCXIbAzl90cifsfRumfQ9igrsQj1Kqc9OA4EdZRwuI7BZG6tAA9h+k/xKiYuGy+wN3TqVUl6QBwY8yjxYwcUgfoiIC1H/g2AIH34fLfwA9+gTmnEqpLksDgp+cq6hlz4mSwM5f9PEvIDoOpn4ncOdUSnVZQZiKs2uoqXOx/1QJOxzn2Hm8mG25RRhD4G5Iy/4PHE2HLy2B7j0Dc06lVJemAcEDTpfh8JkydjiK2ekoZqfjHPtPllLjdAHQLyaS5MRYbklNZFIg1j8wBj5eAj0HwORvtv/5lFIhQQNCM/598CzrD55lp6OY3XklVNZak7T26t6NcYNjuffKJFIS+5CcGMvgPj0QkcAV7sjHkLsR5iyFiB6BO69SqkvTgNCE8uo67n3pUyLCwxg7qDfzJw8hZUgsyYl9GB4XQ1hYAL/8GzPG6juIHQqpdwevHEqpLkcDQhMcRZW4DCydl8KXUwYFuzjnO/A+nNgGc5+Hbt2DXRqlVBeio4yakFdcAcDgvh2sOcYY676DfhdDym3BLo1SqovRgNAER1ElAIkdLSAU58DpXTDl2xCuF3dKKf/SgNCEvKJKIruFER/TwZpkcrOs56QrglsOpVSXpAGhCY7iSgb36RHczuOm5GyE7rFwUbNLTCillM80IDTBUVTZ8ZqLAHIzYehUCAvg1NpKqZDhUUAQkVkickBEDovIwia2DxORj0Rkp4hkiEii27anRGS3/Zjvli4iskREDorIPhH5gX+q1HZ5RdYVQodSng/5B2HoZcEuiVKqi2q1Z1JEwoEXgJmAA9gsIquNMXvddlsKrDTGrBCRa4EngbtE5AYgFZgAdAcyROR9Y0wJcA8wBBhtjHGJyEX+rJivqmqd5JdVd7yAkJtpPQ+7PLjlUEp1WZ5cIUwBDhtjjhpjaoDXgZsa7TMG+Nh+ne62fQyw3hhTZ4wpB3YCs+xt3wUWG2NcAMaYM75Xw3/yiu0RRv06WEDIyYTw7jBoYrBLopTqojwJCIOB427vHXaaux3ALfbrm4FeIhJnp88SkWgRiQeuwboqALgEmC8iW0TkfREZ4Wsl/CnPHnI6uE90kEvSSO5GGJymN6MppdqNvwazPwg8LyL3AOuBPMBpjFknIpOBjcBZIBNw2sd0B6qMMZNE5BZgOTC9ccYisgBYAJCQkEBGRoZPBSwrK/Po2IzjtQAc37+dipyO0eceXlfJlSd2kDv0Fo75UH9P695VhXL9Q7nuENr196nuxpgWH8BlwFq394uARS3s3xNwNLPtNWCO/Xo/MNx+LcC51sqSlpZmfJWenu7Rfr/+1z5zyaJ/mto6p8/n8rvDHxvzWG9jDn7g0+Ge1r2rCuX6h3LdjQnt+rvXHdhiWvl+NcZ41GS0GRghIsNFJBK4FVjtvoOIxItIfV6LsH7tIyLhdtMRIpIMJAPr7P3exmpCArgaOOhxFGtHeUWVDIiNolu4l1cHxkDBkfYpVG4mSBgMmdI++SulFB70IRhj6oAHgLXAPuBNY8weEVksInPt3WYAB0TkIJAALLHTI4ANIrIXWAbcaecH8CvgqyKyC2tU0n1+qlObOHwdcrrnH/BcGpza7f9C5WyEhHEQ1dv/eSullM2jPgRjzBpgTaO0R91erwJWNXFcFdZIo6byLAZu8KawgZBXXMnll8R7f+DRfwMG9r8HA8b5r0B1NdbayWnf8F+eSinVhI7Ra9pB1NS5OF1S5dssp/XzDB1437+FOrkD6ir1hjSlVLvTgODm1LkqXMaHWU4rCiH/APRMgJPboeSE/wqVu9F61oCglGpnGhDcOOx1EBK97UM4vsl6vvph6/ngv/xXqJxMa/2DXgn+y1MppZqgAcFNw01p3l4h5GZCWARMuB36Jvmv2cjlguNZMFSnq1BKtT8NCG4cRZWIwMBYbwPCJmtKiYgeMGqO1cFcU972AuUfgMoiGKbNRUqp9qcBwU1ecSUJvaKI7ObFn6W2ylrjeOg06/3IWeCshiPpbS9QjvYfKKUCRwOCm7yiSu+bi058Bs6azwPCsMutRWz80WyUm2l1VPe7uO15KaVUKzQguHEUV3g/wui4Pdx0yFTrOTwCRnzR6lh2OZs/zhM5mdbVgXSwlduUUl2SBgSb02U4WVzl/V3KuVkQPxJi3G5mGzUHKvIhb6vvBSrOhRKHrn+glAoYDQi20yVV1LmMd01GLpcVEOqvDupdeh2EdYMDa5o+zhM59oI42n+glAoQDQi2hoVx+nqxDkL+AagqvvBLu0dfK+1AG+5HyM2E7r0hYazveSillBc0INg+XxjHiyuE+ukq6juU3Y2aA2f3QeEx3wqUm2nNbhoW7tvxSinlJQ0INkeRdZey1wEhpn/To4BG2SuF+nLXckUhnN2vzUVKqYDSgGDLK64kvmckPSK9+EWem2ldHTQ1CqjfxdB/tG/9CLl2/4F2KCulAkgDgs3rdRBKTkJxTsu/4kfNtm4uqyz2rjA5GyE8EgalenecUkq1gQYEm9c3pTXcf9BE/0G9kbPBVQeHP/SuMLmZMDgNIqK8O04ppdpAAwLWutJ5xZXejTDKzYJuPWBgcvP7JE6C6Hjv7lquKbfWQND+A6VUgHkUEERklogcEJHDIrKwie3DROQjEdkpIhkikui27SkR2W0/5rulvywix0Rku/2Y4J8qeS+/rIbqOpf3HcqJk6w7k5sTFm7NbXT4A3DWepavY4t1VaH9B0qpAGs1IIhIOPACMBtrOczbRKTxsphLgZXGmGRgMdYayYjIDUAqMAGYCjwoIu4LAz9kjJkV3DFlAAAZfklEQVRgP7a3uTY+qh9h5PG0FdWlcGpn08NNGxs1C6rOfd5R3JrcTECsIadKKRVAnlwhTAEOG2OOGmNqgNeBmxrtMwb42H6d7rZ9DLDeGFNnjCkHdgKz2l5s/6q/Kc3jPgTHFjAuzwLCxddAeHfPm41yNkLCOIiK9Wx/pZTyE08CwmDguNt7h53mbgdwi/36ZqCXiMTZ6bNEJFpE4oFrgCFuxy2xm5l+KyLdfaqBH3h9U1puFkgYJHrwK757Txh+lRUQjGl5X2ctODbr+gdKqaDo5qd8HgSeF5F7gPVAHuA0xqwTkcnARuAskAnUTwG6CDgFRALLgIexmpvOIyILgAUACQkJZGRk+FTAsrKyZo/dtLeamAjYmvWJR3kl73yfyOhhbMna5tH+g+QSRhZ9wKdrXqEiZmiz+/UqOUhabQV7ymI562M9m9JS3UNBKNc/lOsOoV1/n+pujGnxAVwGrHV7vwhY1ML+PQFHM9teA+Y0kT4DeK+1sqSlpRlfpaenN7vt3pc+NbN/t96zjOpqjfnFQGPe+4nnJy92GPNYb2M2PNPyfp88a+1XctLzvD3QUt1DQSjXP5Trbkxo19+97sAW08r3qzHGoyajzcAIERkuIpHArcBq9x1EJF5E6vNaBCy308PtpiNEJBlIBtbZ7wfazwJ8BdjtXSjzH0dRhef9B6d3QW25Z/0H9WIHw8CU1vsRcjKh73DoNcDzvJVSyk9aDQjGmDrgAWAtsA940xizR0QWi8hce7cZwAEROQgkAEvs9Ahgg4jsxWoWutPOD+BVEdkF7ALigV/4qU5eMcaQV1Tp+Qij3E3WszcBAazJ7o5/CmVnm97uclkjjHS4qVIqSDzqQzDGrAHWNEp71O31KmBVE8dVYY00airPa70qaTs5V1lLeY3Tiw7lTIgdArGJre/rbuQsyHgSDq2DiXdcuL3gEFQW6g1pSqmgCfk7lR1F9esgeBAQjLFGGHl7dQBWk1GvQc1Pdpez0XrWKwSlVJBoQCjyYmGc4hwoO+VbQBCxJrs7kg61VRduz81sfiptpZQKgJAPCA03pXnSZJTrwYR2LRk12+qQzt5w4bacTKu5qKmptJVSKgBCPiA4iiqIjgynT3QLcxLVy82E7rFw0Rd8O1nSdIiIubDZ6JwDzuVqc5FSKqhCPiDUjzAST36Z52a1bVnLiCi49FprrWX3u5Zz7HmOtENZKRVEGhCKPVwYp2FZy6ltO+HI2VB6wpriul7uRojsBQPGty1vpZRqg5APCA5PF8Y5/qn13NZf8SOvB+T8tZbbeuWhlFJ+ENIBoay6jnOVtZ6NMMrNhLCIti9rGRNvffnX9yNUFMKZvTqhnVIq6EI6IHg1y+nxTda9BJFerKrWnFGzrSajc3lWvgBDtUNZKRVcIR0QPF4Yp7YK8rb6dv9BU0bNsZ4P/su6IS0sAga38cpDKaXayF/TX3dKHi+Mc3I7OGv8NwoofqQ1id2B96Gq2AoGEV4s36mUUu0gxK8QKonsFkZ8TCtr8zTckNbGEUb1RKyrhGPr4cR2HW6qlOoQQjog5BVVktinB2FhrdyDkJsFcZdCz/7+O/moWeCsBlet3pCmlOoQQjogOIo9GHLqcsFxHye0a8nQy+x1k8V/Vx5KKdUGIR0Q8ooqWh9hVHAIKot8n7+oOeERMO5rMOwK6NHHv3krpZQPQrZTuarWSX5ZTesjjHLbcVqJG37j/zyVUspHIRsQPB5hlJsF0fEQd4n/C6EzmyqlOhCPmoxEZJaIHBCRwyKysIntw0TkIxHZKSIZIpLotu0pEdltP+Y3ceyzIlLWtmp4z9FwU1orN5rlZlr9B/rlrZTq4loNCCISDrwAzMZaDvM2EWm8LOZSYKUxJhlYDDxpH3sDkApMAKYCD4pIb7e8JwF9/VAPr+V5slJa6SkoyvZ/h7JSSnVAnlwhTAEOG2OOGmNqgNeBmxrtMwb42H6d7rZ9DLDeGFNnjCkHdgKzoCHQPA38tG1V8E1ecQXdwoSE3lHN71R//4HeJ6CUCgGeBITBwHG39w47zd0O4Bb79c1ALxGJs9NniUi0iMQD1wBD7P0eAFYbY076Wvi2cBRVMiA2ivCW7kHIzYJuUTAgOXAFU0qpIPFXp/KDwPMicg+wHsgDnMaYdSIyGdgInAUyAaeIDALmATNay1hEFgALABISEsjIyPCpgGVlZecduze7kp5htJhf6t4PcMVcyvb/bPTpnB1F47qHmlCufyjXHUK7/j7V3RjT4gO4DFjr9n4RsKiF/XsCjma2vQbMAW4ATgHZ9sOF1SzVYlnS0tKMr9LT0897P+2XH5ofv7G9+QOqSo15vK8xHy72+ZwdReO6h5pQrn8o192Y0K6/e92BLaaV71djjEdXCJuBESIyHOuX/63A7e472M1BhcYYlx0wltvp4UAfY0yBiCQDycA6Y0wdMMDt+DJjzKXehTLf1dS5OFVS1fKQ07wtYJzaoayUChmtBgRjTJ2IPACsBcKB5caYPSKyGCvqrMZq+nlSRAxWk9H99uERwAZ7veIS4E47GATVqXNVGNPKCKPcTYBA4uSAlUsppYLJoz4EY8waYE2jtEfdXq8CVjVxXBXWSKPW8u/pSTn8xVFsr4PQ0rQVuZmQMFanlVBKhYyQvFPZ0XAPQqOb0kpOQs4nkP0fa+GaiXcGoXRKKRUcIRkQ8ooqEYEBUgA734PsDZD9CRQesXbo3hsuvhom3xfcgiqlVACFVkAozoXsT7h8z2rmdd9K5LOnrfSoWGtN40n3QtKV1n0HYeHBLatSSgVYaASEjxYzdfMrkHEGgLHSk73dx5M440eQdAUkjNMAoJQKeaEREJw1lPW8hB4zfgJJVzJnxSkmDotjymUTg10ypZTqMEIjIHzpF+yJzGDGtBk4XYYT53K5sbWFcZRSKsSE3Ippp0uqqHOZC0cYKaVUiAu5gODxwjhKKRViQqPJyI2jyLoprdW1lJXqompra3E4HFRVVQW7KO0uNjaWffv2BbsYARMVFUViYiIRERE+HR9yAcGjhXGU6sIcDge9evUiKSkJ6eIrAZaWltKrV69gFyMgjDEUFBTgcDgYPny4T3mEZJNRfM9IoiJ0mKkKTVVVVcTFxXX5YBBqRIS4uLg2XfmFXEBwFFVqc5EKeRoMuqa2fq4hFxDyiip1hJFSXcCJEyf42te+FuxidCkhFRCMMeQVV+oII6W6gEGDBrFq1QWTLDerri54M+8H89zeCKmAcLasmuo6lzYZKRVEmzdvJjk5maqqKsrLyxk7diy7d++mrKyM6667jtTUVMaPH88777wDwMKFC3nhhRcajn/88cdZunQp2dnZjBs3DgCn08lDDz3E5MmTSU5O5k9/+hMAGzZsYPr06cydO5cxYy6cif+73/0ukyZNYuzYsTz22GPnlfHyyy8nJSWFKVOmUFpaitPp5MEHH2TcuHEkJyfz3HPPAZCUlER+fj4AW7ZsYcaMGQ3lvOuuu7jiiiu46667yM7OZvr06aSmppKamsrGjZ8vzfvUU08xfvx4UlJSWLhwIUeOHCE1NbVh+6FDh857315CapSRjjBS6nw/f3cPe0+U+DXPMYN689iXxza7ffLkycydO5dHHnmEyspK7rzzTsaNG0ddXR1vvfUWvXv3Jj8/n2nTpjF37lzmz5/Pj370I+6/31p3680332Tt2rU4nc6GPF988UViY2PZvHkz1dXVXHHFFXzpS18CYNu2bezevbvJkTdLliyhX79+OJ1OrrvuOnbu3Mno0aOZP38+b7zxBpMnT6akpIQePXqwbNkysrOz2b59O926daOwsLDVv8XevXv5z3/+Q48ePaioqOCDDz4gKiqKQ4cOcdttt7Flyxbef/993nnnHTZt2kR0dDSFhYX069eP2NhYtm/fzoQJE3jppZe49957vf0ovBZSAaF+HQRtMlIquB599FEmT55MVFQUzz77LGA16f7sZz9j/fr1hIWFkZeXx+nTp5k4cSJnzpzhxIkTnD17lr59+zJkyBCys7Mb8lu3bh07d+5saEI6d+4chw4dAmDKlCnNDsN88803WbZsGXV1dZw8eZK9e/ciIgwcOJDJk63VEnv37g3Ahx9+yHe+8x26dbO+Nvv169dqPefOnUuPHtb3TW1tLQ888ADbt28nPDycgwcPNuR77733Eh0dfV6+9913Hy+99BLPPPMMb7zxBp9++qnnf2AfhVRAaLhLWZuMlAJo8Zd8eyooKKCsrIza2lqqqqqIiYnh1Vdf5ezZs2zdupWIiAiSkpIahlDOmzePVatWcerUKebPn39BfsYYnnvuOa6//vrz0tesWUNMTEyTZTh27BhLly5l8+bN9O3bl3vuucenIZvdunXD5XIBXHC8+7l/+9vfkpCQwI4dO3C5XERFRbWY71e/+lV+/vOfc+2115KWlkZcXJzXZfOWR30IIjJLRA6IyGERWdjE9mEi8pGI7BSRDBFJdNv2lIjsth/z3dJfFJEd9jGrRKTdl9HMK6oktkcEvaJ8u4tPKeUf3/72t3niiSe44447ePjhhwHrV/1FF11EREQE6enp5OTkNOw/f/58Xn/9dVatWsW8efMuyO/666/nD3/4A7W1tQAcPHiQ8vLyFstQUlJCTEwMsbGxnD59mvfffx+AUaNGcfLkSTZv3gxYN7fV1dUxc+ZM/vSnPzV0ENc3GSUlJbF161YA/v73vzd7vnPnzjFw4EDCwsJ45ZVXGpq8Zs6cyUsvvURFRcV5+UZFRXH99dfz3e9+NyDNReBBQBCRcOAFYDbW+si3iUjj3pmlwEpjTDKwGHjSPvYGIBWYAEwFHhSR3vYx/2WMSbGPyQUe8EN9WuQoqtCrA6WCbOXKlURERHD77bezcOFCNm/ezMcff8wdd9zBli1bGD9+PCtXrmT06NENx4wdO5bS0lIGDx7MwIEDL8jzvvvuY8yYMaSmpjJu3Di+/e1vtzqyJyUlhYkTJzJ69Ghuv/12rrjiCgAiIyN54403+P73v09KSgozZ86kqqqK++67j6FDh5KcnExKSgqvvfYaAI899hg//OEPmTRpEuHhzd/w+r3vfY8VK1aQkpLC/v37G64eZs2axdy5c5k0aRITJkxg6dKlDcfccccdhIWFNfSHtDtjTIsP4DJgrdv7RcCiRvvsAYbYrwUosV8/BPyP234vAl9vdKwAfwAebq0saWlpxlfp6elm5jMZ5lsrNvucR2eVnp4e7CIEVSjXv6m67927N/AFCZKSkpJgF6FNnn76afPII494dUz95+v+2QNbTCvfr8YYj/oQBgPH3d47sH7tu9sB3AL8HrgZ6CUicXb6YyLyGyAauAbYW3+QiLwEzLHTftLUyUVkAbAAICEhgYyMDA+KfKHS0jJy84VhUVU+59FZlZWVhVyd3YVy/Zuqe2xsLKWlpcEpUIA5nc5OW9fbb7+dY8eO8d5773lVh6oq6zvOl3/3/upUfhB4XkTuAdYDeYDTGLNORCYDG4GzQCbQMFbMGHOv3ST1HDAfeKlxxsaYZcAygEmTJpn6Mb7eem9dOlXOCqaOG8GM6Rf7lEdnlZGRga9/t64glOvfVN337dsXMhO+debJ7d59912fjouKimLixIk+/bv3pFM5Dxji9j7RTmtgjDlhjLnFGDMR+G87rdh+XmKMmWCMmYnVPHSw0bFO4HXgq16V3Ev5ldYoAJ22QimlmuZJQNgMjBCR4SISCdwKrHbfQUTiRaQ+r0XAcjs93G46QkSSgWRgnVgutdMFmAvs90eFmlNQZQC9KU0ppZrTapORMaZORB4A1gLhwHJjzB4RWYzVUbEamAE8KSIGq8nofvvwCGCDPQNfCXCnnV8YsMIecSRYfQ3f9W/VzpdfaQUEHWWklFJN86gPwRizBljTKO1Rt9ergAtmmTLGVGENVW2c7gKu8LawbZFf6SImMpw+0XoPglJKNSVkJrcrqDQM7ttD54FXqoOpn6yuJWfPnmXq1KlMnDiRDRs2eH2Ol19+mQcesG51evvtt9m7d28rR4SmkAkI+ZVGm4uU6qQ++ugjxo8fz2effcb06dPblFdHCAjGmIbpLjqSkAkIBVUuHWGkVAexZMkSRo4cyZVXXsmBAwca0o8cOcKsWbNIS0tj+vTp7N+/n+3bt/PTn/6Ud955hwkTJlBZWdnstNWNp6KeM2fOeefduHEjq1ev5qGHHmLChAkcOXLkvO3vvvtuw5XIF7/4RU6fPg1Y93Pce++9jB8/nuTk5IYpKv71r3+RmppKSkoK1113HXDhFc+4cePIzs4mOzubUaNGcffddzNu3DiOHz/u1fTbV111Fdu3b2/Y58orr2THjh1t+hwaC4nJ7Uqraimv1VlOlbrA+wvh1C7/5jlgPMz+VbObt27dyuuvv8727dupq6sjNTWVtLQ0ABYsWMAf//hHRowYwaZNm/je977Hxx9/zOLFi9myZQvPP/880PS01cnJya0W7fLLL2fu3LnceOONTa62duWVV5KVlYWI8Oc//5lf//rX/OY3v+GJJ54gNjaWXbusv1VRURFnz57lW9/6FuvXr2f48OEeTYd96NAhVqxYwbRp05qtR3PTb3/zm9/k5Zdf5ne/+x0HDx6kqqqKlJSUVs/pjZAICDrLqVIdx4YNG7j55psbpnueO3cuYP0K37hx43mT11VXVzeZR1PTVnsSEFrjcDiYP38+J0+epKampmHa7A8//JDXX3+9Yb++ffvy7rvvctVVVzXs48l02MOGDWsIBs3Vo7npt+fNm8cTTzzB008/zfLly7nnnnvaXN/GQiMg6MI4SjWthV/ygeZyuejTp895zSJNaWna6pamovbE97//fX784x8zd+5cMjIyePzxx73Ow70MjcvhPh22t9NvR0dHM3PmTN555x3efPPNhhlW/Skk+hB0YRylOo6rrrqKt99+m8rKSkpLSxumaOjduzfDhw/nb3/7G2B1vDbVRt7ctNXg2VTUvXr1anZuoHPnzjF48GAAVqxY0ZA+c+bM85bxLCoqYtq0aaxfv55jx44B50+HvW3bNsBara1+u6f1aG76bbBmdf3BD37A5MmT6du3b5P5tkVIBIS84koiwqB/z+7BLopSIS81NZX58+eTkpLC7NmzG5pGAF599VVefPFFUlJSGDt2bMO6yu6am7YaPJuK+tZbb+Xpp59m4sSJF3QqP/7448ybN4+0tDTi4+Mb0h955BGKiooYN24cKSkppKen079/f5YtW8Ytt9xCSkpKw8I9X/3qVyksLGTs2LE8//zzjBw5sslyeDv9NkBaWhq9e/duv/URPJkStaM8fJ3++nt/2Wqm/vyfPh3bFYTy9M/GhHb9dfrrzj39dWN5eXlmxIgRxul0NrtPW6a/DokrhDGDepOaEBLdJUqpLmrlypVMnTqVJUuWEBbWPl/dIfEtef81l5IhjmAXQymlfHb33Xdz9913t+s5QuIKQSmlVOs0ICgVgqxmZdXVtPVz1YCgVIiJioqioKBAg0IXY4yhoKCAqKgon/MIiT4EpdTnEhMTcTgcnD17NthFaXdVVVVt+oLsbKKiokhMTPT5eA0ISoWYiIiIhukWurqMjAwmTpwY7GJ0GtpkpJRSCtCAoJRSyqYBQSmlFADSmUYaiMhZIMfHw+OBfD8WpzMJ5bpDaNc/lOsOoV1/97oPM8b0b+2AThUQ2kJEthhjJgW7HMEQynWH0K5/KNcdQrv+vtRdm4yUUkoBGhCUUkrZQikgLAt2AYIolOsOoV3/UK47hHb9va57yPQhKKWUalkoXSEopZRqQUgEBBGZJSIHROSwiCwMdnkCSUSyRWSXiGwXkS3BLk97E5HlInJGRHa7pfUTkQ9E5JD97P/FaDuAZur+uIjk2Z//dhGZE8wythcRGSIi6SKyV0T2iMgP7fQu/9m3UHevP/su32QkIuHAQWAm4AA2A7cZY/YGtWABIiLZwCRjTEiMxRaRq4AyYKUxZpyd9mug0BjzK/sHQV9jzMPBLGd7aKbujwNlxpilwSxbexORgcBAY8w2EekFbAW+AtxDF//sW6j71/Hysw+FK4QpwGFjzFFjTA3wOnBTkMuk2okxZj1Q2Cj5JmCF/XoF1n+WLqeZuocEY8xJY8w2+3UpsA8YTAh89i3U3WuhEBAGA8fd3jvw8Y/VSRlgnYhsFZEFwS5MkCQYY07ar08BCcEsTBA8ICI77SalLtdk0piIJAETgU2E2GffqO7g5WcfCgEh1F1pjEkFZgP3280KIctYbaRdu530fH8ALgEmACeB3wS3OO1LRHoCfwd+ZIwpcd/W1T/7Juru9WcfCgEhDxji9j7RTgsJxpg8+/kM8BZWE1qoOW23s9a3t54JcnkCxhhz2hjjNMa4gP+jC3/+IhKB9YX4qjHmH3ZySHz2TdXdl88+FALCZmCEiAwXkUjgVmB1kMsUECISY3cyISIxwJeA3S0f1SWtBr5hv/4G8E4QyxJQ9V+Gtpvpop+/iAjwIrDPGPOM26Yu/9k3V3dfPvsuP8oIwB5u9TsgHFhujFkS5CIFhIhcjHVVANbqeK919bqLyF+BGVgzPZ4GHgPeBt4EhmLNlvt1Y0yX63xtpu4zsJoMDJANfNutTb3LEJErgQ3ALsBlJ/8Mqy29S3/2LdT9Nrz87EMiICillGpdKDQZKaWU8oAGBKWUUoAGBKWUUjYNCEoppQANCEoppWwaEJRSSgEaEJRSStk0ICillALg/wOQ/7qVwiWAMgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f65e05cdc18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xavier_log = []\n",
    "default_log = []\n",
    "for epoch in range(25):\n",
    "\n",
    "    for x_batch,y_batch in iterate_minibatches(X_train,y_train,batchsize=32,shuffle=True):\n",
    "        train(xavier_network,x_batch,y_batch)\n",
    "        train(default_network,x_batch,y_batch)\n",
    "    \n",
    "    xavier_log.append(np.mean(predict(xavier_network,X_train)==y_train))\n",
    "    default_log.append(np.mean(predict(default_network,X_train)==y_train))\n",
    "    \n",
    "    clear_output()\n",
    "    print(\"Epoch\",epoch)\n",
    "    print(\"xavier accuracy:\",xavier_log[-1])\n",
    "    print(\"default accuracy:\",default_log[-1])\n",
    "    plt.plot(xavier_log,label='xavier accuracy')\n",
    "    plt.plot(default_log,label='default accuracy')\n",
    "    plt.legend(loc='best')\n",
    "    plt.grid()\n",
    "    plt.show()"
   ]
  }
 ],
 "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.5.2"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "264px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}