diff --git "a/\352\261\264\353\247\220\354\262\234\352\260\204_Q1_FullyConnectedNets.ipynb" "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q1_FullyConnectedNets.ipynb"
new file mode 100644
index 0000000..67ec8f5
--- /dev/null
+++ "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q1_FullyConnectedNets.ipynb"
@@ -0,0 +1,1719 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GEzcoD2JRCEa",
+        "outputId": "27d3cb11-adfe-4fd5-95ca-0f7383cf88e8"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5tqKVNICRCsX",
+        "outputId": "30063944-8df3-4d53-dec0-6deabf735dc9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "/content/drive/MyDrive/Colab Notebooks/EURON/cs231n-master/assignment2\n"
+          ]
+        }
+      ],
+      "source": [
+        "%cd \"/content/drive/MyDrive/Colab Notebooks/EURON/cs231n-master/assignment2\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XF3UPQxRLo5W"
+      },
+      "source": [
+        "# Fully-Connected Neural Nets\n",
+        "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Oanh_J5eLo5b"
+      },
+      "source": [
+        "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
+        "\n",
+        "```python\n",
+        "def layer_forward(x, w):\n",
+        "  \"\"\" Receive inputs x and weights w \"\"\"\n",
+        "  # Do some computations ...\n",
+        "  z = # ... some intermediate value\n",
+        "  # Do some more computations ...\n",
+        "  out = # the output\n",
+        "   \n",
+        "  cache = (x, w, z, out) # Values we need to compute gradients\n",
+        "   \n",
+        "  return out, cache\n",
+        "```\n",
+        "\n",
+        "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
+        "\n",
+        "```python\n",
+        "def layer_backward(dout, cache):\n",
+        "  \"\"\"\n",
+        "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
+        "  and compute derivative with respect to inputs.\n",
+        "  \"\"\"\n",
+        "  # Unpack cache values\n",
+        "  x, w, z, out = cache\n",
+        "  \n",
+        "  # Use values in cache to compute derivatives\n",
+        "  dx = # Derivative of loss with respect to x\n",
+        "  dw = # Derivative of loss with respect to w\n",
+        "  \n",
+        "  return dx, dw\n",
+        "```\n",
+        "\n",
+        "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
+        "\n",
+        "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
+        "  "
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ysnIIM7xQzMA",
+        "outputId": "73e483ac-a52c-4279-f75c-c1908c1d68ef"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "240119_BatchNormalization.ipynb  collectSubmission.sh\t      frameworkpython  requirements.txt\n",
+            "240119_Dropout.ipynb\t\t ConvolutionalNetworks.ipynb  notebook_images  start_ipython_osx.sh\n",
+            "240119_FullyConnectedNets.ipynb  cs231n\t\t\t      PyTorch.ipynb    TensorFlow.ipynb\n"
+          ]
+        }
+      ],
+      "source": [
+        "!ls"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lrejozozQ0kc",
+        "outputId": "d056a337-721c-4c4b-b8d0-41cc808fe1e6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "/content/drive/MyDrive/Colab Notebooks/EURON/cs231n-master/assignment2\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pwd"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "V6Mb0HmQLo5d",
+        "outputId": "170499f9-7082-4f81-da9f-afa3f390ad89"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "The autoreload extension is already loaded. To reload it, use:\n",
+            "  %reload_ext autoreload\n"
+          ]
+        }
+      ],
+      "source": [
+        "# As usual, a bit of setup\n",
+        "from __future__ import print_function\n",
+        "import time\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from cs231n.classifiers.fc_net import *\n",
+        "from cs231n.data_utils import get_CIFAR10_data\n",
+        "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
+        "from cs231n.solver import Solver\n",
+        "\n",
+        "%matplotlib inline\n",
+        "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
+        "plt.rcParams['image.interpolation'] = 'nearest'\n",
+        "plt.rcParams['image.cmap'] = 'gray'\n",
+        "\n",
+        "# for auto-reloading external modules\n",
+        "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
+        "%load_ext autoreload\n",
+        "%autoreload 2\n",
+        "\n",
+        "def rel_error(x, y):\n",
+        "  \"\"\" returns relative error \"\"\"\n",
+        "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y)))) # 1e-8: threshold"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Rv2QKhUzLo5e",
+        "outputId": "0b2e9e0f-aec0-43b4-85a4-caca73fff900",
+        "scrolled": true
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "('X_train: ', (49000, 3, 32, 32))\n",
+            "('y_train: ', (49000,))\n",
+            "('X_val: ', (1000, 3, 32, 32))\n",
+            "('y_val: ', (1000,))\n",
+            "('X_test: ', (1000, 3, 32, 32))\n",
+            "('y_test: ', (1000,))\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Load the (preprocessed) CIFAR10 data.\n",
+        "\n",
+        "data = get_CIFAR10_data()\n",
+        "for k, v in list(data.items()):\n",
+        "  print(('%s: ' % k, v.shape))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jes-Mi2KLo5f"
+      },
+      "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": "markdown",
+      "metadata": {
+        "id": "aTiM6cC3M79i"
+      },
+      "source": [
+        "`affine layer` = `FC layer`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4t2yvr8TLo5f",
+        "outputId": "8e82a201-6dbd-47c7-fed0-abebbafcd63e",
+        "scrolled": false
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing affine_forward function:\n",
+            "difference:  9.769849468192957e-10\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Test the affine_forward function\n",
+        "\n",
+        "num_inputs = 2\n",
+        "input_shape = (4, 5, 6)\n",
+        "output_dim = 3\n",
+        "\n",
+        "input_size = num_inputs * np.prod(input_shape)\n",
+        "weight_size = output_dim * np.prod(input_shape)\n",
+        "\n",
+        "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
+        "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
+        "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
+        "\n",
+        "out, _ = affine_forward(x, w, b)\n",
+        "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
+        "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
+        "\n",
+        "# Compare your output with ours. The error should be around e-9 or less.\n",
+        "print('Testing affine_forward function:')\n",
+        "print('difference: ', rel_error(out, correct_out))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O5KlbbWfLo5g"
+      },
+      "source": [
+        "# Affine layer: backward\n",
+        "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2S0CuPbxLo5g",
+        "outputId": "3499a77d-ff26-4527-8aed-18497317b09f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing affine_backward function:\n",
+            "dx error:  5.399100368651805e-11\n",
+            "dw error:  9.904211865398145e-11\n",
+            "db error:  2.4122867568119087e-11\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Test the affine_backward function\n",
+        "np.random.seed(231)\n",
+        "x = np.random.randn(10, 2, 3)\n",
+        "w = np.random.randn(6, 5)\n",
+        "b = np.random.randn(5)\n",
+        "dout = np.random.randn(10, 5)\n",
+        "\n",
+        "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
+        "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
+        "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
+        "\n",
+        "_, cache = affine_forward(x, w, b)\n",
+        "dx, dw, db = affine_backward(dout, cache)\n",
+        "\n",
+        "# The error should be around e-10 or less\n",
+        "print('Testing affine_backward function:')\n",
+        "print('dx error: ', rel_error(dx_num, dx))\n",
+        "print('dw error: ', rel_error(dw_num, dw))\n",
+        "print('db error: ', rel_error(db_num, db))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tv98LyZeLo5h"
+      },
+      "source": [
+        "# ReLU activation: forward\n",
+        "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mepcb3U_Lo5i",
+        "outputId": "7a4980e6-f5dc-489f-bf86-54d49f3d5d19"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing relu_forward function:\n",
+            "difference:  4.999999798022158e-08\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Test the relu_forward function\n",
+        "\n",
+        "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
+        "\n",
+        "out, _ = relu_forward(x)\n",
+        "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
+        "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
+        "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
+        "\n",
+        "# Compare your output with ours. The error should be on the order of e-8\n",
+        "print('Testing relu_forward function:')\n",
+        "print('difference: ', rel_error(out, correct_out))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1k7iVaCiLo5i"
+      },
+      "source": [
+        "# ReLU activation: backward\n",
+        "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KPH900P9Lo5i",
+        "outputId": "b9ef54ab-d0f5-4a49-a700-4fef25655ad6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing relu_backward function:\n",
+            "dx error:  3.2756349136310288e-12\n"
+          ]
+        }
+      ],
+      "source": [
+        "np.random.seed(231)\n",
+        "x = np.random.randn(10, 10)\n",
+        "dout = np.random.randn(*x.shape)\n",
+        "\n",
+        "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
+        "\n",
+        "_, cache = relu_forward(x)\n",
+        "dx = relu_backward(dout, cache)\n",
+        "\n",
+        "# The error should be on the order of e-12\n",
+        "print('Testing relu_backward function:')\n",
+        "print('dx error: ', rel_error(dx_num, dx))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YhF3P5JdLo5j"
+      },
+      "source": [
+        "## Inline Question 1:\n",
+        "\n",
+        "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
+        "1. Sigmoid\n",
+        "2. ReLU\n",
+        "3. Leaky ReLU\n",
+        "\n",
+        "## Answer:\n",
+        "1,2.\n",
+        "\n",
+        "1은 input 값이 절댓값이 큰 양수와 음수에서 기울기가 거의 0이 된다.\n",
+        "\n",
+        "2는 input 값이 음수이면 기울기가 0이 된다. 양수일 때는 1이 된다."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yxULPpXLLo5j"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YFTUoGN1Lo5j",
+        "outputId": "5fdc7b23-9c29-484c-e41a-cb8e6af08b4b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing affine_relu_forward and affine_relu_backward:\n",
+            "dx error:  2.299579177309368e-11\n",
+            "dw error:  8.162011105764925e-11\n",
+            "db error:  7.826724021458994e-12\n"
+          ]
+        }
+      ],
+      "source": [
+        "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
+        "np.random.seed(231)\n",
+        "x = np.random.randn(2, 3, 4)\n",
+        "w = np.random.randn(12, 10)\n",
+        "b = np.random.randn(10)\n",
+        "dout = np.random.randn(2, 10)\n",
+        "\n",
+        "out, cache = affine_relu_forward(x, w, b)\n",
+        "dx, dw, db = affine_relu_backward(dout, cache)\n",
+        "\n",
+        "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
+        "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
+        "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
+        "\n",
+        "# Relative error should be around e-10 or less\n",
+        "print('Testing affine_relu_forward and affine_relu_backward:')\n",
+        "print('dx error: ', rel_error(dx_num, dx))\n",
+        "print('dw error: ', rel_error(dw_num, dw))\n",
+        "print('db error: ', rel_error(db_num, db))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_0TdGRSVLo5j"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cd3-FkDNLo5j",
+        "outputId": "2dc4f482-bf8d-4d78-92af-86d838ba1872"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing svm_loss:\n",
+            "loss:  8.999602749096233\n",
+            "dx error:  1.4021566006651672e-09\n",
+            "\n",
+            "Testing softmax_loss:\n",
+            "loss:  2.3025458445007376\n",
+            "dx error:  8.234144091578429e-09\n"
+          ]
+        }
+      ],
+      "source": [
+        "np.random.seed(231)\n",
+        "num_classes, num_inputs = 10, 50\n",
+        "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
+        "y = np.random.randint(num_classes, size=num_inputs)\n",
+        "\n",
+        "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
+        "loss, dx = svm_loss(x, y)\n",
+        "\n",
+        "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
+        "print('Testing svm_loss:')\n",
+        "print('loss: ', loss)\n",
+        "print('dx error: ', rel_error(dx_num, dx))\n",
+        "\n",
+        "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
+        "loss, dx = softmax_loss(x, y)\n",
+        "\n",
+        "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
+        "print('\\nTesting softmax_loss:')\n",
+        "print('loss: ', loss)\n",
+        "print('dx error: ', rel_error(dx_num, dx))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rHrkbVnELo5k"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YLH8m6zKLo5k",
+        "outputId": "603f314b-52fc-4a91-9ee6-1cc1dec7cfd2"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Testing initialization ... \n",
+            "Testing test-time forward pass ... \n",
+            "Testing training loss (no regularization)\n",
+            "Running numeric gradient check with reg =  0.0\n",
+            "W1 relative error: 1.83e-08\n",
+            "W2 relative error: 3.20e-10\n",
+            "b1 relative error: 9.83e-09\n",
+            "b2 relative error: 4.33e-10\n",
+            "Running numeric gradient check with reg =  0.7\n",
+            "W1 relative error: 2.53e-07\n",
+            "W2 relative error: 2.85e-08\n",
+            "b1 relative error: 1.56e-08\n",
+            "b2 relative error: 9.09e-10\n"
+          ]
+        }
+      ],
+      "source": [
+        "np.random.seed(231)\n",
+        "N, D, H, C = 3, 5, 50, 7\n",
+        "X = np.random.randn(N, D)\n",
+        "y = np.random.randint(C, size=N)\n",
+        "\n",
+        "std = 1e-3\n",
+        "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
+        "\n",
+        "print('Testing initialization ... ')\n",
+        "W1_std = abs(model.params['W1'].std() - std)\n",
+        "b1 = model.params['b1']\n",
+        "W2_std = abs(model.params['W2'].std() - std)\n",
+        "b2 = model.params['b2']\n",
+        "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
+        "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
+        "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
+        "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
+        "\n",
+        "print('Testing test-time forward pass ... ')\n",
+        "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
+        "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
+        "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
+        "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
+        "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
+        "scores = model.loss(X)\n",
+        "correct_scores = np.asarray(\n",
+        "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
+        "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
+        "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
+        "scores_diff = np.abs(scores - correct_scores).sum()\n",
+        "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
+        "\n",
+        "print('Testing training loss (no regularization)')\n",
+        "y = np.asarray([0, 5, 1])\n",
+        "loss, grads = model.loss(X, y)\n",
+        "correct_loss = 3.4702243556\n",
+        "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
+        "\n",
+        "model.reg = 1.0\n",
+        "loss, grads = model.loss(X, y)\n",
+        "correct_loss = 26.5948426952\n",
+        "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
+        "\n",
+        "# Errors should be around e-7 or less\n",
+        "for reg in [0.0, 0.7]:\n",
+        "  print('Running numeric gradient check with reg = ', reg)\n",
+        "  model.reg = reg\n",
+        "  loss, grads = model.loss(X, y)\n",
+        "\n",
+        "  for name in sorted(grads):\n",
+        "    f = lambda _: model.loss(X, y)[0]\n",
+        "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
+        "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mAukdu9aLo5k"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "k2UbGVP6Lo5k",
+        "outputId": "e732a0b5-4e8f-49c1-a217-210e71aa7b18"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "(Iteration 1 / 4900) loss: 2.316765\n",
+            "(Epoch 0 / 10) train acc: 0.164000; val_acc: 0.134000\n",
+            "(Epoch 1 / 10) train acc: 0.441000; val_acc: 0.456000\n",
+            "(Epoch 2 / 10) train acc: 0.491000; val_acc: 0.474000\n",
+            "(Iteration 1001 / 4900) loss: 1.491941\n",
+            "(Epoch 3 / 10) train acc: 0.497000; val_acc: 0.478000\n",
+            "(Epoch 4 / 10) train acc: 0.493000; val_acc: 0.485000\n",
+            "(Iteration 2001 / 4900) loss: 1.478132\n",
+            "(Epoch 5 / 10) train acc: 0.531000; val_acc: 0.486000\n",
+            "(Epoch 6 / 10) train acc: 0.560000; val_acc: 0.515000\n",
+            "(Iteration 3001 / 4900) loss: 1.212179\n",
+            "(Epoch 7 / 10) train acc: 0.522000; val_acc: 0.492000\n",
+            "(Epoch 8 / 10) train acc: 0.540000; val_acc: 0.495000\n",
+            "(Iteration 4001 / 4900) loss: 1.226817\n",
+            "(Epoch 9 / 10) train acc: 0.584000; val_acc: 0.515000\n",
+            "(Epoch 10 / 10) train acc: 0.566000; val_acc: 0.478000\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",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "model = TwoLayerNet(hidden_dim=100, reg=0.1)\n",
+        "\n",
+        "solver = Solver(model, data, update_rule='sgd', optim_config={\n",
+        "                'learning_rate': 1e-3\n",
+        "                },\n",
+        "                lr_decay=0.97, num_epochs=10, batch_size=100,print_every=1000)\n",
+        "solver.train()\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "##############################################################################\n",
+        "#                             END OF YOUR CODE                               #\n",
+        "##############################################################################"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "1CTy9btVLo5l",
+        "outputId": "91305c7e-1fb9-41ea-aa46-e4a528ae6bbc"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1500x1200 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": {
+        "id": "xFk3Rf7gLo5l"
+      },
+      "source": [
+        "# Multilayer network\n",
+        "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
+        "\n",
+        "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
+        "\n",
+        "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aSc2UXc6Lo5l"
+      },
+      "source": [
+        "## Initial loss and gradient check\n",
+        "\n",
+        "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
+        "\n",
+        "For gradient checking, you should expect to see errors around 1e-7 or less."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "UWiUq-IxLo5l",
+        "outputId": "77fdae7a-d08c-4dcc-b860-803a4f66bd92"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Running check with reg =  0\n",
+            "Initial loss:  2.300479089768492\n",
+            "W1 relative error: 1.03e-07\n",
+            "W2 relative error: 2.21e-05\n",
+            "W3 relative error: 4.56e-07\n",
+            "b1 relative error: 4.66e-09\n",
+            "b2 relative error: 2.09e-09\n",
+            "b3 relative error: 1.69e-10\n",
+            "Running check with reg =  3.14\n",
+            "Initial loss:  7.052114776533016\n",
+            "W1 relative error: 1.41e-08\n",
+            "W2 relative error: 6.87e-08\n",
+            "W3 relative error: 2.13e-08\n",
+            "b1 relative error: 1.48e-08\n",
+            "b2 relative error: 1.72e-09\n",
+            "b3 relative error: 2.38e-10\n"
+          ]
+        }
+      ],
+      "source": [
+        "np.random.seed(231)\n",
+        "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
+        "X = np.random.randn(N, D)\n",
+        "y = np.random.randint(C, size=(N,))\n",
+        "\n",
+        "for reg in [0, 3.14]:\n",
+        "  print('Running check with reg = ', reg)\n",
+        "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
+        "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
+        "\n",
+        "  loss, grads = model.loss(X, y)\n",
+        "  print('Initial loss: ', loss)\n",
+        "\n",
+        "  # Most of the errors should be on the order of e-7 or smaller.\n",
+        "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
+        "  # for the check when reg = 0.0\n",
+        "  for name in sorted(grads):\n",
+        "    f = lambda _: model.loss(X, y)[0]\n",
+        "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
+        "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8DhnODEpLo5l"
+      },
+      "source": [
+        "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "hEE2q8VILo5m",
+        "outputId": "918c9a81-a1b3-4409-d2a9-07a37cfb4234",
+        "scrolled": false
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "(Iteration 1 / 40) loss: 2.363364\n",
+            "(Epoch 0 / 20) train acc: 0.020000; val_acc: 0.105000\n",
+            "(Epoch 1 / 20) train acc: 0.020000; val_acc: 0.106000\n",
+            "(Epoch 2 / 20) train acc: 0.020000; val_acc: 0.110000\n",
+            "(Epoch 3 / 20) train acc: 0.020000; val_acc: 0.110000\n",
+            "(Epoch 4 / 20) train acc: 0.040000; val_acc: 0.109000\n",
+            "(Epoch 5 / 20) train acc: 0.040000; val_acc: 0.111000\n",
+            "(Iteration 11 / 40) loss: 2.270022\n",
+            "(Epoch 6 / 20) train acc: 0.040000; val_acc: 0.111000\n",
+            "(Epoch 7 / 20) train acc: 0.060000; val_acc: 0.112000\n",
+            "(Epoch 8 / 20) train acc: 0.060000; val_acc: 0.111000\n",
+            "(Epoch 9 / 20) train acc: 0.040000; val_acc: 0.110000\n",
+            "(Epoch 10 / 20) train acc: 0.040000; val_acc: 0.109000\n",
+            "(Iteration 21 / 40) loss: 2.309562\n",
+            "(Epoch 11 / 20) train acc: 0.060000; val_acc: 0.110000\n",
+            "(Epoch 12 / 20) train acc: 0.060000; val_acc: 0.110000\n",
+            "(Epoch 13 / 20) train acc: 0.060000; val_acc: 0.110000\n",
+            "(Epoch 14 / 20) train acc: 0.060000; val_acc: 0.110000\n",
+            "(Epoch 15 / 20) train acc: 0.060000; val_acc: 0.113000\n",
+            "(Iteration 31 / 40) loss: 2.285026\n",
+            "(Epoch 16 / 20) train acc: 0.060000; val_acc: 0.117000\n",
+            "(Epoch 17 / 20) train acc: 0.080000; val_acc: 0.113000\n",
+            "(Epoch 18 / 20) train acc: 0.080000; val_acc: 0.118000\n",
+            "(Epoch 19 / 20) train acc: 0.100000; val_acc: 0.118000\n",
+            "(Epoch 20 / 20) train acc: 0.100000; val_acc: 0.120000\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x800 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# TODO: Use a three-layer Net to overfit 50 training examples by\n",
+        "# tweaking just the learning rate and initialization scale.\n",
+        "\n",
+        "num_train = 50\n",
+        "small_data = {\n",
+        "  'X_train': data['X_train'][:num_train],\n",
+        "  'y_train': data['y_train'][:num_train],\n",
+        "  'X_val': data['X_val'],\n",
+        "  'y_val': data['y_val'],\n",
+        "}\n",
+        "\n",
+        "weight_scale = 1e-2   # Experiment with this!\n",
+        "learning_rate = 1e-4  # Experiment with this!\n",
+        "model = FullyConnectedNet([100, 100],\n",
+        "              weight_scale=weight_scale, dtype=np.float64)\n",
+        "solver = Solver(model, small_data,\n",
+        "                print_every=10, num_epochs=20, batch_size=25,\n",
+        "                update_rule='sgd',\n",
+        "                optim_config={\n",
+        "                  'learning_rate': learning_rate,\n",
+        "                }\n",
+        "         )\n",
+        "solver.train()\n",
+        "\n",
+        "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": {
+        "id": "LicqjxZNLo5m"
+      },
+      "source": [
+        "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "7cDzWdPsLo5m",
+        "outputId": "00830ef4-a01e-4c24-9311-52b8dc77058a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "(Iteration 1 / 40) loss: 2.302585\n",
+            "(Epoch 0 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 1 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 2 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 3 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 4 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 5 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Iteration 11 / 40) loss: 2.301962\n",
+            "(Epoch 6 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 7 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 8 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 9 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 10 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Iteration 21 / 40) loss: 2.301859\n",
+            "(Epoch 11 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 12 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 13 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 14 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 15 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Iteration 31 / 40) loss: 2.301798\n",
+            "(Epoch 16 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 17 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 18 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 19 / 20) train acc: 0.160000; val_acc: 0.079000\n",
+            "(Epoch 20 / 20) train acc: 0.160000; val_acc: 0.079000\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x800 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# TODO: Use a five-layer Net to overfit 50 training examples by\n",
+        "# tweaking just the learning rate and initialization scale.\n",
+        "\n",
+        "num_train = 50\n",
+        "small_data = {\n",
+        "  'X_train': data['X_train'][:num_train],\n",
+        "  'y_train': data['y_train'][:num_train],\n",
+        "  'X_val': data['X_val'],\n",
+        "  'y_val': data['y_val'],\n",
+        "}\n",
+        "\n",
+        "learning_rate = 2e-3  # Experiment with this!\n",
+        "weight_scale = 1e-5   # Experiment with this!\n",
+        "model = FullyConnectedNet([100, 100, 100, 100],\n",
+        "                weight_scale=weight_scale, dtype=np.float64)\n",
+        "solver = Solver(model, small_data,\n",
+        "                print_every=10, num_epochs=20, batch_size=25,\n",
+        "                update_rule='sgd',\n",
+        "                optim_config={\n",
+        "                  'learning_rate': learning_rate,\n",
+        "                }\n",
+        "         )\n",
+        "solver.train()\n",
+        "\n",
+        "plt.plot(solver.loss_history, 'o')\n",
+        "plt.title('Training loss history')\n",
+        "plt.xlabel('Iteration')\n",
+        "plt.ylabel('Training loss')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kLwN_FVHLo5m"
+      },
+      "source": [
+        "## Inline Question 2:\n",
+        "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
+        "\n",
+        "## Answer:\n",
+        "three-layer net이 더 initialization scale에 sensitive하다고 생각한다. 이 ipynb에서는 regularization에 대해 고려하지 않으므로, 모델의 복잡성은 layer 개수에 비례하게 된다. 또한 모델이 복잡할수록 parameter 개수가 많다. 따라서 three-layer는 parameter가 조금만 바뀌어도 그 결과에 영향을 미치는 정도가 크므로 initialization scale에 더 sensitive하다.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iC7ID4ARLo5m"
+      },
+      "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": {
+        "id": "Ax6Ed3LqLo5n"
+      },
+      "source": [
+        "# SGD+Momentum\n",
+        "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
+        "\n",
+        "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mVnqA5wuLo5n",
+        "outputId": "dcf1cc9b-726d-4c6f-bc6d-b892ac8fc9a7"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "next_w error:  8.882347033505819e-09\n",
+            "velocity error:  4.269287743278663e-09\n"
+          ]
+        }
+      ],
+      "source": [
+        "from cs231n.optim import sgd_momentum\n",
+        "\n",
+        "N, D = 4, 5\n",
+        "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
+        "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
+        "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
+        "\n",
+        "config = {'learning_rate': 1e-3, 'velocity': v}\n",
+        "next_w, _ = sgd_momentum(w, dw, config=config)\n",
+        "\n",
+        "expected_next_w = np.asarray([\n",
+        "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
+        "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
+        "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
+        "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
+        "expected_velocity = np.asarray([\n",
+        "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
+        "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
+        "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
+        "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
+        "\n",
+        "# Should see relative errors around e-8 or less\n",
+        "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
+        "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "64ABZYdnLo5n"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "5YdC14A7Lo5n",
+        "outputId": "369cb155-299f-40b3-9904-9c9f766c3291",
+        "scrolled": false
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "running with  sgd\n",
+            "(Iteration 1 / 200) loss: 2.559978\n",
+            "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
+            "(Iteration 11 / 200) loss: 2.356069\n",
+            "(Iteration 21 / 200) loss: 2.214091\n",
+            "(Iteration 31 / 200) loss: 2.205928\n",
+            "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
+            "(Iteration 41 / 200) loss: 2.132095\n",
+            "(Iteration 51 / 200) loss: 2.118950\n",
+            "(Iteration 61 / 200) loss: 2.116443\n",
+            "(Iteration 71 / 200) loss: 2.132549\n",
+            "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
+            "(Iteration 81 / 200) loss: 1.977227\n",
+            "(Iteration 91 / 200) loss: 2.007528\n",
+            "(Iteration 101 / 200) loss: 2.004762\n",
+            "(Iteration 111 / 200) loss: 1.885342\n",
+            "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
+            "(Iteration 121 / 200) loss: 1.891516\n",
+            "(Iteration 131 / 200) loss: 1.923677\n",
+            "(Iteration 141 / 200) loss: 1.957743\n",
+            "(Iteration 151 / 200) loss: 1.966736\n",
+            "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
+            "(Iteration 161 / 200) loss: 1.801483\n",
+            "(Iteration 171 / 200) loss: 1.973780\n",
+            "(Iteration 181 / 200) loss: 1.666573\n",
+            "(Iteration 191 / 200) loss: 1.909494\n",
+            "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
+            "\n",
+            "running with  sgd_momentum\n",
+            "(Iteration 1 / 200) loss: 3.153778\n",
+            "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
+            "(Iteration 11 / 200) loss: 2.227203\n",
+            "(Iteration 21 / 200) loss: 2.125706\n",
+            "(Iteration 31 / 200) loss: 1.932695\n",
+            "(Epoch 1 / 5) train acc: 0.307000; val_acc: 0.260000\n",
+            "(Iteration 41 / 200) loss: 1.946488\n",
+            "(Iteration 51 / 200) loss: 1.778583\n",
+            "(Iteration 61 / 200) loss: 1.758119\n",
+            "(Iteration 71 / 200) loss: 1.849137\n",
+            "(Epoch 2 / 5) train acc: 0.382000; val_acc: 0.322000\n",
+            "(Iteration 81 / 200) loss: 2.048671\n",
+            "(Iteration 91 / 200) loss: 1.693223\n",
+            "(Iteration 101 / 200) loss: 1.511693\n",
+            "(Iteration 111 / 200) loss: 1.390754\n",
+            "(Epoch 3 / 5) train acc: 0.458000; val_acc: 0.338000\n",
+            "(Iteration 121 / 200) loss: 1.670614\n",
+            "(Iteration 131 / 200) loss: 1.540271\n",
+            "(Iteration 141 / 200) loss: 1.597365\n",
+            "(Iteration 151 / 200) loss: 1.609851\n",
+            "(Epoch 4 / 5) train acc: 0.490000; val_acc: 0.327000\n",
+            "(Iteration 161 / 200) loss: 1.472687\n",
+            "(Iteration 171 / 200) loss: 1.378620\n",
+            "(Iteration 181 / 200) loss: 1.378175\n",
+            "(Iteration 191 / 200) loss: 1.305934\n",
+            "(Epoch 5 / 5) train acc: 0.536000; val_acc: 0.368000\n",
+            "\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1500x1500 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': 5e-3,\n",
+        "                  },\n",
+        "                  verbose=True)\n",
+        "  solvers[update_rule] = solver\n",
+        "  solver.train()\n",
+        "  print()\n",
+        "\n",
+        "plt.subplot(3, 1, 1)\n",
+        "plt.title('Training loss')\n",
+        "plt.xlabel('Iteration')\n",
+        "\n",
+        "plt.subplot(3, 1, 2)\n",
+        "plt.title('Training accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "\n",
+        "plt.subplot(3, 1, 3)\n",
+        "plt.title('Validation accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "\n",
+        "for update_rule, solver in solvers.items():\n",
+        "  plt.subplot(3, 1, 1)\n",
+        "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
+        "\n",
+        "  plt.subplot(3, 1, 2)\n",
+        "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
+        "\n",
+        "  plt.subplot(3, 1, 3)\n",
+        "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
+        "\n",
+        "for i in [1, 2, 3]:\n",
+        "  plt.subplot(3, 1, i)\n",
+        "  plt.legend(loc='upper center', ncol=4)\n",
+        "plt.gcf().set_size_inches(15, 15)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zGDbSeXTLo5n"
+      },
+      "source": [
+        "# RMSProp and Adam\n",
+        "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
+        "\n",
+        "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
+        "\n",
+        "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes.\n",
+        "\n",
+        "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
+        "\n",
+        "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3b_Rv0K1Lo5o",
+        "outputId": "4ac61204-907b-47bc-c48c-d30cea967910"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "next_w error:  9.524687511038133e-08\n",
+            "cache error:  2.6477955807156126e-09\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Test RMSProp implementation\n",
+        "from cs231n.optim import rmsprop\n",
+        "\n",
+        "N, D = 4, 5\n",
+        "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
+        "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
+        "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
+        "\n",
+        "config = {'learning_rate': 1e-2, 'cache': cache}\n",
+        "next_w, _ = rmsprop(w, dw, config=config)\n",
+        "\n",
+        "expected_next_w = np.asarray([\n",
+        "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
+        "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
+        "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
+        "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
+        "expected_cache = np.asarray([\n",
+        "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
+        "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
+        "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
+        "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
+        "\n",
+        "# You should see relative errors around e-7 or less\n",
+        "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
+        "print('cache error: ', rel_error(expected_cache, config['cache']))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "-dlu4pR6Lo5o",
+        "outputId": "565b7db6-fbcd-4592-bed8-91247dd2b6bc"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "next_w error:  1.1395691798535431e-07\n",
+            "v error:  4.208314038113071e-09\n",
+            "m error:  4.214963193114416e-09\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Test Adam implementation\n",
+        "from cs231n.optim import adam\n",
+        "\n",
+        "N, D = 4, 5\n",
+        "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
+        "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
+        "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
+        "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
+        "\n",
+        "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
+        "next_w, _ = adam(w, dw, config=config)\n",
+        "\n",
+        "expected_next_w = np.asarray([\n",
+        "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
+        "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
+        "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
+        "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
+        "expected_v = np.asarray([\n",
+        "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
+        "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
+        "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
+        "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
+        "expected_m = np.asarray([\n",
+        "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
+        "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
+        "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
+        "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
+        "\n",
+        "# You should see relative errors around e-7 or less\n",
+        "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
+        "print('v error: ', rel_error(expected_v, config['v']))\n",
+        "print('m error: ', rel_error(expected_m, config['m']))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gVOP4c-WLo5o"
+      },
+      "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": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "0wvM3bJELo5u",
+        "outputId": "f961f83c-5d6f-4ac4-9da6-7d07eb16e7f3"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "running with  adam\n",
+            "(Iteration 1 / 200) loss: 3.476928\n",
+            "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
+            "(Iteration 11 / 200) loss: 2.027712\n",
+            "(Iteration 21 / 200) loss: 2.183358\n",
+            "(Iteration 31 / 200) loss: 1.744257\n",
+            "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
+            "(Iteration 41 / 200) loss: 1.707951\n",
+            "(Iteration 51 / 200) loss: 1.703835\n",
+            "(Iteration 61 / 200) loss: 2.094758\n",
+            "(Iteration 71 / 200) loss: 1.505558\n",
+            "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.362000\n",
+            "(Iteration 81 / 200) loss: 1.594431\n",
+            "(Iteration 91 / 200) loss: 1.511452\n",
+            "(Iteration 101 / 200) loss: 1.389237\n",
+            "(Iteration 111 / 200) loss: 1.463575\n",
+            "(Epoch 3 / 5) train acc: 0.497000; val_acc: 0.368000\n",
+            "(Iteration 121 / 200) loss: 1.231313\n",
+            "(Iteration 131 / 200) loss: 1.520198\n",
+            "(Iteration 141 / 200) loss: 1.363221\n",
+            "(Iteration 151 / 200) loss: 1.355143\n",
+            "(Epoch 4 / 5) train acc: 0.543000; val_acc: 0.347000\n",
+            "(Iteration 161 / 200) loss: 1.436402\n",
+            "(Iteration 171 / 200) loss: 1.231426\n",
+            "(Iteration 181 / 200) loss: 1.153575\n",
+            "(Iteration 191 / 200) loss: 1.209479\n",
+            "(Epoch 5 / 5) train acc: 0.619000; val_acc: 0.374000\n",
+            "\n",
+            "running with  rmsprop\n",
+            "(Iteration 1 / 200) loss: 2.589166\n",
+            "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
+            "(Iteration 11 / 200) loss: 2.032921\n",
+            "(Iteration 21 / 200) loss: 1.897278\n",
+            "(Iteration 31 / 200) loss: 1.770793\n",
+            "(Epoch 1 / 5) train acc: 0.381000; val_acc: 0.320000\n",
+            "(Iteration 41 / 200) loss: 1.895731\n",
+            "(Iteration 51 / 200) loss: 1.681091\n",
+            "(Iteration 61 / 200) loss: 1.487204\n",
+            "(Iteration 71 / 200) loss: 1.629973\n",
+            "(Epoch 2 / 5) train acc: 0.429000; val_acc: 0.350000\n",
+            "(Iteration 81 / 200) loss: 1.506686\n",
+            "(Iteration 91 / 200) loss: 1.610742\n",
+            "(Iteration 101 / 200) loss: 1.486124\n",
+            "(Iteration 111 / 200) loss: 1.559454\n",
+            "(Epoch 3 / 5) train acc: 0.492000; val_acc: 0.361000\n",
+            "(Iteration 121 / 200) loss: 1.497406\n",
+            "(Iteration 131 / 200) loss: 1.530736\n",
+            "(Iteration 141 / 200) loss: 1.550957\n",
+            "(Iteration 151 / 200) loss: 1.652046\n",
+            "(Epoch 4 / 5) train acc: 0.530000; val_acc: 0.361000\n",
+            "(Iteration 161 / 200) loss: 1.599574\n",
+            "(Iteration 171 / 200) loss: 1.401073\n",
+            "(Iteration 181 / 200) loss: 1.509365\n",
+            "(Iteration 191 / 200) loss: 1.365772\n",
+            "(Epoch 5 / 5) train acc: 0.531000; val_acc: 0.369000\n",
+            "\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1500x1500 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 list(solvers.items()):\n",
+        "  plt.subplot(3, 1, 1)\n",
+        "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
+        "\n",
+        "  plt.subplot(3, 1, 2)\n",
+        "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
+        "\n",
+        "  plt.subplot(3, 1, 3)\n",
+        "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
+        "\n",
+        "for i in [1, 2, 3]:\n",
+        "  plt.subplot(3, 1, i)\n",
+        "  plt.legend(loc='upper center', ncol=4)\n",
+        "plt.gcf().set_size_inches(15, 15)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3A6eh2MiLo5u"
+      },
+      "source": [
+        "## Inline Question 3:\n",
+        "\n",
+        "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
+        "\n",
+        "```\n",
+        "cache += dw**2\n",
+        "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
+        "```\n",
+        "\n",
+        "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
+        "\n",
+        "\n",
+        "## Answer:\n",
+        "cache 값은 dw의 제곱을 누적해서 계속 더하기 때문에 학습이 진행될수록 점점 커진다. 따라서 w의 변화량의 분모가 점점 커지게 되어 parameter가 update되는 정도가 작아진다.\n",
+        "\n",
+        "Adam은 이러한 문제가 발생하지 않는다. 왜냐하면 학습이 진행될수록 update에 영향을 미치는 요소의 분모가 더 작게 자동으로 조정되기 때문이다.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WGC9kpJULo5v"
+      },
+      "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": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mj_C4Z3bLo5v",
+        "outputId": "636c4b56-5a02-480b-8223-56e2527b0191",
+        "scrolled": false
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "learning_rates: 0.001 weight_scale: 0.05 batch_size: 50 dropout_ratio: 1 batch_norm: True acc: 0.505\n",
+            "learning_rates: 0.001 weight_scale: 0.05 batch_size: 100 dropout_ratio: 1 batch_norm: True acc: 0.505\n",
+            "learning_rates: 0.0001 weight_scale: 0.05 batch_size: 50 dropout_ratio: 1 batch_norm: True acc: 0.5\n",
+            "learning_rates: 0.0001 weight_scale: 0.05 batch_size: 100 dropout_ratio: 1 batch_norm: True acc: 0.455\n"
+          ]
+        }
+      ],
+      "source": [
+        "best_model = None\n",
+        "################################################################################\n",
+        "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
+        "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
+        "# the best_model variable.                                                     #\n",
+        "################################################################################\n",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "best_acc = -1\n",
+        "\n",
+        "learning_rates = [1e-3, 1e-4]\n",
+        "weight_scale = [5e-2]\n",
+        "dropout_keep_ratio = [1, 0.5]\n",
+        "batch_size = [50,100]\n",
+        "normalize = [True, False]\n",
+        "\n",
+        "for lr in learning_rates:\n",
+        "  for w in weight_scale:\n",
+        "    for bs in batch_size:\n",
+        "        model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=w)\n",
+        "        solver = Solver(\n",
+        "            model,\n",
+        "            data,\n",
+        "            num_epochs=5,\n",
+        "            batch_size=bs,\n",
+        "            update_rule='adam',\n",
+        "            optim_config={'learning_rate': lr},\n",
+        "            verbose=False)\n",
+        "\n",
+        "        solver.train()\n",
+        "\n",
+        "        acc = solver.check_accuracy(data['X_val'], data['y_val'], batch_size = 100)\n",
+        "        print('learning_rates:',lr,'weight_scale:',w, 'batch_size:', bs, 'dropout_ratio:', drop_p, 'batch_norm:', bn, 'acc:',acc)\n",
+        "\n",
+        "        if acc > best_acc:\n",
+        "          best_acc = acc\n",
+        "          best_model = model\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "################################################################################\n",
+        "#                              END OF YOUR CODE                                #\n",
+        "################################################################################"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1caBDEvTLo5v"
+      },
+      "source": [
+        "# Test your model!\n",
+        "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
+        "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
+        "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
+        "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qyozqKethC62"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "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"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git "a/\352\261\264\353\247\220\354\262\234\352\260\204_Q2_BatchNormalization.ipynb" "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q2_BatchNormalization.ipynb"
new file mode 100644
index 0000000..5418485
--- /dev/null
+++ "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q2_BatchNormalization.ipynb"
@@ -0,0 +1,1309 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "0Ed5BBM7gNY3",
+        "outputId": "38069997-4205-49c4-fe8f-6bd5d1bfa527",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 69
+        }
+      },
+      "source": [
+        "# this mounts your Google Drive to the Colab VM.\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive', force_remount=True)\n",
+        "\n",
+        "# enter the foldername in your Drive where you have saved the unzipped\n",
+        "# assignment folder, e.g. 'cs231n/assignment2'\n",
+        "FOLDERNAME = 'cs231n/assignment2'\n",
+        "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
+        "\n",
+        "# now that we've mounted your Drive, this ensures that\n",
+        "# the Python interpreter of the Colab VM can load\n",
+        "# python files from within it.\n",
+        "import sys\n",
+        "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
+        "\n",
+        "# this downloads the CIFAR-10 dataset to your Drive\n",
+        "# if it doesn't already exist.\n",
+        "%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
+        "!bash get_datasets.sh\n",
+        "%cd /content"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Mounted at /content/drive\n",
+            "/content/drive/My Drive/cs231n/assignment2/cs231n/datasets\n",
+            "/content\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-title"
+        ],
+        "id": "pyyct9pngNY_"
+      },
+      "source": [
+        "# Batch Normalization\n",
+        "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train.\n",
+        "One idea along these lines is batch normalization which was proposed by [1] in 2015.\n",
+        "\n",
+        "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
+        "\n",
+        "The authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
+        "\n",
+        "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
+        "\n",
+        "[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
+        "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "YuFDz93TgNZA"
+      },
+      "source": [
+        "# As usual, a bit of setup\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))))\n",
+        "\n",
+        "def print_mean_std(x,axis=0):\n",
+        "    print('  means: ', x.mean(axis=axis))\n",
+        "    print('  stds:  ', x.std(axis=axis))\n",
+        "    print()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "gLSFC2dOgNZD",
+        "outputId": "3ec1bb80-7c73-43c8-cb33-accd2ad494ae",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 121
+        }
+      },
+      "source": [
+        "# Load the (preprocessed) CIFAR10 data.\n",
+        "data = get_CIFAR10_data()\n",
+        "for k, v in data.items():\n",
+        "  print('%s: ' % k, v.shape)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "X_train:  (49000, 3, 32, 32)\n",
+            "y_train:  (49000,)\n",
+            "X_val:  (1000, 3, 32, 32)\n",
+            "y_val:  (1000,)\n",
+            "X_test:  (1000, 3, 32, 32)\n",
+            "y_test:  (1000,)\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "l5z_w447gNZH"
+      },
+      "source": [
+        "## Batch normalization: forward\n",
+        "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
+        "\n",
+        "Referencing the paper linked to above in [1] may be helpful!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "NuYItfh3gNZH",
+        "outputId": "776461e5-20eb-4f34-940e-289536b3a532",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 225
+        }
+      },
+      "source": [
+        "# Check the training-time forward pass by checking means and variances\n",
+        "# of features both before and after batch normalization\n",
+        "\n",
+        "# Simulate the forward pass for a two-layer network\n",
+        "np.random.seed(231)\n",
+        "N, D1, D2, D3 = 200, 50, 60, 3\n",
+        "X = np.random.randn(N, D1)\n",
+        "W1 = np.random.randn(D1, D2)\n",
+        "W2 = np.random.randn(D2, D3)\n",
+        "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
+        "\n",
+        "print('Before batch normalization:')\n",
+        "print_mean_std(a,axis=0)\n",
+        "\n",
+        "gamma = np.ones((D3,))\n",
+        "beta = np.zeros((D3,))\n",
+        "# Means should be close to zero and stds close to one\n",
+        "print('After batch normalization (gamma=1, beta=0)')\n",
+        "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
+        "print_mean_std(a_norm,axis=0)\n",
+        "\n",
+        "gamma = np.asarray([1.0, 2.0, 3.0])\n",
+        "beta = np.asarray([11.0, 12.0, 13.0])\n",
+        "# Now means should be close to beta and stds close to gamma\n",
+        "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
+        "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
+        "print_mean_std(a_norm,axis=0)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Before batch normalization:\n",
+            "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
+            "  stds:   [27.18502186 34.21455511 37.68611762]\n",
+            "\n",
+            "After batch normalization (gamma=1, beta=0)\n",
+            "  means:  [5.99520433e-17 6.93889390e-17 8.32667268e-19]\n",
+            "  stds:   [0.99999999 1.         1.        ]\n",
+            "\n",
+            "After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n",
+            "  means:  [11. 12. 13.]\n",
+            "  stds:   [0.99999999 1.99999999 2.99999999]\n",
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "L2VW5k0ZgNZK",
+        "outputId": "33a5456d-fac8-4b6c-99d3-c9c34429145c",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 86
+        }
+      },
+      "source": [
+        "# Check the test-time forward pass by running the training-time\n",
+        "# forward pass many times to warm up the running averages, and then\n",
+        "# checking the means and variances of activations after a test-time\n",
+        "# forward pass.\n",
+        "\n",
+        "np.random.seed(231)\n",
+        "N, D1, D2, D3 = 200, 50, 60, 3\n",
+        "W1 = np.random.randn(D1, D2)\n",
+        "W2 = np.random.randn(D2, D3)\n",
+        "\n",
+        "bn_param = {'mode': 'train'}\n",
+        "gamma = np.ones(D3)\n",
+        "beta = np.zeros(D3)\n",
+        "\n",
+        "for t in range(50):\n",
+        "  X = np.random.randn(N, D1)\n",
+        "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
+        "  batchnorm_forward(a, gamma, beta, bn_param)\n",
+        "\n",
+        "bn_param['mode'] = 'test'\n",
+        "X = np.random.randn(N, D1)\n",
+        "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
+        "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
+        "\n",
+        "# Means should be close to zero and stds close to one, but will be\n",
+        "# noisier than training-time forward passes.\n",
+        "print('After batch normalization (test-time):')\n",
+        "print_mean_std(a_norm,axis=0)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "After batch normalization (test-time):\n",
+            "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
+            "  stds:   [1.01531428 1.01238373 0.97819988]\n",
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qH-ut9MsgNZO"
+      },
+      "source": [
+        "## Batch normalization: backward\n",
+        "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
+        "\n",
+        "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
+        "\n",
+        "Once you have finished, run the following to numerically check your backward pass."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "tr2QXX8ZgNZP",
+        "outputId": "a2ad89fb-d78f-4270-96dc-d3ecc31437f7",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 69
+        }
+      },
+      "source": [
+        "# Gradient check batchnorm backward pass\n",
+        "np.random.seed(231)\n",
+        "N, D = 4, 5\n",
+        "x = 5 * np.random.randn(N, D) + 12\n",
+        "gamma = np.random.randn(D)\n",
+        "beta = np.random.randn(D)\n",
+        "dout = np.random.randn(N, D)\n",
+        "\n",
+        "bn_param = {'mode': 'train'}\n",
+        "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
+        "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
+        "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
+        "\n",
+        "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
+        "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
+        "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
+        "\n",
+        "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
+        "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
+        "#You should expect to see relative errors between 1e-13 and 1e-8\n",
+        "print('dx error: ', rel_error(dx_num, dx))\n",
+        "print('dgamma error: ', rel_error(da_num, dgamma))\n",
+        "print('dbeta error: ', rel_error(db_num, dbeta))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "dx error:  1.6674621912029909e-09\n",
+            "dgamma error:  7.417225040694815e-13\n",
+            "dbeta error:  2.379446949959628e-12\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "H1nLncVFgNZS"
+      },
+      "source": [
+        "## Batch normalization: alternative backward\n",
+        "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
+        "\n",
+        "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too!  \n",
+        "\n",
+        "In the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$,\n",
+        "\n",
+        "we first calculate the mean $\\mu$ and variance $v$.\n",
+        "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$  and normalized data $Y$.\n",
+        "The equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n",
+        "\n",
+        "\\begin{align}\n",
+        "& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k  &  v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n",
+        "& \\sigma=\\sqrt{v+\\epsilon}         &  y_i=\\frac{x_i-\\mu}{\\sigma}\n",
+        "\\end{align}"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "dwekPDMUgNZT"
+      },
+      "source": [
+        "<img src=\"https://raw.githubusercontent.com/cs231n/cs231n.github.io/master/assets/a2/batchnorm_graph.png\">"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "0wCU5Y3PgNZU"
+      },
+      "source": [
+        "The meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n",
+        "\n",
+        "The unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at\n",
+        "$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n",
+        "$\\frac{\\partial \\sigma}{\\partial v}$,\n",
+        "$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\n",
+        "and then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n",
+        "\n",
+        "If it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$.\n",
+        "\n",
+        "You should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation.\n",
+        "\n",
+        "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "JQBH5QHPgNZV",
+        "outputId": "df668bb2-c47d-4181-b6e2-4de9be282117",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 86
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "N, D = 100, 500\n",
+        "x = 5 * np.random.randn(N, D) + 12\n",
+        "gamma = np.random.randn(D)\n",
+        "beta = np.random.randn(D)\n",
+        "dout = np.random.randn(N, D)\n",
+        "\n",
+        "bn_param = {'mode': 'train'}\n",
+        "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
+        "\n",
+        "t1 = time.time()\n",
+        "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
+        "t2 = time.time()\n",
+        "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
+        "t3 = time.time()\n",
+        "\n",
+        "print('dx difference: ', rel_error(dx1, dx2))\n",
+        "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
+        "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
+        "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "dx difference:  6.680652523862896e-13\n",
+            "dgamma difference:  0.0\n",
+            "dbeta difference:  0.0\n",
+            "speedup: 0.87x\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Nw8sJbXEgNZY"
+      },
+      "source": [
+        "## Fully Connected Nets with Batch Normalization\n",
+        "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
+        "\n",
+        "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
+        "\n",
+        "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "K0DrUkyJgNZZ",
+        "outputId": "20c3ec45-f58c-464c-e37b-f3b555368300",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
+        "X = np.random.randn(N, D)\n",
+        "y = np.random.randint(C, size=(N,))\n",
+        "\n",
+        "# You should expect losses between 1e-4~1e-10 for W,\n",
+        "# losses between 1e-08~1e-10 for b,\n",
+        "# and losses between 1e-08~1e-09 for beta and gammas.\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",
+        "                            normalization='batchnorm')\n",
+        "\n",
+        "  loss, grads = model.loss(X, y)\n",
+        "  print('Initial loss: ', loss)\n",
+        "\n",
+        "  for name in sorted(grads):\n",
+        "    f = lambda _: model.loss(X, y)[0]\n",
+        "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
+        "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
+        "  if reg == 0: print()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Running check with reg =  0\n",
+            "Initial loss:  2.2611955101340957\n",
+            "W1 relative error: 1.10e-04\n",
+            "W2 relative error: 3.11e-06\n",
+            "W3 relative error: 4.05e-10\n",
+            "b1 relative error: 4.44e-08\n",
+            "b2 relative error: 2.22e-08\n",
+            "b3 relative error: 1.01e-10\n",
+            "beta1 relative error: 7.33e-09\n",
+            "beta2 relative error: 1.89e-09\n",
+            "gamma1 relative error: 6.96e-09\n",
+            "gamma2 relative error: 2.41e-09\n",
+            "\n",
+            "Running check with reg =  3.14\n",
+            "Initial loss:  6.996533220108303\n",
+            "W1 relative error: 1.98e-06\n",
+            "W2 relative error: 2.28e-06\n",
+            "W3 relative error: 1.11e-08\n",
+            "b1 relative error: 5.55e-09\n",
+            "b2 relative error: 2.22e-08\n",
+            "b3 relative error: 2.10e-10\n",
+            "beta1 relative error: 6.65e-09\n",
+            "beta2 relative error: 3.39e-09\n",
+            "gamma1 relative error: 6.27e-09\n",
+            "gamma2 relative error: 5.28e-09\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DbBnmeEYgNZe"
+      },
+      "source": [
+        "# Batchnorm for deep networks\n",
+        "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "j_XgTX-igNZe",
+        "outputId": "4530d78f-1713-4e95-fcc3-c4c731a5acd9",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 795
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "# Try training a very deep net with batchnorm\n",
+        "hidden_dims = [100, 100, 100, 100, 100]\n",
+        "\n",
+        "num_train = 1000\n",
+        "small_data = {\n",
+        "  'X_train': data['X_train'][:num_train],\n",
+        "  'y_train': data['y_train'][:num_train],\n",
+        "  'X_val': data['X_val'],\n",
+        "  'y_val': data['y_val'],\n",
+        "}\n",
+        "\n",
+        "weight_scale = 2e-2\n",
+        "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
+        "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
+        "\n",
+        "print('Solver with batch norm:')\n",
+        "bn_solver = Solver(bn_model, small_data,\n",
+        "                num_epochs=10, batch_size=50,\n",
+        "                update_rule='adam',\n",
+        "                optim_config={\n",
+        "                  'learning_rate': 1e-3,\n",
+        "                },\n",
+        "                verbose=True,print_every=20)\n",
+        "bn_solver.train()\n",
+        "\n",
+        "print('\\nSolver without batch norm:')\n",
+        "solver = Solver(model, small_data,\n",
+        "                num_epochs=10, batch_size=50,\n",
+        "                update_rule='adam',\n",
+        "                optim_config={\n",
+        "                  'learning_rate': 1e-3,\n",
+        "                },\n",
+        "                verbose=True, print_every=20)\n",
+        "solver.train()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Solver with batch norm:\n",
+            "(Iteration 1 / 200) loss: 2.340974\n",
+            "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n",
+            "(Epoch 1 / 10) train acc: 0.314000; val_acc: 0.266000\n",
+            "(Iteration 21 / 200) loss: 2.039345\n",
+            "(Epoch 2 / 10) train acc: 0.395000; val_acc: 0.280000\n",
+            "(Iteration 41 / 200) loss: 2.047471\n",
+            "(Epoch 3 / 10) train acc: 0.484000; val_acc: 0.316000\n",
+            "(Iteration 61 / 200) loss: 1.739554\n",
+            "(Epoch 4 / 10) train acc: 0.525000; val_acc: 0.318000\n",
+            "(Iteration 81 / 200) loss: 1.247064\n",
+            "(Epoch 5 / 10) train acc: 0.601000; val_acc: 0.338000\n",
+            "(Iteration 101 / 200) loss: 1.333654\n",
+            "(Epoch 6 / 10) train acc: 0.627000; val_acc: 0.323000\n",
+            "(Iteration 121 / 200) loss: 1.036104\n",
+            "(Epoch 7 / 10) train acc: 0.695000; val_acc: 0.332000\n",
+            "(Iteration 141 / 200) loss: 1.140680\n",
+            "(Epoch 8 / 10) train acc: 0.723000; val_acc: 0.298000\n",
+            "(Iteration 161 / 200) loss: 0.705776\n",
+            "(Epoch 9 / 10) train acc: 0.760000; val_acc: 0.322000\n",
+            "(Iteration 181 / 200) loss: 0.906980\n",
+            "(Epoch 10 / 10) train acc: 0.771000; val_acc: 0.315000\n",
+            "\n",
+            "Solver without batch norm:\n",
+            "(Iteration 1 / 200) loss: 2.302332\n",
+            "(Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n",
+            "(Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n",
+            "(Iteration 21 / 200) loss: 2.041970\n",
+            "(Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n",
+            "(Iteration 41 / 200) loss: 1.900473\n",
+            "(Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n",
+            "(Iteration 61 / 200) loss: 1.713156\n",
+            "(Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n",
+            "(Iteration 81 / 200) loss: 1.662209\n",
+            "(Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n",
+            "(Iteration 101 / 200) loss: 1.696059\n",
+            "(Epoch 6 / 10) train acc: 0.535000; val_acc: 0.345000\n",
+            "(Iteration 121 / 200) loss: 1.557987\n",
+            "(Epoch 7 / 10) train acc: 0.530000; val_acc: 0.304000\n",
+            "(Iteration 141 / 200) loss: 1.432189\n",
+            "(Epoch 8 / 10) train acc: 0.628000; val_acc: 0.339000\n",
+            "(Iteration 161 / 200) loss: 1.033932\n",
+            "(Epoch 9 / 10) train acc: 0.661000; val_acc: 0.340000\n",
+            "(Iteration 181 / 200) loss: 0.901034\n",
+            "(Epoch 10 / 10) train acc: 0.726000; val_acc: 0.318000\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8LUeqy6LgNZj"
+      },
+      "source": [
+        "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "xIfiZ96hgNZj",
+        "outputId": "5e35088b-d8c5-4d64-e990-3f14ae0fa97e",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 893
+        }
+      },
+      "source": [
+        "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
+        "    \"\"\"utility function for plotting training history\"\"\"\n",
+        "    plt.title(title)\n",
+        "    plt.xlabel(label)\n",
+        "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
+        "    bl_plot = plot_fn(baseline)\n",
+        "    num_bn = len(bn_plots)\n",
+        "    for i in range(num_bn):\n",
+        "        label='with_norm'\n",
+        "        if labels is not None:\n",
+        "            label += str(labels[i])\n",
+        "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
+        "    label='baseline'\n",
+        "    if labels is not None:\n",
+        "        label += str(labels[0])\n",
+        "    plt.plot(bl_plot, bl_marker, label=label)\n",
+        "    plt.legend(loc='lower center', ncol=num_bn+1)\n",
+        "\n",
+        "\n",
+        "plt.subplot(3, 1, 1)\n",
+        "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
+        "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
+        "plt.subplot(3, 1, 2)\n",
+        "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
+        "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
+        "plt.subplot(3, 1, 3)\n",
+        "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
+        "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
+        "\n",
+        "plt.gcf().set_size_inches(15, 15)\n",
+        "\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x1080 with 3 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xIWsuQf5gNZn"
+      },
+      "source": [
+        "# Batch normalization and initialization\n",
+        "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
+        "\n",
+        "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "nJ4dJpNpgNZo",
+        "outputId": "27fce21f-e03a-4d37-ff82-97cba852abee",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 363
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "# Try training a very deep net with batchnorm\n",
+        "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
+        "num_train = 1000\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",
+        "bn_solvers_ws = {}\n",
+        "solvers_ws = {}\n",
+        "weight_scales = np.logspace(-4, 0, num=20)\n",
+        "for i, weight_scale in enumerate(weight_scales):\n",
+        "    print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
+        "    bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
+        "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
+        "\n",
+        "    bn_solver = Solver(bn_model, small_data,\n",
+        "                  num_epochs=10, batch_size=50,\n",
+        "                  update_rule='adam',\n",
+        "                  optim_config={\n",
+        "                    'learning_rate': 1e-3,\n",
+        "                  },\n",
+        "                  verbose=False, print_every=200)\n",
+        "    bn_solver.train()\n",
+        "    bn_solvers_ws[weight_scale] = bn_solver\n",
+        "\n",
+        "    solver = Solver(model, small_data,\n",
+        "                  num_epochs=10, batch_size=50,\n",
+        "                  update_rule='adam',\n",
+        "                  optim_config={\n",
+        "                    'learning_rate': 1e-3,\n",
+        "                  },\n",
+        "                  verbose=False, print_every=200)\n",
+        "    solver.train()\n",
+        "    solvers_ws[weight_scale] = solver"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Running weight scale 1 / 20\n",
+            "Running weight scale 2 / 20\n",
+            "Running weight scale 3 / 20\n",
+            "Running weight scale 4 / 20\n",
+            "Running weight scale 5 / 20\n",
+            "Running weight scale 6 / 20\n",
+            "Running weight scale 7 / 20\n",
+            "Running weight scale 8 / 20\n",
+            "Running weight scale 9 / 20\n",
+            "Running weight scale 10 / 20\n",
+            "Running weight scale 11 / 20\n",
+            "Running weight scale 12 / 20\n",
+            "Running weight scale 13 / 20\n",
+            "Running weight scale 14 / 20\n",
+            "Running weight scale 15 / 20\n",
+            "Running weight scale 16 / 20\n",
+            "Running weight scale 17 / 20\n",
+            "Running weight scale 18 / 20\n",
+            "Running weight scale 19 / 20\n",
+            "Running weight scale 20 / 20\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "PajkSWVhgNZr",
+        "outputId": "fa8155b5-d62a-4662-ee6b-ca65f62f5faa",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 897
+        }
+      },
+      "source": [
+        "# Plot results of weight scale experiment\n",
+        "best_train_accs, bn_best_train_accs = [], []\n",
+        "best_val_accs, bn_best_val_accs = [], []\n",
+        "final_train_loss, bn_final_train_loss = [], []\n",
+        "\n",
+        "for ws in weight_scales:\n",
+        "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
+        "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
+        "\n",
+        "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
+        "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
+        "\n",
+        "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
+        "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
+        "\n",
+        "plt.subplot(3, 1, 1)\n",
+        "plt.title('Best val accuracy vs weight initialization scale')\n",
+        "plt.xlabel('Weight initialization scale')\n",
+        "plt.ylabel('Best val accuracy')\n",
+        "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
+        "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
+        "plt.legend(ncol=2, loc='lower right')\n",
+        "\n",
+        "plt.subplot(3, 1, 2)\n",
+        "plt.title('Best train accuracy vs weight initialization scale')\n",
+        "plt.xlabel('Weight initialization scale')\n",
+        "plt.ylabel('Best training accuracy')\n",
+        "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
+        "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
+        "plt.legend()\n",
+        "\n",
+        "plt.subplot(3, 1, 3)\n",
+        "plt.title('Final training loss vs weight initialization scale')\n",
+        "plt.xlabel('Weight initialization scale')\n",
+        "plt.ylabel('Final training loss')\n",
+        "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
+        "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
+        "plt.legend()\n",
+        "plt.gca().set_ylim(1.0, 3.5)\n",
+        "\n",
+        "plt.gcf().set_size_inches(15, 15)\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x1080 with 3 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "CwhbowpBgNZu"
+      },
+      "source": [
+        "## Inline Question 1:\n",
+        "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n",
+        "\n",
+        "## Answer:\n",
+        "가중치 초기화를 할 때, 너무 크거나 작은 가중치로 시작하면 그래디언트 소실 또는 그래디언트 폭발과 같은 문제가 발생할 수 있으며 추후 이 문제들은 신경망이 제대로 학습할 수 없도록 한다.\n",
+        "\n",
+        "이때 배치 정규화를 사용하면 가중치 초기화의 스케일이 학습에 미치는 영향이 줄어들게 된다. 배치 정규화란 각 계층의 출력을 정규화하여, 그래디언트 소실 또는 그래디언트 폭발 문제를 완화시키는 기술이다.\n",
+        "\n",
+        "또한 배치 정규화는 내부 공변량 이동(internal covariate shift) 문제를 완화한다. 내부 공변량 이동은 학습 도중 각 계층의 입력 분포가 변화하는 현상을 말하는데, 이는 신경망 학습을 느리게 만들거나 학습 과정을 불안정하게 만들 수 있다. 이런 경우에 배치 정규화를 사용하면 각 계층의 입력 분포가 일정하게 유지되므로 해당 문제를 해결할 수 있다.\n",
+        "\n",
+        "즉 배치 정규화는 가중치 초기화의 스케일에 덜 민감하게 만들어 신경망의 성능을 향상시키는 데 도움이 된다. 각 계층의 출력을 배치 정규화 계층에서 강제로 정규화하기 때문에, 가중치 스케일이 잘 최적화되지 않았더라도 배치 정규화 모델은 적절한 정확도를 보인다. 반면 배치 정규화를 사용하지 않는 모델은 가중치 스케일이 잘 최적화되지 않을 경우 정확도가 떨어지는데, 가중치 초기화의 스케일은 배치 정규화를 사용하지 않는 모델에 더 큰 영향을 미치기 때문이다.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qv0zmRnlgNZv"
+      },
+      "source": [
+        "# Batch normalization and batch size\n",
+        "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
+        "\n",
+        "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "bRWP3mhxgNZv",
+        "outputId": "a31e2247-143d-4905-d524-977c93ea43c0",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 86
+        }
+      },
+      "source": [
+        "def run_batchsize_experiments(normalization_mode):\n",
+        "    np.random.seed(231)\n",
+        "    # Try training a very deep net with batchnorm\n",
+        "    hidden_dims = [100, 100, 100, 100, 100]\n",
+        "    num_train = 1000\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_epochs=10\n",
+        "    weight_scale = 2e-2\n",
+        "    batch_sizes = [5,10,50]\n",
+        "    lr = 10**(-3.5)\n",
+        "    solver_bsize = batch_sizes[0]\n",
+        "\n",
+        "    print('No normalization: batch size = ',solver_bsize)\n",
+        "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
+        "    solver = Solver(model, small_data,\n",
+        "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
+        "                    update_rule='adam',\n",
+        "                    optim_config={\n",
+        "                      'learning_rate': lr,\n",
+        "                    },\n",
+        "                    verbose=False)\n",
+        "    solver.train()\n",
+        "\n",
+        "    bn_solvers = []\n",
+        "    for i in range(len(batch_sizes)):\n",
+        "        b_size=batch_sizes[i]\n",
+        "        print('Normalization: batch size = ',b_size)\n",
+        "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
+        "        bn_solver = Solver(bn_model, small_data,\n",
+        "                        num_epochs=n_epochs, batch_size=b_size,\n",
+        "                        update_rule='adam',\n",
+        "                        optim_config={\n",
+        "                          'learning_rate': lr,\n",
+        "                        },\n",
+        "                        verbose=False)\n",
+        "        bn_solver.train()\n",
+        "        bn_solvers.append(bn_solver)\n",
+        "\n",
+        "    return bn_solvers, solver, batch_sizes\n",
+        "\n",
+        "batch_sizes = [5,10,50]\n",
+        "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "No normalization: batch size =  5\n",
+            "Normalization: batch size =  5\n",
+            "Normalization: batch size =  10\n",
+            "Normalization: batch size =  50\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "l8m9PQSigNZz",
+        "outputId": "00762360-156a-48f1-9219-0f335be3c243",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 621
+        }
+      },
+      "source": [
+        "plt.subplot(2, 1, 1)\n",
+        "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
+        "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
+        "plt.subplot(2, 1, 2)\n",
+        "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
+        "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
+        "\n",
+        "plt.gcf().set_size_inches(15, 10)\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x720 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "EOGo5xmGgNZ3"
+      },
+      "source": [
+        "## Inline Question 2:\n",
+        "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
+        "\n",
+        "## Answer:\n",
+        "배치 크기가 클수록 결과가 더 좋은 것으로 나타난다. 이는 큰 배치에서 더 많은 데이터를 통해 더 정확한 평균과 분산을 계산할 수 있기 때문이다. 반면 배치 크기가 작은 경우, 평균과 분산의 추정치가 부정확해지며, 이로 인해 배치 정규화의 효과가 감소하게 된다.\n",
+        "\n",
+        "예를 들어 배치 크기라 5와 같이 매우 작은 경우, 해당 배치의 데이터는 전체 데이터 분포를 정확히 반영하지 못할 가능성이 높다. 이러한 경우 배치 정규화는 이처럼 작은 배치의 평균과 분산을 사용하여 데이터를 정규화하는데, 이때 해당 배치의 평균과 분산이 전체 데이터의 평균과 분산과 크게 다르게 되면 배치 정규화 후의 데이터는 실제 데이터 분포를 잘 반영하지 못하게 되는 것이다. 결과적으로 이는 신경망 성능을 저하시키는 주요 원인이 될 수 있다."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xfrb6lVTgNZ3"
+      },
+      "source": [
+        "# Layer Normalization\n",
+        "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations.\n",
+        "\n",
+        "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
+        "\n",
+        "[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "4vtI3yupgNZ4"
+      },
+      "source": [
+        "## Inline Question 3:\n",
+        "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
+        "\n",
+        "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
+        "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
+        "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
+        "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
+        "\n",
+        "## Answer:\n",
+        "\n",
+        "1&3은 배치 정규화와 유사한 반면 2&4는 레이어 정규화와 유사하다. 우선 1번의 경우 각 픽셀 행에 대해 RGB 채널의 합이 1이 되도록 스케일링 하고있으며, 3번의 경우 전체 데이터셋의 평균 이미지를 각 이미지에서 빼는 과정이다. 이 두 가지 모두 픽셀 단위로 작업을 수행하며, 이는 배치 정규화가 각 피쳐별로 정규화를 수행하는 것과 유사하다고 볼 수 있다. 여기서 전체 데이터셋의 평균 이미지가 배치 평균에 해당하며, 이를 각 이미지에서 빼내는 방식으로 정규화를 수행한다.\n",
+        "\n",
+        "반면 2번의 경우 각 이미지의 모든 픽셀에 대해 RGB 채널의 합이 1이 되도록 스케일링하고, 4번에서는 모든 RGB 값을 0 또는 1로 설정한다. 이 두 가지 모두 이미지 전체에 대해 작업을 수행하며, 이는 레이어 정규화가 각 층의 출력을 독립적으로 정규화하는 것과 유사하다고 볼 수 있다. 여기서 각 이미지가 하나의 층으로 간주되며, 이미지 내의 모든 픽셀이 동일한 스케일링을 받는다.\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uR7ql9xWgNZ5"
+      },
+      "source": [
+        "# Layer Normalization: Implementation\n",
+        "\n",
+        "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
+        "\n",
+        "Here's what you need to do:\n",
+        "\n",
+        "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`.\n",
+        "\n",
+        "Run the cell below to check your results.\n",
+        "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`.\n",
+        "\n",
+        "Run the second cell below to check your results.\n",
+        "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity.\n",
+        "\n",
+        "Run the third cell below to run the batch size experiment on layer normalization."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bHKlKrtJgNZ9",
+        "outputId": "d3e18e60-5e18-41ef-901a-7013a24401a8",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 225
+        }
+      },
+      "source": [
+        "# Check the training-time forward pass by checking means and variances\n",
+        "# of features both before and after layer normalization\n",
+        "\n",
+        "# Simulate the forward pass for a two-layer network\n",
+        "np.random.seed(231)\n",
+        "N, D1, D2, D3 =4, 50, 60, 3\n",
+        "X = np.random.randn(N, D1)\n",
+        "W1 = np.random.randn(D1, D2)\n",
+        "W2 = np.random.randn(D2, D3)\n",
+        "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
+        "\n",
+        "print('Before layer normalization:')\n",
+        "print_mean_std(a,axis=1)\n",
+        "\n",
+        "gamma = np.ones(D3)\n",
+        "beta = np.zeros(D3)\n",
+        "# Means should be close to zero and stds close to one\n",
+        "print('After layer normalization (gamma=1, beta=0)')\n",
+        "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
+        "print_mean_std(a_norm,axis=1)\n",
+        "\n",
+        "gamma = np.asarray([3.0,3.0,3.0])\n",
+        "beta = np.asarray([5.0,5.0,5.0])\n",
+        "# Now means should be close to beta and stds close to gamma\n",
+        "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
+        "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
+        "print_mean_std(a_norm,axis=1)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "Before layer normalization:\n",
+            "  means:  [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n",
+            "  stds:   [10.07429373 28.39478981 35.28360729  4.01831507]\n",
+            "\n",
+            "After layer normalization (gamma=1, beta=0)\n",
+            "  means:  [ 4.81096644e-16 -7.40148683e-17  2.22044605e-16 -5.92118946e-16]\n",
+            "  stds:   [0.99999995 0.99999999 1.         0.99999969]\n",
+            "\n",
+            "After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n",
+            "  means:  [5. 5. 5. 5.]\n",
+            "  stds:   [2.99999985 2.99999998 2.99999999 2.99999907]\n",
+            "\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "10CwNM3zgNaB",
+        "outputId": "ff533c30-6279-42be-8dcd-cb41b434e046",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 69
+        }
+      },
+      "source": [
+        "# Gradient check batchnorm backward pass\n",
+        "np.random.seed(231)\n",
+        "N, D = 4, 5\n",
+        "x = 5 * np.random.randn(N, D) + 12\n",
+        "gamma = np.random.randn(D)\n",
+        "beta = np.random.randn(D)\n",
+        "dout = np.random.randn(N, D)\n",
+        "\n",
+        "ln_param = {}\n",
+        "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
+        "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
+        "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
+        "\n",
+        "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
+        "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
+        "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
+        "\n",
+        "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
+        "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
+        "\n",
+        "#You should expect to see relative errors between 1e-12 and 1e-8\n",
+        "print('dx error: ', rel_error(dx_num, dx))\n",
+        "print('dgamma error: ', rel_error(da_num, dgamma))\n",
+        "print('dbeta error: ', rel_error(db_num, dbeta))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "dx error:  2.107277051835058e-09\n",
+            "dgamma error:  4.519489546032799e-12\n",
+            "dbeta error:  2.5842537629899423e-12\n"
+          ],
+          "name": "stdout"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3oGiJPu_gNaF"
+      },
+      "source": [
+        "# Layer Normalization and batch size\n",
+        "\n",
+        "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "vf9Aa3rngNaG",
+        "outputId": "9fd576b1-de98-4c66-b287-219dd9e1bea4",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 690
+        }
+      },
+      "source": [
+        "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
+        "\n",
+        "plt.subplot(2, 1, 1)\n",
+        "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
+        "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
+        "plt.subplot(2, 1, 2)\n",
+        "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
+        "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
+        "\n",
+        "plt.gcf().set_size_inches(15, 10)\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "No normalization: batch size =  5\n",
+            "Normalization: batch size =  5\n",
+            "Normalization: batch size =  10\n",
+            "Normalization: batch size =  50\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 1080x720 with 2 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "HggXBdBUgNaI"
+      },
+      "source": [
+        "## Inline Question 4:\n",
+        "When is layer normalization likely to not work well, and why?\n",
+        "\n",
+        "1. Using it in a very deep network\n",
+        "2. Having a very small dimension of features\n",
+        "3. Having a high regularization term\n",
+        "\n",
+        "\n",
+        "## Answer:\n",
+        "2번, 피처의 차원이 매우 작은 경우이다. 레이어 정규화는 각 샘플에 대해 독립적으로 수행되며, 특정 레이어의 모든 입력 피처에 대해 평균과 분산을 계산한다. 피처의 차원이 매우 작다면, 이 평균과 분산의 계산이 노이즈에 민감하게 반응할 수 있다. 따라서 노이즈에 크게 영향을 받아 계산된 평균과 분산이 실제 데이터의 특성을 잘 반영하지 못할 수 있다.\n",
+        "\n",
+        "다시 말해 피처의 차원이 작으면 각 레이어에서 다루는 정보의 양이 적어지기 때문에 각 피처가 전체 데이터를 대표하는 표준이 되기 어렵다는 것이다. 이는 배치 정규화에서 배치 크기가 작을 때 발생하는 문제와 유사한데, 배치 크기가 작으면 각 배치의 평균과 분산이 전체 데이터의 평균과 분산을 정확하게 대표하지 못할 수 있는 것과 같은 원리이다.\n"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git "a/\352\261\264\353\247\220\354\262\234\352\260\204_Q3_Dropout.ipynb" "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q3_Dropout.ipynb"
new file mode 100644
index 0000000..d8170fd
--- /dev/null
+++ "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q3_Dropout.ipynb"
@@ -0,0 +1,617 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "tfPkYvCIKpkX",
+        "outputId": "9496ffe9-9bbe-4ac4-ad7d-0943156c9e69",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "# This mounts your Google Drive to the Colab VM.\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "# Enter the foldername in your Drive where you have saved the unzipped\n",
+        "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
+        "FOLDERNAME = \"euron_cs231n\"\n",
+        "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
+        "\n",
+        "# Now that we've mounted your Drive, this ensures that\n",
+        "# the Python interpreter of the Colab VM can load\n",
+        "# python files from within it.\n",
+        "import sys\n",
+        "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
+        "\n",
+        "# This downloads the CIFAR-10 dataset to your Drive\n",
+        "# if it doesn't already exist.\n",
+        "#%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
+        "#!bash get_datasets.sh\n",
+        "%cd /content/drive/My\\ Drive/$FOLDERNAME"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n",
+            "/content/drive/My Drive/euron_cs231n\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-title"
+        ],
+        "id": "kQkZ_okoKpka"
+      },
+      "source": [
+        "# Dropout\n",
+        "Dropout [1] is a technique for regularizing neural networks by randomly setting some output activations to zero during the forward pass. In this exercise you will implement a dropout layer and modify your fully-connected network to optionally use dropout.\n",
+        "\n",
+        "[1] [Geoffrey E. Hinton et al, \"Improving neural networks by preventing co-adaptation of feature detectors\", arXiv 2012](https://arxiv.org/abs/1207.0580)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "qqih8tM3Kpkb",
+        "outputId": "ad448845-5fe6-49c3-fca0-ea70e35f158b",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "# As usual, a bit of setup\n",
+        "from __future__ import print_function\n",
+        "import time\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from cs231n.classifiers.fc_net import *\n",
+        "from cs231n.data_utils import get_CIFAR10_data\n",
+        "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
+        "from cs231n.solver import Solver\n",
+        "\n",
+        "%matplotlib inline\n",
+        "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
+        "plt.rcParams['image.interpolation'] = 'nearest'\n",
+        "plt.rcParams['image.cmap'] = 'gray'\n",
+        "\n",
+        "# for auto-reloading external modules\n",
+        "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
+        "%load_ext autoreload\n",
+        "%autoreload 2\n",
+        "\n",
+        "def rel_error(x, y):\n",
+        "  \"\"\" returns relative error \"\"\"\n",
+        "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
+            "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
+            "\tThe instructions to do this will be given in a section of the notebook below.\n",
+            "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "vsIl9Fa7Kpkd",
+        "outputId": "8dd91d66-ef04-4347-d60e-53df01e704cb",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "# Load the (preprocessed) CIFAR10 data.\n",
+        "\n",
+        "data = get_CIFAR10_data()\n",
+        "for k, v in data.items():\n",
+        "  print('%s: ' % k, v.shape)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "X_train:  (49000, 3, 32, 32)\n",
+            "y_train:  (49000,)\n",
+            "X_val:  (1000, 3, 32, 32)\n",
+            "y_val:  (1000,)\n",
+            "X_test:  (1000, 3, 32, 32)\n",
+            "y_test:  (1000,)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rOgSfusHKpkg"
+      },
+      "source": [
+        "# Dropout forward pass\n",
+        "In the file `cs231n/layers.py`, implement the forward pass for dropout. Since dropout behaves differently during training and testing, make sure to implement the operation for both modes.\n",
+        "\n",
+        "Once you have done so, run the cell below to test your implementation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "2JYhCAqhKpkg",
+        "outputId": "cd9835da-163a-412b-d0b0-ded4a3c3b901",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "x = np.random.randn(500, 500) + 10\n",
+        "\n",
+        "for p in [0.25, 0.4, 0.7]:\n",
+        "  out, _ = dropout_forward(x, {'mode': 'train', 'p': p})\n",
+        "  out_test, _ = dropout_forward(x, {'mode': 'test', 'p': p})\n",
+        "\n",
+        "  print('Running tests with p = ', p)\n",
+        "  print('Mean of input: ', x.mean())\n",
+        "  print('Mean of train-time output: ', out.mean())\n",
+        "  print('Mean of test-time output: ', out_test.mean())\n",
+        "  print('Fraction of train-time output set to zero: ', (out == 0).mean())\n",
+        "  print('Fraction of test-time output set to zero: ', (out_test == 0).mean())\n",
+        "  print()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Running tests with p =  0.25\n",
+            "Mean of input:  10.000207878477502\n",
+            "Mean of train-time output:  10.014059116977283\n",
+            "Mean of test-time output:  10.000207878477502\n",
+            "Fraction of train-time output set to zero:  0.749784\n",
+            "Fraction of test-time output set to zero:  0.0\n",
+            "\n",
+            "Running tests with p =  0.4\n",
+            "Mean of input:  10.000207878477502\n",
+            "Mean of train-time output:  9.977917658761159\n",
+            "Mean of test-time output:  10.000207878477502\n",
+            "Fraction of train-time output set to zero:  0.600796\n",
+            "Fraction of test-time output set to zero:  0.0\n",
+            "\n",
+            "Running tests with p =  0.7\n",
+            "Mean of input:  10.000207878477502\n",
+            "Mean of train-time output:  9.987811912159426\n",
+            "Mean of test-time output:  10.000207878477502\n",
+            "Fraction of train-time output set to zero:  0.30074\n",
+            "Fraction of test-time output set to zero:  0.0\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "r-rGN1gwKpkj"
+      },
+      "source": [
+        "# Dropout backward pass\n",
+        "In the file `cs231n/layers.py`, implement the backward pass for dropout. After doing so, run the following cell to numerically gradient-check your implementation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "6Ih3gNJhKpkj",
+        "outputId": "144e0e0d-1a4a-40e6-8651-ebba4b660222",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "x = np.random.randn(10, 10) + 10\n",
+        "dout = np.random.randn(*x.shape)\n",
+        "\n",
+        "dropout_param = {'mode': 'train', 'p': 0.2, 'seed': 123}\n",
+        "out, cache = dropout_forward(x, dropout_param)\n",
+        "dx = dropout_backward(dout, cache)\n",
+        "dx_num = eval_numerical_gradient_array(lambda xx: dropout_forward(xx, dropout_param)[0], x, dout)\n",
+        "\n",
+        "# Error should be around e-10 or less\n",
+        "print('dx relative error: ', rel_error(dx, dx_num))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "dx relative error:  5.44560814873387e-11\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "zDcnUzKRKpkm"
+      },
+      "source": [
+        "## Inline Question 1:\n",
+        "What happens if we do not divide the values being passed through inverse dropout by `p` in the dropout layer? Why does that happen?\n",
+        "\n",
+        "## Answer:\n",
+        "드롭아웃 층에서 값을 $p$로 나눠주지 않을 경우, 입력값과 출력값의 크기가 달라지게 된다. 예를 들어, 어떤 뉴런의 드롭아웃 이전 출력값이 $x$일 때 $p=0.5$인 경우의 예상 출력값은 $px+(1-p)0$으로 계산된다. 따라서 크기를 맞춰주기 위해 출력값에 $p$를 곱해주는 과정이 추가된다.\n",
+        "\n",
+        "이를 Vanilla dropout이라고 하며, 구체적인 코드는 다음과 같다.\n",
+        "\n",
+        "```python\n",
+        "\"\"\" Vanilla Dropout \"\"\"\n",
+        "\n",
+        "p = 0.5 # 활성 뉴런의 비율로, p값이 높을수록 dropout 비율이 낮음\n",
+        "\n",
+        "def train_step(X):\n",
+        "  \"\"\" X contains the data \"\"\"\n",
+        "  \n",
+        "  # 3층 신경망 예시에서의 forward pass\n",
+        "  H1 = np.maximum(0, np.dot(W1, X) + b1)\n",
+        "  U1 = np.random.rand(*H1.shape) < p # first dropout mask\n",
+        "  H1 *= U1 # drop!\n",
+        "  H2 = np.maximum(0, np.dot(W2, H1) + b2)\n",
+        "  U2 = np.random.rand(*H2.shape) < p # second dropout mask\n",
+        "  H2 *= U2 # drop!\n",
+        "  out = np.dot(W3, H2) + b3\n",
+        "  \n",
+        "  # backward pass: gradient 계산\n",
+        "  # 파라미터 업데이트 과정\n",
+        "  \n",
+        "def predict(X):\n",
+        "  # ensembled forward pass\n",
+        "  H1 = np.maximum(0, np.dot(W1, X) + b1) * p # NOTE: scale the activations\n",
+        "  H2 = np.maximum(0, np.dot(W2, H1) + b2) * p # NOTE: scale the activations\n",
+        "  out = np.dot(W3, H2) + b3\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "or23NNK1Kpkm"
+      },
+      "source": [
+        "# Fully-connected nets with Dropout\n",
+        "In the file `cs231n/classifiers/fc_net.py`, modify your implementation to use dropout. Specifically, if the constructor of the network receives a value that is not 1 for the `dropout` parameter, then the net should add a dropout layer immediately after every ReLU nonlinearity. After doing so, run the following to numerically gradient-check your implementation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "SO1jxK0VKpkn",
+        "outputId": "1f3ee320-5f30-4676-8a1c-6aad1e249771",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "np.random.seed(231)\n",
+        "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
+        "X = np.random.randn(N, D)\n",
+        "y = np.random.randint(C, size=(N,))\n",
+        "\n",
+        "for dropout in [1, 0.75, 0.5]:\n",
+        "  print('Running check with dropout = ', dropout)\n",
+        "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
+        "                            weight_scale=5e-2, dtype=np.float64,\n",
+        "                            dropout=dropout, seed=123)\n",
+        "\n",
+        "  loss, grads = model.loss(X, y)\n",
+        "  print('Initial loss: ', loss)\n",
+        "\n",
+        "  # Relative errors should be around e-6 or less; Note that it's fine\n",
+        "  # if for dropout=1 you have W2 error be on the order of e-5.\n",
+        "  for name in sorted(grads):\n",
+        "    f = lambda _: model.loss(X, y)[0]\n",
+        "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
+        "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
+        "  print()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Running check with dropout =  1\n",
+            "Initial loss:  2.3004790897684924\n",
+            "W1 relative error: 1.48e-07\n",
+            "W2 relative error: 2.21e-05\n",
+            "W3 relative error: 3.53e-07\n",
+            "b1 relative error: 5.38e-09\n",
+            "b2 relative error: 2.09e-09\n",
+            "b3 relative error: 5.80e-11\n",
+            "\n",
+            "Running check with dropout =  0.75\n",
+            "Initial loss:  2.302371489704412\n",
+            "W1 relative error: 1.90e-07\n",
+            "W2 relative error: 4.76e-06\n",
+            "W3 relative error: 2.60e-08\n",
+            "b1 relative error: 4.73e-09\n",
+            "b2 relative error: 1.82e-09\n",
+            "b3 relative error: 1.70e-10\n",
+            "\n",
+            "Running check with dropout =  0.5\n",
+            "Initial loss:  2.3042759220785896\n",
+            "W1 relative error: 3.11e-07\n",
+            "W2 relative error: 1.84e-08\n",
+            "W3 relative error: 5.35e-08\n",
+            "b1 relative error: 5.37e-09\n",
+            "b2 relative error: 2.99e-09\n",
+            "b3 relative error: 1.13e-10\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Hdw_cNDRKpkq"
+      },
+      "source": [
+        "# Regularization experiment\n",
+        "As an experiment, we will train a pair of two-layer networks on 500 training examples: one will use no dropout, and one will use a keep probability of 0.25. We will then visualize the training and validation accuracies of the two networks over time."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "scrolled": false,
+        "id": "T3dkruOLKpkq",
+        "outputId": "af36d99d-264d-4631-c448-d63d181ae8a3",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "source": [
+        "# Train two identical nets, one with dropout and one without\n",
+        "np.random.seed(231)\n",
+        "num_train = 500\n",
+        "small_data = {\n",
+        "  'X_train': data['X_train'][:num_train],\n",
+        "  'y_train': data['y_train'][:num_train],\n",
+        "  'X_val': data['X_val'],\n",
+        "  'y_val': data['y_val'],\n",
+        "}\n",
+        "\n",
+        "solvers = {}\n",
+        "dropout_choices = [1, 0.25]\n",
+        "for dropout in dropout_choices:\n",
+        "  model = FullyConnectedNet([500], dropout=dropout)\n",
+        "  print(dropout)\n",
+        "\n",
+        "  solver = Solver(model, small_data,\n",
+        "                  num_epochs=25, batch_size=100,\n",
+        "                  update_rule='adam',\n",
+        "                  optim_config={\n",
+        "                    'learning_rate': 5e-4,\n",
+        "                  },\n",
+        "                  verbose=True, print_every=100)\n",
+        "  solver.train()\n",
+        "  solvers[dropout] = solver\n",
+        "  print()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1\n",
+            "(Iteration 1 / 125) loss: 7.856643\n",
+            "(Epoch 0 / 25) train acc: 0.260000; val_acc: 0.184000\n",
+            "(Epoch 1 / 25) train acc: 0.416000; val_acc: 0.258000\n",
+            "(Epoch 2 / 25) train acc: 0.482000; val_acc: 0.276000\n",
+            "(Epoch 3 / 25) train acc: 0.532000; val_acc: 0.277000\n",
+            "(Epoch 4 / 25) train acc: 0.600000; val_acc: 0.271000\n",
+            "(Epoch 5 / 25) train acc: 0.708000; val_acc: 0.299000\n",
+            "(Epoch 6 / 25) train acc: 0.722000; val_acc: 0.282000\n",
+            "(Epoch 7 / 25) train acc: 0.832000; val_acc: 0.255000\n",
+            "(Epoch 8 / 25) train acc: 0.880000; val_acc: 0.268000\n",
+            "(Epoch 9 / 25) train acc: 0.902000; val_acc: 0.277000\n",
+            "(Epoch 10 / 25) train acc: 0.898000; val_acc: 0.261000\n",
+            "(Epoch 11 / 25) train acc: 0.924000; val_acc: 0.263000\n",
+            "(Epoch 12 / 25) train acc: 0.960000; val_acc: 0.300000\n",
+            "(Epoch 13 / 25) train acc: 0.972000; val_acc: 0.314000\n",
+            "(Epoch 14 / 25) train acc: 0.972000; val_acc: 0.310000\n",
+            "(Epoch 15 / 25) train acc: 0.974000; val_acc: 0.314000\n",
+            "(Epoch 16 / 25) train acc: 0.994000; val_acc: 0.303000\n",
+            "(Epoch 17 / 25) train acc: 0.970000; val_acc: 0.304000\n",
+            "(Epoch 18 / 25) train acc: 0.992000; val_acc: 0.312000\n",
+            "(Epoch 19 / 25) train acc: 0.992000; val_acc: 0.309000\n",
+            "(Epoch 20 / 25) train acc: 0.992000; val_acc: 0.289000\n",
+            "(Iteration 101 / 125) loss: 0.001969\n",
+            "(Epoch 21 / 25) train acc: 0.996000; val_acc: 0.291000\n",
+            "(Epoch 22 / 25) train acc: 1.000000; val_acc: 0.306000\n",
+            "(Epoch 23 / 25) train acc: 0.996000; val_acc: 0.309000\n",
+            "(Epoch 24 / 25) train acc: 0.998000; val_acc: 0.314000\n",
+            "(Epoch 25 / 25) train acc: 0.998000; val_acc: 0.305000\n",
+            "\n",
+            "0.25\n",
+            "(Iteration 1 / 125) loss: 17.318478\n",
+            "(Epoch 0 / 25) train acc: 0.230000; val_acc: 0.177000\n",
+            "(Epoch 1 / 25) train acc: 0.378000; val_acc: 0.243000\n",
+            "(Epoch 2 / 25) train acc: 0.402000; val_acc: 0.254000\n",
+            "(Epoch 3 / 25) train acc: 0.502000; val_acc: 0.276000\n",
+            "(Epoch 4 / 25) train acc: 0.528000; val_acc: 0.298000\n",
+            "(Epoch 5 / 25) train acc: 0.562000; val_acc: 0.296000\n",
+            "(Epoch 6 / 25) train acc: 0.626000; val_acc: 0.291000\n",
+            "(Epoch 7 / 25) train acc: 0.622000; val_acc: 0.297000\n",
+            "(Epoch 8 / 25) train acc: 0.688000; val_acc: 0.313000\n",
+            "(Epoch 9 / 25) train acc: 0.712000; val_acc: 0.297000\n",
+            "(Epoch 10 / 25) train acc: 0.724000; val_acc: 0.306000\n",
+            "(Epoch 11 / 25) train acc: 0.768000; val_acc: 0.307000\n",
+            "(Epoch 12 / 25) train acc: 0.774000; val_acc: 0.284000\n",
+            "(Epoch 13 / 25) train acc: 0.828000; val_acc: 0.308000\n",
+            "(Epoch 14 / 25) train acc: 0.812000; val_acc: 0.346000\n",
+            "(Epoch 15 / 25) train acc: 0.850000; val_acc: 0.338000\n",
+            "(Epoch 16 / 25) train acc: 0.844000; val_acc: 0.307000\n",
+            "(Epoch 17 / 25) train acc: 0.858000; val_acc: 0.302000\n",
+            "(Epoch 18 / 25) train acc: 0.860000; val_acc: 0.318000\n",
+            "(Epoch 19 / 25) train acc: 0.884000; val_acc: 0.316000\n",
+            "(Epoch 20 / 25) train acc: 0.862000; val_acc: 0.315000\n",
+            "(Iteration 101 / 125) loss: 4.293572\n",
+            "(Epoch 21 / 25) train acc: 0.886000; val_acc: 0.330000\n",
+            "(Epoch 22 / 25) train acc: 0.898000; val_acc: 0.314000\n",
+            "(Epoch 23 / 25) train acc: 0.934000; val_acc: 0.323000\n",
+            "(Epoch 24 / 25) train acc: 0.918000; val_acc: 0.322000\n",
+            "(Epoch 25 / 25) train acc: 0.922000; val_acc: 0.324000\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "jiOUcPvxKpks",
+        "outputId": "a25b4e64-6f84-4f6c-819a-412aa6b98c3c",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 757
+        }
+      },
+      "source": [
+        "# Plot train and validation accuracies of the two models\n",
+        "\n",
+        "train_accs = []\n",
+        "val_accs = []\n",
+        "for dropout in dropout_choices:\n",
+        "  solver = solvers[dropout]\n",
+        "  train_accs.append(solver.train_acc_history[-1])\n",
+        "  val_accs.append(solver.val_acc_history[-1])\n",
+        "\n",
+        "plt.subplot(3, 1, 1)\n",
+        "for dropout in dropout_choices:\n",
+        "  plt.plot(solvers[dropout].train_acc_history, 'o', label='%.2f dropout' % dropout)\n",
+        "plt.title('Train accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.legend(ncol=2, loc='lower right')\n",
+        "\n",
+        "plt.subplot(3, 1, 2)\n",
+        "for dropout in dropout_choices:\n",
+        "  plt.plot(solvers[dropout].val_acc_history, 'o', label='%.2f dropout' % dropout)\n",
+        "plt.title('Val accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.legend(ncol=2, loc='lower right')\n",
+        "\n",
+        "plt.gcf().set_size_inches(15, 15)\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1500x1500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "7sH-SVFmKpkv"
+      },
+      "source": [
+        "## Inline Question 2:\n",
+        "Compare the validation and training accuracies with and without dropout -- what do your results suggest about dropout as a regularizer?\n",
+        "\n",
+        "## Answer:\n",
+        "위의 결과는 $p=0.25$인 드롭아웃을 적용하였을 때와 드롭아웃을 적용하지 않았을 때의 train accuracy, valid accuracy를 나타낸다.\n",
+        "\n",
+        "- train accuracy는 전체적으로 드롭아웃을 적용하였을 때가 더 낮았지만, epoch가 증가함에 따라 약 0.93까지 도달하였다.\n",
+        "- valid accuracy의 경우 드롭아웃을 적용하였을 때가 비교적 높았다.\n",
+        "\n",
+        "드롭아웃이 overfitting을 방지하는 데 도움을 주었음을 확인할 수 있다. 각 경우의 구체적인 accuracy 값들은 다음과 같다.\n",
+        "\n",
+        "- 드롭아웃을 적용하지 않았을 때의 train, valid accuracy는 각각 0.998, 0.305이다. (epoch 25)\n",
+        "- 드롭아웃을 적용하였을 때의 train, valid accuracy는 각각 0.922, 0.324이다. (epoch 25)\n",
+        "\n",
+        "따라서 드롭아웃은 overfitting을 방지하는 regularizer로 기능한다고 볼 수 있다."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "wdYffxs7Kpkv"
+      },
+      "source": [
+        "## Inline Question 3:\n",
+        "Suppose we are training a deep fully-connected network for image classification, with dropout after hidden layers (parameterized by keep probability p). If we are concerned about overfitting, how should we modify p (if at all) when we decide to decrease the size of the hidden layers (that is, the number of nodes in each layer)?\n",
+        "\n",
+        "## Answer:\n",
+        "신경망의 은닉층 크기를 줄여 overfitting을 방지하고자 한다면, 드롭아웃 층의 $p$ 값을 줄이는 것이 도움이 될 수 있다. $p$ 값을 감소시켜 뉴런이 비활성화되는 비율을 높일 경우, 각 층의 노드 수가 감소하므로 결과적으로 은닉층의 크기가 $p$에 비례하여 줄어들기 때문이다."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "uoRhfz77Q-QE"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git "a/\352\261\264\353\247\220\354\262\234\352\260\204_Q4_ConvolutionalNetworks.ipynb" "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q4_ConvolutionalNetworks.ipynb"
new file mode 100644
index 0000000..8cf32bc
--- /dev/null
+++ "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q4_ConvolutionalNetworks.ipynb"
@@ -0,0 +1,1304 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": [
+     "pdf-title"
+    ]
+   },
+   "source": [
+    "# Convolutional Networks\n",
+    "So far we have worked with deep fully-connected networks, using them to explore different optimization strategies and network architectures. Fully-connected networks are a good testbed for experimentation because they are very computationally efficient, but in practice all state-of-the-art results use convolutional networks instead.\n",
+    "\n",
+    "First you will implement several layer types that are used in convolutional networks. You will then use these layers to train a convolutional network on the CIFAR-10 dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\2277007\\Desktop\\assignment2\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd C:\\Users\\2277007\\Desktop\\assignment2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "tags": [
+     "pdf-ignore"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "# As usual, a bit of setup\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from cs231n.classifiers.cnn import *\n",
+    "from cs231n.data_utils import get_CIFAR10_data\n",
+    "from cs231n.gradient_check import eval_numerical_gradient_array, eval_numerical_gradient\n",
+    "from cs231n.layers import *\n",
+    "from cs231n.fast_layers import *\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": 3,
+   "metadata": {
+    "tags": [
+     "pdf-ignore"
+    ]
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X_train:  (49000, 3, 32, 32)\n",
+      "y_train:  (49000,)\n",
+      "X_val:  (1000, 3, 32, 32)\n",
+      "y_val:  (1000,)\n",
+      "X_test:  (1000, 3, 32, 32)\n",
+      "y_test:  (1000,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load the (preprocessed) CIFAR10 data.\n",
+    "\n",
+    "data = get_CIFAR10_data()\n",
+    "for k, v in data.items():\n",
+    "  print('%s: ' % k, v.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Convolution: Naive forward pass\n",
+    "The core of a convolutional network is the convolution operation. In the file `cs231n/layers.py`, implement the forward pass for the convolution layer in the function `conv_forward_naive`. \n",
+    "\n",
+    "You don't have to worry too much about efficiency at this point; just write the code in whatever way you find most clear.\n",
+    "\n",
+    "You can test your implementation by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing conv_forward_naive\n",
+      "difference:  2.2121476417505994e-08\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_shape = (2, 3, 4, 4)\n",
+    "w_shape = (3, 3, 4, 4)\n",
+    "x = np.linspace(-0.1, 0.5, num=np.prod(x_shape)).reshape(x_shape)\n",
+    "w = np.linspace(-0.2, 0.3, num=np.prod(w_shape)).reshape(w_shape)\n",
+    "b = np.linspace(-0.1, 0.2, num=3)\n",
+    "\n",
+    "conv_param = {'stride': 2, 'pad': 1}\n",
+    "out, _ = conv_forward_naive(x, w, b, conv_param)\n",
+    "correct_out = np.array([[[[-0.08759809, -0.10987781],\n",
+    "                           [-0.18387192, -0.2109216 ]],\n",
+    "                          [[ 0.21027089,  0.21661097],\n",
+    "                           [ 0.22847626,  0.23004637]],\n",
+    "                          [[ 0.50813986,  0.54309974],\n",
+    "                           [ 0.64082444,  0.67101435]]],\n",
+    "                         [[[-0.98053589, -1.03143541],\n",
+    "                           [-1.19128892, -1.24695841]],\n",
+    "                          [[ 0.69108355,  0.66880383],\n",
+    "                           [ 0.59480972,  0.56776003]],\n",
+    "                          [[ 2.36270298,  2.36904306],\n",
+    "                           [ 2.38090835,  2.38247847]]]])\n",
+    "\n",
+    "# Compare your output to ours; difference should be around e-8\n",
+    "print('Testing conv_forward_naive')\n",
+    "print('difference: ', rel_error(out, correct_out))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Aside: Image processing via convolutions\n",
+    "\n",
+    "As fun way to both check your implementation and gain a better understanding of the type of operation that convolutional layers can perform, we will set up an input containing two images and manually set up filters that perform common image processing operations (grayscale conversion and edge detection). The convolution forward pass will apply these operations to each of the input images. We can then visualize the results as a sanity check."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": [
+     "pdf-ignore-input"
+    ]
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\2277007\\AppData\\Local\\Temp\\ipykernel_9448\\2829536601.py:4: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n",
+      "  kitten = imread('notebook_images/kitten.jpg')\n",
+      "C:\\Users\\2277007\\AppData\\Local\\Temp\\ipykernel_9448\\2829536601.py:5: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n",
+      "  puppy = imread('notebook_images/puppy.jpg')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 6 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from imageio import imread\n",
+    "from PIL import Image\n",
+    "\n",
+    "kitten = imread('notebook_images/kitten.jpg')\n",
+    "puppy = imread('notebook_images/puppy.jpg')\n",
+    "# kitten is wide, and puppy is already square\n",
+    "d = kitten.shape[1] - kitten.shape[0]\n",
+    "kitten_cropped = kitten[:, d//2:-d//2, :]\n",
+    "\n",
+    "img_size = 200   # Make this smaller if it runs too slow\n",
+    "resized_puppy = np.array(Image.fromarray(puppy).resize((img_size, img_size)))\n",
+    "resized_kitten = np.array(Image.fromarray(kitten_cropped).resize((img_size, img_size)))\n",
+    "x = np.zeros((2, 3, img_size, img_size))\n",
+    "x[0, :, :, :] = resized_puppy.transpose((2, 0, 1))\n",
+    "x[1, :, :, :] = resized_kitten.transpose((2, 0, 1))\n",
+    "\n",
+    "# Set up a convolutional weights holding 2 filters, each 3x3\n",
+    "w = np.zeros((2, 3, 3, 3))\n",
+    "\n",
+    "# The first filter converts the image to grayscale.\n",
+    "# Set up the red, green, and blue channels of the filter.\n",
+    "w[0, 0, :, :] = [[0, 0, 0], [0, 0.3, 0], [0, 0, 0]]\n",
+    "w[0, 1, :, :] = [[0, 0, 0], [0, 0.6, 0], [0, 0, 0]]\n",
+    "w[0, 2, :, :] = [[0, 0, 0], [0, 0.1, 0], [0, 0, 0]]\n",
+    "\n",
+    "# Second filter detects horizontal edges in the blue channel.\n",
+    "w[1, 2, :, :] = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]\n",
+    "\n",
+    "# Vector of biases. We don't need any bias for the grayscale\n",
+    "# filter, but for the edge detection filter we want to add 128\n",
+    "# to each output so that nothing is negative.\n",
+    "b = np.array([0, 128])\n",
+    "\n",
+    "# Compute the result of convolving each input in x with each filter in w,\n",
+    "# offsetting by b, and storing the results in out.\n",
+    "out, _ = conv_forward_naive(x, w, b, {'stride': 1, 'pad': 1})\n",
+    "\n",
+    "def imshow_no_ax(img, normalize=True):\n",
+    "    \"\"\" Tiny helper to show images as uint8 and remove axis labels \"\"\"\n",
+    "    if normalize:\n",
+    "        img_max, img_min = np.max(img), np.min(img)\n",
+    "        img = 255.0 * (img - img_min) / (img_max - img_min)\n",
+    "    plt.imshow(img.astype('uint8'))\n",
+    "    plt.gca().axis('off')\n",
+    "\n",
+    "# Show the original images and the results of the conv operation\n",
+    "plt.subplot(2, 3, 1)\n",
+    "imshow_no_ax(puppy, normalize=False)\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(2, 3, 2)\n",
+    "imshow_no_ax(out[0, 0])\n",
+    "plt.title('Grayscale')\n",
+    "plt.subplot(2, 3, 3)\n",
+    "imshow_no_ax(out[0, 1])\n",
+    "plt.title('Edges')\n",
+    "plt.subplot(2, 3, 4)\n",
+    "imshow_no_ax(kitten_cropped, normalize=False)\n",
+    "plt.subplot(2, 3, 5)\n",
+    "imshow_no_ax(out[1, 0])\n",
+    "plt.subplot(2, 3, 6)\n",
+    "imshow_no_ax(out[1, 1])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Convolution: Naive backward pass\n",
+    "Implement the backward pass for the convolution operation in the function `conv_backward_naive` in the file `cs231n/layers.py`. Again, you don't need to worry too much about computational efficiency.\n",
+    "\n",
+    "When you are done, run the following to check your backward pass with a numeric gradient check."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing conv_backward_naive function\n",
+      "dx error:  5.332438838802517e-09\n",
+      "dw error:  2.678293773461729e-10\n",
+      "db error:  3.8835192329918934e-11\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "x = np.random.randn(4, 3, 5, 5)\n",
+    "w = np.random.randn(2, 3, 3, 3)\n",
+    "b = np.random.randn(2,)\n",
+    "dout = np.random.randn(4, 2, 5, 5)\n",
+    "conv_param = {'stride': 1, 'pad': 1}\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(lambda x: conv_forward_naive(x, w, b, conv_param)[0], x, dout)\n",
+    "dw_num = eval_numerical_gradient_array(lambda w: conv_forward_naive(x, w, b, conv_param)[0], w, dout)\n",
+    "db_num = eval_numerical_gradient_array(lambda b: conv_forward_naive(x, w, b, conv_param)[0], b, dout)\n",
+    "\n",
+    "out, cache = conv_forward_naive(x, w, b, conv_param)\n",
+    "dx, dw, db = conv_backward_naive(dout, cache)\n",
+    "\n",
+    "# Your errors should be around e-8 or less.\n",
+    "print('Testing conv_backward_naive function')\n",
+    "print('dx error: ', rel_error(dx, dx_num))\n",
+    "print('dw error: ', rel_error(dw, dw_num))\n",
+    "print('db error: ', rel_error(db, db_num))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Max-Pooling: Naive forward\n",
+    "Implement the forward pass for the max-pooling operation in the function `max_pool_forward_naive` in the file `cs231n/layers.py`. Again, don't worry too much about computational efficiency.\n",
+    "\n",
+    "Check your implementation by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing max_pool_forward_naive function:\n",
+      "difference:  4.1666665157267834e-08\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_shape = (2, 3, 4, 4)\n",
+    "x = np.linspace(-0.3, 0.4, num=np.prod(x_shape)).reshape(x_shape)\n",
+    "pool_param = {'pool_width': 2, 'pool_height': 2, 'stride': 2}\n",
+    "\n",
+    "out, _ = max_pool_forward_naive(x, pool_param)\n",
+    "\n",
+    "correct_out = np.array([[[[-0.26315789, -0.24842105],\n",
+    "                          [-0.20421053, -0.18947368]],\n",
+    "                         [[-0.14526316, -0.13052632],\n",
+    "                          [-0.08631579, -0.07157895]],\n",
+    "                         [[-0.02736842, -0.01263158],\n",
+    "                          [ 0.03157895,  0.04631579]]],\n",
+    "                        [[[ 0.09052632,  0.10526316],\n",
+    "                          [ 0.14947368,  0.16421053]],\n",
+    "                         [[ 0.20842105,  0.22315789],\n",
+    "                          [ 0.26736842,  0.28210526]],\n",
+    "                         [[ 0.32631579,  0.34105263],\n",
+    "                          [ 0.38526316,  0.4       ]]]])\n",
+    "\n",
+    "# Compare your output with ours. Difference should be on the order of e-8.\n",
+    "print('Testing max_pool_forward_naive function:')\n",
+    "print('difference: ', rel_error(out, correct_out))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Max-Pooling: Naive backward\n",
+    "Implement the backward pass for the max-pooling operation in the function `max_pool_backward_naive` in the file `cs231n/layers.py`. You don't need to worry about computational efficiency.\n",
+    "\n",
+    "Check your implementation with numeric gradient checking by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing max_pool_backward_naive function:\n",
+      "dx error:  3.27562514223145e-12\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "x = np.random.randn(3, 2, 8, 8)\n",
+    "dout = np.random.randn(3, 2, 4, 4)\n",
+    "pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(lambda x: max_pool_forward_naive(x, pool_param)[0], x, dout)\n",
+    "\n",
+    "out, cache = max_pool_forward_naive(x, pool_param)\n",
+    "dx = max_pool_backward_naive(dout, cache)\n",
+    "\n",
+    "# Your error should be on the order of e-12\n",
+    "print('Testing max_pool_backward_naive function:')\n",
+    "print('dx error: ', rel_error(dx, dx_num))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "%cd C:\\Users\\2277007\\Desktop\\assignment2\\cs231n\n",
+    "!python setup.py build_ext --inplace\n",
+    "%cd C:\\Users\\2277007\\Desktop\\assignment2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "%cd C:\\Users\\2277007\\Desktop\\cs231n-master-jabe\\cs231n-master\\assignment2\\cs231n\n",
+    "!python setup.py build_ext --inplace \n",
+    "%cd C:\\Users\\2277007\\Desktop\\cs231n-master-jabe\\cs231n-master\\assignment2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fast layers\n",
+    "Making convolution and pooling layers fast can be challenging. To spare you the pain, we've provided fast implementations of the forward and backward passes for convolution and pooling layers in the file `cs231n/fast_layers.py`.\n",
+    "\n",
+    "The fast convolution implementation depends on a Cython extension; to compile it you need to run the following from the `cs231n` directory:\n",
+    "\n",
+    "```bash\n",
+    "python setup.py build_ext --inplace\n",
+    "```\n",
+    "\n",
+    "The API for the fast versions of the convolution and pooling layers is exactly the same as the naive versions that you implemented above: the forward pass receives data, weights, and parameters and produces outputs and a cache object; the backward pass recieves upstream derivatives and the cache object and produces gradients with respect to the data and weights.\n",
+    "\n",
+    "**NOTE:** The fast implementation for pooling will only perform optimally if the pooling regions are non-overlapping and tile the input. If these conditions are not met then the fast pooling implementation will not be much faster than the naive implementation.\n",
+    "\n",
+    "You can compare the performance of the naive and fast versions of these layers by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing conv_forward_fast:\n",
+      "Naive: 0.004047s\n",
+      "Fast: 0.008284s\n",
+      "Speedup: 0.488516x\n",
+      "Difference:  0.0\n",
+      "\n",
+      "Testing conv_backward_fast:\n",
+      "Naive: 0.373406s\n",
+      "Fast: 0.009666s\n",
+      "Speedup: 38.631928x\n",
+      "dx difference:  1.949764775345631e-11\n",
+      "dw difference:  6.284191946907482e-13\n",
+      "db difference:  5.606046075994916e-15\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Rel errors should be around e-9 or less\n",
+    "from cs231n.fast_layers import conv_forward_fast, conv_backward_fast\n",
+    "from time import time\n",
+    "np.random.seed(231)\n",
+    "x = np.random.randn(100, 3, 31, 31)\n",
+    "w = np.random.randn(25, 3, 3, 3)\n",
+    "b = np.random.randn(25,)\n",
+    "dout = np.random.randn(100, 25, 16, 16)\n",
+    "conv_param = {'stride': 2, 'pad': 1}\n",
+    "\n",
+    "t0 = time()\n",
+    "out_naive, cache_naive = conv_forward_naive(x, w, b, conv_param)\n",
+    "t1 = time()\n",
+    "out_fast, cache_fast = conv_forward_fast(x, w, b, conv_param)\n",
+    "t2 = time()\n",
+    "\n",
+    "print('Testing conv_forward_fast:')\n",
+    "print('Naive: %fs' % (t1 - t0))\n",
+    "print('Fast: %fs' % (t2 - t1))\n",
+    "print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n",
+    "print('Difference: ', rel_error(out_naive, out_fast))\n",
+    "\n",
+    "t0 = time()\n",
+    "dx_naive, dw_naive, db_naive = conv_backward_naive(dout, cache_naive)\n",
+    "t1 = time()\n",
+    "dx_fast, dw_fast, db_fast = conv_backward_fast(dout, cache_fast)\n",
+    "t2 = time()\n",
+    "\n",
+    "print('\\nTesting conv_backward_fast:')\n",
+    "print('Naive: %fs' % (t1 - t0))\n",
+    "print('Fast: %fs' % (t2 - t1))\n",
+    "print('Speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n",
+    "print('dx difference: ', rel_error(dx_naive, dx_fast))\n",
+    "print('dw difference: ', rel_error(dw_naive, dw_fast))\n",
+    "print('db difference: ', rel_error(db_naive, db_fast))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing pool_forward_fast:\n",
+      "Naive: 0.003110s\n",
+      "fast: 0.005553s\n",
+      "speedup: 0.560069x\n",
+      "difference:  0.0\n",
+      "\n",
+      "Testing pool_backward_fast:\n",
+      "Naive: 0.021852s\n",
+      "fast: 0.011665s\n",
+      "speedup: 1.873319x\n",
+      "dx difference:  0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Relative errors should be close to 0.0\n",
+    "from cs231n.fast_layers import max_pool_forward_fast, max_pool_backward_fast\n",
+    "np.random.seed(231)\n",
+    "x = np.random.randn(100, 3, 32, 32)\n",
+    "dout = np.random.randn(100, 3, 16, 16)\n",
+    "pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n",
+    "\n",
+    "t0 = time()\n",
+    "out_naive, cache_naive = max_pool_forward_naive(x, pool_param)\n",
+    "t1 = time()\n",
+    "out_fast, cache_fast = max_pool_forward_fast(x, pool_param)\n",
+    "t2 = time()\n",
+    "\n",
+    "print('Testing pool_forward_fast:')\n",
+    "print('Naive: %fs' % (t1 - t0))\n",
+    "print('fast: %fs' % (t2 - t1))\n",
+    "print('speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n",
+    "print('difference: ', rel_error(out_naive, out_fast))\n",
+    "\n",
+    "t0 = time()\n",
+    "dx_naive = max_pool_backward_naive(dout, cache_naive)\n",
+    "t1 = time()\n",
+    "dx_fast = max_pool_backward_fast(dout, cache_fast)\n",
+    "t2 = time()\n",
+    "\n",
+    "print('\\nTesting pool_backward_fast:')\n",
+    "print('Naive: %fs' % (t1 - t0))\n",
+    "print('fast: %fs' % (t2 - t1))\n",
+    "print('speedup: %fx' % ((t1 - t0) / (t2 - t1)))\n",
+    "print('dx difference: ', rel_error(dx_naive, dx_fast))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Convolutional \"sandwich\" layers\n",
+    "Previously we introduced the concept of \"sandwich\" layers that combine multiple operations into commonly used patterns. In the file `cs231n/layer_utils.py` you will find sandwich layers that implement a few commonly used patterns for convolutional networks. Run the cells below to sanity check they're working."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing conv_relu_pool\n",
+      "dx error:  9.591132621921372e-09\n",
+      "dw error:  5.802455944849637e-09\n",
+      "db error:  3.57960501324485e-10\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cs231n.layer_utils import conv_relu_pool_forward, conv_relu_pool_backward\n",
+    "np.random.seed(231)\n",
+    "x = np.random.randn(2, 3, 16, 16)\n",
+    "w = np.random.randn(3, 3, 3, 3)\n",
+    "b = np.random.randn(3,)\n",
+    "dout = np.random.randn(2, 3, 8, 8)\n",
+    "conv_param = {'stride': 1, 'pad': 1}\n",
+    "pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n",
+    "\n",
+    "out, cache = conv_relu_pool_forward(x, w, b, conv_param, pool_param)\n",
+    "dx, dw, db = conv_relu_pool_backward(dout, cache)\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(lambda x: conv_relu_pool_forward(x, w, b, conv_param, pool_param)[0], x, dout)\n",
+    "dw_num = eval_numerical_gradient_array(lambda w: conv_relu_pool_forward(x, w, b, conv_param, pool_param)[0], w, dout)\n",
+    "db_num = eval_numerical_gradient_array(lambda b: conv_relu_pool_forward(x, w, b, conv_param, pool_param)[0], b, dout)\n",
+    "\n",
+    "# Relative errors should be around e-8 or less\n",
+    "print('Testing conv_relu_pool')\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": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing conv_relu:\n",
+      "dx error:  1.5218619980349303e-09\n",
+      "dw error:  3.3715893156038223e-10\n",
+      "db error:  4.8422803898140394e-11\n"
+     ]
+    }
+   ],
+   "source": [
+    "from cs231n.layer_utils import conv_relu_forward, conv_relu_backward\n",
+    "np.random.seed(231)\n",
+    "x = np.random.randn(2, 3, 8, 8)\n",
+    "w = np.random.randn(3, 3, 3, 3)\n",
+    "b = np.random.randn(3,)\n",
+    "dout = np.random.randn(2, 3, 8, 8)\n",
+    "conv_param = {'stride': 1, 'pad': 1}\n",
+    "\n",
+    "out, cache = conv_relu_forward(x, w, b, conv_param)\n",
+    "dx, dw, db = conv_relu_backward(dout, cache)\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(lambda x: conv_relu_forward(x, w, b, conv_param)[0], x, dout)\n",
+    "dw_num = eval_numerical_gradient_array(lambda w: conv_relu_forward(x, w, b, conv_param)[0], w, dout)\n",
+    "db_num = eval_numerical_gradient_array(lambda b: conv_relu_forward(x, w, b, conv_param)[0], b, dout)\n",
+    "\n",
+    "# Relative errors should be around e-8 or less\n",
+    "print('Testing conv_relu:')\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": [
+    "# Three-layer ConvNet\n",
+    "Now that you have implemented all the necessary layers, we can put them together into a simple convolutional network.\n",
+    "\n",
+    "Open the file `cs231n/classifiers/cnn.py` and complete the implementation of the `ThreeLayerConvNet` class. Remember you can use the fast/sandwich layers (already imported for you) in your implementation. Run the following cells to help you debug:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sanity check loss\n",
+    "After you build a new network, one of the first things you should do is sanity check the loss. When we use the softmax loss, we expect the loss for random weights (and no regularization) to be about `log(C)` for `C` classes. When we add regularization the loss should go up slightly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial loss (no regularization):  2.302586071243987\n",
+      "Initial loss (with regularization):  2.508255638232932\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = ThreeLayerConvNet()\n",
+    "\n",
+    "N = 50\n",
+    "X = np.random.randn(N, 3, 32, 32)\n",
+    "y = np.random.randint(10, size=N)\n",
+    "\n",
+    "loss, grads = model.loss(X, y)\n",
+    "print('Initial loss (no regularization): ', loss)\n",
+    "\n",
+    "model.reg = 0.5\n",
+    "loss, grads = model.loss(X, y)\n",
+    "print('Initial loss (with regularization): ', loss)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Gradient check\n",
+    "After the loss looks reasonable, use numeric gradient checking to make sure that your backward pass is correct. When you use numeric gradient checking you should use a small amount of artifical data and a small number of neurons at each layer. Note: correct implementations may still have relative errors up to the order of e-2."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "W1 max relative error: 3.053965e-04\n",
+      "W2 max relative error: 1.822723e-02\n",
+      "W3 max relative error: 3.422399e-04\n",
+      "b1 max relative error: 3.397321e-06\n",
+      "b2 max relative error: 2.517459e-03\n",
+      "b3 max relative error: 9.711800e-10\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_inputs = 2\n",
+    "input_dim = (3, 16, 16)\n",
+    "reg = 0.0\n",
+    "num_classes = 10\n",
+    "np.random.seed(231)\n",
+    "X = np.random.randn(num_inputs, *input_dim)\n",
+    "y = np.random.randint(num_classes, size=num_inputs)\n",
+    "\n",
+    "model = ThreeLayerConvNet(num_filters=3, filter_size=3,\n",
+    "                          input_dim=input_dim, hidden_dim=7,\n",
+    "                          dtype=np.float64)\n",
+    "loss, grads = model.loss(X, y)\n",
+    "# Errors should be small, but correct implementations may have\n",
+    "# relative errors up to the order of e-2\n",
+    "for param_name in sorted(grads):\n",
+    "    f = lambda _: model.loss(X, y)[0]\n",
+    "    param_grad_num = eval_numerical_gradient(f, model.params[param_name], verbose=False, h=1e-6)\n",
+    "    e = rel_error(param_grad_num, grads[param_name])\n",
+    "    print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overfit small data\n",
+    "A nice trick is to train your model with just a few training samples. You should be able to overfit small datasets, which will result in very high training accuracy and comparatively low validation accuracy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Iteration 1 / 30) loss: 2.414060\n",
+      "(Epoch 0 / 15) train acc: 0.200000; val_acc: 0.137000\n",
+      "(Iteration 2 / 30) loss: 3.102925\n",
+      "(Epoch 1 / 15) train acc: 0.140000; val_acc: 0.087000\n",
+      "(Iteration 3 / 30) loss: 2.270330\n",
+      "(Iteration 4 / 30) loss: 2.096705\n",
+      "(Epoch 2 / 15) train acc: 0.240000; val_acc: 0.094000\n",
+      "(Iteration 5 / 30) loss: 1.838880\n",
+      "(Iteration 6 / 30) loss: 1.934188\n",
+      "(Epoch 3 / 15) train acc: 0.510000; val_acc: 0.173000\n",
+      "(Iteration 7 / 30) loss: 1.827912\n",
+      "(Iteration 8 / 30) loss: 1.639574\n",
+      "(Epoch 4 / 15) train acc: 0.520000; val_acc: 0.188000\n",
+      "(Iteration 9 / 30) loss: 1.330082\n",
+      "(Iteration 10 / 30) loss: 1.756115\n",
+      "(Epoch 5 / 15) train acc: 0.630000; val_acc: 0.167000\n",
+      "(Iteration 11 / 30) loss: 1.024162\n",
+      "(Iteration 12 / 30) loss: 1.041826\n",
+      "(Epoch 6 / 15) train acc: 0.750000; val_acc: 0.229000\n",
+      "(Iteration 13 / 30) loss: 1.142777\n",
+      "(Iteration 14 / 30) loss: 0.835706\n",
+      "(Epoch 7 / 15) train acc: 0.790000; val_acc: 0.247000\n",
+      "(Iteration 15 / 30) loss: 0.587786\n",
+      "(Iteration 16 / 30) loss: 0.645509\n",
+      "(Epoch 8 / 15) train acc: 0.820000; val_acc: 0.252000\n",
+      "(Iteration 17 / 30) loss: 0.786844\n",
+      "(Iteration 18 / 30) loss: 0.467054\n",
+      "(Epoch 9 / 15) train acc: 0.820000; val_acc: 0.178000\n",
+      "(Iteration 19 / 30) loss: 0.429880\n",
+      "(Iteration 20 / 30) loss: 0.635498\n",
+      "(Epoch 10 / 15) train acc: 0.900000; val_acc: 0.206000\n",
+      "(Iteration 21 / 30) loss: 0.365807\n",
+      "(Iteration 22 / 30) loss: 0.284220\n",
+      "(Epoch 11 / 15) train acc: 0.820000; val_acc: 0.201000\n",
+      "(Iteration 23 / 30) loss: 0.469343\n",
+      "(Iteration 24 / 30) loss: 0.509369\n",
+      "(Epoch 12 / 15) train acc: 0.920000; val_acc: 0.211000\n",
+      "(Iteration 25 / 30) loss: 0.111638\n",
+      "(Iteration 26 / 30) loss: 0.145388\n",
+      "(Epoch 13 / 15) train acc: 0.930000; val_acc: 0.213000\n",
+      "(Iteration 27 / 30) loss: 0.155575\n",
+      "(Iteration 28 / 30) loss: 0.143398\n",
+      "(Epoch 14 / 15) train acc: 0.960000; val_acc: 0.212000\n",
+      "(Iteration 29 / 30) loss: 0.158160\n",
+      "(Iteration 30 / 30) loss: 0.118934\n",
+      "(Epoch 15 / 15) train acc: 0.990000; val_acc: 0.220000\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "\n",
+    "num_train = 100\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",
+    "model = ThreeLayerConvNet(weight_scale=1e-2)\n",
+    "\n",
+    "solver = Solver(model, small_data,\n",
+    "                num_epochs=15, batch_size=50,\n",
+    "                update_rule='adam',\n",
+    "                optim_config={\n",
+    "                  'learning_rate': 1e-3,\n",
+    "                },\n",
+    "                verbose=True, print_every=1)\n",
+    "solver.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plotting the loss, training accuracy, and validation accuracy should show clear overfitting:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.subplot(2, 1, 1)\n",
+    "plt.plot(solver.loss_history, 'o')\n",
+    "plt.xlabel('iteration')\n",
+    "plt.ylabel('loss')\n",
+    "\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(solver.train_acc_history, '-o')\n",
+    "plt.plot(solver.val_acc_history, '-o')\n",
+    "plt.legend(['train', 'val'], loc='upper left')\n",
+    "plt.xlabel('epoch')\n",
+    "plt.ylabel('accuracy')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train the net\n",
+    "By training the three-layer convolutional network for one epoch, you should achieve greater than 40% accuracy on the training set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(Iteration 1 / 980) loss: 2.304740\n",
+      "(Epoch 0 / 1) train acc: 0.103000; val_acc: 0.107000\n",
+      "(Iteration 21 / 980) loss: 2.098229\n",
+      "(Iteration 41 / 980) loss: 1.949788\n",
+      "(Iteration 61 / 980) loss: 1.888398\n",
+      "(Iteration 81 / 980) loss: 1.877093\n",
+      "(Iteration 101 / 980) loss: 1.851877\n",
+      "(Iteration 121 / 980) loss: 1.859353\n",
+      "(Iteration 141 / 980) loss: 1.800181\n",
+      "(Iteration 161 / 980) loss: 2.143292\n",
+      "(Iteration 181 / 980) loss: 1.830573\n",
+      "(Iteration 201 / 980) loss: 2.037280\n",
+      "(Iteration 221 / 980) loss: 2.020304\n",
+      "(Iteration 241 / 980) loss: 1.823728\n",
+      "(Iteration 261 / 980) loss: 1.692679\n",
+      "(Iteration 281 / 980) loss: 1.882594\n",
+      "(Iteration 301 / 980) loss: 1.798261\n",
+      "(Iteration 321 / 980) loss: 1.851960\n",
+      "(Iteration 341 / 980) loss: 1.716323\n",
+      "(Iteration 361 / 980) loss: 1.897655\n",
+      "(Iteration 381 / 980) loss: 1.319744\n",
+      "(Iteration 401 / 980) loss: 1.738790\n",
+      "(Iteration 421 / 980) loss: 1.488866\n",
+      "(Iteration 441 / 980) loss: 1.718409\n",
+      "(Iteration 461 / 980) loss: 1.744440\n",
+      "(Iteration 481 / 980) loss: 1.605460\n",
+      "(Iteration 501 / 980) loss: 1.494847\n",
+      "(Iteration 521 / 980) loss: 1.835179\n",
+      "(Iteration 541 / 980) loss: 1.483923\n",
+      "(Iteration 561 / 980) loss: 1.676871\n",
+      "(Iteration 581 / 980) loss: 1.438325\n",
+      "(Iteration 601 / 980) loss: 1.443469\n",
+      "(Iteration 621 / 980) loss: 1.529369\n",
+      "(Iteration 641 / 980) loss: 1.763475\n",
+      "(Iteration 661 / 980) loss: 1.790329\n",
+      "(Iteration 681 / 980) loss: 1.693343\n",
+      "(Iteration 701 / 980) loss: 1.637078\n",
+      "(Iteration 721 / 980) loss: 1.644564\n",
+      "(Iteration 741 / 980) loss: 1.708919\n",
+      "(Iteration 761 / 980) loss: 1.494252\n",
+      "(Iteration 781 / 980) loss: 1.901751\n",
+      "(Iteration 801 / 980) loss: 1.898991\n",
+      "(Iteration 821 / 980) loss: 1.489988\n",
+      "(Iteration 841 / 980) loss: 1.377615\n",
+      "(Iteration 861 / 980) loss: 1.763751\n",
+      "(Iteration 881 / 980) loss: 1.540284\n",
+      "(Iteration 901 / 980) loss: 1.525582\n",
+      "(Iteration 921 / 980) loss: 1.674166\n",
+      "(Iteration 941 / 980) loss: 1.714316\n",
+      "(Iteration 961 / 980) loss: 1.534668\n",
+      "(Epoch 1 / 1) train acc: 0.504000; val_acc: 0.499000\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = ThreeLayerConvNet(weight_scale=0.001, hidden_dim=500, reg=0.001)\n",
+    "\n",
+    "solver = Solver(model, data,\n",
+    "                num_epochs=1, batch_size=50,\n",
+    "                update_rule='adam',\n",
+    "                optim_config={\n",
+    "                  'learning_rate': 1e-3,\n",
+    "                },\n",
+    "                verbose=True, print_every=20)\n",
+    "solver.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize Filters\n",
+    "You can visualize the first-layer convolutional filters from the trained network by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from cs231n.vis_utils import visualize_grid\n",
+    "\n",
+    "grid = visualize_grid(model.params['W1'].transpose(0, 2, 3, 1))\n",
+    "plt.imshow(grid.astype('uint8'))\n",
+    "plt.axis('off')\n",
+    "plt.gcf().set_size_inches(5, 5)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Spatial Batch Normalization\n",
+    "We already saw that batch normalization is a very useful technique for training deep fully-connected networks. As proposed in the original paper (link in `BatchNormalization.ipynb`), batch normalization can also be used for convolutional networks, but we need to tweak it a bit; the modification will be called \"spatial batch normalization.\"\n",
+    "\n",
+    "Normally batch-normalization accepts inputs of shape `(N, D)` and produces outputs of shape `(N, D)`, where we normalize across the minibatch dimension `N`. For data coming from convolutional layers, batch normalization needs to accept inputs of shape `(N, C, H, W)` and produce outputs of shape `(N, C, H, W)` where the `N` dimension gives the minibatch size and the `(H, W)` dimensions give the spatial size of the feature map.\n",
+    "\n",
+    "If the feature map was produced using convolutions, then we expect every feature channel's statistics e.g. mean, variance to be relatively consistent both between different images, and different locations within the same image -- after all, every feature channel is produced by the same convolutional filter! Therefore spatial batch normalization computes a mean and variance for each of the `C` feature channels by computing statistics over the minibatch dimension `N` as well the spatial dimensions `H` and `W`.\n",
+    "\n",
+    "\n",
+    "[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
+    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Spatial batch normalization: forward\n",
+    "\n",
+    "In the file `cs231n/layers.py`, implement the forward pass for spatial batch normalization in the function `spatial_batchnorm_forward`. Check your implementation by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before spatial batch normalization:\n",
+      "  Shape:  (2, 3, 4, 5)\n",
+      "  Means:  [9.33463814 8.90909116 9.11056338]\n",
+      "  Stds:  [3.61447857 3.19347686 3.5168142 ]\n",
+      "After spatial batch normalization:\n",
+      "  Shape:  (2, 3, 4, 5)\n",
+      "  Means:  [ 6.18949336e-16  5.99520433e-16 -1.22124533e-16]\n",
+      "  Stds:  [0.99999962 0.99999951 0.9999996 ]\n",
+      "After spatial batch normalization (nontrivial gamma, beta):\n",
+      "  Shape:  (2, 3, 4, 5)\n",
+      "  Means:  [6. 7. 8.]\n",
+      "  Stds:  [2.99999885 3.99999804 4.99999798]\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "# Check the training-time forward pass by checking means and variances\n",
+    "# of features both before and after spatial batch normalization\n",
+    "\n",
+    "N, C, H, W = 2, 3, 4, 5\n",
+    "x = 4 * np.random.randn(N, C, H, W) + 10\n",
+    "\n",
+    "print('Before spatial batch normalization:')\n",
+    "print('  Shape: ', x.shape)\n",
+    "print('  Means: ', x.mean(axis=(0, 2, 3)))\n",
+    "print('  Stds: ', x.std(axis=(0, 2, 3)))\n",
+    "\n",
+    "# Means should be close to zero and stds close to one\n",
+    "gamma, beta = np.ones(C), np.zeros(C)\n",
+    "bn_param = {'mode': 'train'}\n",
+    "out, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\n",
+    "print('After spatial batch normalization:')\n",
+    "print('  Shape: ', out.shape)\n",
+    "print('  Means: ', out.mean(axis=(0, 2, 3)))\n",
+    "print('  Stds: ', out.std(axis=(0, 2, 3)))\n",
+    "\n",
+    "# Means should be close to beta and stds close to gamma\n",
+    "gamma, beta = np.asarray([3, 4, 5]), np.asarray([6, 7, 8])\n",
+    "out, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\n",
+    "print('After spatial batch normalization (nontrivial gamma, beta):')\n",
+    "print('  Shape: ', out.shape)\n",
+    "print('  Means: ', out.mean(axis=(0, 2, 3)))\n",
+    "print('  Stds: ', out.std(axis=(0, 2, 3)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After spatial batch normalization (test-time):\n",
+      "  means:  [-0.08034406  0.07562881  0.05716371  0.04378383]\n",
+      "  stds:  [0.96718744 1.0299714  1.02887624 1.00585577]\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "# Check the test-time forward pass by running the training-time\n",
+    "# forward pass many times to warm up the running averages, and then\n",
+    "# checking the means and variances of activations after a test-time\n",
+    "# forward pass.\n",
+    "N, C, H, W = 10, 4, 11, 12\n",
+    "\n",
+    "bn_param = {'mode': 'train'}\n",
+    "gamma = np.ones(C)\n",
+    "beta = np.zeros(C)\n",
+    "for t in range(50):\n",
+    "  x = 2.3 * np.random.randn(N, C, H, W) + 13\n",
+    "  spatial_batchnorm_forward(x, gamma, beta, bn_param)\n",
+    "bn_param['mode'] = 'test'\n",
+    "x = 2.3 * np.random.randn(N, C, H, W) + 13\n",
+    "a_norm, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\n",
+    "\n",
+    "# Means should be close to zero and stds close to one, but will be\n",
+    "# noisier than training-time forward passes.\n",
+    "print('After spatial batch normalization (test-time):')\n",
+    "print('  means: ', a_norm.mean(axis=(0, 2, 3)))\n",
+    "print('  stds: ', a_norm.std(axis=(0, 2, 3)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Spatial batch normalization: backward\n",
+    "In the file `cs231n/layers.py`, implement the backward pass for spatial batch normalization in the function `spatial_batchnorm_backward`. Run the following to check your implementation using a numeric gradient check:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dx error:  2.786648193872555e-07\n",
+      "dgamma error:  7.0974817113608705e-12\n",
+      "dbeta error:  3.275608725278405e-12\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "N, C, H, W = 2, 3, 4, 5\n",
+    "x = 5 * np.random.randn(N, C, H, W) + 12\n",
+    "gamma = np.random.randn(C)\n",
+    "beta = np.random.randn(C)\n",
+    "dout = np.random.randn(N, C, H, W)\n",
+    "\n",
+    "bn_param = {'mode': 'train'}\n",
+    "fx = lambda x: spatial_batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
+    "fg = lambda a: spatial_batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
+    "fb = lambda b: spatial_batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
+    "da_num = eval_numerical_gradient_array(fg, gamma, dout)\n",
+    "db_num = eval_numerical_gradient_array(fb, beta, dout)\n",
+    "\n",
+    "#You should expect errors of magnitudes between 1e-12~1e-06\n",
+    "_, cache = spatial_batchnorm_forward(x, gamma, beta, bn_param)\n",
+    "dx, dgamma, dbeta = spatial_batchnorm_backward(dout, cache)\n",
+    "print('dx error: ', rel_error(dx_num, dx))\n",
+    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
+    "print('dbeta error: ', rel_error(db_num, dbeta))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Group Normalization\n",
+    "In the previous notebook, we mentioned that Layer Normalization is an alternative normalization technique that mitigates the batch size limitations of Batch Normalization. However, as the authors of [2] observed, Layer Normalization does not perform as well as Batch Normalization when used with Convolutional Layers:\n",
+    "\n",
+    ">With fully connected layers, all the hidden units in a layer tend to make similar contributions to the final prediction, and re-centering and rescaling the summed inputs to a layer works well. However, the assumption of similar contributions is no longer true for convolutional neural networks. The large number of the hidden units whose\n",
+    "receptive fields lie near the boundary of the image are rarely turned on and thus have very different\n",
+    "statistics from the rest of the hidden units within the same layer.\n",
+    "\n",
+    "The authors of [3] propose an intermediary technique. In contrast to Layer Normalization, where you normalize over the entire feature per-datapoint, they suggest a consistent splitting of each per-datapoint feature into G groups, and a per-group per-datapoint normalization instead. \n",
+    "\n",
+    "![Comparison of normalization techniques discussed so far](notebook_images/normalization.png)\n",
+    "<center>**Visual comparison of the normalization techniques discussed so far (image edited from [3])**</center>\n",
+    "\n",
+    "Even though an assumption of equal contribution is still being made within each group, the authors hypothesize that this is not as problematic, as innate grouping arises within features for visual recognition. One example they use to illustrate this is that many high-performance handcrafted features in traditional Computer Vision have terms that are explicitly grouped together. Take for example Histogram of Oriented Gradients [4]-- after computing histograms per spatially local block, each per-block histogram is normalized before being concatenated together to form the final feature vector.\n",
+    "\n",
+    "You will now implement Group Normalization. Note that this normalization technique that you are to implement in the following cells was introduced and published to ECCV just in 2018 -- this truly is still an ongoing and excitingly active field of research!\n",
+    "\n",
+    "[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)\n",
+    "\n",
+    "\n",
+    "[3] [Wu, Yuxin, and Kaiming He. \"Group Normalization.\" arXiv preprint arXiv:1803.08494 (2018).](https://arxiv.org/abs/1803.08494)\n",
+    "\n",
+    "\n",
+    "[4] [N. Dalal and B. Triggs. Histograms of oriented gradients for\n",
+    "human detection. In Computer Vision and Pattern Recognition\n",
+    "(CVPR), 2005.](https://ieeexplore.ieee.org/abstract/document/1467360/)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Group normalization: forward\n",
+    "\n",
+    "In the file `cs231n/layers.py`, implement the forward pass for group normalization in the function `spatial_groupnorm_forward`. Check your implementation by running the following:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before spatial group normalization:\n",
+      "  Shape:  (2, 6, 4, 5)\n",
+      "  Means:  [9.72505327 8.51114185 8.9147544  9.43448077]\n",
+      "  Stds:  [3.67070958 3.09892597 4.27043622 3.97521327]\n",
+      "After spatial group normalization:\n",
+      "  Shape:  (2, 6, 4, 5)\n",
+      "  Means:  [-2.14643118e-16  5.25505565e-16  2.65528340e-16 -3.38618023e-16]\n",
+      "  Stds:  [0.99999963 0.99999948 0.99999973 0.99999968]\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "# Check the training-time forward pass by checking means and variances\n",
+    "# of features both before and after spatial batch normalization\n",
+    "\n",
+    "N, C, H, W = 2, 6, 4, 5\n",
+    "G = 2\n",
+    "x = 4 * np.random.randn(N, C, H, W) + 10\n",
+    "x_g = x.reshape((N*G,-1))\n",
+    "print('Before spatial group normalization:')\n",
+    "print('  Shape: ', x.shape)\n",
+    "print('  Means: ', x_g.mean(axis=1))\n",
+    "print('  Stds: ', x_g.std(axis=1))\n",
+    "\n",
+    "# Means should be close to zero and stds close to one\n",
+    "gamma, beta = np.ones((1,C,1,1)), np.zeros((1,C,1,1))\n",
+    "bn_param = {'mode': 'train'}\n",
+    "\n",
+    "out, _ = spatial_groupnorm_forward(x, gamma, beta, G, bn_param)\n",
+    "out_g = out.reshape((N*G,-1))\n",
+    "print('After spatial group normalization:')\n",
+    "print('  Shape: ', out.shape)\n",
+    "print('  Means: ', out_g.mean(axis=1))\n",
+    "print('  Stds: ', out_g.std(axis=1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Spatial group normalization: backward\n",
+    "In the file `cs231n/layers.py`, implement the backward pass for spatial batch normalization in the function `spatial_groupnorm_backward`. Run the following to check your implementation using a numeric gradient check:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dx error:  7.413109437563619e-08\n",
+      "dgamma error:  9.468195772749234e-12\n",
+      "dbeta error:  3.354494437653335e-12\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(231)\n",
+    "N, C, H, W = 2, 6, 4, 5\n",
+    "G = 2\n",
+    "x = 5 * np.random.randn(N, C, H, W) + 12\n",
+    "gamma = np.random.randn(1,C,1,1)\n",
+    "beta = np.random.randn(1,C,1,1)\n",
+    "dout = np.random.randn(N, C, H, W)\n",
+    "\n",
+    "gn_param = {}\n",
+    "fx = lambda x: spatial_groupnorm_forward(x, gamma, beta, G, gn_param)[0]\n",
+    "fg = lambda a: spatial_groupnorm_forward(x, gamma, beta, G, gn_param)[0]\n",
+    "fb = lambda b: spatial_groupnorm_forward(x, gamma, beta, G, gn_param)[0]\n",
+    "\n",
+    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
+    "da_num = eval_numerical_gradient_array(fg, gamma, dout)\n",
+    "db_num = eval_numerical_gradient_array(fb, beta, dout)\n",
+    "\n",
+    "_, cache = spatial_groupnorm_forward(x, gamma, beta, G, gn_param)\n",
+    "dx, dgamma, dbeta = spatial_groupnorm_backward(dout, cache)\n",
+    "#You should expect errors of magnitudes between 1e-12~1e-07\n",
+    "print('dx error: ', rel_error(dx_num, dx))\n",
+    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
+    "print('dbeta error: ', rel_error(db_num, dbeta))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git "a/\352\261\264\353\247\220\354\262\234\352\260\204_Q5_PyTorch.ipynb" "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q5_PyTorch.ipynb"
new file mode 100644
index 0000000..e5ff705
--- /dev/null
+++ "b/\352\261\264\353\247\220\354\262\234\352\260\204_Q5_PyTorch.ipynb"
@@ -0,0 +1,1809 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KtukLD6hUyN1",
+        "outputId": "50919433-76f5-4baf-bd6e-10aae9c792c1"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n",
+            "/content/drive/My Drive/euron_cs231n\n"
+          ]
+        }
+      ],
+      "source": [
+        "# This mounts your Google Drive to the Colab VM.\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "# Enter the foldername in your Drive where you have saved the unzipped\n",
+        "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
+        "FOLDERNAME = \"euron_cs231n\"\n",
+        "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
+        "\n",
+        "# Now that we've mounted your Drive, this ensures that\n",
+        "# the Python interpreter of the Colab VM can load\n",
+        "# python files from within it.\n",
+        "import sys\n",
+        "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
+        "\n",
+        "# This downloads the CIFAR-10 dataset to your Drive\n",
+        "# if it doesn't already exist.\n",
+        "#%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
+        "#!bash get_datasets.sh\n",
+        "%cd /content/drive/My\\ Drive/$FOLDERNAME"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-title"
+        ],
+        "id": "BE6MuJ2oUyN4"
+      },
+      "source": [
+        "# Introduction to PyTorch\n",
+        "\n",
+        "You've written a lot of code in this assignment to provide a whole host of neural network functionality. Dropout, Batch Norm, and 2D convolutions are some of the workhorses of deep learning in computer vision. You've also worked hard to make your code efficient and vectorized.\n",
+        "\n",
+        "For the last part of this assignment, though, we're going to leave behind your beautiful codebase and instead migrate to one of two popular deep learning frameworks: in this instance, PyTorch."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "3OaFf-aSUyN5"
+      },
+      "source": [
+        "## Why do we use deep learning frameworks?\n",
+        "\n",
+        "* Our code will now run on GPUs! This will allow our models to train much faster. When using a framework like PyTorch you can harness the power of the GPU for your own custom neural network architectures without having to write CUDA code directly (which is beyond the scope of this class).\n",
+        "* In this class, we want you to be ready to use one of these frameworks for your project so you can experiment more efficiently than if you were writing every feature you want to use by hand.\n",
+        "* We want you to stand on the shoulders of giants! PyTorch is an excellent frameworks that will make your lives a lot easier, and now that you understand their guts, you are free to use them :)\n",
+        "* Finally, we want you to be exposed to the sort of deep learning code you might run into in academia or industry.\n",
+        "\n",
+        "## What is PyTorch?\n",
+        "\n",
+        "PyTorch is a system for executing dynamic computational graphs over Tensor objects that behave similarly as numpy ndarray. It comes with a powerful automatic differentiation engine that removes the need for manual back-propagation.\n",
+        "\n",
+        "## How do I learn PyTorch?\n",
+        "\n",
+        "One of our former instructors, Justin Johnson, made an excellent [tutorial](https://github.com/jcjohnson/pytorch-examples) for PyTorch.\n",
+        "\n",
+        "You can also find the detailed [API doc](http://pytorch.org/docs/stable/index.html) here. If you have other questions that are not addressed by the API docs, the [PyTorch forum](https://discuss.pytorch.org/) is a much better place to ask than StackOverflow."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MVM_F3e6UyN6"
+      },
+      "source": [
+        "# Table of Contents\n",
+        "\n",
+        "This assignment has 5 parts. You will learn PyTorch on **three different levels of abstraction**, which will help you understand it better and prepare you for the final project.\n",
+        "\n",
+        "1. Part I, Preparation: we will use CIFAR-10 dataset.\n",
+        "2. Part II, Barebones PyTorch: **Abstraction level 1**, we will work directly with the lowest-level PyTorch Tensors.\n",
+        "3. Part III, PyTorch Module API: **Abstraction level 2**, we will use `nn.Module` to define arbitrary neural network architecture.\n",
+        "4. Part IV, PyTorch Sequential API: **Abstraction level 3**, we will use `nn.Sequential` to define a linear feed-forward network very conveniently.\n",
+        "5. Part V, CIFAR-10 open-ended challenge: please implement your own network to get as high accuracy as possible on CIFAR-10. You can experiment with any layer, optimizer, hyperparameters or other advanced features.\n",
+        "\n",
+        "Here is a table of comparison:\n",
+        "\n",
+        "| API           | Flexibility | Convenience |\n",
+        "|---------------|-------------|-------------|\n",
+        "| Barebone      | High        | Low         |\n",
+        "| `nn.Module`     | High        | Medium      |\n",
+        "| `nn.Sequential` | Low         | High        |"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "LxopyWIEUyN7"
+      },
+      "source": [
+        "# GPU\n",
+        "\n",
+        "You can manually switch to a GPU device on Colab by clicking `Runtime -> Change runtime type` and selecting `GPU` under `Hardware Accelerator`. You should do this before running the following cells to import packages, since the kernel gets restarted upon switching runtimes."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eIXZDL0mUyN8",
+        "outputId": "796ad7fa-d47c-41e5-b31e-92c4a3312949"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "using device: cpu\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torch.utils.data import DataLoader\n",
+        "from torch.utils.data import sampler\n",
+        "\n",
+        "import torchvision.datasets as dset\n",
+        "import torchvision.transforms as T\n",
+        "\n",
+        "import numpy as np\n",
+        "\n",
+        "USE_GPU = True\n",
+        "dtype = torch.float32 # We will be using float throughout this tutorial.\n",
+        "\n",
+        "if USE_GPU and torch.cuda.is_available():\n",
+        "    device = torch.device('cuda')\n",
+        "else:\n",
+        "    device = torch.device('cpu')\n",
+        "\n",
+        "# Constant to control how frequently we print train loss.\n",
+        "print_every = 100\n",
+        "print('using device:', device)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DL4vC4b5UyN9"
+      },
+      "source": [
+        "# Part I. Preparation\n",
+        "\n",
+        "Now, let's load the CIFAR-10 dataset. This might take a couple minutes the first time you do it, but the files should stay cached after that.\n",
+        "\n",
+        "In previous parts of the assignment we had to write our own code to download the CIFAR-10 dataset, preprocess it, and iterate through it in minibatches; PyTorch provides convenient tools to automate this process for us."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "h8gJ_G3kUyN9",
+        "outputId": "6143ce9d-4b27-4c3f-bd95-c6f2c55fe1a1"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Files already downloaded and verified\n",
+            "Files already downloaded and verified\n",
+            "Files already downloaded and verified\n"
+          ]
+        }
+      ],
+      "source": [
+        "NUM_TRAIN = 49000\n",
+        "\n",
+        "# The torchvision.transforms package provides tools for preprocessing data\n",
+        "# and for performing data augmentation; here we set up a transform to\n",
+        "# preprocess the data by subtracting the mean RGB value and dividing by the\n",
+        "# standard deviation of each RGB value; we've hardcoded the mean and std.\n",
+        "transform = T.Compose([\n",
+        "                T.ToTensor(),\n",
+        "                T.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
+        "            ])\n",
+        "\n",
+        "# We set up a Dataset object for each split (train / val / test); Datasets load\n",
+        "# training examples one at a time, so we wrap each Dataset in a DataLoader which\n",
+        "# iterates through the Dataset and forms minibatches. We divide the CIFAR-10\n",
+        "# training set into train and val sets by passing a Sampler object to the\n",
+        "# DataLoader telling how it should sample from the underlying Dataset.\n",
+        "cifar10_train = dset.CIFAR10('./cs231n/datasets', train=True, download=True,\n",
+        "                             transform=transform)\n",
+        "loader_train = DataLoader(cifar10_train, batch_size=64,\n",
+        "                          sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN)))\n",
+        "\n",
+        "cifar10_val = dset.CIFAR10('./cs231n/datasets', train=True, download=True,\n",
+        "                           transform=transform)\n",
+        "loader_val = DataLoader(cifar10_val, batch_size=64,\n",
+        "                        sampler=sampler.SubsetRandomSampler(range(NUM_TRAIN, 50000)))\n",
+        "\n",
+        "cifar10_test = dset.CIFAR10('./cs231n/datasets', train=False, download=True,\n",
+        "                            transform=transform)\n",
+        "loader_test = DataLoader(cifar10_test, batch_size=64)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Zg0DMc80UyN-"
+      },
+      "source": [
+        "# Part II. Barebones PyTorch\n",
+        "\n",
+        "PyTorch ships with high-level APIs to help us define model architectures conveniently, which we will cover in Part II of this tutorial. In this section, we will start with the barebone PyTorch elements to understand the autograd engine better. After this exercise, you will come to appreciate the high-level model API more.\n",
+        "\n",
+        "We will start with a simple fully-connected ReLU network with two hidden layers and no biases for CIFAR classification.\n",
+        "This implementation computes the forward pass using operations on PyTorch Tensors, and uses PyTorch autograd to compute gradients. It is important that you understand every line, because you will write a harder version after the example.\n",
+        "\n",
+        "When we create a PyTorch Tensor with `requires_grad=True`, then operations involving that Tensor will not just compute values; they will also build up a computational graph in the background, allowing us to easily backpropagate through the graph to compute gradients of some Tensors with respect to a downstream loss. Concretely if x is a Tensor with `x.requires_grad == True` then after backpropagation `x.grad` will be another Tensor holding the gradient of x with respect to the scalar loss at the end."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "dqcyLkMCUyN-"
+      },
+      "source": [
+        "### PyTorch Tensors: Flatten Function\n",
+        "A PyTorch Tensor is conceptionally similar to a numpy array: it is an n-dimensional grid of numbers, and like numpy PyTorch provides many functions to efficiently operate on Tensors. As a simple example, we provide a `flatten` function below which reshapes image data for use in a fully-connected neural network.\n",
+        "\n",
+        "Recall that image data is typically stored in a Tensor of shape N x C x H x W, where:\n",
+        "\n",
+        "* N is the number of datapoints\n",
+        "* C is the number of channels\n",
+        "* H is the height of the intermediate feature map in pixels\n",
+        "* W is the height of the intermediate feature map in pixels\n",
+        "\n",
+        "This is the right way to represent the data when we are doing something like a 2D convolution, that needs spatial understanding of where the intermediate features are relative to each other. When we use fully connected affine layers to process the image, however, we want each datapoint to be represented by a single vector -- it's no longer useful to segregate the different channels, rows, and columns of the data. So, we use a \"flatten\" operation to collapse the `C x H x W` values per representation into a single long vector. The flatten function below first reads in the N, C, H, and W values from a given batch of data, and then returns a \"view\" of that data. \"View\" is analogous to numpy's \"reshape\" method: it reshapes x's dimensions to be N x ??, where ?? is allowed to be anything (in this case, it will be C x H x W, but we don't need to specify that explicitly)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wexwtAMmUyN_",
+        "outputId": "5849cc6f-766a-4457-8562-96b51b7fb673"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Before flattening:  tensor([[[[ 0,  1],\n",
+            "          [ 2,  3],\n",
+            "          [ 4,  5]]],\n",
+            "\n",
+            "\n",
+            "        [[[ 6,  7],\n",
+            "          [ 8,  9],\n",
+            "          [10, 11]]]])\n",
+            "After flattening:  tensor([[ 0,  1,  2,  3,  4,  5],\n",
+            "        [ 6,  7,  8,  9, 10, 11]])\n"
+          ]
+        }
+      ],
+      "source": [
+        "def flatten(x):\n",
+        "    N = x.shape[0] # read in N, C, H, W\n",
+        "    return x.view(N, -1)  # \"flatten\" the C * H * W values into a single vector per image\n",
+        "\n",
+        "def test_flatten():\n",
+        "    x = torch.arange(12).view(2, 1, 3, 2)\n",
+        "    print('Before flattening: ', x)\n",
+        "    print('After flattening: ', flatten(x))\n",
+        "\n",
+        "test_flatten()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-ignore"
+        ],
+        "id": "uO-w1QQ2UyN_"
+      },
+      "source": [
+        "### Barebones PyTorch: Two-Layer Network\n",
+        "\n",
+        "Here we define a function `two_layer_fc` which performs the forward pass of a two-layer fully-connected ReLU network on a batch of image data. After defining the forward pass we check that it doesn't crash and that it produces outputs of the right shape by running zeros through the network.\n",
+        "\n",
+        "You don't have to write any code here, but it's important that you read and understand the implementation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gDU0jE0iUyN_",
+        "outputId": "2630ca67-ce34-4550-d303-eff0d6d96644"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([64, 10])\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch.nn.functional as F  # useful stateless functions\n",
+        "\n",
+        "def two_layer_fc(x, params):\n",
+        "    \"\"\"\n",
+        "    A fully-connected neural networks; the architecture is:\n",
+        "    NN is fully connected -> ReLU -> fully connected layer.\n",
+        "    Note that this function only defines the forward pass;\n",
+        "    PyTorch will take care of the backward pass for us.\n",
+        "\n",
+        "    The input to the network will be a minibatch of data, of shape\n",
+        "    (N, d1, ..., dM) where d1 * ... * dM = D. The hidden layer will have H units,\n",
+        "    and the output layer will produce scores for C classes.\n",
+        "\n",
+        "    Inputs:\n",
+        "    - x: A PyTorch Tensor of shape (N, d1, ..., dM) giving a minibatch of\n",
+        "      input data.\n",
+        "    - params: A list [w1, w2] of PyTorch Tensors giving weights for the network;\n",
+        "      w1 has shape (D, H) and w2 has shape (H, C).\n",
+        "\n",
+        "    Returns:\n",
+        "    - scores: A PyTorch Tensor of shape (N, C) giving classification scores for\n",
+        "      the input data x.\n",
+        "    \"\"\"\n",
+        "    # first we flatten the image\n",
+        "    x = flatten(x)  # shape: [batch_size, C x H x W]\n",
+        "\n",
+        "    w1, w2 = params\n",
+        "\n",
+        "    # Forward pass: compute predicted y using operations on Tensors. Since w1 and\n",
+        "    # w2 have requires_grad=True, operations involving these Tensors will cause\n",
+        "    # PyTorch to build a computational graph, allowing automatic computation of\n",
+        "    # gradients. Since we are no longer implementing the backward pass by hand we\n",
+        "    # don't need to keep references to intermediate values.\n",
+        "    # you can also use `.clamp(min=0)`, equivalent to F.relu()\n",
+        "    x = F.relu(x.mm(w1))\n",
+        "    x = x.mm(w2)\n",
+        "    return x\n",
+        "\n",
+        "\n",
+        "def two_layer_fc_test():\n",
+        "    hidden_layer_size = 42\n",
+        "    x = torch.zeros((64, 50), dtype=dtype)  # minibatch size 64, feature dimension 50\n",
+        "    w1 = torch.zeros((50, hidden_layer_size), dtype=dtype)\n",
+        "    w2 = torch.zeros((hidden_layer_size, 10), dtype=dtype)\n",
+        "    scores = two_layer_fc(x, [w1, w2])\n",
+        "    print(scores.size())  # you should see [64, 10]\n",
+        "\n",
+        "two_layer_fc_test()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_Gbp1mR7UyOA"
+      },
+      "source": [
+        "### Barebones PyTorch: Three-Layer ConvNet\n",
+        "\n",
+        "Here you will complete the implementation of the function `three_layer_convnet`, which will perform the forward pass of a three-layer convolutional network. Like above, we can immediately test our implementation by passing zeros through the network. The network should have the following architecture:\n",
+        "\n",
+        "1. A convolutional layer (with bias) with `channel_1` filters, each with shape `KW1 x KH1`, and zero-padding of two\n",
+        "2. ReLU nonlinearity\n",
+        "3. A convolutional layer (with bias) with `channel_2` filters, each with shape `KW2 x KH2`, and zero-padding of one\n",
+        "4. ReLU nonlinearity\n",
+        "5. Fully-connected layer with bias, producing scores for C classes.\n",
+        "\n",
+        "Note that we have **no softmax activation** here after our fully-connected layer: this is because PyTorch's cross entropy loss performs a softmax activation for you, and by bundling that step in makes computation more efficient.\n",
+        "\n",
+        "**HINT**: For convolutions: http://pytorch.org/docs/stable/nn.html#torch.nn.functional.conv2d; pay attention to the shapes of convolutional filters!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "OwNP4NleUyOA"
+      },
+      "outputs": [],
+      "source": [
+        "def three_layer_convnet(x, params):\n",
+        "    \"\"\"\n",
+        "    Performs the forward pass of a three-layer convolutional network with the\n",
+        "    architecture defined above.\n",
+        "\n",
+        "    Inputs:\n",
+        "    - x: A PyTorch Tensor of shape (N, 3, H, W) giving a minibatch of images\n",
+        "    - params: A list of PyTorch Tensors giving the weights and biases for the\n",
+        "      network; should contain the following:\n",
+        "      - conv_w1: PyTorch Tensor of shape (channel_1, 3, KH1, KW1) giving weights\n",
+        "        for the first convolutional layer\n",
+        "      - conv_b1: PyTorch Tensor of shape (channel_1,) giving biases for the first\n",
+        "        convolutional layer\n",
+        "      - conv_w2: PyTorch Tensor of shape (channel_2, channel_1, KH2, KW2) giving\n",
+        "        weights for the second convolutional layer\n",
+        "      - conv_b2: PyTorch Tensor of shape (channel_2,) giving biases for the second\n",
+        "        convolutional layer\n",
+        "      - fc_w: PyTorch Tensor giving weights for the fully-connected layer. Can you\n",
+        "        figure out what the shape should be?\n",
+        "      - fc_b: PyTorch Tensor giving biases for the fully-connected layer. Can you\n",
+        "        figure out what the shape should be?\n",
+        "\n",
+        "    Returns:\n",
+        "    - scores: PyTorch Tensor of shape (N, C) giving classification scores for x\n",
+        "    \"\"\"\n",
+        "    conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b = params\n",
+        "    scores = None\n",
+        "    ################################################################################\n",
+        "    # TODO: Implement the forward pass for the three-layer ConvNet.                #\n",
+        "    ################################################################################\n",
+        "    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "    conv1 = F.conv2d(x, weight=conv_w1, bias=conv_b1, padding=2)\n",
+        "    relu1 = F.relu(conv1)\n",
+        "    conv2 = F.conv2d(relu1, weight=conv_w2, bias=conv_b2, padding=1)\n",
+        "    relu2 = F.relu(conv2)\n",
+        "    relu2_flat = flatten(relu2)\n",
+        "    scores = relu2_flat.mm(fc_w) + fc_b\n",
+        "\n",
+        "    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "    ################################################################################\n",
+        "    #                                 END OF YOUR CODE                             #\n",
+        "    ################################################################################\n",
+        "    return scores"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jgzyYemtUyOB"
+      },
+      "source": [
+        "After defining the forward pass of the ConvNet above, run the following cell to test your implementation.\n",
+        "\n",
+        "When you run this function, scores should have shape (64, 10)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "test": "barebones_output_shape",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Goe1XLttUyOB",
+        "outputId": "2fb93952-2b79-47e5-8aaf-eb9d44c47e01"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([64, 10])\n"
+          ]
+        }
+      ],
+      "source": [
+        "def three_layer_convnet_test():\n",
+        "    x = torch.zeros((64, 3, 32, 32), dtype=dtype)  # minibatch size 64, image size [3, 32, 32]\n",
+        "\n",
+        "    conv_w1 = torch.zeros((6, 3, 5, 5), dtype=dtype)  # [out_channel, in_channel, kernel_H, kernel_W]\n",
+        "    conv_b1 = torch.zeros((6,))  # out_channel\n",
+        "    conv_w2 = torch.zeros((9, 6, 3, 3), dtype=dtype)  # [out_channel, in_channel, kernel_H, kernel_W]\n",
+        "    conv_b2 = torch.zeros((9,))  # out_channel\n",
+        "\n",
+        "    # you must calculate the shape of the tensor after two conv layers, before the fully-connected layer\n",
+        "    fc_w = torch.zeros((9 * 32 * 32, 10))\n",
+        "    fc_b = torch.zeros(10)\n",
+        "\n",
+        "    scores = three_layer_convnet(x, [conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b])\n",
+        "    print(scores.size())  # you should see [64, 10]\n",
+        "three_layer_convnet_test()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Tu5m0VJsUyOB"
+      },
+      "source": [
+        "### Barebones PyTorch: Initialization\n",
+        "Let's write a couple utility methods to initialize the weight matrices for our models.\n",
+        "\n",
+        "- `random_weight(shape)` initializes a weight tensor with the Kaiming normalization method.\n",
+        "- `zero_weight(shape)` initializes a weight tensor with all zeros. Useful for instantiating bias parameters.\n",
+        "\n",
+        "The `random_weight` function uses the Kaiming normal initialization method, described in:\n",
+        "\n",
+        "He et al, *Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification*, ICCV 2015, https://arxiv.org/abs/1502.01852"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eaFeJ2zkUyOB",
+        "outputId": "6e2ba8cc-65ec-4df5-85ba-22ce464f86b1"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "tensor([[ 0.2756,  0.6988,  0.7051, -1.0388, -0.6274],\n",
+              "        [ 0.5087,  1.6098, -0.6274,  0.1564, -0.5640],\n",
+              "        [-0.5564,  0.1941, -0.3109,  1.0692,  1.2826]], requires_grad=True)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 8
+        }
+      ],
+      "source": [
+        "def random_weight(shape):\n",
+        "    \"\"\"\n",
+        "    Create random Tensors for weights; setting requires_grad=True means that we\n",
+        "    want to compute gradients for these Tensors during the backward pass.\n",
+        "    We use Kaiming normalization: sqrt(2 / fan_in)\n",
+        "    \"\"\"\n",
+        "    if len(shape) == 2:  # FC weight\n",
+        "        fan_in = shape[0]\n",
+        "    else:\n",
+        "        fan_in = np.prod(shape[1:]) # conv weight [out_channel, in_channel, kH, kW]\n",
+        "    # randn is standard normal distribution generator.\n",
+        "    w = torch.randn(shape, device=device, dtype=dtype) * np.sqrt(2. / fan_in)\n",
+        "    w.requires_grad = True\n",
+        "    return w\n",
+        "\n",
+        "def zero_weight(shape):\n",
+        "    return torch.zeros(shape, device=device, dtype=dtype, requires_grad=True)\n",
+        "\n",
+        "# create a weight of shape [3 x 5]\n",
+        "# you should see the type `torch.cuda.FloatTensor` if you use GPU.\n",
+        "# Otherwise it should be `torch.FloatTensor`\n",
+        "random_weight((3, 5))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nqzxxcnjUyOC"
+      },
+      "source": [
+        "### Barebones PyTorch: Check Accuracy\n",
+        "When training the model we will use the following function to check the accuracy of our model on the training or validation sets.\n",
+        "\n",
+        "When checking accuracy we don't need to compute any gradients; as a result we don't need PyTorch to build a computational graph for us when we compute scores. To prevent a graph from being built we scope our computation under a `torch.no_grad()` context manager."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "dMcKcF2rUyOC"
+      },
+      "outputs": [],
+      "source": [
+        "def check_accuracy_part2(loader, model_fn, params):\n",
+        "    \"\"\"\n",
+        "    Check the accuracy of a classification model.\n",
+        "\n",
+        "    Inputs:\n",
+        "    - loader: A DataLoader for the data split we want to check\n",
+        "    - model_fn: A function that performs the forward pass of the model,\n",
+        "      with the signature scores = model_fn(x, params)\n",
+        "    - params: List of PyTorch Tensors giving parameters of the model\n",
+        "\n",
+        "    Returns: Nothing, but prints the accuracy of the model\n",
+        "    \"\"\"\n",
+        "    split = 'val' if loader.dataset.train else 'test'\n",
+        "    print('Checking accuracy on the %s set' % split)\n",
+        "    num_correct, num_samples = 0, 0\n",
+        "    with torch.no_grad():\n",
+        "        for x, y in loader:\n",
+        "            x = x.to(device=device, dtype=dtype)  # move to device, e.g. GPU\n",
+        "            y = y.to(device=device, dtype=torch.int64)\n",
+        "            scores = model_fn(x, params)\n",
+        "            _, preds = scores.max(1)\n",
+        "            num_correct += (preds == y).sum()\n",
+        "            num_samples += preds.size(0)\n",
+        "        acc = float(num_correct) / num_samples\n",
+        "        print('Got %d / %d correct (%.2f%%)' % (num_correct, num_samples, 100 * acc))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BfASB7kUUyOC"
+      },
+      "source": [
+        "### BareBones PyTorch: Training Loop\n",
+        "We can now set up a basic training loop to train our network. We will train the model using stochastic gradient descent without momentum. We will use `torch.functional.cross_entropy` to compute the loss; you can [read about it here](http://pytorch.org/docs/stable/nn.html#cross-entropy).\n",
+        "\n",
+        "The training loop takes as input the neural network function, a list of initialized parameters (`[w1, w2]` in our example), and learning rate."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "tags": [
+          "pdf-ignore-input"
+        ],
+        "id": "N_z54s43UyOD"
+      },
+      "outputs": [],
+      "source": [
+        "def train_part2(model_fn, params, learning_rate):\n",
+        "    \"\"\"\n",
+        "    Train a model on CIFAR-10.\n",
+        "\n",
+        "    Inputs:\n",
+        "    - model_fn: A Python function that performs the forward pass of the model.\n",
+        "      It should have the signature scores = model_fn(x, params) where x is a\n",
+        "      PyTorch Tensor of image data, params is a list of PyTorch Tensors giving\n",
+        "      model weights, and scores is a PyTorch Tensor of shape (N, C) giving\n",
+        "      scores for the elements in x.\n",
+        "    - params: List of PyTorch Tensors giving weights for the model\n",
+        "    - learning_rate: Python scalar giving the learning rate to use for SGD\n",
+        "\n",
+        "    Returns: Nothing\n",
+        "    \"\"\"\n",
+        "    for t, (x, y) in enumerate(loader_train):\n",
+        "        # Move the data to the proper device (GPU or CPU)\n",
+        "        x = x.to(device=device, dtype=dtype)\n",
+        "        y = y.to(device=device, dtype=torch.long)\n",
+        "\n",
+        "        # Forward pass: compute scores and loss\n",
+        "        scores = model_fn(x, params)\n",
+        "        loss = F.cross_entropy(scores, y)\n",
+        "\n",
+        "        # Backward pass: PyTorch figures out which Tensors in the computational\n",
+        "        # graph has requires_grad=True and uses backpropagation to compute the\n",
+        "        # gradient of the loss with respect to these Tensors, and stores the\n",
+        "        # gradients in the .grad attribute of each Tensor.\n",
+        "        loss.backward()\n",
+        "\n",
+        "        # Update parameters. We don't want to backpropagate through the\n",
+        "        # parameter updates, so we scope the updates under a torch.no_grad()\n",
+        "        # context manager to prevent a computational graph from being built.\n",
+        "        with torch.no_grad():\n",
+        "            for w in params:\n",
+        "                w -= learning_rate * w.grad\n",
+        "\n",
+        "                # Manually zero the gradients after running the backward pass\n",
+        "                w.grad.zero_()\n",
+        "\n",
+        "        if t % print_every == 0:\n",
+        "            print('Iteration %d, loss = %.4f' % (t, loss.item()))\n",
+        "            check_accuracy_part2(loader_val, model_fn, params)\n",
+        "            print()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "thb69nw_UyOD"
+      },
+      "source": [
+        "### BareBones PyTorch: Train a Two-Layer Network\n",
+        "Now we are ready to run the training loop. We need to explicitly allocate tensors for the fully connected weights, `w1` and `w2`.\n",
+        "\n",
+        "Each minibatch of CIFAR has 64 examples, so the tensor shape is `[64, 3, 32, 32]`.\n",
+        "\n",
+        "After flattening, `x` shape should be `[64, 3 * 32 * 32]`. This will be the size of the first dimension of `w1`.\n",
+        "The second dimension of `w1` is the hidden layer size, which will also be the first dimension of `w2`.\n",
+        "\n",
+        "Finally, the output of the network is a 10-dimensional vector that represents the probability distribution over 10 classes.\n",
+        "\n",
+        "You don't need to tune any hyperparameters but you should see accuracies above 40% after training for one epoch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "vUHZGfkyUyOD",
+        "outputId": "54403c3c-e3db-49ac-966e-0c9b5e424f0b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 3.5433\n",
+            "Checking accuracy on the val set\n",
+            "Got 161 / 1000 correct (16.10%)\n",
+            "\n",
+            "Iteration 100, loss = 1.9514\n",
+            "Checking accuracy on the val set\n",
+            "Got 341 / 1000 correct (34.10%)\n",
+            "\n",
+            "Iteration 200, loss = 2.0469\n",
+            "Checking accuracy on the val set\n",
+            "Got 306 / 1000 correct (30.60%)\n",
+            "\n",
+            "Iteration 300, loss = 1.7676\n",
+            "Checking accuracy on the val set\n",
+            "Got 413 / 1000 correct (41.30%)\n",
+            "\n",
+            "Iteration 400, loss = 1.7364\n",
+            "Checking accuracy on the val set\n",
+            "Got 409 / 1000 correct (40.90%)\n",
+            "\n",
+            "Iteration 500, loss = 1.6219\n",
+            "Checking accuracy on the val set\n",
+            "Got 429 / 1000 correct (42.90%)\n",
+            "\n",
+            "Iteration 600, loss = 2.0924\n",
+            "Checking accuracy on the val set\n",
+            "Got 415 / 1000 correct (41.50%)\n",
+            "\n",
+            "Iteration 700, loss = 1.9333\n",
+            "Checking accuracy on the val set\n",
+            "Got 411 / 1000 correct (41.10%)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "hidden_layer_size = 4000\n",
+        "learning_rate = 1e-2\n",
+        "\n",
+        "w1 = random_weight((3 * 32 * 32, hidden_layer_size))\n",
+        "w2 = random_weight((hidden_layer_size, 10))\n",
+        "\n",
+        "train_part2(two_layer_fc, [w1, w2], learning_rate)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "K7zRNB0BUyOD"
+      },
+      "source": [
+        "### BareBones PyTorch: Training a ConvNet\n",
+        "\n",
+        "In the below you should use the functions defined above to train a three-layer convolutional network on CIFAR. The network should have the following architecture:\n",
+        "\n",
+        "1. Convolutional layer (with bias) with 32 5x5 filters, with zero-padding of 2\n",
+        "2. ReLU\n",
+        "3. Convolutional layer (with bias) with 16 3x3 filters, with zero-padding of 1\n",
+        "4. ReLU\n",
+        "5. Fully-connected layer (with bias) to compute scores for 10 classes\n",
+        "\n",
+        "You should initialize your weight matrices using the `random_weight` function defined above, and you should initialize your bias vectors using the `zero_weight` function above.\n",
+        "\n",
+        "You don't need to tune any hyperparameters, but if everything works correctly you should achieve an accuracy above 42% after one epoch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "test": "barebones_accuracy",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ELUIv164UyOD",
+        "outputId": "8d3ac589-8ed1-412e-8c0e-6e19c26279d6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 2.8413\n",
+            "Checking accuracy on the val set\n",
+            "Got 108 / 1000 correct (10.80%)\n",
+            "\n",
+            "Iteration 100, loss = 1.8054\n",
+            "Checking accuracy on the val set\n",
+            "Got 367 / 1000 correct (36.70%)\n",
+            "\n",
+            "Iteration 200, loss = 1.7080\n",
+            "Checking accuracy on the val set\n",
+            "Got 416 / 1000 correct (41.60%)\n",
+            "\n",
+            "Iteration 300, loss = 1.4180\n",
+            "Checking accuracy on the val set\n",
+            "Got 416 / 1000 correct (41.60%)\n",
+            "\n",
+            "Iteration 400, loss = 1.6381\n",
+            "Checking accuracy on the val set\n",
+            "Got 461 / 1000 correct (46.10%)\n",
+            "\n",
+            "Iteration 500, loss = 1.5293\n",
+            "Checking accuracy on the val set\n",
+            "Got 458 / 1000 correct (45.80%)\n",
+            "\n",
+            "Iteration 600, loss = 1.4177\n",
+            "Checking accuracy on the val set\n",
+            "Got 473 / 1000 correct (47.30%)\n",
+            "\n",
+            "Iteration 700, loss = 1.4980\n",
+            "Checking accuracy on the val set\n",
+            "Got 489 / 1000 correct (48.90%)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "learning_rate = 3e-3\n",
+        "\n",
+        "channel_1 = 32\n",
+        "channel_2 = 16\n",
+        "\n",
+        "conv_w1 = None\n",
+        "conv_b1 = None\n",
+        "conv_w2 = None\n",
+        "conv_b2 = None\n",
+        "fc_w = None\n",
+        "fc_b = None\n",
+        "\n",
+        "################################################################################\n",
+        "# TODO: Initialize the parameters of a three-layer ConvNet.                    #\n",
+        "################################################################################\n",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "conv_w1 = random_weight((channel_1, 3, 5, 5))\n",
+        "conv_b1 = zero_weight((channel_1,))\n",
+        "conv_w2 = random_weight((channel_2, 32, 3, 3))\n",
+        "conv_b2 = zero_weight((channel_2,))\n",
+        "fc_w = random_weight((channel_2*32*32, 10))\n",
+        "fc_b = zero_weight((10,))\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "################################################################################\n",
+        "#                                 END OF YOUR CODE                             #\n",
+        "################################################################################\n",
+        "\n",
+        "params = [conv_w1, conv_b1, conv_w2, conv_b2, fc_w, fc_b]\n",
+        "train_part2(three_layer_convnet, params, learning_rate)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1QyKTSf6UyOD"
+      },
+      "source": [
+        "# Part III. PyTorch Module API\n",
+        "\n",
+        "Barebone PyTorch requires that we track all the parameter tensors by hand. This is fine for small networks with a few tensors, but it would be extremely inconvenient and error-prone to track tens or hundreds of tensors in larger networks.\n",
+        "\n",
+        "PyTorch provides the `nn.Module` API for you to define arbitrary network architectures, while tracking every learnable parameters for you. In Part II, we implemented SGD ourselves. PyTorch also provides the `torch.optim` package that implements all the common optimizers, such as RMSProp, Adagrad, and Adam. It even supports approximate second-order methods like L-BFGS! You can refer to the [doc](http://pytorch.org/docs/master/optim.html) for the exact specifications of each optimizer.\n",
+        "\n",
+        "To use the Module API, follow the steps below:\n",
+        "\n",
+        "1. Subclass `nn.Module`. Give your network class an intuitive name like `TwoLayerFC`.\n",
+        "\n",
+        "2. In the constructor `__init__()`, define all the layers you need as class attributes. Layer objects like `nn.Linear` and `nn.Conv2d` are themselves `nn.Module` subclasses and contain learnable parameters, so that you don't have to instantiate the raw tensors yourself. `nn.Module` will track these internal parameters for you. Refer to the [doc](http://pytorch.org/docs/master/nn.html) to learn more about the dozens of builtin layers. **Warning**: don't forget to call the `super().__init__()` first!\n",
+        "\n",
+        "3. In the `forward()` method, define the *connectivity* of your network. You should use the attributes defined in `__init__` as function calls that take tensor as input and output the \"transformed\" tensor. Do *not* create any new layers with learnable parameters in `forward()`! All of them must be declared upfront in `__init__`.\n",
+        "\n",
+        "After you define your Module subclass, you can instantiate it as an object and call it just like the NN forward function in part II.\n",
+        "\n",
+        "### Module API: Two-Layer Network\n",
+        "Here is a concrete example of a 2-layer fully connected network:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9AO25FPdUyOE",
+        "outputId": "fb79a0d0-0ae3-4232-ae52-6c6ece5d696e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([64, 10])\n"
+          ]
+        }
+      ],
+      "source": [
+        "class TwoLayerFC(nn.Module):\n",
+        "    def __init__(self, input_size, hidden_size, num_classes):\n",
+        "        super().__init__()\n",
+        "        # assign layer objects to class attributes\n",
+        "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
+        "        # nn.init package contains convenient initialization methods\n",
+        "        # http://pytorch.org/docs/master/nn.html#torch-nn-init\n",
+        "        nn.init.kaiming_normal_(self.fc1.weight)\n",
+        "        self.fc2 = nn.Linear(hidden_size, num_classes)\n",
+        "        nn.init.kaiming_normal_(self.fc2.weight)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # forward always defines connectivity\n",
+        "        x = flatten(x)\n",
+        "        scores = self.fc2(F.relu(self.fc1(x)))\n",
+        "        return scores\n",
+        "\n",
+        "def test_TwoLayerFC():\n",
+        "    input_size = 50\n",
+        "    x = torch.zeros((64, input_size), dtype=dtype)  # minibatch size 64, feature dimension 50\n",
+        "    model = TwoLayerFC(input_size, 42, 10)\n",
+        "    scores = model(x)\n",
+        "    print(scores.size())  # you should see [64, 10]\n",
+        "test_TwoLayerFC()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UD5xHzPpUyOE"
+      },
+      "source": [
+        "### Module API: Three-Layer ConvNet\n",
+        "It's your turn to implement a 3-layer ConvNet followed by a fully connected layer. The network architecture should be the same as in Part II:\n",
+        "\n",
+        "1. Convolutional layer with `channel_1` 5x5 filters with zero-padding of 2\n",
+        "2. ReLU\n",
+        "3. Convolutional layer with `channel_2` 3x3 filters with zero-padding of 1\n",
+        "4. ReLU\n",
+        "5. Fully-connected layer to `num_classes` classes\n",
+        "\n",
+        "You should initialize the weight matrices of the model using the Kaiming normal initialization method.\n",
+        "\n",
+        "**HINT**: http://pytorch.org/docs/stable/nn.html#conv2d\n",
+        "\n",
+        "After you implement the three-layer ConvNet, the `test_ThreeLayerConvNet` function will run your implementation; it should print `(64, 10)` for the shape of the output scores."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "test": "module_output_shape",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XcHcf9oQUyOE",
+        "outputId": "38bfa47a-4350-4260-b4e1-e472dc10ac3b"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([64, 10])\n"
+          ]
+        }
+      ],
+      "source": [
+        "class ThreeLayerConvNet(nn.Module):\n",
+        "    def __init__(self, in_channel, channel_1, channel_2, num_classes):\n",
+        "        super().__init__()\n",
+        "        ########################################################################\n",
+        "        # TODO: Set up the layers you need for a three-layer ConvNet with the  #\n",
+        "        # architecture defined above.                                          #\n",
+        "        ########################################################################\n",
+        "        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "        self.conv1 = nn.Conv2d(in_channel, channel_1, kernel_size=5, padding=2, bias=True)\n",
+        "        nn.init.kaiming_normal_(self.conv1.weight)\n",
+        "        nn.init.constant_(self.conv1.bias, 0)\n",
+        "\n",
+        "        self.conv2 = nn.Conv2d(channel_1, channel_2, kernel_size=3, padding=1, bias=True)\n",
+        "        nn.init.kaiming_normal_(self.conv2.weight)\n",
+        "        nn.init.constant_(self.conv2.bias, 0)\n",
+        "\n",
+        "        self.fc = nn.Linear(channel_2*32*32, num_classes)\n",
+        "        nn.init.kaiming_normal_(self.fc.weight)\n",
+        "        nn.init.constant_(self.fc.bias, 0)\n",
+        "\n",
+        "        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "        ########################################################################\n",
+        "        #                          END OF YOUR CODE                            #\n",
+        "        ########################################################################\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        scores = None\n",
+        "        ########################################################################\n",
+        "        # TODO: Implement the forward function for a 3-layer ConvNet. you      #\n",
+        "        # should use the layers you defined in __init__ and specify the        #\n",
+        "        # connectivity of those layers in forward()                            #\n",
+        "        ########################################################################\n",
+        "        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "        relu1 = F.relu(self.conv1(x))\n",
+        "        relu2 = F.relu(self.conv2(relu1))\n",
+        "        scores = self.fc(flatten(relu2))\n",
+        "\n",
+        "        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "        ########################################################################\n",
+        "        #                             END OF YOUR CODE                         #\n",
+        "        ########################################################################\n",
+        "        return scores\n",
+        "\n",
+        "\n",
+        "def test_ThreeLayerConvNet():\n",
+        "    x = torch.zeros((64, 3, 32, 32), dtype=dtype)  # minibatch size 64, image size [3, 32, 32]\n",
+        "    model = ThreeLayerConvNet(in_channel=3, channel_1=12, channel_2=8, num_classes=10)\n",
+        "    scores = model(x)\n",
+        "    print(scores.size())  # you should see [64, 10]\n",
+        "test_ThreeLayerConvNet()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AmtCNhxoUyOE"
+      },
+      "source": [
+        "### Module API: Check Accuracy\n",
+        "Given the validation or test set, we can check the classification accuracy of a neural network.\n",
+        "\n",
+        "This version is slightly different from the one in part II. You don't manually pass in the parameters anymore."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Pt-k9_eWUyOF"
+      },
+      "outputs": [],
+      "source": [
+        "def check_accuracy_part34(loader, model):\n",
+        "    if loader.dataset.train:\n",
+        "        print('Checking accuracy on validation set')\n",
+        "    else:\n",
+        "        print('Checking accuracy on test set')\n",
+        "    num_correct = 0\n",
+        "    num_samples = 0\n",
+        "    model.eval()  # set model to evaluation mode\n",
+        "    with torch.no_grad():\n",
+        "        for x, y in loader:\n",
+        "            x = x.to(device=device, dtype=dtype)  # move to device, e.g. GPU\n",
+        "            y = y.to(device=device, dtype=torch.long)\n",
+        "            scores = model(x)\n",
+        "            _, preds = scores.max(1)\n",
+        "            num_correct += (preds == y).sum()\n",
+        "            num_samples += preds.size(0)\n",
+        "        acc = float(num_correct) / num_samples\n",
+        "        print('Got %d / %d correct (%.2f)' % (num_correct, num_samples, 100 * acc))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "I4QmW61lUyOF"
+      },
+      "source": [
+        "### Module API: Training Loop\n",
+        "We also use a slightly different training loop. Rather than updating the values of the weights ourselves, we use an Optimizer object from the `torch.optim` package, which abstract the notion of an optimization algorithm and provides implementations of most of the algorithms commonly used to optimize neural networks."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hqRJUk8kUyOF"
+      },
+      "outputs": [],
+      "source": [
+        "def train_part34(model, optimizer, epochs=1):\n",
+        "    \"\"\"\n",
+        "    Train a model on CIFAR-10 using the PyTorch Module API.\n",
+        "\n",
+        "    Inputs:\n",
+        "    - model: A PyTorch Module giving the model to train.\n",
+        "    - optimizer: An Optimizer object we will use to train the model\n",
+        "    - epochs: (Optional) A Python integer giving the number of epochs to train for\n",
+        "\n",
+        "    Returns: Nothing, but prints model accuracies during training.\n",
+        "    \"\"\"\n",
+        "    model = model.to(device=device)  # move the model parameters to CPU/GPU\n",
+        "    for e in range(epochs):\n",
+        "        for t, (x, y) in enumerate(loader_train):\n",
+        "            model.train()  # put model to training mode\n",
+        "            x = x.to(device=device, dtype=dtype)  # move to device, e.g. GPU\n",
+        "            y = y.to(device=device, dtype=torch.long)\n",
+        "\n",
+        "            scores = model(x)\n",
+        "            loss = F.cross_entropy(scores, y)\n",
+        "\n",
+        "            # Zero out all of the gradients for the variables which the optimizer\n",
+        "            # will update.\n",
+        "            optimizer.zero_grad()\n",
+        "\n",
+        "            # This is the backwards pass: compute the gradient of the loss with\n",
+        "            # respect to each  parameter of the model.\n",
+        "            loss.backward()\n",
+        "\n",
+        "            # Actually update the parameters of the model using the gradients\n",
+        "            # computed by the backwards pass.\n",
+        "            optimizer.step()\n",
+        "\n",
+        "            if t % print_every == 0:\n",
+        "                print('Iteration %d, loss = %.4f' % (t, loss.item()))\n",
+        "                check_accuracy_part34(loader_val, model)\n",
+        "                print()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Q3rhB6LWUyOF"
+      },
+      "source": [
+        "### Module API: Train a Two-Layer Network\n",
+        "Now we are ready to run the training loop. In contrast to part II, we don't explicitly allocate parameter tensors anymore.\n",
+        "\n",
+        "Simply pass the input size, hidden layer size, and number of classes (i.e. output size) to the constructor of `TwoLayerFC`.\n",
+        "\n",
+        "You also need to define an optimizer that tracks all the learnable parameters inside `TwoLayerFC`.\n",
+        "\n",
+        "You don't need to tune any hyperparameters, but you should see model accuracies above 40% after training for one epoch."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "E0LpnI-GUyOG",
+        "outputId": "00e5ef44-e875-4122-ea0c-e525bfd37f39"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 2.7778\n",
+            "Checking accuracy on validation set\n",
+            "Got 161 / 1000 correct (16.10)\n",
+            "\n",
+            "Iteration 100, loss = 2.3438\n",
+            "Checking accuracy on validation set\n",
+            "Got 320 / 1000 correct (32.00)\n",
+            "\n",
+            "Iteration 200, loss = 1.8845\n",
+            "Checking accuracy on validation set\n",
+            "Got 383 / 1000 correct (38.30)\n",
+            "\n",
+            "Iteration 300, loss = 1.6858\n",
+            "Checking accuracy on validation set\n",
+            "Got 390 / 1000 correct (39.00)\n",
+            "\n",
+            "Iteration 400, loss = 1.4889\n",
+            "Checking accuracy on validation set\n",
+            "Got 402 / 1000 correct (40.20)\n",
+            "\n",
+            "Iteration 500, loss = 1.7451\n",
+            "Checking accuracy on validation set\n",
+            "Got 441 / 1000 correct (44.10)\n",
+            "\n",
+            "Iteration 600, loss = 1.7219\n",
+            "Checking accuracy on validation set\n",
+            "Got 413 / 1000 correct (41.30)\n",
+            "\n",
+            "Iteration 700, loss = 1.5190\n",
+            "Checking accuracy on validation set\n",
+            "Got 433 / 1000 correct (43.30)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "hidden_layer_size = 4000\n",
+        "learning_rate = 1e-2\n",
+        "model = TwoLayerFC(3 * 32 * 32, hidden_layer_size, 10)\n",
+        "optimizer = optim.SGD(model.parameters(), lr=learning_rate)\n",
+        "\n",
+        "train_part34(model, optimizer)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Kl3tLz9aUyOG"
+      },
+      "source": [
+        "### Module API: Train a Three-Layer ConvNet\n",
+        "You should now use the Module API to train a three-layer ConvNet on CIFAR. This should look very similar to training the two-layer network! You don't need to tune any hyperparameters, but you should achieve above above 45% after training for one epoch.\n",
+        "\n",
+        "You should train the model using stochastic gradient descent without momentum."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "test": "module_accuracy",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0ahJ6sMLUyOG",
+        "outputId": "25630b9e-3b6b-4bf5-c57f-16ee95ef07ec"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 3.1185\n",
+            "Checking accuracy on validation set\n",
+            "Got 89 / 1000 correct (8.90)\n",
+            "\n",
+            "Iteration 100, loss = 1.5767\n",
+            "Checking accuracy on validation set\n",
+            "Got 354 / 1000 correct (35.40)\n",
+            "\n",
+            "Iteration 200, loss = 1.6303\n",
+            "Checking accuracy on validation set\n",
+            "Got 366 / 1000 correct (36.60)\n",
+            "\n",
+            "Iteration 300, loss = 1.8178\n",
+            "Checking accuracy on validation set\n",
+            "Got 411 / 1000 correct (41.10)\n",
+            "\n",
+            "Iteration 400, loss = 1.7186\n",
+            "Checking accuracy on validation set\n",
+            "Got 413 / 1000 correct (41.30)\n",
+            "\n",
+            "Iteration 500, loss = 1.7037\n",
+            "Checking accuracy on validation set\n",
+            "Got 443 / 1000 correct (44.30)\n",
+            "\n",
+            "Iteration 600, loss = 1.4189\n",
+            "Checking accuracy on validation set\n",
+            "Got 460 / 1000 correct (46.00)\n",
+            "\n",
+            "Iteration 700, loss = 1.5092\n",
+            "Checking accuracy on validation set\n",
+            "Got 465 / 1000 correct (46.50)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "learning_rate = 3e-3\n",
+        "channel_1 = 32\n",
+        "channel_2 = 16\n",
+        "\n",
+        "model = None\n",
+        "optimizer = None\n",
+        "################################################################################\n",
+        "# TODO: Instantiate your ThreeLayerConvNet model and a corresponding optimizer #\n",
+        "################################################################################\n",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "model = ThreeLayerConvNet(3, channel_1, channel_2, 10)\n",
+        "optimizer = optim.SGD(model.parameters(), lr=learning_rate)\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "################################################################################\n",
+        "#                                 END OF YOUR CODE                             #\n",
+        "################################################################################\n",
+        "\n",
+        "train_part34(model, optimizer)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rbGjpixRUyOL"
+      },
+      "source": [
+        "# Part IV. PyTorch Sequential API\n",
+        "\n",
+        "Part III introduced the PyTorch Module API, which allows you to define arbitrary learnable layers and their connectivity.\n",
+        "\n",
+        "For simple models like a stack of feed forward layers, you still need to go through 3 steps: subclass `nn.Module`, assign layers to class attributes in `__init__`, and call each layer one by one in `forward()`. Is there a more convenient way?\n",
+        "\n",
+        "Fortunately, PyTorch provides a container Module called `nn.Sequential`, which merges the above steps into one. It is not as flexible as `nn.Module`, because you cannot specify more complex topology than a feed-forward stack, but it's good enough for many use cases.\n",
+        "\n",
+        "### Sequential API: Two-Layer Network\n",
+        "Let's see how to rewrite our two-layer fully connected network example with `nn.Sequential`, and train it using the training loop defined above.\n",
+        "\n",
+        "Again, you don't need to tune any hyperparameters here, but you shoud achieve above 40% accuracy after one epoch of training."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d9ZX-PIFUyOM",
+        "outputId": "350f149d-351b-436e-b80d-badbdea12f98"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 2.3044\n",
+            "Checking accuracy on validation set\n",
+            "Got 143 / 1000 correct (14.30)\n",
+            "\n",
+            "Iteration 100, loss = 1.7458\n",
+            "Checking accuracy on validation set\n",
+            "Got 368 / 1000 correct (36.80)\n",
+            "\n",
+            "Iteration 200, loss = 1.7914\n",
+            "Checking accuracy on validation set\n",
+            "Got 409 / 1000 correct (40.90)\n",
+            "\n",
+            "Iteration 300, loss = 1.5567\n",
+            "Checking accuracy on validation set\n",
+            "Got 430 / 1000 correct (43.00)\n",
+            "\n",
+            "Iteration 400, loss = 1.9446\n",
+            "Checking accuracy on validation set\n",
+            "Got 433 / 1000 correct (43.30)\n",
+            "\n",
+            "Iteration 500, loss = 1.7955\n",
+            "Checking accuracy on validation set\n",
+            "Got 419 / 1000 correct (41.90)\n",
+            "\n",
+            "Iteration 600, loss = 1.5037\n",
+            "Checking accuracy on validation set\n",
+            "Got 450 / 1000 correct (45.00)\n",
+            "\n",
+            "Iteration 700, loss = 1.7519\n",
+            "Checking accuracy on validation set\n",
+            "Got 436 / 1000 correct (43.60)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# We need to wrap `flatten` function in a module in order to stack it\n",
+        "# in nn.Sequential\n",
+        "class Flatten(nn.Module):\n",
+        "    def forward(self, x):\n",
+        "        return flatten(x)\n",
+        "\n",
+        "hidden_layer_size = 4000\n",
+        "learning_rate = 1e-2\n",
+        "\n",
+        "model = nn.Sequential(\n",
+        "    Flatten(),\n",
+        "    nn.Linear(3 * 32 * 32, hidden_layer_size),\n",
+        "    nn.ReLU(),\n",
+        "    nn.Linear(hidden_layer_size, 10),\n",
+        ")\n",
+        "\n",
+        "# you can use Nesterov momentum in optim.SGD\n",
+        "optimizer = optim.SGD(model.parameters(), lr=learning_rate,\n",
+        "                     momentum=0.9, nesterov=True)\n",
+        "\n",
+        "train_part34(model, optimizer)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EpSb3WojUyOM"
+      },
+      "source": [
+        "### Sequential API: Three-Layer ConvNet\n",
+        "Here you should use `nn.Sequential` to define and train a three-layer ConvNet with the same architecture we used in Part III:\n",
+        "\n",
+        "1. Convolutional layer (with bias) with 32 5x5 filters, with zero-padding of 2\n",
+        "2. ReLU\n",
+        "3. Convolutional layer (with bias) with 16 3x3 filters, with zero-padding of 1\n",
+        "4. ReLU\n",
+        "5. Fully-connected layer (with bias) to compute scores for 10 classes\n",
+        "\n",
+        "You can use the default PyTorch weight initialization.\n",
+        "\n",
+        "You should optimize your model using stochastic gradient descent with Nesterov momentum 0.9.\n",
+        "\n",
+        "Again, you don't need to tune any hyperparameters but you should see accuracy above 55% after one epoch of training."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "test": "sequential_accuracy",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "8WvN-HqcUyOM",
+        "outputId": "ab9524cf-5922-413a-a781-7b1e24e99e45"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 2.3104\n",
+            "Checking accuracy on validation set\n",
+            "Got 126 / 1000 correct (12.60)\n",
+            "\n",
+            "Iteration 100, loss = 1.8362\n",
+            "Checking accuracy on validation set\n",
+            "Got 414 / 1000 correct (41.40)\n",
+            "\n",
+            "Iteration 200, loss = 1.4738\n",
+            "Checking accuracy on validation set\n",
+            "Got 469 / 1000 correct (46.90)\n",
+            "\n",
+            "Iteration 300, loss = 1.3190\n",
+            "Checking accuracy on validation set\n",
+            "Got 531 / 1000 correct (53.10)\n",
+            "\n",
+            "Iteration 400, loss = 1.2590\n",
+            "Checking accuracy on validation set\n",
+            "Got 529 / 1000 correct (52.90)\n",
+            "\n",
+            "Iteration 500, loss = 1.3656\n",
+            "Checking accuracy on validation set\n",
+            "Got 528 / 1000 correct (52.80)\n",
+            "\n",
+            "Iteration 600, loss = 1.1432\n",
+            "Checking accuracy on validation set\n",
+            "Got 572 / 1000 correct (57.20)\n",
+            "\n",
+            "Iteration 700, loss = 1.5138\n",
+            "Checking accuracy on validation set\n",
+            "Got 578 / 1000 correct (57.80)\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "channel_1 = 32\n",
+        "channel_2 = 16\n",
+        "learning_rate = 1e-2\n",
+        "\n",
+        "model = None\n",
+        "optimizer = None\n",
+        "\n",
+        "################################################################################\n",
+        "# TODO: Rewrite the 2-layer ConvNet with bias from Part III with the           #\n",
+        "# Sequential API.                                                              #\n",
+        "################################################################################\n",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "model = nn.Sequential(nn.Conv2d(3, channel_1, 5, padding = 2),\n",
+        "                      nn.ReLU(),\n",
+        "                      nn.Conv2d(channel_1, channel_2, 3, padding = 1),\n",
+        "                      nn.ReLU(),\n",
+        "                      Flatten(),\n",
+        "                      nn.Linear(channel_2 * 32 * 32, 10))\n",
+        "\n",
+        "optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True)\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "################################################################################\n",
+        "#                                 END OF YOUR CODE                             #\n",
+        "################################################################################\n",
+        "\n",
+        "train_part34(model, optimizer)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aqOl0qLiUyOM"
+      },
+      "source": [
+        "# Part V. CIFAR-10 open-ended challenge\n",
+        "\n",
+        "In this section, you can experiment with whatever ConvNet architecture you'd like on CIFAR-10.\n",
+        "\n",
+        "Now it's your job to experiment with architectures, hyperparameters, loss functions, and optimizers to train a model that achieves **at least 70%** accuracy on the CIFAR-10 **validation** set within 10 epochs. You can use the check_accuracy and train functions from above. You can use either `nn.Module` or `nn.Sequential` API.\n",
+        "\n",
+        "Describe what you did at the end of this notebook.\n",
+        "\n",
+        "Here are the official API documentation for each component. One note: what we call in the class \"spatial batch norm\" is called \"BatchNorm2D\" in PyTorch.\n",
+        "\n",
+        "* Layers in torch.nn package: http://pytorch.org/docs/stable/nn.html\n",
+        "* Activations: http://pytorch.org/docs/stable/nn.html#non-linear-activations\n",
+        "* Loss functions: http://pytorch.org/docs/stable/nn.html#loss-functions\n",
+        "* Optimizers: http://pytorch.org/docs/stable/optim.html\n",
+        "\n",
+        "\n",
+        "### Things you might try:\n",
+        "- **Filter size**: Above we used 5x5; would smaller filters be more efficient?\n",
+        "- **Number of filters**: Above we used 32 filters. Do more or fewer do better?\n",
+        "- **Pooling vs Strided Convolution**: Do you use max pooling or just stride convolutions?\n",
+        "- **Batch normalization**: Try adding spatial batch normalization after convolution layers and vanilla batch normalization after affine layers. Do your networks train faster?\n",
+        "- **Network architecture**: The network above has two layers of trainable parameters. Can you do better with a deep network? Good architectures to try include:\n",
+        "    - [conv-relu-pool]xN -> [affine]xM -> [softmax or SVM]\n",
+        "    - [conv-relu-conv-relu-pool]xN -> [affine]xM -> [softmax or SVM]\n",
+        "    - [batchnorm-relu-conv]xN -> [affine]xM -> [softmax or SVM]\n",
+        "- **Global Average Pooling**: Instead of flattening and then having multiple affine layers, perform convolutions until your image gets small (7x7 or so) and then perform an average pooling operation to get to a 1x1 image picture (1, 1 , Filter#), which is then reshaped into a (Filter#) vector. This is used in [Google's Inception Network](https://arxiv.org/abs/1512.00567) (See Table 1 for their architecture).\n",
+        "- **Regularization**: Add l2 weight regularization, or perhaps use Dropout.\n",
+        "\n",
+        "### Tips for training\n",
+        "For each network architecture that you try, you should tune the learning rate and other hyperparameters. When doing this there are a couple important things to keep in mind:\n",
+        "\n",
+        "- If the parameters are working well, you should see improvement within a few hundred iterations\n",
+        "- Remember the coarse-to-fine approach for hyperparameter tuning: start by testing a large range of hyperparameters for just a few training iterations to find the combinations of parameters that are working at all.\n",
+        "- Once you have found some sets of parameters that seem to work, search more finely around these parameters. You may need to train for more epochs.\n",
+        "- You should use the validation set for hyperparameter search, and save your test set for evaluating your architecture on the best parameters as selected by the validation set.\n",
+        "\n",
+        "### Going above and beyond\n",
+        "If you are feeling adventurous there are many other features you can implement to try and improve your performance. You are **not required** to implement any of these, but don't miss the fun if you have time!\n",
+        "\n",
+        "- Alternative optimizers: you can try Adam, Adagrad, RMSprop, etc.\n",
+        "- Alternative activation functions such as leaky ReLU, parametric ReLU, ELU, or MaxOut.\n",
+        "- Model ensembles\n",
+        "- Data augmentation\n",
+        "- New Architectures\n",
+        "  - [ResNets](https://arxiv.org/abs/1512.03385) where the input from the previous layer is added to the output.\n",
+        "  - [DenseNets](https://arxiv.org/abs/1608.06993) where inputs into previous layers are concatenated together.\n",
+        "  - [This blog has an in-depth overview](https://chatbotslife.com/resnets-highwaynets-and-densenets-oh-my-9bb15918ee32)\n",
+        "\n",
+        "### Have fun and happy training!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "################################################################################\n",
+        "# TODO:                                                                        #\n",
+        "# Experiment with any architectures, optimizers, and hyperparameters.          #\n",
+        "# Achieve AT LEAST 70% accuracy on the *validation set* within 10 epochs.      #\n",
+        "#                                                                              #\n",
+        "# Note that you can use the check_accuracy function to evaluate on either      #\n",
+        "# the test set or the validation set, by passing either loader_test or         #\n",
+        "# loader_val as the second argument to check_accuracy. You should not touch    #\n",
+        "# the test set until you have finished your architecture and  hyperparameter   #\n",
+        "# tuning, and only run the test set once at the end to report a final value.   #\n",
+        "################################################################################\n",
+        "model = None\n",
+        "optimizer = None\n",
+        "\n",
+        "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "\n",
+        "num_classes = 10\n",
+        "\n",
+        "conv1 = nn.Sequential(nn.Conv2d(3, 16, kernel_size=5, padding=2),\n",
+        "                      nn.BatchNorm2d(16),\n",
+        "                      nn.ReLU(),\n",
+        "                      nn.MaxPool2d(2))\n",
+        "\n",
+        "conv2 = nn.Sequential(nn.Conv2d(16, 32, kernel_size=3, padding=1),\n",
+        "                      nn.BatchNorm2d(32),\n",
+        "                      nn.ReLU(),\n",
+        "                      nn.MaxPool2d(2))\n",
+        "\n",
+        "conv3 = nn.Sequential(nn.Conv2d(32, 64, kernel_size=3, padding=1),\n",
+        "                      nn.BatchNorm2d(64),\n",
+        "                      nn.ReLU(),\n",
+        "                      nn.MaxPool2d(2))\n",
+        "\n",
+        "fc =  nn.Sequential(nn.Dropout(0.2, inplace=True),\n",
+        "                    nn.Linear(64*4*4, num_classes))\n",
+        "\n",
+        "model = nn.Sequential(conv1,\n",
+        "                      conv2,\n",
+        "                      conv3,\n",
+        "                      Flatten(),\n",
+        "                      fc)\n",
+        "\n",
+        "learning_rate = 1e-3\n",
+        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
+        "\n",
+        "# Print training status every epoch: set print_every to a large number\n",
+        "print_every = 10000\n",
+        "\n",
+        "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
+        "################################################################################\n",
+        "#                                 END OF YOUR CODE\n",
+        "################################################################################\n",
+        "\n",
+        "# You should get at least 70% accuracy\n",
+        "train_part34(model, optimizer, epochs=10)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GqjkvkxQx68S",
+        "outputId": "927c5261-73d0-4f23-9a0a-0619c61aac66"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration 0, loss = 2.5435\n",
+            "Checking accuracy on validation set\n",
+            "Got 104 / 1000 correct (10.40)\n",
+            "\n",
+            "Iteration 0, loss = 0.9266\n",
+            "Checking accuracy on validation set\n",
+            "Got 611 / 1000 correct (61.10)\n",
+            "\n",
+            "Iteration 0, loss = 1.0116\n",
+            "Checking accuracy on validation set\n",
+            "Got 677 / 1000 correct (67.70)\n",
+            "\n",
+            "Iteration 0, loss = 0.9464\n",
+            "Checking accuracy on validation set\n",
+            "Got 684 / 1000 correct (68.40)\n",
+            "\n",
+            "Iteration 0, loss = 0.7033\n",
+            "Checking accuracy on validation set\n",
+            "Got 708 / 1000 correct (70.80)\n",
+            "\n",
+            "Iteration 0, loss = 1.1305\n",
+            "Checking accuracy on validation set\n",
+            "Got 703 / 1000 correct (70.30)\n",
+            "\n",
+            "Iteration 0, loss = 0.7823\n",
+            "Checking accuracy on validation set\n",
+            "Got 734 / 1000 correct (73.40)\n",
+            "\n",
+            "Iteration 0, loss = 0.5802\n",
+            "Checking accuracy on validation set\n",
+            "Got 724 / 1000 correct (72.40)\n",
+            "\n",
+            "Iteration 0, loss = 0.7206\n",
+            "Checking accuracy on validation set\n",
+            "Got 755 / 1000 correct (75.50)\n",
+            "\n",
+            "Iteration 0, loss = 0.5087\n",
+            "Checking accuracy on validation set\n",
+            "Got 761 / 1000 correct (76.10)\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "dksAoNI2UyOM"
+      },
+      "source": [
+        "## Describe what you did\n",
+        "\n",
+        "In the cell below you should write an explanation of what you did, any additional features that you implemented, and/or any graphs that you made in the process of training and evaluating your network."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "tags": [
+          "pdf-inline"
+        ],
+        "id": "YMqzag5iUyON"
+      },
+      "source": [
+        "- 모델 구조:  \n",
+        "`(Conv -> BatchNorm -> ReLU -> MaxPool) * 3 -> fc`\n",
+        "\n",
+        "\n",
+        "- 필터 크기: 5x5, 3x3, 3x3\n",
+        "- 필터 개수: 16, 32, 64\n",
+        "- 풀링: `2x2` Max pooling\n",
+        "- Normalization: Batch normalization\n",
+        "- Regularization: Dropout\n",
+        "- Optimizer: Adam"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XMva051WUyON"
+      },
+      "source": [
+        "## Test set -- run this only once\n",
+        "\n",
+        "Now that we've gotten a result we're happy with, we test our final model on the test set (which you should store in best_model). Think about how this compares to your validation set accuracy."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VaT6Zb-dUyON",
+        "outputId": "ab1811c2-eb32-4c8c-a583-b147a54071f0"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Checking accuracy on test set\n",
+            "Got 7440 / 10000 correct (74.40)\n"
+          ]
+        }
+      ],
+      "source": [
+        "best_model = model\n",
+        "check_accuracy_part34(loader_test, best_model)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "F5CuE2TNakuS"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "toc_visible": true
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file