neural-network-numpy.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5gqr-Wl_0C7t"
      },
      "source": [
        "# Download Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 229,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F8J8Arat0C7x",
        "outputId": "5cce4d96-614a-4303-adeb-f452deb861fc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading train-images-idx3-ubyte.gz...\n",
            "Downloaded train-images-idx3-ubyte.gz!\n",
            "Downloading t10k-images-idx3-ubyte.gz...\n",
            "Downloaded t10k-images-idx3-ubyte.gz!\n",
            "Downloading train-labels-idx1-ubyte.gz...\n",
            "Downloaded train-labels-idx1-ubyte.gz!\n",
            "Downloading t10k-labels-idx1-ubyte.gz...\n",
            "Downloaded t10k-labels-idx1-ubyte.gz!\n",
            "Downloaded all files!\n",
            "Saving mnist.pkl...\n",
            "Saved mnist.pkl!\n",
            "Deleting temporary file train-images-idx3-ubyte.gz...\n",
            "Deleted temporary file train-images-idx3-ubyte.gz!\n",
            "Deleting temporary file t10k-images-idx3-ubyte.gz...\n",
            "Deleted temporary file t10k-images-idx3-ubyte.gz!\n",
            "Deleting temporary file train-labels-idx1-ubyte.gz...\n",
            "Deleted temporary file train-labels-idx1-ubyte.gz!\n",
            "Deleting temporary file t10k-labels-idx1-ubyte.gz...\n",
            "Deleted temporary file t10k-labels-idx1-ubyte.gz!\n",
            "Deleted all temporary files!\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import gzip, pickle, os\n",
        "from urllib import request\n",
        "\n",
        "base_uri = \"http://yann.lecun.com/exdb/mnist/\"\n",
        "\n",
        "filename = [\n",
        "    [\"training_images\",\"train-images-idx3-ubyte.gz\"],\n",
        "    [\"test_images\",\"t10k-images-idx3-ubyte.gz\"],\n",
        "    [\"training_labels\",\"train-labels-idx1-ubyte.gz\"],\n",
        "    [\"test_labels\",\"t10k-labels-idx1-ubyte.gz\"]\n",
        "]\n",
        "\n",
        "\n",
        "def download_mnist():\n",
        "    for name in filename:\n",
        "        print(f'Downloading {name[1]}...')\n",
        "        request.urlretrieve(f'{base_uri}{name[1]}', name[1])\n",
        "        print(f'Downloaded {name[1]}!')\n",
        "    print(f'Downloaded all files!')\n",
        "\n",
        "\n",
        "def save_mnist():\n",
        "    print(f'Saving mnist.pkl...')\n",
        "    mnist = {}\n",
        "    for name in filename[:2]:\n",
        "        with gzip.open(name[1], 'rb') as f:\n",
        "            mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=16).reshape(-1,28*28)\n",
        "    for name in filename[-2:]:\n",
        "        with gzip.open(name[1], 'rb') as f:\n",
        "            mnist[name[0]] = np.frombuffer(f.read(), np.uint8, offset=8)\n",
        "    with open(\"mnist.pkl\", 'wb') as f:\n",
        "        pickle.dump(mnist,f)\n",
        "    print(\"Saved mnist.pkl!\")\n",
        "\n",
        "\n",
        "def delete_temp_files():\n",
        "    for name in filename:\n",
        "        print(f'Deleting temporary file {name[1]}...')\n",
        "        os.remove(name[1])\n",
        "        print(f'Deleted temporary file {name[1]}!')\n",
        "    print(f'Deleted all temporary files!')\n",
        "\n",
        "\n",
        "download_mnist()\n",
        "save_mnist()\n",
        "delete_temp_files()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o4SWicMv0C70"
      },
      "source": [
        "# Load Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 230,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QB8QlcVO0C71",
        "outputId": "6d431a4a-41b1-467b-c77a-cf6dcabee41b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training images shape: (60000, 784)\n",
            "Training labels shape: (60000,)\n",
            "Testing images shape: (10000, 784)\n",
            "Testing labels shape: (10000,)\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "from urllib import request\n",
        "import gzip\n",
        "import pickle\n",
        "\n",
        "\n",
        "def load():\n",
        "    with open(\"mnist.pkl\",'rb') as f:\n",
        "        mnist = pickle.load(f)\n",
        "\n",
        "        training_images, training_labels, testing_images, testing_labels = mnist[\"training_images\"], mnist[\"training_labels\"], mnist[\"test_images\"], mnist[\"test_labels\"]\n",
        "        # Normalize the images\n",
        "        training_images.astype('float32')\n",
        "        testing_images.astype('float32')\n",
        "        training_images = training_images / 255\n",
        "        testing_images = testing_images / 255\n",
        "        return training_images, training_labels, testing_images, testing_labels\n",
        "\n",
        "\n",
        "training_images,training_labels,testing_images,testing_labels=load()\n",
        "print(f'Training images shape: {training_images.shape}')\n",
        "print(f'Training labels shape: {training_labels.shape}')\n",
        "print(f'Testing images shape: {testing_images.shape}')\n",
        "print(f'Testing labels shape: {testing_labels.shape}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqncnTBb0C72"
      },
      "source": [
        "# Display Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 231,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 530
        },
        "id": "IZ2FrBIX0C72",
        "outputId": "ea29fcc4-bb03-4fd1-ae0b-87e42b3f373a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 540x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def show_random_grid(training_images, training_labels, num_row, num_col):\n",
        "    \"\"\"Shows a grid of random images from the training set\n",
        "\n",
        "    Args:\n",
        "        training_images (numpy.ndarray): The training images\n",
        "        training_labels (numpy.ndarray): The training labels\n",
        "        num_row (int): The number of rows in the grid\n",
        "        num_col (int): The number of columns in the grid\n",
        "    \"\"\"\n",
        "    num = num_row * num_col\n",
        "\n",
        "    images = training_images[:num].reshape(num, 28,28)\n",
        "    labels = training_labels[:num]\n",
        "\n",
        "    # plot images\n",
        "    fig, axes = plt.subplots(num_row, num_col, figsize=(1.5*num_col,2*num_row))\n",
        "    for i in range(num):\n",
        "        ax = axes[i//num_col, i%num_col]\n",
        "        ax.imshow(images[i], cmap='gray')\n",
        "        ax.set_title('Label: {}'.format(labels[i]))\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "show_grid(2,5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FelJYT4r0C73"
      },
      "source": [
        "# The Neural Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 232,
      "metadata": {
        "id": "rmTbf-SS0C74"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import time\n",
        "\n",
        "class NeuralNetwork():\n",
        "  def __init__ (self, layer_sizes, layer_activation_functions, learning_rate, momentum, epochs, batch_size):\n",
        "    # Used to map the activation functions to the correct function\n",
        "    activation_functions_map = {\n",
        "      'sigmoid': self._sigmoid,\n",
        "      'relu': self._relu,\n",
        "      'tanh': self._tanh,\n",
        "      'softmax': self._softmax,\n",
        "    }\n",
        "\n",
        "    self.layer_sizes = layer_sizes\n",
        "    self.layer_activation_functions = [ activation_functions_map[function] for function in layer_activation_functions ]\n",
        "    self.learning_rate = learning_rate\n",
        "    self.momentum = momentum\n",
        "    self.epochs = epochs\n",
        "    self.batch_size = batch_size\n",
        "\n",
        "\n",
        "  def train(self, training_images, training_labels):\n",
        "    \"\"\"Trains the network.\n",
        "\n",
        "    Args:\n",
        "        training_images (numpy.ndarray): The training images.\n",
        "        training_labels (numpy.ndarray): The training labels.\n",
        "    \"\"\"\n",
        "\n",
        "    print('Training the neural network...')\n",
        "\n",
        "    # Initialize the weights and biases with random values to avoid local minima\n",
        "    self.W = [] \n",
        "    self.B = []\n",
        "    for layer in range(len(self.layer_sizes) - 1):\n",
        "      self.W.append(0.1 * np.random.randn(self.layer_sizes[layer], self.layer_sizes[layer + 1]))\n",
        "      self.B.append(np.zeros((1, self.layer_sizes[layer + 1])))\n",
        "\n",
        "    # Interates over the epochs\n",
        "    for epoch in range(self.epochs):\n",
        "      start_time = time.time()\n",
        "\n",
        "      # Trains in batches to speed up the training\n",
        "      for batch_start in range(0, training_images.shape[0], self.batch_size):\n",
        "        batch_images = training_images[batch_start:batch_start+self.batch_size]\n",
        "        batch_labels = training_labels[batch_start:batch_start+self.batch_size]\n",
        "\n",
        "        # Forward pass\n",
        "        hidden_layers = self._forward(batch_images)\n",
        "\n",
        "        # Backward pass\n",
        "        self._backpass(hidden_layers=hidden_layers, training_images=batch_images, training_labels=batch_labels)\n",
        "\n",
        "      end_time = time.time() - start_time\n",
        "      print ('Epoch {}/{}, time: {:.2f}s, training accuracy: {:.2f}%'.format(epoch + 1, self.epochs, end_time, self.evaluate(training_images, training_labels) * 100))\n",
        "\n",
        "    print('Training complete!')\n",
        "\n",
        "\n",
        "  def _forward (self, training_images):\n",
        "    \"\"\"Performs a forward pass through the network.\n",
        "\n",
        "    Args:\n",
        "        training_images (numpy.ndarray): The training images.\n",
        "    Returns:\n",
        "        output_layers (list): A list of the output layers of the network.\n",
        "        \n",
        "    \"\"\"\n",
        "    output_layers = [training_images]\n",
        "    input = output_layers[0]\n",
        "\n",
        "    for layer in range(len(self.layer_sizes) - 1):\n",
        "      hidden_layer = self.layer_activation_functions[layer](np.dot(input, self.W[layer]) + self.B[layer])\n",
        "      output_layers.append(hidden_layer)\n",
        "      input = hidden_layer\n",
        "\n",
        "    # output = self._softmax(scores)\n",
        "    return output_layers\n",
        "\n",
        "\n",
        "  def _backpass (self, hidden_layers, training_images, training_labels):\n",
        "    \"\"\"Performs a backpass on the network.\n",
        "\n",
        "    Args:\n",
        "        hidden_layer1 (numpy.ndarray): The first hidden layer of the network.\n",
        "        hidden_layer2 (numpy.ndarray): The second hidden layer of the network.\n",
        "        hidden_layer2 (numpy.ndarray): The output layer of the network.\n",
        "        training_images (numpy.ndarray): The training images.\n",
        "        training_labels (numpy.ndarray): The training labels.\n",
        "    \"\"\"\n",
        "\n",
        "    layers = hidden_layers\n",
        "\n",
        "    # Calculates the deltas for the output layer to use in the backpropagation\n",
        "    delta_weights = []\n",
        "    delta_biases = []\n",
        "    delta_hidden = []\n",
        "\n",
        "    dscores = layers[-1]\n",
        "    dscores[range(len(training_images)), training_labels] -= 1\n",
        "    dscores /= len(training_images)\n",
        "\n",
        "    delta_hidden.append(dscores)\n",
        "\n",
        "    # Performs the backpropagation on the hidden layers to calculate the deltas for the weights and biases\n",
        "    for layer in reversed(range(len(layers) - 1)):\n",
        "      delta_weights.insert(0, np.dot(layers[layer].T, delta_hidden[0]))\n",
        "      delta_biases.insert(0, np.sum(delta_hidden[0], axis=0, keepdims=True))\n",
        "\n",
        "      if layer == 0:\n",
        "        break\n",
        "\n",
        "      delta_hidden.insert(0, np.dot(delta_hidden[0], self.W[layer].T))\n",
        "      delta_hidden[0][layers[layer] <= 0] = 0\n",
        "\n",
        "    # Update delta weights with momentum.\n",
        "    for layer in reversed(range(len(delta_weights))):\n",
        "      delta_weights[layer] += self.momentum*self.W[layer]\n",
        "\n",
        "    # Updates the network's weights and biases.\n",
        "    for layer in range(len(delta_weights)):\n",
        "      self.W[layer] += -self.learning_rate * delta_weights[layer]\n",
        "      self.B[layer] += -self.learning_rate * delta_biases[layer]\n",
        "\n",
        "\n",
        "  def predict(self, image):\n",
        "    \"\"\"Predicts the label of an image.\n",
        "\n",
        "    Args:\n",
        "        image (numpy.ndarray): The image to predict the label of.\n",
        "\n",
        "    Returns:\n",
        "        int: The predicted label.\n",
        "    \"\"\"\n",
        "\n",
        "    outputs = self._forward(image)\n",
        "    return np.argmax(outputs[-1])\n",
        "\n",
        "\n",
        "  def evaluate (self, validation_images, validation_labels):\n",
        "    \"\"\"Evaluates the accuracy of the network on a validation set.\n",
        "\n",
        "    Args:\n",
        "        validation_images (numpy.ndarray): The validation images.\n",
        "        validation_labels (numpy.ndarray): The validation labels.\n",
        "\n",
        "    Returns:\n",
        "        accuracy (float): The accuracy of the network on the validation set.\n",
        "    \"\"\"\n",
        "\n",
        "    outputs = self._forward(validation_images)\n",
        "\n",
        "    count = 0\n",
        "    for i in range(len(validation_images)):\n",
        "      if np.argmax(outputs[-1][i]) == validation_labels[i]:\n",
        "        count += 1\n",
        "    return count / len(validation_images)\n",
        "\n",
        "\n",
        "  def _sigmoid(self, x, derivative=False):\n",
        "    \"\"\"Computes the sigmoid function.\n",
        "\n",
        "    Args:\n",
        "        x (numpy.ndarray): The input to the sigmoid function.\n",
        "        derivative (bool): Whether to compute the derivative of the sigmoid function or not.\n",
        "\n",
        "    Returns:\n",
        "        _type_: _description_\n",
        "    \"\"\"\n",
        "    if derivative:\n",
        "      return x * (1 - x)\n",
        "    return 1 / (1 + np.exp(-x))\n",
        "\n",
        "\n",
        "  def _relu(self, x, derivative=False):\n",
        "    \"\"\"Computes the rectified linear unit.\n",
        "    \n",
        "    Args:\n",
        "        x (numpy.ndarray): The input data.\n",
        "        derivative (bool): Whether to compute the derivative of the relu or not.\n",
        "        \n",
        "    Returns:\n",
        "        numpy.ndarray: The relu of the input data.\n",
        "    \"\"\"    \n",
        "\n",
        "    if derivative:\n",
        "      return np.where(x > 0, 1, 0)\n",
        "    return np.maximum(0, x)\n",
        "\n",
        "\n",
        "  def _tanh(self, x, derivative=False):\n",
        "    \"\"\"Computes the hyperbolic tangent function.\n",
        "\n",
        "    Args:\n",
        "        x (numpy.ndarray): The input to the tanh function.\n",
        "        derivative (bool): Whether to compute the derivative of the tanh function or not.\n",
        "\n",
        "    Returns:\n",
        "        _type_: _description_\n",
        "    \"\"\"\n",
        "    if derivative:\n",
        "      return 1 - np.power(x, 2)\n",
        "    return np.tanh(x)\n",
        "\n",
        "\n",
        "  def _softmax(self, x, derivative=False):\n",
        "    \"\"\"Computes the softmax activation function.\n",
        "    \n",
        "    Args:\n",
        "        x (numpy.ndarray): The input data.\n",
        "        derivative (bool): Whether to compute the derivative of the softmax or not.\n",
        "        \n",
        "    Returns:\n",
        "        numpy.ndarray: The softmax of the input data.\n",
        "    \"\"\"\n",
        "\n",
        "    if derivative:\n",
        "      return x * (1 - x)\n",
        "    return np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ncSa59O0C75"
      },
      "source": [
        "# Network Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 233,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 467
        },
        "id": "hXBwEvH00C76",
        "outputId": "fff4d442-89d0-4e96-d019-6222157fe032"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Starting model 1...\n",
            "Training the neural network...\n",
            "Epoch 1/10, time: 0.79s, training accuracy: 77.98%\n",
            "Epoch 2/10, time: 0.83s, training accuracy: 79.90%\n",
            "Epoch 3/10, time: 0.84s, training accuracy: 81.38%\n",
            "Epoch 4/10, time: 0.82s, training accuracy: 82.52%\n",
            "Epoch 5/10, time: 0.98s, training accuracy: 83.58%\n",
            "Epoch 6/10, time: 1.74s, training accuracy: 84.44%\n",
            "Epoch 7/10, time: 0.91s, training accuracy: 85.34%\n",
            "Epoch 8/10, time: 0.90s, training accuracy: 85.62%\n",
            "Epoch 9/10, time: 1.23s, training accuracy: 85.92%\n",
            "Epoch 10/10, time: 0.87s, training accuracy: 85.98%\n",
            "Training complete!\n",
            "Model 1 complete!\n",
            "Model 1 testing set accuracy: 85.81%\n"
          ]
        }
      ],
      "source": [
        "# Model 1\n",
        "print(f'Starting model 1...')\n",
        "np.random.seed(0)\n",
        "nn = NeuralNetwork([784, 64, 10], ['tanh', 'tanh', 'tanh'], 0.1, 1e-3, 10, 128)\n",
        "nn.train(training_images, training_labels)\n",
        "print('Model 1 complete!')\n",
        "print('Model 1 testing set accuracy: {:.2f}%'.format(nn.evaluate(testing_images, testing_labels) * 100))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 234,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Starting model 2...\n",
            "Training the neural network...\n",
            "Epoch 1/10, time: 1.02s, training accuracy: 85.69%\n",
            "Epoch 2/10, time: 0.90s, training accuracy: 87.36%\n",
            "Epoch 3/10, time: 0.74s, training accuracy: 87.66%\n",
            "Epoch 4/10, time: 0.78s, training accuracy: 87.09%\n",
            "Epoch 5/10, time: 0.74s, training accuracy: 87.09%\n",
            "Epoch 6/10, time: 0.91s, training accuracy: 87.32%\n",
            "Epoch 7/10, time: 1.14s, training accuracy: 86.90%\n",
            "Epoch 8/10, time: 1.07s, training accuracy: 86.50%\n",
            "Epoch 9/10, time: 1.34s, training accuracy: 86.57%\n",
            "Epoch 10/10, time: 0.77s, training accuracy: 86.67%\n",
            "Training complete!\n",
            "Model 2 complete!\n",
            "Model 2 testing set accuracy: 87.25%\n"
          ]
        }
      ],
      "source": [
        "# Model 2\n",
        "print(f'Starting model 2...')\n",
        "np.random.seed(0)\n",
        "nn = NeuralNetwork([784, 64, 10], ['sigmoid', 'sigmoid', 'softmax'], 0.1, 1e-3, 10, 128)\n",
        "nn.train(training_images, training_labels)\n",
        "print('Model 2 complete!')\n",
        "print('Model 2 testing set accuracy: {:.2f}%'.format(nn.evaluate(testing_images, testing_labels) * 100))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 235,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Starting model 3...\n",
            "Training the neural network...\n",
            "Epoch 1/10, time: 5.74s, training accuracy: 90.27%\n",
            "Epoch 2/10, time: 3.64s, training accuracy: 92.97%\n",
            "Epoch 3/10, time: 3.56s, training accuracy: 94.22%\n",
            "Epoch 4/10, time: 3.37s, training accuracy: 94.99%\n",
            "Epoch 5/10, time: 3.52s, training accuracy: 95.58%\n",
            "Epoch 6/10, time: 3.27s, training accuracy: 95.95%\n",
            "Epoch 7/10, time: 4.56s, training accuracy: 96.25%\n",
            "Epoch 8/10, time: 3.99s, training accuracy: 96.53%\n",
            "Epoch 9/10, time: 3.32s, training accuracy: 96.75%\n",
            "Epoch 10/10, time: 3.07s, training accuracy: 96.92%\n",
            "Training complete!\n",
            "Model 3 complete!\n",
            "Model 3 testing set accuracy: 96.49%\n"
          ]
        }
      ],
      "source": [
        "# Model 3\n",
        "print(f'Starting model 3...')\n",
        "np.random.seed(0)\n",
        "nn = NeuralNetwork([784, 256, 64, 10], ['relu', 'relu', 'relu', 'softmax'], 0.1, 1e-3, 10, 128)\n",
        "nn.train(training_images, training_labels)\n",
        "print('Model 3 complete!')\n",
        "print('Model 3 testing set accuracy: {:.2f}%'.format(nn.evaluate(testing_images, testing_labels) * 100))"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "neural-network-numpy.ipynb",
      "provenance": []
    },
    "interpreter": {
      "hash": "3ec7080d4d3dba4fb1047f3029dc229d1696710d69ce79e95c5066655a8eeb4b"
    },
    "kernelspec": {
      "display_name": "Python 3.10.2 64-bit",
      "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.10.2"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 0
}