Implement a NN - Part 5: Batch Norm.ipynb

implement-a-nn-part-5-batch-norm.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNfHhzNpb033mKQ/GWigsoV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/MaverickMeerkat/99207ab15847d510fca13e99bf3a50bf/implement-a-nn-part-5-batch-norm.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this notebook we will revisit the manual implementation of a NN, but add a Batch-Norm layer.\n",
        "\n",
        "Like always we will start by loading the necessary libraries. \n",
        "\n",
        "Note that we are only using `torchvision` for the MNIST dataset - loading and handling it. We are not using any of the `pytorch` capabilities for actual training. "
      ],
      "metadata": {
        "id": "-WbuIOHMkD9o"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xxTn68vggPaW"
      },
      "outputs": [],
      "source": [
        "import numpy as np # for doing all the math and matrix work\n",
        "import matplotlib.pyplot as plt  # for a bit of graphing\n",
        "\n",
        "from scipy.special import expit # sigmoid function\n",
        "\n",
        "from torchvision import datasets, transforms # for the MNIST dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Set plotting DPI for bigger plots, and a random seed for reproducibility."
      ],
      "metadata": {
        "id": "uzGYsyc8yrMs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.rcParams['figure.dpi'] = 120  # set plotting dpi\n",
        "\n",
        "# set seed for reproducibility\n",
        "random_seed = 247\n",
        "np.random.seed(random_seed)"
      ],
      "metadata": {
        "id": "HQpxM713yphQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Data: MNIST"
      ],
      "metadata": {
        "id": "wj8G9MxSal17"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Like before, we will use the MNIST data, only now we have to transform it into a numpy tensor instead of a torch tensor. "
      ],
      "metadata": {
        "id": "KnvcrC7aStYo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "training_data = datasets.MNIST(\n",
        "    root=\"data\",\n",
        "    train=True,\n",
        "    download=True,\n",
        "    transform=transforms.ToTensor()\n",
        ")\n",
        "\n",
        "validation_data = datasets.MNIST(\n",
        "    root=\"data\",\n",
        "    train=False,\n",
        "    download=True,\n",
        "    transform=transforms.ToTensor()\n",
        ")"
      ],
      "metadata": {
        "id": "98dSnsU3Ss9_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We'll convert the dataset to numpy arrays:"
      ],
      "metadata": {
        "id": "iKxl05lG5zAq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = training_data.data.numpy()\n",
        "x = x.reshape(-1, 784)\n",
        "y = training_data.targets.numpy()\n",
        "\n",
        "x_val = validation_data.data.numpy()\n",
        "x_val = x_val.reshape(-1, 784)\n",
        "y_val = validation_data.targets.numpy()"
      ],
      "metadata": {
        "id": "he4biHXk5-jC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The task is <font color=\"red\">Classification</font>** - we want to classify the image to the corresponding digit.  "
      ],
      "metadata": {
        "id": "NUijTRWPthQi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Modifying the NN\n",
        "\n",
        "Let's load the code we need for the NN from the previous implementation notebook. \n",
        "\n",
        "We have to modify:\n",
        "* In the `update` function add the parameters for a BatchNorm layer\n",
        "* Implement a `sigmoid` activation function: there are numerical dificulties that arise here, if we call `exp(x)` on a number that is too large we will get an overflow issue. We could check each number and if it's $>0$ use the $\\frac{1}{1+e^{-x}}$ implementation, otherwise use the $\\frac{e^x}{1+e^x}$ implementation. The problem is that we have to check this for every element in the observations matrix. Luckily, the `scipy` library has a very good implementation of sigmoid (called \"expit\") which we can use instead.\n"
      ],
      "metadata": {
        "id": "L0zUbU8hCIhM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# BN on the $a$'s\n",
        "\n",
        "In out current implementation, it's easier to run BN on the outputs ($a$'s) and not inputs ($z$'s) of the activations. We will later change the implementation to also pass BN on the inputs. "
      ],
      "metadata": {
        "id": "uoISblP9CwPf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearLayer():\n",
        "    def __init__(self, input_size, output_size, activation_fn):\n",
        "        self.W = np.random.randn(input_size, output_size)*0.1\n",
        "        self.b = np.zeros(output_size)\n",
        "        self.activation_fn = activation_fn\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        self.input = x  # a_{l-1}\n",
        "        self.output = x @ self.W + self.b  # z_l\n",
        "        return self.activation_fn(self.output)  # a_l\n",
        "\n",
        "    def backward(self, grad):\n",
        "        grad = grad * self.activation_fn(self.output, derivative=True)\n",
        "        self.grad_W = self.input.T @ grad\n",
        "        self.grad_b = np.sum(grad, axis=0)\n",
        "        return grad @ self.W.T"
      ],
      "metadata": {
        "id": "O2BeeQkUCPFX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def relu(x, derivative=False):\n",
        "    if derivative:\n",
        "        return (x > 0).astype(float)\n",
        "    else:\n",
        "        return np.maximum(0, x)\n",
        "\n",
        "def identity(x, derivative=False):\n",
        "    if derivative:\n",
        "        return np.ones_like(x)\n",
        "    else:\n",
        "        return x\n",
        "\n",
        "def sigmoid(x, derivative=False):\n",
        "    if derivative:\n",
        "        return expit(x) * (1-expit(x)) \n",
        "    else:\n",
        "        return expit(x) "
      ],
      "metadata": {
        "id": "K982wh8OCR4P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class NeuralNetwork():\n",
        "    def __init__(self, layers):\n",
        "        self.layers = layers\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        for layer in self.layers:\n",
        "            x = layer.forward(x, training)\n",
        "        return x\n",
        "\n",
        "    def backward(self, grad):\n",
        "        for layer in reversed(self.layers):\n",
        "            grad = layer.backward(grad)\n",
        "\n",
        "    def update(self, learning_rate):\n",
        "        for layer in self.layers:\n",
        "            if isinstance(layer, LinearLayer):\n",
        "                layer.W -= learning_rate * layer.grad_W\n",
        "                layer.b -= learning_rate * layer.grad_b\n",
        "            if isinstance(layer, BatchNormLayer):\n",
        "                layer.gamma -= learning_rate * layer.grad_gamma\n",
        "                layer.beta -= learning_rate * layer.grad_beta\n",
        "\n",
        "    def train(self, x, y, x_val, y_val, learning_rate, loss_fn, num_epochs, batch_size):\n",
        "        train_accs = []\n",
        "        val_accs = []\n",
        "        for epoch in range(num_epochs):\n",
        "            # training mode\n",
        "            indices = np.random.permutation(len(x))\n",
        "            correct = 0\n",
        "            for i in range(0, len(x), batch_size):\n",
        "                x_batch = x[indices[i:i+batch_size]]\n",
        "                y_batch = y[indices[i:i+batch_size]]\n",
        "                y_pred = self.forward(x_batch, training=True)\n",
        "                loss_i, grad = loss_fn(y_batch, y_pred)\n",
        "                self.backward(grad)\n",
        "                self.update(learning_rate)\n",
        "                pred = np.argmax(y_pred, axis=1)\n",
        "                correct += (y_batch == pred).sum()\n",
        "            accuracy = 100. * correct / len(x)\n",
        "            train_accs.append(accuracy)\n",
        "\n",
        "            # validation mode\n",
        "            val_indices = np.random.permutation(len(x_val))\n",
        "            correct_val = 0\n",
        "            for i in range(0, len(x_val), batch_size):\n",
        "                x_batch_val = x_val[val_indices[i:i+batch_size]]\n",
        "                y_batch_val = y_val[val_indices[i:i+batch_size]]\n",
        "                y_pred_val = self.forward(x_batch_val, training=False)\n",
        "                pred_val = np.argmax(y_pred_val, axis=1)\n",
        "                correct_val += (y_batch_val == pred_val).sum()\n",
        "            val_accuracy = 100. * correct_val / len(x_val)\n",
        "            val_accs.append(val_accuracy)\n",
        "\n",
        "            print(f'Epoch: {epoch}, Train Acc.: {accuracy}, Val Acc.: {val_accuracy}')\n",
        "        return train_accs, val_accs"
      ],
      "metadata": {
        "id": "aRkRgNoBRjLT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def CrossEntropy(y, logits):\n",
        "    num_samples = y.shape[0]\n",
        "    shifted_logits = logits - np.max(logits, axis=1, keepdims=True)\n",
        "    Z = np.sum(np.exp(shifted_logits), axis=1, keepdims=True)\n",
        "    log_probs = shifted_logits - np.log(Z)\n",
        "    loss = -np.sum(log_probs[np.arange(num_samples), y]) / num_samples\n",
        "\n",
        "    y_one_hot = np.zeros((len(y), 10))\n",
        "    y_one_hot[np.arange(len(y)), y] = 1\n",
        "    a = np.exp(log_probs)\n",
        "    delta = (a - y_one_hot) / num_samples\n",
        "\n",
        "    return loss, delta"
      ],
      "metadata": {
        "id": "n8zd5jNa4GFF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Adding the BatchNorm\n",
        "\n",
        "Now we will implement a BatchNorm layer."
      ],
      "metadata": {
        "id": "51PoSQZIwBpJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Remember the formulas shown in class:\n",
        "\n",
        "$$ \\frac{\\partial \\mathcal L}{\\partial \\gamma} = 1^T(\\delta \\cdot z_{l,n})=\\sum_i \\delta_i \\cdot z_{i,l,n} \\\\\n",
        "\\frac{\\partial \\mathcal L}{\\partial \\beta} = 1^T \\delta \\\\\n",
        "\\frac{\\partial \\mathcal L}{\\partial z_{l,n}} = \\delta \\cdot \\gamma \\\\\n",
        "\\frac{\\partial \\mathcal L}{\\partial z} = \\frac{1}{n \\sqrt {\\sigma^2+\\epsilon}}[n\\frac{\\partial \\mathcal L}{\\partial z_{l,n}} - 1^T\\frac{\\partial \\mathcal L}{\\partial z_{l,n}}-z_{l,n}(1^T\\frac{\\partial \\mathcal L}{\\partial z_{l,n}}z_{l,n})]\\\\\n",
        "$$"
      ],
      "metadata": {
        "id": "TdhdHCa2DhW3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BatchNormLayer():\n",
        "    def __init__(self, input_size, momentum=0.9, epsilon=1e-5):\n",
        "        self.gamma = np.ones(input_size) \n",
        "        self.beta = np.zeros(input_size)\n",
        "        self.momentum = momentum\n",
        "        self.epsilon = epsilon\n",
        "        self.running_mu = np.zeros(input_size)\n",
        "        self.running_sig2 = np.ones(input_size)\n",
        "\n",
        "    def forward(self, x, training=True):\n",
        "        if training:\n",
        "            # Compute mean and variance\n",
        "            self.mu = np.mean(x, axis=0)\n",
        "            self.sig2 = np.var(x, axis=0)\n",
        "\n",
        "            # Normalize\n",
        "            self.x_norm = (x - self.mu) / np.sqrt(self.sig2 + self.epsilon)\n",
        "\n",
        "            # Scale and shift\n",
        "            self.out = self.gamma * self.x_norm + self.beta\n",
        "\n",
        "            # Update running mean and variance\n",
        "            self.running_mu = self.momentum * self.running_mu + (1 - self.momentum) * self.mu\n",
        "            self.running_sig2 = self.momentum * self.running_sig2 + (1 - self.momentum) * self.sig2\n",
        "        else:\n",
        "            # Normalize using the running mean and variance\n",
        "            self.x_norm = (x - self.running_mu) / np.sqrt(self.running_sig2 + self.epsilon)\n",
        "\n",
        "            # Scale and shift\n",
        "            self.out = self.gamma * self.x_norm + self.beta\n",
        "        return self.out\n",
        "\n",
        "    def backward(self, grad):\n",
        "        # Compute gradients of gamma and beta\n",
        "        self.grad_gamma = np.sum(grad * self.x_norm, axis=0)\n",
        "        self.grad_beta = np.sum(grad, axis=0)\n",
        "\n",
        "        # Compute gradient of input x\n",
        "        n = grad.shape[0]\n",
        "        grad_x_norm = grad * self.gamma\n",
        "        dx = (1 / (n*np.sqrt(self.sig2 + self.epsilon)))*(n * grad_x_norm - np.sum(grad_x_norm, axis=0) - self.x_norm * np.sum(grad_x_norm*self.x_norm, axis=0))\n",
        "        return dx"
      ],
      "metadata": {
        "id": "2NJDcAFYwKYK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training\n",
        "\n",
        "We will train with a 3 hidden layers of size 50, and sigmoid activation functions. We are going to use different learning rates. Specifically, I will set a small learning rate for the BN network becaue we are applying BatchNorm on the the outputs of the activations, so it seems to be more sensitive (maybe because the equations where we showed the scale invariance of BN $BN(aW) = BN(a(cW)), etc.$ no longer apply). \n",
        "\n",
        "[Note that I searched for the best learning rate for the simple network and found it to be 0.1; Without searching as much I found a much better LR for the BN network].\n",
        "\n",
        "The simple network:"
      ],
      "metadata": {
        "id": "yd7teSi2EtsV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(random_seed)"
      ],
      "metadata": {
        "id": "3YMBVymtB88Z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "linear1 = LinearLayer(784, 50, sigmoid)\n",
        "linear2 = LinearLayer(50, 50, sigmoid)\n",
        "linear3 = LinearLayer(50, 50, sigmoid)\n",
        "linear4 = LinearLayer(50, 10, identity)\n",
        "simple_nn = NeuralNetwork([linear1, linear2, linear3, linear4])"
      ],
      "metadata": {
        "id": "JNLgb1qUB88a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_accs_s, val_accs_s = simple_nn.train(x, y, x_val, y_val, learning_rate=0.1, loss_fn=CrossEntropy, num_epochs=10, batch_size=128)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c338576b-7729-44b1-e9d0-27bf2d8f8fae",
        "id": "CMwWurvRB88a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0, Train Acc.: 14.401666666666667, Val Acc.: 24.25\n",
            "Epoch: 1, Train Acc.: 32.98, Val Acc.: 51.8\n",
            "Epoch: 2, Train Acc.: 58.81333333333333, Val Acc.: 68.24\n",
            "Epoch: 3, Train Acc.: 71.72666666666667, Val Acc.: 75.7\n",
            "Epoch: 4, Train Acc.: 76.28333333333333, Val Acc.: 80.53\n",
            "Epoch: 5, Train Acc.: 79.515, Val Acc.: 80.3\n",
            "Epoch: 6, Train Acc.: 80.21666666666667, Val Acc.: 81.32\n",
            "Epoch: 7, Train Acc.: 82.18333333333334, Val Acc.: 82.41\n",
            "Epoch: 8, Train Acc.: 81.825, Val Acc.: 81.51\n",
            "Epoch: 9, Train Acc.: 81.65333333333334, Val Acc.: 82.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now for the BN network:"
      ],
      "metadata": {
        "id": "9tL5-BhMFUbV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(random_seed)"
      ],
      "metadata": {
        "id": "jkV0JfY_-RSj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "linear1 = LinearLayer(784, 50, sigmoid)\n",
        "bn1 = BatchNormLayer(50)\n",
        "linear2 = LinearLayer(50, 50, sigmoid)\n",
        "bn2 = BatchNormLayer(50)\n",
        "linear3 = LinearLayer(50, 50, sigmoid)\n",
        "bn3 = BatchNormLayer(50)\n",
        "linear4 = LinearLayer(50, 10, identity)\n",
        "bn_nn = NeuralNetwork([linear1, bn1, linear2, bn2, linear3, bn3, linear4])"
      ],
      "metadata": {
        "id": "Zq3tjB3b1Xan"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_accs_bn, val_accs_bn = bn_nn.train(x, y, x_val, y_val, learning_rate=0.01, loss_fn=CrossEntropy, num_epochs=10, batch_size=128)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0m-yVaDk1Xfr",
        "outputId": "3a905bef-a07c-4a1f-d44e-edd0b372044c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0, Train Acc.: 66.71833333333333, Val Acc.: 80.54\n",
            "Epoch: 1, Train Acc.: 81.69833333333334, Val Acc.: 84.8\n",
            "Epoch: 2, Train Acc.: 85.115, Val Acc.: 86.94\n",
            "Epoch: 3, Train Acc.: 86.86666666666666, Val Acc.: 88.36\n",
            "Epoch: 4, Train Acc.: 87.84833333333333, Val Acc.: 88.38\n",
            "Epoch: 5, Train Acc.: 88.31, Val Acc.: 89.49\n",
            "Epoch: 6, Train Acc.: 89.07, Val Acc.: 90.16\n",
            "Epoch: 7, Train Acc.: 89.76166666666667, Val Acc.: 90.72\n",
            "Epoch: 8, Train Acc.: 90.20166666666667, Val Acc.: 90.95\n",
            "Epoch: 9, Train Acc.: 90.30666666666667, Val Acc.: 91.28\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(val_accs_s, label=\"Simple Network\")\n",
        "plt.plot(val_accs_bn, label=\"Batch Norm Network (on a's)\")\n",
        "plt.title(\"Simple vs. BN Validation Accuracy\")\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Val. Acc.')\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "1V9IYqu_WnX0",
        "outputId": "2e878750-3075-45b6-dbf0-aafcbecdbbdf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f69bedee4f0>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# BN on the $z$'s\n",
        "\n",
        "For running BN on the $z$'s we need to make some more changes to our implementation:\n",
        "\n",
        "* Since we want to run the BatchNorm on the $z$'s (before the activation) we have to separate between the linear layer and the activation functions. \n",
        "* So the linear layer will no longer recieve an activation function; they will compute a simple linear transformation in the forward pass, and give only the gradient w.r.t. the linear operation.\n",
        "* We will create classes of activations instead of the functions from before, which will keep rolling the gradient for the backprop algorithm."
      ],
      "metadata": {
        "id": "f_HN6ib8CqVn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearLayer():\n",
        "    def __init__(self, input_size, output_size): \n",
        "        self.W = np.random.randn(input_size, output_size)*0.1\n",
        "        self.b = np.zeros(output_size)\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        self.input = x  # a_{l-1}\n",
        "        self.output = x @ self.W + self.b  # z_l\n",
        "        return self.output \n",
        "\n",
        "    def backward(self, grad):\n",
        "        self.grad_W = self.input.T @ grad\n",
        "        self.grad_b = np.sum(grad, axis=0)\n",
        "        return grad @ self.W.T"
      ],
      "metadata": {
        "id": "nmABG_f8DV7u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class ReLU():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        return np.maximum(0, x)\n",
        "\n",
        "    def backward(self, grad):\n",
        "        drelu = (x > 0).astype(float)\n",
        "        return grad * drelu\n",
        "\n",
        "class Identity():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        self.x = x\n",
        "        return x\n",
        "\n",
        "    def backward(self, grad):\n",
        "        di = np.ones_like(self.x)\n",
        "        return grad * di\n",
        "\n",
        "class Sigmoid():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def forward(self, x, training):\n",
        "        self.x = x\n",
        "        return expit(x)\n",
        "\n",
        "    def backward(self, grad):\n",
        "        dsig = expit(self.x) * (1-expit(self.x)) \n",
        "        return grad * dsig"
      ],
      "metadata": {
        "id": "DuOw8YWsDV7u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now let's run this again. We will use bigger learning rate now for the BN network. \n",
        "\n",
        "The simple network:"
      ],
      "metadata": {
        "id": "9AV2qXtvDV7x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(random_seed)"
      ],
      "metadata": {
        "id": "Bs1H_mzJDV7x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "linear1 = LinearLayer(784, 50)\n",
        "sig1 = Sigmoid()\n",
        "linear2 = LinearLayer(50, 50)\n",
        "sig2 = Sigmoid()\n",
        "linear3 = LinearLayer(50, 50)\n",
        "sig3 = Sigmoid()\n",
        "linear4 = LinearLayer(50, 10)\n",
        "simple_nn = NeuralNetwork([linear1, sig1, linear2, sig2, linear3, sig3, linear4])"
      ],
      "metadata": {
        "id": "Y1mhtrKmDV7x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_accs_s, val_accs_s = simple_nn.train(x, y, x_val, y_val, learning_rate=0.1, loss_fn=CrossEntropy, num_epochs=10, batch_size=128)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a987d56-6bd7-4052-dca5-9758b365b297",
        "id": "7m5h0HfNDV7x"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0, Train Acc.: 14.401666666666667, Val Acc.: 24.25\n",
            "Epoch: 1, Train Acc.: 32.98, Val Acc.: 51.8\n",
            "Epoch: 2, Train Acc.: 58.81333333333333, Val Acc.: 68.24\n",
            "Epoch: 3, Train Acc.: 71.72666666666667, Val Acc.: 75.7\n",
            "Epoch: 4, Train Acc.: 76.28333333333333, Val Acc.: 80.53\n",
            "Epoch: 5, Train Acc.: 79.515, Val Acc.: 80.3\n",
            "Epoch: 6, Train Acc.: 80.21666666666667, Val Acc.: 81.32\n",
            "Epoch: 7, Train Acc.: 82.18333333333334, Val Acc.: 82.41\n",
            "Epoch: 8, Train Acc.: 81.825, Val Acc.: 81.51\n",
            "Epoch: 9, Train Acc.: 81.65333333333334, Val Acc.: 82.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We see that for the simple network we got the exact same results as before. Now let's train the batch norm network:"
      ],
      "metadata": {
        "id": "ERRijUHCJBde"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(random_seed)"
      ],
      "metadata": {
        "id": "J4B2JM_mDV7x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "linear1 = LinearLayer(784, 50)\n",
        "bn1 = BatchNormLayer(50)\n",
        "sig1 = Sigmoid()\n",
        "linear2 = LinearLayer(50, 50)\n",
        "bn2 = BatchNormLayer(50)\n",
        "sig2 = Sigmoid()\n",
        "linear3 = LinearLayer(50, 50)\n",
        "bn3 = BatchNormLayer(50)\n",
        "sig3 = Sigmoid()\n",
        "linear4 = LinearLayer(50, 10)\n",
        "bn_nn = NeuralNetwork([linear1, bn1, sig1, linear2, bn2, sig2, linear3, bn3, sig3, linear4])"
      ],
      "metadata": {
        "id": "srujNAPkDV7y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_accs_bn, val_accs_bn = bn_nn.train(x, y, x_val, y_val, learning_rate=2, loss_fn=CrossEntropy, num_epochs=10, batch_size=128)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5705593-80f4-4d0f-b7eb-a239e6d9a19e",
        "id": "FlKUfJK8DV7z"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0, Train Acc.: 87.54666666666667, Val Acc.: 91.03\n",
            "Epoch: 1, Train Acc.: 94.13666666666667, Val Acc.: 94.29\n",
            "Epoch: 2, Train Acc.: 95.645, Val Acc.: 96.09\n",
            "Epoch: 3, Train Acc.: 96.68, Val Acc.: 96.49\n",
            "Epoch: 4, Train Acc.: 97.17166666666667, Val Acc.: 96.54\n",
            "Epoch: 5, Train Acc.: 97.42166666666667, Val Acc.: 97.13\n",
            "Epoch: 6, Train Acc.: 97.82166666666667, Val Acc.: 97.01\n",
            "Epoch: 7, Train Acc.: 98.09666666666666, Val Acc.: 97.13\n",
            "Epoch: 8, Train Acc.: 98.33333333333333, Val Acc.: 97.53\n",
            "Epoch: 9, Train Acc.: 98.42833333333333, Val Acc.: 97.66\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(val_accs_s, label=\"Simple Network\")\n",
        "plt.plot(val_accs_bn, label=\"Batch Norm Network (on z's)\")\n",
        "plt.title(\"Simple vs. BN Validation Accuracy\")\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Val. Acc.')\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "rlvxFVtWWTjv",
        "outputId": "17df31a6-2acd-4acf-a843-05f353750479"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f69bec76970>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The results pretty much speak for themselves 😉."
      ],
      "metadata": {
        "id": "Kjq23KGFJNcR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "© David Refaeli 2023."
      ],
      "metadata": {
        "id": "7qdQQjjy1XpH"
      }
    }
  ]
}