neural_net.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nriedman/MNIST-network/blob/main/neural_net.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Notes:\n",
        "\n",
        "dE/dW(l) = [x1, x2, ..., xi].T @ [ -- dE/dz(l) -- ] <-- (dE/dz(l).shape = (1, output), X.T.shape = (input, 1))\n",
        "^\n",
        "Since I define my matrix W indexed in the opposite way, for shape purposes let's do it like this:\n",
        "\n",
        "dE/dW(l) = [ -- dE/dz(l) -- ].T @ [x1, x2, ..., xi] <-- (output, 1) @ (1, input) = (output, input)\n",
        "X = input from (l-1), so post activation function\n",
        "dE/dz(l) ="
      ],
      "metadata": {
        "collapsed": false,
        "pycharm": {
          "name": "#%% md\n"
        },
        "id": "F9_kKk-Z3_pM"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "foO4RAAa3_pP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "# Download MNIST training and test data in CSV format here:\n",
        "# https://www.kaggle.com/datasets/oddrationale/mnist-in-csv\n",
        "\n",
        "class Layer:\n",
        "    \"\"\"\n",
        "    The Layer class represents a single layer of the network. The functionality\n",
        "    of each node is represented by matrix operations that feed inputs forward\n",
        "    and update the layer's weights and baises via back propogation.\n",
        "\n",
        "    Params:\n",
        "        (int) size: The number of nodes in the layer.\n",
        "        (2D-array) W: Weight matrix storing the weights between each pair of\n",
        "                      nodes in this layer and the previous layer.\n",
        "                      Shape - (this layer size, prev layer size)\n",
        "        (2D-array) b: Bias vector storing the bias for each node of the layer.\n",
        "                      Shape - (this layer size, 1)\n",
        "        (2D-array) z: The most recent weighted input processed by the layer.\n",
        "                      Shape - (this layer size, 1)\n",
        "        (2D-array) x: The most recent activation from the previous layer.\n",
        "                      Shape - (prev layer size, 1)\n",
        "        (bool) hidden: True if layer is a hidden layer, false otherwise.\n",
        "    \"\"\"\n",
        "    def __init__(self, input_size, output_size, hide=True):\n",
        "        self.size = output_size\n",
        "        self.W = np.random.randn(output_size, input_size)\n",
        "        self.b = np.random.randn(output_size, 1)\n",
        "        self.z = 0\n",
        "        self.x = 0\n",
        "        self.hidden = hide\n",
        "\n",
        "    # The activation function for a hidden layer\n",
        "    # Given a weighted input z, return ReLU(z)\n",
        "    # z should be a matrix of shape (output_size, 1)\n",
        "    def ReLU(self, z):\n",
        "        return np.maximum(z,0)\n",
        "\n",
        "    # The activation function for the output layer\n",
        "    # Given a weighted input z, return softmax(z)\n",
        "    # z should be a matrix of shape (output_size, 1)\n",
        "    def softmax(self, z):\n",
        "        # subtract max value of z for numerical stability\n",
        "        x = z - max(z)\n",
        "        exp = np.exp(x)\n",
        "        return exp / (np.sum(exp))\n",
        "\n",
        "    # Given an input vector inpt, return the layer's activation vector\n",
        "    # inpt should have shape (input_size, 1)\n",
        "    def feed_forward(self, inpt):\n",
        "        # Calculate weighted input according to weights and biases\n",
        "        self.z = (self.W @ inpt) + self.b\n",
        "        self.x = inpt\n",
        "        return self.ReLU(self.z) if self.hidden else self.softmax(self.z)\n",
        "\n",
        "    # Subtract partial deriv of loss w respect to weights and biases\n",
        "    # to implement one step of gradient descent\n",
        "    def update_param(self, dW, db, alpha):\n",
        "        self.b -= alpha * db\n",
        "        self.W -= alpha * dW\n",
        "\n",
        "    # Given dE/dz, calculate partials with respect to W and b, update\n",
        "    # parameters, and return dz for next layer\n",
        "    def back_prop(self, dz, alpha, num_samples):\n",
        "        # Calculate partial derivatives w respect to weights and biases\n",
        "        dW = (1/num_samples) * dz @ self.x.T\n",
        "        db = (1/num_samples) * dz\n",
        "        self.update_param(dW, db, alpha)\n",
        "\n",
        "        # Calculate dE/dz for next layer ('backpropogate error')\n",
        "        new_dz = self.W.T @ dz\n",
        "        deriv_relu = self.x > 0\n",
        "        return new_dz * deriv_relu\n",
        "\n",
        "class Network:\n",
        "    \"\"\"\n",
        "    The Network class is the high level object representing the entire neural\n",
        "    network. It stores a collection of Layer objects and network-scale methods\n",
        "    for feeding inputs forward (classify) and backpropogating error, as well\n",
        "    as methods to train and test the Network given appropriate datasets.\n",
        "\n",
        "    Params:\n",
        "        (float) alpha: Learning rate for gradient descent\n",
        "        (int) num_categories: Number of categories that a given input may be\n",
        "                              classified into (equal to size of output layer)\n",
        "        (int) num_layers: Number of layers in network (including first 'layer')\n",
        "        (ndarray) layers: An array containing the Layer objects of the network\n",
        "                          in order from input to output. Excludes the first\n",
        "                          'layer' (layers[0] is first hidden or output layer)\n",
        "\n",
        "    \"\"\"\n",
        "    def __init__(self, shape, learn_rate):\n",
        "        self.alpha = learn_rate\n",
        "        self.num_categories = shape[-1]\n",
        "        self.num_layers = len(shape)\n",
        "        self.layers = np.asarray([Layer(shape[i-1], shape[i], True) for i in range(1,len(shape))])\n",
        "        self.layers[-1].hidden = False\n",
        "\n",
        "    # Given an input vector x, returns a vector of probabilities that the input\n",
        "    # is part of each category\n",
        "    def classify(self, x):\n",
        "        frwrd_inpt = x\n",
        "        for layer in self.layers:\n",
        "            frwrd_inpt = layer.feed_forward(frwrd_inpt)\n",
        "        return frwrd_inpt\n",
        "\n",
        "    # Given the network's classification (y_hat) and the input's label (y),\n",
        "    # update the weights and biases of the network via backpropogation\n",
        "    def back_prop(self, y_hat, y, num_samples):\n",
        "        # Derivative of error w respect to weighted input of final layer given\n",
        "        # cross entropy loss function\n",
        "        dz = y_hat - y\n",
        "        for layer in self.layers[::-1]:\n",
        "            dz = layer.back_prop(dz, self.alpha, num_samples)\n",
        "        return \"Backpropogation complete\"\n",
        "\n",
        "    # Given index of correct classification (label), return 'one-hot'\n",
        "    # probability vector\n",
        "    def one_hot(self, label):\n",
        "        pmf = np.zeros((self.num_categories, 1))\n",
        "        pmf[int(label)] = 1\n",
        "        return pmf\n",
        "\n",
        "    # Given the network's classification y_hat and one-hot label y,\n",
        "    # return the loss as MSE\n",
        "    def loss(self, y_hat, y):\n",
        "        err = y - y_hat\n",
        "        return (err.T @ err)[0]\n",
        "\n",
        "    # Given a matrix of training examples x_train and their corresponding labels\n",
        "    # y_train, run gradient descent to train the network to classify inputs\n",
        "    # Returns a list of the loss at each iteration\n",
        "    def train(self, x_train, y_train):\n",
        "        num_samples = y_train.shape[0]\n",
        "        loss = []\n",
        "        for inpt, label in zip(x_train, y_train):\n",
        "            x = inpt.reshape(inpt.shape[0], 1)\n",
        "            y_hat = self.classify(x)\n",
        "            y = self.one_hot(label)\n",
        "            loss.append(self.loss(y_hat, y))\n",
        "            self.back_prop(y_hat, y, num_samples)\n",
        "        print('Training complete')\n",
        "        return loss\n",
        "\n",
        "    # Given test examples x_test, their labels y_test, and the total number of\n",
        "    # test examples, return the accuracy of the network\n",
        "    def test(self, x_test, y_test, total):\n",
        "        correct = 0\n",
        "        for inpt,label in zip(x_test, y_test):\n",
        "            # Classify each test example\n",
        "            x = inpt.reshape(inpt.shape[0], 1)\n",
        "            y_hat = self.classify(x)\n",
        "            # Add correct classigications to running tally\n",
        "            correct += (label == np.argmax(y_hat))\n",
        "        return correct / total"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "r7pHii493_pQ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "# Import data and save into numpy array\n",
        "train_data = pd.read_csv('mnist_train.csv')\n",
        "train_data = np.array(train_data)\n",
        "\n",
        "test_data = pd.read_csv('mnist_test.csv')\n",
        "test_data = np.array(test_data)\n",
        "\n",
        "# Shuffle each data bin to ensure random sampling\n",
        "np.random.shuffle(test_data)\n",
        "np.random.shuffle(train_data)"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "8MslHE3H3_pS"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [],
      "source": [
        "# Process test and train data into x and y (inputs and labels)\n",
        "# Note: the 0th col is the label of each row example\n",
        "y_train = train_data[:6000,0]\n",
        "x_train = train_data[:6000,1:]\n",
        "\n",
        "y_test = test_data[:6000,0]\n",
        "x_test = test_data[:6000,1:]"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "m3c5k-xN3_pS"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n"
          ]
        }
      ],
      "source": [
        "# Create learning rates to test\n",
        "lrs = [0.001, 0.0025, 0.005, 0.0075, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25]\n",
        "accuracies = []\n",
        "# Store accuracy for each learning rate\n",
        "for lr in lrs:\n",
        "    N = Network((784, 90, 10), lr)\n",
        "    # Train with the lr\n",
        "    N.train(x_train, y_train)\n",
        "    accuracies.append(N.test(x_test, y_test, x_test.shape[0]))"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "omAZrMOK3_pT",
        "outputId": "33f35b89-7143-4a1b-cc0f-959c2c36898e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Accuracy by Learning Rate')"
            ]
          },
          "metadata": {},
          "execution_count": 66
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig = plt.figure(figsize=(7,5))\n",
        "plt.plot(lrs, accuracies)\n",
        "plt.xlabel(\"Learning Rate\")\n",
        "plt.ylabel(\"Accuracy (% Correctly Labeled)\")\n",
        "plt.title('Accuracy by Learning Rate')"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "-TFn1Fm73_pU",
        "outputId": "25c515aa-d153-491c-87b3-bf648915a5ef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        }
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n",
            "Training complete\n"
          ]
        }
      ],
      "source": [
        "# Create different layer shapes to test\n",
        "shapes = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150]\n",
        "accuracies = []\n",
        "# Do a learning rate of .075 to maximize accuracy\n",
        "alpha = .075\n",
        "# Store accuracy for each layer shape\n",
        "for node_num in shapes:\n",
        "    N = Network((784, node_num, 10), alpha)\n",
        "    # Train with the shape\n",
        "    N.train(x_train, y_train)\n",
        "    accuracies.append(N.test(x_test, y_test, x_test.shape[0]))"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "L-px5RL63_pV",
        "outputId": "4035d03b-cbb7-4a41-b81c-39bde0db0f71",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Accuracy by Hidden Layer Shape')"
            ]
          },
          "metadata": {},
          "execution_count": 68
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 700x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig = plt.figure(figsize=(7,5))\n",
        "plt.plot(shapes, accuracies)\n",
        "plt.xlabel(\"Number of Hidden Layer Nodes\")\n",
        "plt.ylabel(\"Accuracy (% Correctly Labeled)\")\n",
        "plt.title('Accuracy by Hidden Layer Shape')"
      ],
      "metadata": {
        "pycharm": {
          "name": "#%%\n"
        },
        "id": "qzgAhj_S3_pV",
        "outputId": "ecc86088-7d11-45a1-b3e6-d96b518bd39d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        }
      }
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 2
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython2",
      "version": "2.7.6"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}