Convolutional_Neural_Network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "toc_visible": true,
      "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/github/levyjonathan31/GoogleCollabCNN/blob/main/Convolutional_Neural_Network.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "no0Aj9OXaki1"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from scipy.signal import convolve2d\n",
        "import matplotlib.pyplot as plt\n",
        "from keras.datasets import fashion_mnist"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load mnist data\n",
        "(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()"
      ],
      "metadata": {
        "id": "nS77UZsHbHYc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Set random seed\n",
        "np.random.seed(7)"
      ],
      "metadata": {
        "id": "pwBc0eGPMwWU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The layer classes for our network"
      ],
      "metadata": {
        "id": "PhkYihoDlMIH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from abc import ABC, abstractmethod  # this is important for some of the OOP we're doing\n",
        "from typing import List              # this is also important for some type suggestion stuff"
      ],
      "metadata": {
        "id": "3EI7eaN7mdEB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Abstract base layer"
      ],
      "metadata": {
        "id": "XWTpKJ48n8rU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Layer(ABC):\n",
        "    '''\n",
        "        Abstract class for other layer classes to inherit from.\n",
        "    '''\n",
        "    @abstractmethod\n",
        "    def forward_propagate(self, input_data):\n",
        "        pass\n",
        "\n",
        "    @abstractmethod\n",
        "    def back_propagate(self, gradient, lr):\n",
        "        pass"
      ],
      "metadata": {
        "id": "Pc5tUH39lLbh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conv Layer"
      ],
      "metadata": {
        "id": "SI3C1xj3n-6n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class ConvLayer(Layer):\n",
        "    def __init__(self, num_filters, conv_size=(3, 3), activation='relu'):\n",
        "        self.num_filters = num_filters\n",
        "        self.conv_width, self.conv_height = conv_size\n",
        "\n",
        "        # Determine activation function\n",
        "        if activation == 'sigmoid': activation_function = lambda x: 1 / (1 + np.exp(-x))\n",
        "        elif activation == 'tanh': activation_function = lambda x: np.tanh(x)\n",
        "        else: activation_function = lambda x: np.maximum(0, x)  # relu by default, just in case\n",
        "\n",
        "        # Vectorize it for ease of use with numpy\n",
        "        self.activation = np.vectorize(activation_function)\n",
        "\n",
        "        # Using Xavier initialization\n",
        "        # xavier_scaling = np.sqrt(6.0 / (conv_width * conv_height * input_channels))\n",
        "        # self.W = xavier_scaling * np.random.randn(num_filters, conv_width, conv_height, input_channels)\n",
        "        self.W = np.random.uniform(low=-0.3, high=0.3, size=(self.num_filters, self.conv_width, self.conv_height))\n",
        "        self.b = np.zeros((num_filters, 1))\n",
        "\n",
        "    def forward_propagate(self, input):\n",
        "        input_height, input_width = input.shape\n",
        "\n",
        "        # initialize output array (note: this is typically num_filters x 30 x 30, or whatever your input shape is)\n",
        "        output = np.zeros((self.num_filters, input_height - self.conv_height + 1, input_width - self.conv_width + 1))\n",
        "\n",
        "        # apply convolution\n",
        "        for f in range(self.num_filters):\n",
        "            output[f] += convolve2d(input, self.W[f], mode='valid', boundary='fill') + self.b[f]\n",
        "\n",
        "        # clip values and apply activation function\n",
        "        output = self.activation(output)\n",
        "        output = np.clip(output, 0, 255)\n",
        "\n",
        "        # black padding to the output\n",
        "        return np.pad(output, ((0, 0), (1, 1), (1, 1)), mode='constant', constant_values=0)\n",
        "\n",
        "    def back_propagate(self, gradient, lr):\n",
        "        raise Exception(\"Not yet implemented\")"
      ],
      "metadata": {
        "id": "9MLgBnUxoBUI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Pooling Layer"
      ],
      "metadata": {
        "id": "mgiFiRyjokCn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MaxPoolingLayer(Layer):\n",
        "    def __init__(self, pool_size=(2, 2)):\n",
        "        self.pool_size = pool_size\n",
        "\n",
        "    def forward_propagate(self, input):\n",
        "        batch_size, input_height, input_width = input.shape\n",
        "        pool_height, pool_width = self.pool_size\n",
        "\n",
        "        # Calculate dimensions of the pooled output\n",
        "        output_height = input_height // pool_height\n",
        "        output_width = input_width // pool_width\n",
        "\n",
        "        # reshape the input to make pooling more efficient\n",
        "        reshaped_input = input.reshape(batch_size, output_height, pool_height, output_width, pool_width)\n",
        "\n",
        "        # effectively performs max pooling over the specified pool_height and pool_width\n",
        "        output = reshaped_input.max(axis=(2, 4))\n",
        "\n",
        "        return output\n",
        "\n",
        "    def back_propagate(self, gradient, lr):\n",
        "        raise Exception(\"Not yet implemented\")"
      ],
      "metadata": {
        "id": "OEKF0fFdolb2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Flatten Layer"
      ],
      "metadata": {
        "id": "cecUmSewqt-9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FlattenLayer(Layer):\n",
        "    def __init__(self):\n",
        "        pass  # i don't think we need anything?\n",
        "\n",
        "    def forward_propagate(self, input):\n",
        "        batch_size = input.shape[0]\n",
        "\n",
        "        # Calculate the flattened size\n",
        "        flattened_size = np.prod(input.shape[1:])  # ignores the first dimension (batch size or num filters ??)\n",
        "\n",
        "        # Reshape the input to a flat vector\n",
        "        flattened_output = input.reshape(batch_size, flattened_size)\n",
        "\n",
        "        return flattened_output\n",
        "\n",
        "    def back_propagate(self, gradient, lr):\n",
        "        raise Exception(\"Not yet implemented\")"
      ],
      "metadata": {
        "id": "3XkWnbzYqvTj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "input_image = x_train[1]\n",
        "conv_layer = ConvLayer(num_filters=5, conv_size=(3, 3))\n",
        "max_pooling_layer = MaxPoolingLayer(pool_size=(2, 2))\n",
        "flatten_layer = FlattenLayer()\n",
        "\n",
        "feature_map = conv_layer.forward_propagate(input_image)\n",
        "plot_images_in_a_line(feature_map)\n",
        "\n",
        "output_images = max_pooling_layer.forward_propagate(feature_map)\n",
        "plot_images_in_a_line(output_images)\n",
        "\n",
        "output_images = max_pooling_layer.forward_propagate(output_images)\n",
        "plot_images_in_a_line(output_images)\n",
        "\n",
        "feature_vectors = flatten_layer.forward_propagate(output_images)\n",
        "\n",
        "print(feature_vectors[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 558
        },
        "id": "4PuAskkRYoyD",
        "outputId": "131df37b-f53e-47d1-dc64-663147a5ac6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAABpCAYAAABF9zs7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAOmElEQVR4nO3d2c4UVReA4f0po7M4oCAOOMXhwMQhHhoTr8BEr807MN6BiR5wTtAYo0gMoqJGQP1QZBCV/+DX7ds7vfrb1VVdQ/f7HC2wh6ratZtyrT1s3bhx40aSJEkb7aahD0CSJA3PBwJJkuQDgSRJ8oFAkiQlHwgkSVLygUCSJCUfCCRJUvKBQJIkpZR21b5wa2trlcexsbpYF8q2WY22bWO7rIZ9ZrzsM+NU2y5mCCRJkg8EkiSpQclgFfbs2TPz56eeeirHhw4dyvG1a9dy/MUXX+R49+7dOT58+HCO77jjjrnfd/HixRyfOnUqx0xTPfPMMzneteu/y3P69OmZz/rhhx9yfNddd+X4woULc797rHjud999d47La8jzZXuM0SOPPJLj++67L8fnzp3L8TfffNPrMdW4+eabc/zkk0/m+Keffsrx7bffPvOe/fv355hpwaNHj+b4+PHjOWa77tu3L8ds0zvvvHPu8fHevnz5co5vueWWHF+6dCnH58+fn3l/lLbkOVy5cmXua4Z2003//b/Tgw8+mGNeq19//XXmPTz/mj5z66235vj3339f6jhTSmnv3r1zY7YZ+0VKs7+l7CdXr15d+jj6wHZ54IEHcry9vZ1jnve6YLt2+XtshkCSJPlAIEmSUtqq3f64zehPpkJfffXV8DOZxh1jSpdY0nj66adzfOzYsRz//fffO37O0COm2TaM//jjj1bHNEZMKf7yyy85jlJufY+Yfumll3L8559/zo3LdD6/gylqpoCJZTDen3/99dfcz2QKnyUGpvlZJmB6tkyh87tZfmDpkOca9Z8h+gz7O/sGz7G2z7A0Fx0T2yNqS6bL2XeZ5uf1ZJuV58//xnQ74xp995mHHnoox2fPnm313VPFaxZdf2cZSJKkaj4QSJKkfkoGr732Wo4//fTTHE9tRH6NpiOmhy4ZTGGEd1c4ipvnHd2HfaQ/OWvgzTffzPGXX36ZY6bky7Q0v4NpY6acI0zhs2zCz+HnM4XPmNcpSm+nNJu+Pnny5NzX1NyPffUZjuTm9eT14XXjsac0e7/xs5jqp5oSSVTyIR7r9evX58bRMaQ0O0vnxx9/zDFnGkX66DMsXUXnuknYlm3LbGYIJEmSDwSSJGmFCxNx5PDnn3+e49oywT333JNjpju4CEq0OApTk1E6hZ/JkcJt0+YHDx7M8ZkzZ1p91qocOXIkx99+++2AR9IvLvbC+2VIDz/8cI654M0HH3yQ49tuuy3HTFenNJtiZXqXC88wlcrP4kJdTMOynzBFTbx+jDk7iN+V0uwCXpExlbCi9DXLBCwLlPcUyztDlUejmSGLZkBxZsGBAwdyXFMy6AP7AH/fN7VkUDObrZYZAkmS5AOBJElaYcmAKUuuxV6L6Tq+/+eff577+ujv+zbWtBVTv32kYlky4jVhqYbr6jO9ytesat8ElpV4rH0vyMTFiDizgGlApkjLFD6vD0sGXLCFqV7uBfL888/n+LPPPsvxvffem2O2Ba8Nj+ntt9+e+znlIkp8/xNPPJFjnjdfUzN6ui9R+YCzB8q+z+OPzoUlI5YuozIR38tj4nXjols8Pqb/y99Lfu5vv/2W46g0NOT+ADyOcr+MVRvyt6JGzSJFi5ghkCRJPhBIkqQVlgw4ovi7775r/P6a7T+jhVg4srZm+06uLc502zKWOdc+MM3W5YjnqA24lTXbgOnIaOveaBtmplQ//vjjFkc9O8Ke16bvNOCLL76Y43feeWfuMfHalKnrKC3Iz/3oo4/mvoZ7O3DBMJb7WG5gn2TJ5ZVXXsnxu+++Gx4bry1n40SLMA2dnuV9Gy24FKXzU5otE9x///055j3N8gzvb5ZJ+Rr2Hy5qxWNlO/E+Z7mpnK3CtmI5gCUp3hdff/11GsqiRZXaqPl3gPcB70nONuE1428irzHbtMvf47YLQ5khkCRJPhBIkqQVlgyY2lpGlBZ66623cnzq1KkcMwXJ1B3TX0zbMSXH1xw/fjzHTAPVlDBKQ6c8iedebku7CkxBNxWlI9nGbUWj+PvA+4qlNaYOuTBXtF9BSvGeBfxczjjgwkH8XKZCWXLjyHR+5unTp3PM1DXPrUyhs8xQY4j+E30nZxDwHJmiLduG58vR/vzdYhzpakEg/ubx/kpp9jyia8B27huv36ruhZpycfTvQNN/H/r4DV6GGQJJkuQDgSRJ8oFAkiSljscQsLbWdipFVJN57733Wn1uE21XHeRKbX2vqFXiVKcuvf766zk+ceJEjlmv5Kp03EzpscceyzHHcfDe4d8fPnw4x1yVb2qee+65HLMWz/EAHEPD2nRtHZ73W7SKJ+vXvNd5bTkNMJp6xzbl1LZyHBDr1DWrZbKW3RdO9+Txc1off+fYZuV4Do7R4LlwTMfZs2dzzH7ClQq/+uqrHD/66KM5PnfuXI45hZdT2tj2nN5ZTl9l27KdalaqjMaxdInjF1a10iqvIc+J582xDJxeyPbl2Jmov0bTF4dmhkCSJPlAIEmSOi4ZcD93Tm+aEq7exqmTtWkdTtka09QSpvO79Mknn+SY0wK5qhnTlry+TKcxVfvss8/m+MyZMznmSmJdTknjam59OHLkSI65siWn+DEly7i8p6KVyY4dO5ZjpkI5dZBlBbYXywQsAfD6872cqsvPL0WbVkUri/aRii5tb2/v+Bqm28vNpoj3N+97XqNo9UC2AcsEvG4sSfK7WEqI7u1y07BoWl+0YiL7a9sp5jW6XM0vwlJE1C68brwPons1ureXmcbeBzMEkiTJBwJJkpTS1o3K3RCi/cA5ep0fxTRS2z2aX3jhhRxz9C1TMEyZRfvHRxuR8L1MyX7//fc55kp/Kc2ODub5lam4nbTdjKL8fmKqkal31WnbNlG7vPHGGznm/RZtuMR7j/dkSrMp3WiDKI5o5r3OPsAR9dHfsy9Fsz84Ir6cCfL444/PfT9fx1RqVBZaZZ9po1zJj9eLx8+2HXr2URP87WX5gL8tq+ozbf8N2XS118wMgSRJ8oFAkiR1UDJYZ0z5Nd2YpdYq05+HDh2a+xqOpuVo5jEtkNFG00VCIqtKf7JdeEwcqcx7j6n2coOnDz/8MMcvv/xyjpnGjRbSqenTvAY8Jt43nMVw8uTJHJfXm2UMlkqiEdpRmnjokkG0OE25YRBLCNHGORyFHqk5X5Z2+HqeJ/s3y60pzbYBZ7tEMyp43iz5rKrPsMzC7+B5WEqIWTKQJEnVfCCQJEndLky0bsq12KemHJH+L6b+mP7k4jTlHuzl3vZjNvbSR9QunA3Ae4/nc/To0Zn3vP/++znmCP0oDR+l3qNUbZRq5N9z9PmisgzPo2bRobGmgKOZRJzxkVK8uBT7Eq9J1MealnZqZoyw35d/Lvv+GHBWCvGcGLMUU7bXqsq/62Da/+JJkqRO+EAgSZL6KRkw5cW0Tpk2ZMq07dbDXahNWU5t0QymzKK4HDE9pQVUporXn/cRU7jcOjeleCbMojX254nS0lFqf5ly2hT6Rpe4pwD7E9P4LCWwDbr6TWE7LdqDYaxr6+8kKrPwfDhrIqV4O3CZIZAkSckHAkmSlHoqGTDltWh08dhSimM7nq5E6UimL7m4z9RMrYTzr+i4uQhQeT4cHR6VDJhWbXNt+PnR9y6yaYubRde6aWmg6XWLZhxE5YOUhtlqepX4Wzb12WJ98kpJkiQfCCRJ0sgWJmKaekqLR0wpLZ1SfLxcF5wzPqZmqiWD6FhZMihHh9fMMqhZjKhmkSJ+Pvcv0Hy8pk3LNk3biTG/q6Zdy/esA5ZALBnU80pJkiQfCCRJ0ohLBtHa1X2aUrq5C+uSNly30exMf5Zr0Nfs28DrEW2xXDMyPfouU7I7a1oCqPntqSkHRHsZlK9f59+6KZc/+2ZPliRJPhBIkqSRlQw4cnl7e3u4A/nHOqfRdrIu5YN1Uy4YFZUAuBdImxJKtO4+P59bzS5if/o/XsemCxbV/P2i/WLmvX7dTWnG2tDMEEiSJB8IJEnSyEoGY5hZQJucNp/yXgY1KdOpKhcmanOPRjMI+B18Db+LJYParZY3KU1dimZ0UM2sgdqFhuaJygrrbpPvu6Y2566QJEkhHwgkSdK4SgabPApZqrn/yxJIzYj1aNGhpqlUpr2XKe9tcuo22muA7VGz/XG0L0WNaKbDMp81JZt83zVlhkCSJPlAIEmSRlYyMLUzHuucQpyyclYBU7/RjIqaVHQ0WyHqk8vM3tjk/t1m22mq2e+gZoGjUllC0GYyQyBJknwgkCRJIysZSF3YpHJHmwVmohkH0Uj2aEaDa8V3r80CRBSVhco+ss7lnE36PWjLDIEkSfKBQJIk+UAgSZLSyMYQWOuRFiv7SM1KhRRtVtR0CmLN69WNaKXJpqsWLnq9YwiUkhkCSZKUfCCQJElpZCUDU4/jsc4pxClbtFJhVDKINtOJPmfR9+30+Wom6mdNVyRsumph7XGsg3U+t66ZIZAkST4QSJKkkZUMltkwRathGnicrl69OvPnffv25ZgrBu7evXvu+6NZBhSln6PR7t4rO4tG+DcdAc/fyKYlg+h41t3169eHPoTJMEMgSZJ8IJAkSSMrGVy7dm3oQ9A/2myaM7Q9e/bkeN023inLart2/deFo5JBmxHo0QZIUep6kWgmwyZge/B61VyTpqPk2TYs5/BemXL/boq/B1psc+4KSZIU8oFAkiSNq2Rw8ODBHF+4cCHHHCW6d+/eHDPtFS3QQlHqjWm1y5cv53j//v05vnLlysJjXzflaPYpYRuum4sXL4b/LRrtX5P2j14fjYhfJv2/yaO9z58/P/QhzDhw4MDMn9d51sGlS5eGPoTJMEMgSZJ8IJAkSSlt3ajMFbke9Gp0kaqzbVajbdvYLqthnxkv+8w41baLGQJJkuQDgSRJalAykCRJ68sMgSRJ8oFAkiT5QCBJkpIPBJIkKflAIEmSkg8EkiQp+UAgSZKSDwSSJCn5QCBJklJK/wPmInKlk6qMcgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 5 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAABpCAYAAABF9zs7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAE4klEQVR4nO3dzU4Ubx4F4INA0xoDYhS3JOpKl16A8Ra8CC/HxMRb8CJcunLvQjd+RSOKxsRoC8pHz3L+YzITTmEDOs+zPm+/1V1V5FCL+s1Np9NpAID/a6eO+wAAgOOnEAAACgEAoBAAAFEIAIAoBABAFAIAIAoBAJBk4aDBubm56oNv3rzZHktGo1G9pjGZTKr8kON5/Phxlf/+/Xu9x6/ac7O+vl7vsbGxUeV//PhR79G4ceNGvWZzc7PKv379ut7jn5aXl6v87du36z0+ffpU5dvfoDXken7+/PnM9/jVeDyu8pcvX673+Pr1a5Vv7+P9/f0qf+HChSqfJB8+fKjy7969q/f4p9OnT1f5Id/p7du39ZqTZmlpqcpvb28fKOcJAQCgEAAACgEAEIUAAIhCAABEIQAAohAAAFEIAIAoBABAFAIAIAoBAJBilkHr48eP9Zpr165V+S9fvlT5tbW1Kv/w4cMqnySXLl2q1xzWlStXqvyQOQO7u7tV/vr161X+/PnzVf7Ro0dVPkkuXrxYrzmM+/fvV/mnT5/We7TXdHvu79y5U+Xv3r1b5ZP+/fW/Qzs3YMjfs6tXr1b53zGj4X9pZysk/X15WCsrK1X+8+fP9R6rq6tV/ufPn1W+vZ7beSRJf0wH5QkBAKAQAAAKAQAQhQAAiEIAAEQhAACiEAAAUQgAgCgEAEAUAgAgCgEAEIUAAEgx3KgdoPPy5cv6YNqhEzs7O1W+He4xZFDRkAEih7W8vFzlX716Ve9x69atKv/mzZsqv7i4WOVHo1GVT2Y3EOS/efHiRZV/9uxZvce5c+eq/MbGRpVvz+PW1laVPy7j8bjKnzrV/+/U3pftcKP2HhgyPKkdAnVYe3t7VX7I9TadTqv8/v5+lT+Ke6D9DgflCQEAoBAAAAoBABCFAACIQgAARCEAAKIQAABRCACAKAQAQBQCACAKAQCQZG56wJcit++0np+frw9maWmpyg95N3fjKN6X/zveSd2em/X19XqPIfMPZmnIu+Xbd5If9ty05+XevXv1Hg8ePKjy3759q/Jnz56t8k+ePKnySTKZTKr8cdwzQ6ytrVX5djZL+x2G/D17//59lT/qe6b9jZNkc3OzXvOnO+h58YQAAFAIAACFAACIQgAARCEAAKIQAABRCACAKAQAQBQCACAKAQAQhQAASLIwqw/e29ur16ysrFT5Wc8yGPId/gQLCzM77UdmyKyMdpbBUVtdXa3XbG9vV/n2d2uvlaOYEfCn2N3dPe5D+A9D7pmTbnFx8bgP4a/iCQEAoBAAAAoBABCFAACIQgAARCEAAKIQAABRCACAKAQAQBQCACAKAQCQGc4yGGLWswlaf+ssA06mnZ2dek37vvzRaFTv0TDL4N+m02mV99v1Tvp8kj+NJwQAgEIAACgEAEAUAgAgCgEAEIUAAIhCAABEIQAAohAAAFEIAIAoBABAFAIAICdsuNGZM2eq/KyHDw35/K2trRkcCb9aXFys1wwZHnSUJpNJvWZhobuF22u6vZ7n5+er/N9sPB5XecONOG6eEAAACgEAoBAAAFEIAIAoBABAFAIAIAoBABCFAACIQgAARCEAAKIQAABJ5qbT6fS4DwIAOF6eEAAACgEAoBAAAFEIAIAoBABAFAIAIAoBABCFAACIQgAAJPkXM/cYdbvnDRcAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2.86793707e-01 6.41119533e+01 7.06599561e+01 7.05263015e+01\n",
            " 5.93963832e+01 6.59311941e+01 9.47916832e+00 0.00000000e+00\n",
            " 4.35560861e+01 8.56752831e+01 7.08368821e+01 8.26669136e+01\n",
            " 1.14941668e+01 3.29815934e+01 3.74046988e+01 1.02782322e+01\n",
            " 5.98548848e+01 5.57658850e+01 5.82414878e+01 3.39392450e+01\n",
            " 2.15181913e+01 1.34079107e-01 3.50450137e+00 1.08878604e+01\n",
            " 0.00000000e+00 0.00000000e+00 6.60335224e+00 1.71313968e-01\n",
            " 0.00000000e+00 2.28000050e-01 2.53392120e+01 0.00000000e+00\n",
            " 0.00000000e+00 3.35006269e+00 0.00000000e+00 0.00000000e+00\n",
            " 4.54744983e-01 1.57653290e+01 0.00000000e+00 0.00000000e+00\n",
            " 3.95951325e-01 0.00000000e+00 0.00000000e+00 1.67951275e-01\n",
            " 2.57553883e+01 1.27766483e+01 1.27161648e+01 9.02637754e+00\n",
            " 4.61950445e-02]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fully Connected Layer"
      ],
      "metadata": {
        "id": "UAIfb-N_p1Yn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class FCLayer(Layer):\n",
        "    def __init__(self, input_dim, output_dim, activation = \"relu\"):\n",
        "        # using He initialization\n",
        "        he = np.sqrt(2/(input_dim + output_dim))\n",
        "        self.W = np.random.uniform(low=-he, high=he, size=(output_dim, input_dim))\n",
        "        self.activation = activation\n",
        "        self.input_vector = None\n",
        "\n",
        "    def activate(self, Z):\n",
        "        return np.maximum(0.0, Z)  # ReLU\n",
        "\n",
        "    def gradient(self, dA, Z):\n",
        "        return dA * (Z > 0.0)  # ReLU derivative\n",
        "\n",
        "    def soft_max(self, Z):\n",
        "        # Essentially factoring out e^Z/e^Z\n",
        "        shifted_Z = Z - np.max(Z, axis=1, keepdims=True)\n",
        "        exp_Z = np.exp(shifted_Z)\n",
        "        softmax_result = exp_Z / np.sum(exp_Z, axis=1, keepdims=True)\n",
        "        return softmax_result\n",
        "\n",
        "    def forward_propagate(self, input):\n",
        "        # y = Wx + b\n",
        "        self.input_vector = input\n",
        "        linear_transform = input @ self.W.T\n",
        "        nonlinear_transform = self.activate(linear_transform)\n",
        "        if self.activation == \"softmax\":\n",
        "            nonlinear_transform = self.soft_max(linear_transform)\n",
        "        return nonlinear_transform\n",
        "\n",
        "    def back_propagate(self, grad_y, lr):\n",
        "        # Apply the derivative of the activation function\n",
        "        # Compute the gradients of the loss with respect to the weights and biases\n",
        "        grad_w = grad_y.T @ self.input_vector\n",
        "        np.clip(grad_w, -0.5, 0.5, out=grad_w)\n",
        "        self.W -= lr * grad_w\n",
        "        # compute next grad_y\n",
        "        grad_y = grad_y @ self.W\n",
        "        relu_derivative = (self.input_vector > 0).astype(float)\n",
        "        grad_y = np.multiply(grad_y, relu_derivative)\n",
        "        return grad_y"
      ],
      "metadata": {
        "id": "HR5OA4SSp25B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " # class ActivationLayer(FCLayer):\n",
        "#     def activate(Z):\n",
        "#         return np.maximum(0.0, Z)  # ReLU\n",
        "\n",
        "#     def gradient(dA, Z):\n",
        "#         return dA * (Z > 0.0)  # ReLU derivative"
      ],
      "metadata": {
        "id": "dgD56f8aAp35"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# class FCLayerSoftMax(Layer):\n",
        "#     def activate(Z):\n",
        "#         return np.exp(Z)/np.sum(np.exp(Z), axis=1, keepdims = True)"
      ],
      "metadata": {
        "id": "oWkKiS6XQgGy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Other (helper) functions"
      ],
      "metadata": {
        "id": "ORBGYIGLM3RA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def convert_to_onehot(y_train):\n",
        "    num_classes = len(np.unique(y_train))\n",
        "    y_cat = np.eye(num_classes)[y_train]\n",
        "    return y_cat\n",
        "\n",
        "def plot_images_in_a_line(images, cmap='gray'):\n",
        "    num_images = len(images)\n",
        "    for i in range(num_images):\n",
        "        plt.subplot(1, num_images, i + 1)\n",
        "        plt.imshow(images[i], cmap=cmap, vmin=0, vmax=255)\n",
        "        plt.axis('off')  # Turn off axis ticks and labels\n",
        "\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "P1wwMwHtM3Ee"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Our Network"
      ],
      "metadata": {
        "id": "qSyJqzEik1Qu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Network:\n",
        "    def __init__(self, layers: List[Layer] = None):\n",
        "        if layers is None:\n",
        "            layers = []\n",
        "        self.layers = layers  # The layers for our CNN\n",
        "\n",
        "    def summary(self):\n",
        "        ''' Prints a summary of the network architecture '''\n",
        "        raise Exception(\"Not yet implemented\")\n",
        "\n",
        "    def complete_forward_propagation(self, X):\n",
        "        ''' Forward propagation through all layers '''\n",
        "        b = X\n",
        "        for layer in self.layers:\n",
        "            b = layer.forward_propagate(b)\n",
        "        return b\n",
        "\n",
        "    def complete_backward_propagation(self, lr, grad, inputs):\n",
        "        ''' Backward propagation through all layers '''\n",
        "        # technically this is dL/dy\n",
        "        dy = grad\n",
        "        for layer in reversed(self.layers):\n",
        "            dy = layer.back_propagate(dy, lr)\n",
        "\n",
        "    def predict(self, X):\n",
        "        ''' Forward propagation to obtain predictions '''\n",
        "        # reshaped it so it can be treated as a 2d array\n",
        "        X = X.reshape(1,-1)\n",
        "        return self.complete_forward_propagation(X)\n",
        "\n",
        "    def categorical_cross_entropy(self, pred, y_cat):\n",
        "        ''' Compare truth values to predicted using cce'''\n",
        "        cce = -np.sum(y_cat * np.log(pred), axis=1, keepdims=True) # Ensure y_cat is one hot encoded\n",
        "        return cce\n",
        "\n",
        "    def fit(self, x_train_norm, y_cat, x_test_norm, y_test_cat, epochs, batch_size, lr):\n",
        "        ''' Propagates forward, performs cce, backpropagates '''\n",
        "        for epoch in range(epochs):\n",
        "            # Shuffles training data and splits into batches\n",
        "            randomized_indices = np.random.permutation(len(x_train_norm))\n",
        "            randomized_data = x_train_norm[randomized_indices]\n",
        "            randomized_labels = y_cat[randomized_indices]\n",
        "            avg_loss = 0\n",
        "            print(\"EPOCH: \", epoch + 1)\n",
        "            # Trains on each batch\n",
        "            for i in range(0, len(x_train_norm), batch_size):\n",
        "              batch_data = randomized_data[i:i + batch_size]\n",
        "              batch_cat = randomized_labels[i:i + batch_size]\n",
        "              forward_prop = self.complete_forward_propagation(batch_data)\n",
        "              pred = forward_prop\n",
        "              pred = np.clip(pred, 1e-8, None)\n",
        "              self.complete_backward_propagation(lr, pred - batch_cat, forward_prop)\n",
        "              cce = np.sum(self.categorical_cross_entropy(pred, batch_cat), axis=1)\n",
        "              avg_loss += np.mean(cce)\n",
        "            # Calculate avg loss\n",
        "            avg_loss /= np.ceil(len(x_train_norm) / batch_size)\n",
        "            print(\"Categorical Cross Entropy: \", avg_loss)\n",
        "\n",
        "            # Run through test set calculate accuracy\n",
        "            test_preds = self.complete_forward_propagation(x_test_norm)\n",
        "\n",
        "            pred_cats = np.argmax(test_preds, axis=1)\n",
        "            true_cats = np.argmax(y_test_cat, axis=1)\n",
        "            accuracy = np.mean(np.equal(pred_cats, true_cats))\n",
        "            print(\"Test Set Accuracy: \", accuracy)\n",
        "            print(\"----------------------------------------------\")\n",
        "\n",
        "    def add_layer(self, layer: Layer):\n",
        "        ''' Add a layer to the network dynamically '''\n",
        "        self.layers.append(layer)"
      ],
      "metadata": {
        "id": "e9lu93G2k0vG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Helper (MNIST Fashion Specific)"
      ],
      "metadata": {
        "id": "Ei8ZyoTShXNS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def label_to_fashion(label):\n",
        "    labels = [\"T-shirt\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\", \"Sandal\", \"Shirt\", \"Sneaker\", \"Bag\", \"Ankleboot\"]\n",
        "    return labels[label]"
      ],
      "metadata": {
        "id": "S2C6yLvUhWyK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "y_categorical = convert_to_onehot(y_train)\n",
        "y_test_categorical = convert_to_onehot(y_test)\n",
        "my_nn = Network()\n",
        "fc_layer_1 = FCLayer(784, 392)\n",
        "fc_layer_2 = FCLayer(392, 196)\n",
        "fc_layer_3 = FCLayer(196, 98)\n",
        "fc_layer_4 = FCLayer(98, 49)\n",
        "fc_layer_5 = FCLayer(49, 10, \"softmax\")\n",
        "my_nn.add_layer(fc_layer_1)\n",
        "my_nn.add_layer(fc_layer_2)\n",
        "my_nn.add_layer(fc_layer_3)\n",
        "my_nn.add_layer(fc_layer_4)\n",
        "my_nn.add_layer(fc_layer_5)"
      ],
      "metadata": {
        "id": "ByJqd9izZPEn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_train_normalized = x_train.reshape(60000,28*28)/255\n",
        "x_test_normalized = x_test.reshape(10000, 28*28)/255\n",
        "my_nn.fit(x_train_normalized, y_categorical, x_test_normalized, y_test_categorical, 20, 1000, 0.0005)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2UFK5oP4-8L8",
        "outputId": "feab2f61-4672-4d82-fd5e-6dcfcd29bbbe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EPOCH:  1\n",
            "Categorical Cross Entropy:  1.9250800808081052\n",
            "Test Set Accuracy:  0.5541\n",
            "----------------------------------------------\n",
            "EPOCH:  2\n",
            "Categorical Cross Entropy:  1.053332906096983\n",
            "Test Set Accuracy:  0.6246\n",
            "----------------------------------------------\n",
            "EPOCH:  3\n",
            "Categorical Cross Entropy:  0.8381914849094948\n",
            "Test Set Accuracy:  0.6872\n",
            "----------------------------------------------\n",
            "EPOCH:  4\n",
            "Categorical Cross Entropy:  0.7492646050490201\n",
            "Test Set Accuracy:  0.7157\n",
            "----------------------------------------------\n",
            "EPOCH:  5\n",
            "Categorical Cross Entropy:  0.692553851764614\n",
            "Test Set Accuracy:  0.7314\n",
            "----------------------------------------------\n",
            "EPOCH:  6\n",
            "Categorical Cross Entropy:  0.6579545824500124\n",
            "Test Set Accuracy:  0.7598\n",
            "----------------------------------------------\n",
            "EPOCH:  7\n",
            "Categorical Cross Entropy:  0.6314306270018287\n",
            "Test Set Accuracy:  0.7629\n",
            "----------------------------------------------\n",
            "EPOCH:  8\n",
            "Categorical Cross Entropy:  0.6163182405026061\n",
            "Test Set Accuracy:  0.7642\n",
            "----------------------------------------------\n",
            "EPOCH:  9\n",
            "Categorical Cross Entropy:  0.6002875751818613\n",
            "Test Set Accuracy:  0.7745\n",
            "----------------------------------------------\n",
            "EPOCH:  10\n",
            "Categorical Cross Entropy:  0.5903660739128855\n",
            "Test Set Accuracy:  0.7763\n",
            "----------------------------------------------\n",
            "EPOCH:  11\n",
            "Categorical Cross Entropy:  0.5836254201603986\n",
            "Test Set Accuracy:  0.7825\n",
            "----------------------------------------------\n",
            "EPOCH:  12\n",
            "Categorical Cross Entropy:  0.5779598229891296\n",
            "Test Set Accuracy:  0.7794\n",
            "----------------------------------------------\n",
            "EPOCH:  13\n",
            "Categorical Cross Entropy:  0.5755439787791764\n",
            "Test Set Accuracy:  0.7614\n",
            "----------------------------------------------\n",
            "EPOCH:  14\n",
            "Categorical Cross Entropy:  0.5755272977642002\n",
            "Test Set Accuracy:  0.7645\n",
            "----------------------------------------------\n",
            "EPOCH:  15\n",
            "Categorical Cross Entropy:  0.575384931319879\n",
            "Test Set Accuracy:  0.7844\n",
            "----------------------------------------------\n",
            "EPOCH:  16\n",
            "Categorical Cross Entropy:  0.5728297293465953\n",
            "Test Set Accuracy:  0.7851\n",
            "----------------------------------------------\n",
            "EPOCH:  17\n",
            "Categorical Cross Entropy:  0.5750372786782625\n",
            "Test Set Accuracy:  0.7843\n",
            "----------------------------------------------\n",
            "EPOCH:  18\n",
            "Categorical Cross Entropy:  0.5738307963641343\n",
            "Test Set Accuracy:  0.7858\n",
            "----------------------------------------------\n",
            "EPOCH:  19\n",
            "Categorical Cross Entropy:  0.5801716620254287\n",
            "Test Set Accuracy:  0.7895\n",
            "----------------------------------------------\n",
            "EPOCH:  20\n",
            "Categorical Cross Entropy:  0.5839283162351865\n",
            "Test Set Accuracy:  0.7857\n",
            "----------------------------------------------\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Other Considerations...\n",
        "Dropout weights"
      ],
      "metadata": {
        "id": "GhLfgPGzyrYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ind = np.random.randint(0, 9000)\n",
        "x_test_v = x_test[ind].reshape(28*28)\n",
        "fwd_prop = my_nn.predict(x_test_v)\n",
        "print(fwd_prop)\n",
        "pred_label = np.argmax(fwd_prop)\n",
        "print(\"Predicted Label: \",label_to_fashion(pred_label))\n",
        "print(\"Actual Label: \",label_to_fashion(y_test[ind]))\n",
        "plt.imshow(x_test[ind], cmap='gray')"
      ],
      "metadata": {
        "id": "HiwQa0vP4Ddq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 534
        },
        "outputId": "e875268c-e72f-4959-e71e-ac99eed5bd44"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.00000000e+000 0.00000000e+000 1.20540841e-083 0.00000000e+000\n",
            "  1.00000000e+000 0.00000000e+000 8.38856682e-205 0.00000000e+000\n",
            "  0.00000000e+000 0.00000000e+000]]\n",
            "Predicted Label:  Coat\n",
            "Actual Label:  Coat\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7956935500d0>"
            ]
          },
          "metadata": {},
          "execution_count": 46
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAguUlEQVR4nO3df2xV9f3H8Vdb2ksL7a1t6S8pWFBhkx/LEDqiMpQG6DIjSjZRl4AxEFgxA+Z0NQrqlnRq4tdoGP7hBjMRVDaB6BwLopQ5AcOvEaLroOsEBi1KaAtt6c/z/YOsW6WAnw+3931bno/kJO29593z7rnn9tXTe+67cUEQBAIAIMrirRsAAFydCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYGGDdwFd1dnbq+PHjSk1NVVxcnHU7AABHQRDozJkzys/PV3z8xc9zYi6Ajh8/roKCAus2AABX6OjRoxo6dOhF74+5AEpNTbVuAVexLVu2ONdcc801zjUJCQnONefOnXOuqa+vd66RpJkzZ3rVAf/rcj/Pey2AVq5cqeeff141NTUaP368Xn75ZU2aNOmydfzZrX/zeXyjOa5w0KBBzjWDBw92rhkwwP2p51PT3t7uXBNNsX484Mpc7vHtlYsQ3nzzTS1btkwrVqzQ3r17NX78eM2YMUMnT57sjc0BAPqgXgmgF154QfPnz9eDDz6ob37zm3rllVeUkpKi3/72t72xOQBAHxTxAGptbdWePXtUXFz8343Ex6u4uFg7duy4YP2WlhY1NDR0WwAA/V/EA+jLL79UR0eHcnJyut2ek5OjmpqaC9YvLy9XOBzuWrgCDgCuDuZvRC0rK1N9fX3XcvToUeuWAABREPGr4LKyspSQkKDa2tput9fW1io3N/eC9UOhkEKhUKTbAADEuIifASUlJWnChAnaunVr122dnZ3aunWrJk+eHOnNAQD6qF55H9CyZcs0d+5c3XzzzZo0aZJefPFFNTY26sEHH+yNzQEA+qBeCaB7771XX3zxhZYvX66amhp961vf0ubNmy+4MAEAcPWKC2LsbcUNDQ0Kh8PWbVxSLL9726c339fgfEbDRMucOXO86tatW+dcc+LECeeaqqoq55rhw4c711x77bXONZL0+OOPO9c8++yzXtuKBp8pElLsT5KIdfX19UpLS7vo/eZXwQEArk4EEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwQQAAAEwQQAMAEAQQAMEEAAQBM9Mo07P4uWoNF4+Oj8/tBLA8VlaSf//znzjVLlizx2lZTU5Nzzauvvupcs3z5cucan39n8tJLLznXSNLChQudayorK51rNm7c6Fzjw3eoqM9z0OfnQ4zNhI4azoAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACbighgbw9rQ0KBwOGzdRsT5TNXt7OzshU4uNGbMGK+68vLyqGwrKyvLuaalpcW5RvLb50OGDHGuKSoqcq75wx/+4FyTlpbmXCNJdXV1UdlWXFycc43PcffCCy8410hSW1ubV50rn/0QYz+6e1RfX3/J44IzIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYYRuohlgcHrl+/3rmmuLjYa1s+A1bPnj3rXOMzENLnMZL8hpEOHz7cueYvf/mLc83o0aOda1pbW51rJKm5udm5pqOjw7lm8ODBzjWhUMi55vTp0841kvTee+851yxdutRrW/0Rw0gBADGJAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACAiQHWDeDiXn31Veea2bNnO9ccOnTIuUbyGwqZkpLiXJOQkOBcU1dX51zjuy2fQZc+g1xramqca5KSkpxrJGnQoEHONT6DTxsaGpxrGhsbnWt8h9POmzfPueaPf/yjc83777/vXNMfcAYEADBBAAEATEQ8gJ566inFxcV1W3z+jwkAoH/rldeAbrrppm5/0xwwgJeaAADd9UoyDBgwQLm5ub3xpQEA/USvvAZ06NAh5efna8SIEXrggQd05MiRi67b0tKihoaGbgsAoP+LeAAVFRVpzZo12rx5s1atWqXq6mrddtttOnPmTI/rl5eXKxwOdy0FBQWRbgkAEIMiHkAlJSX6wQ9+oHHjxmnGjBl67733VFdXp7feeqvH9cvKylRfX9+1HD16NNItAQBiUK9fHZCenq4bb7xRhw8f7vH+UCjk9YZGAEDf1uvvAzp79qyqqqqUl5fX25sCAPQhEQ+gRx55RBUVFfrXv/6ljz/+WHfffbcSEhJ03333RXpTAIA+LOJ/gjt27Jjuu+8+nTp1SkOGDNGtt96qnTt3asiQIZHeFACgD4sLgiCwbuJ/NTQ0KBwOW7cRE/7xj38416SmpjrXtLW1OddI0XuDcXt7u3NNS0uL17Y6Ozuda9LT051rPvvsM+eanJwc5xrfx8jnddmmpibnmnPnzjnXdHR0ONf4DJmVpOuuu865Zu/evc41d9xxh3NNX1BfX6+0tLSL3s8sOACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACaiM00Suvnmm51rcnNznWvq6+uda3z/IaDP4E6f4ZM+AzUTExOdayS//nz2Q1xcnHONz0BNn+1IfgM/ffaD7+PkatCgQV51PkNtMzIyvLZ1NeIMCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABggmnYUfLDH/7QucZnknFSUlJUaiS/ick+04V9piwHQeBcI0nx8e6/k7W3t0dlOz5Ty32nYbe1tTnX+Ezrjpa0tDSvutbWVueazMxM5xqfx8n3GI8lnAEBAEwQQAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwwTDSKBk1alRUtuMzoDA9Pd1rW2fOnHGu8enPZ4Cp72DMAQPcnxK+w1xd+Qx/9Rl6KvkNWPUZGuvzOPkM7kxJSXGukaI3YHXixInONZ988kkvdBJdnAEBAEwQQAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwwTDSKBkxYoRzjc9wx1Ao5FzjM1RU8hsKmZqa6lzT1NTkXOOrra3NucZnP/gMufQ5HhITE51rJCk5Odm5prW11bnG53g4efKkc83HH3/sXCNJkydPdq7xOYaGDx/uXMMwUgAAPBFAAAATzgG0fft23XnnncrPz1dcXJw2btzY7f4gCLR8+XLl5eUpOTlZxcXFOnToUKT6BQD0E84B1NjYqPHjx2vlypU93v/cc8/ppZde0iuvvKJdu3Zp0KBBmjFjhs6dO3fFzQIA+g/nixBKSkpUUlLS431BEOjFF1/UE088obvuukuS9NprryknJ0cbN27UnDlzrqxbAEC/EdHXgKqrq1VTU6Pi4uKu28LhsIqKirRjx44ea1paWtTQ0NBtAQD0fxENoJqaGklSTk5Ot9tzcnK67vuq8vJyhcPhrqWgoCCSLQEAYpT5VXBlZWWqr6/vWo4ePWrdEgAgCiIaQLm5uZKk2trabrfX1tZ23fdVoVBIaWlp3RYAQP8X0QAqLCxUbm6utm7d2nVbQ0ODdu3a5fWOYgBA/+V8FdzZs2d1+PDhrs+rq6u1f/9+ZWRkaNiwYVqyZIl++ctf6oYbblBhYaGefPJJ5efna9asWZHsGwDQxzkH0O7du3X77bd3fb5s2TJJ0ty5c7VmzRo9+uijamxs1IIFC1RXV6dbb71Vmzdv1sCBAyPXNQCgz3MOoKlTpyoIgoveHxcXp2eeeUbPPPPMFTXW34TDYecan+GOmZmZzjX33Xefc40k/ehHP3Ku+f73v+9c09zc7FzjM+xTit5gUR8DBkRvdvClnuMX4zMsNTs727nm97//vXPNp59+6lwjSXfccYdzTXt7u3NNfn6+c01/YH4VHADg6kQAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwQQAAAEwQQAMAEAQQAMBG98bpXufr6eueaUCjUC51c6N///rdX3alTpyLcSc98JjP71Eh+E6fj491/j/Op8f2efLS0tDjXtLW19UInF6qoqHCu8ZkSL/k9Tj5T7AsLC51r+gPOgAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJhgGGmUpKSkONe0t7c718TFxUVlO1L0hk9GayirFL197jPk0mc7CQkJzjWS3z73+Z58vPXWW841ZWVlvdBJz3yeFxkZGb3QSezjDAgAYIIAAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJhpFGic8w0tbW1l7o5EJffPGFV11TU1OEO+mZz0BN3wGrsTxY1IfvfkhOTnau6ezs9NpWNCQlJXnVRWvAalZWVlS2E2s4AwIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGCCYaRR4jMMsbm5uRc6uVBLS4tX3cCBAyPcSc98hrIGQdALnfTMZ7BotAZ3+m6nra0twp3YamhosG7hkgYNGmTdggnOgAAAJgggAIAJ5wDavn277rzzTuXn5ysuLk4bN27sdv+8efMUFxfXbZk5c2ak+gUA9BPOAdTY2Kjx48dr5cqVF11n5syZOnHiRNeybt26K2oSAND/OF+EUFJSopKSkkuuEwqFlJub690UAKD/65XXgLZt26bs7GyNGjVKixYt0qlTpy66bktLixoaGrotAID+L+IBNHPmTL322mvaunWrnn32WVVUVKikpEQdHR09rl9eXq5wONy1FBQURLolAEAMivj7gObMmdP18dixYzVu3DiNHDlS27Zt07Rp0y5Yv6ysTMuWLev6vKGhgRACgKtAr1+GPWLECGVlZenw4cM93h8KhZSWltZtAQD0f70eQMeOHdOpU6eUl5fX25sCAPQhzn+CO3v2bLezmerqau3fv18ZGRnKyMjQ008/rdmzZys3N1dVVVV69NFHdf3112vGjBkRbRwA0Lc5B9Du3bt1++23d33+n9dv5s6dq1WrVunAgQP63e9+p7q6OuXn52v69On6xS9+oVAoFLmuAQB9nnMATZ069ZKDHv/85z9fUUN9QUJCgnONz8DKaA3UbGpq8qrLysqKcCc98xmMmZiY6LWti12teSnx8e5/yfap8TnufPkMMfU5xqMlWoN9faWkpFi3YIJZcAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwQQAAAExH/l9xXg8zMTOeaaE1M9nH69GmvuoyMjAh30rMBA9wPU9995zPR2Wdb0ZqO7jsVvL293bkmWserj1ifhn21/rua2D1iAAD9GgEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwQQAAAEwQQAMAEAQQAMEEAAQBMEEAAABMMI/WQkpISle0kJCREZTs+Qy4lKRwOR7iTnkVr2KcUvX3e0dHhXNPW1uZc4zuM1EdnZ2fUtuWqsbExatuK5tDYvo4zIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYYRuohIyPDucZnyKXvQM1oGThwYFS24zPk0neoqM/gU58an/58Bla2t7c710jSgAHuPxpaW1u9thUNzc3NUduWz/PW5xjqD67O7xoAYI4AAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJhpF6SE1NtW4hJgwePNi5pq2tzbkm1oc7dnR0RGU7QRBEZTu+Ynl4bmNjY9S25XPsxfpj21s4AwIAmCCAAAAmnAKovLxcEydOVGpqqrKzszVr1ixVVlZ2W+fcuXMqLS1VZmamBg8erNmzZ6u2tjaiTQMA+j6nAKqoqFBpaal27typLVu2qK2tTdOnT+/299WlS5fqnXfe0fr161VRUaHjx4/rnnvuiXjjAIC+zekihM2bN3f7fM2aNcrOztaePXs0ZcoU1dfX6ze/+Y3Wrl2rO+64Q5K0evVqfeMb39DOnTv1ne98J3KdAwD6tCt6Dai+vl7Sf/9F9Z49e9TW1qbi4uKudUaPHq1hw4Zpx44dPX6NlpYWNTQ0dFsAAP2fdwB1dnZqyZIluuWWWzRmzBhJUk1NjZKSkpSent5t3ZycHNXU1PT4dcrLyxUOh7uWgoIC35YAAH2IdwCVlpbq4MGDeuONN66ogbKyMtXX13ctR48evaKvBwDoG7zeiLp48WK9++672r59u4YOHdp1e25urlpbW1VXV9ftLKi2tla5ubk9fq1QKKRQKOTTBgCgD3M6AwqCQIsXL9aGDRv0wQcfqLCwsNv9EyZMUGJiorZu3dp1W2VlpY4cOaLJkydHpmMAQL/gdAZUWlqqtWvXatOmTUpNTe16XSccDis5OVnhcFgPPfSQli1bpoyMDKWlpenhhx/W5MmTuQIOANCNUwCtWrVKkjR16tRut69evVrz5s2TJP3f//2f4uPjNXv2bLW0tGjGjBn69a9/HZFmAQD9h1MAfZ2BeQMHDtTKlSu1cuVK76Zinc8w0s7OTueaxMRE55poyszMdK7x2Q8+rxEOGOA3Z9dnsKhPTbQGdyYkJHjVtbe3R7iTyPnf152/rtOnT/dCJz2L5aGssYZZcAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwQQAAAE34jg69yycnJzjVfZ5L4V/lOMo4Wn2ndPtOw4+Pdf0/yqZGktrY25xqfx9Zn2rTP1O2kpCTnGklqbW31qouGnJwc55r6+vpe6KRnPtOwfZ4X/QFnQAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwwjNRDKBRyrvEZUOjj9OnTUdmOJLW0tDjXDBw40Lkm1oc7+gwjTU1N7YVOLuQ70HbAAPcfDc3NzV7bcjVs2DDnmn/+85+90EnPfI49n+G0/QFnQAAAEwQQAMAEAQQAMEEAAQBMEEAAABMEEADABAEEADBBAAEATBBAAAATBBAAwAQBBAAwQQABAEwwjNSDz/BJn4GaPjWJiYnONdHU1tbmXOOzvzs6OpxrfLfV2NjoXOMzNDYtLc25xvd4iNYwV5+BttnZ2c41R44cca7xFR/v/nt9tIYVxxrOgAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJhgGKkHn4GaPsMxfQdqRsvAgQOdaxISEpxrkpOTnWt8hopKfo+tz/DJffv2OdcMGTLEuSYnJ8e5RpKam5uda3wGi/ocD+3t7c41PoNcffkMFvU57voDzoAAACYIIACACacAKi8v18SJE5Wamqrs7GzNmjVLlZWV3daZOnWq4uLiui0LFy6MaNMAgL7PKYAqKipUWlqqnTt3asuWLWpra9P06dMv+Idc8+fP14kTJ7qW5557LqJNAwD6PqeLEDZv3tzt8zVr1ig7O1t79uzRlClTum5PSUlRbm5uZDoEAPRLV/QaUH19vSQpIyOj2+2vv/66srKyNGbMGJWVlampqemiX6OlpUUNDQ3dFgBA/+d9GXZnZ6eWLFmiW265RWPGjOm6/f7779fw4cOVn5+vAwcO6LHHHlNlZaXefvvtHr9OeXm5nn76ad82AAB9lHcAlZaW6uDBg/roo4+63b5gwYKuj8eOHau8vDxNmzZNVVVVGjly5AVfp6ysTMuWLev6vKGhQQUFBb5tAQD6CK8AWrx4sd59911t375dQ4cOveS6RUVFkqTDhw/3GEChUEihUMinDQBAH+YUQEEQ6OGHH9aGDRu0bds2FRYWXrZm//79kqS8vDyvBgEA/ZNTAJWWlmrt2rXatGmTUlNTVVNTI0kKh8NKTk5WVVWV1q5dq+9973vKzMzUgQMHtHTpUk2ZMkXjxo3rlW8AANA3OQXQqlWrJJ1/s+n/Wr16tebNm6ekpCS9//77evHFF9XY2KiCggLNnj1bTzzxRMQaBgD0D85/gruUgoICVVRUXFFDAICrA9OwPQwbNsy5JjU11bnGZyJxUlKSc42vxMRE5xqffeczydj3whafScY+j+3BgwedazIzM51rsrKynGsk6dy5c1GpOXPmjHPN559/7lyzaNEi5xpfPs/B9PT0yDfSBzCMFABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAmGkXr45JNPnGv27t3rXOMz1PBPf/qTc000HTlyxLqFPuuLL76wbqHP2rdvn1fd3/72N+can4G227dvd67pDzgDAgCYIIAAACYIIACACQIIAGCCAAIAmCCAAAAmCCAAgAkCCABgggACAJgggAAAJgggAICJmJsFFwSBdQuX1d7e7lxz9uxZ5xqfWXDnzp1zrgH6O5/nrOT3vPWZBdfc3Oxc0xdc7ud5XBBjP/GPHTumgoIC6zYAAFfo6NGjGjp06EXvj7kA6uzs1PHjx5WamnrBbxINDQ0qKCjQ0aNHlZaWZtShPfbDeeyH89gP57EfzouF/RAEgc6cOaP8/HzFx1/8lZ6Y+xNcfHz8JRNTktLS0q7qA+w/2A/nsR/OYz+cx344z3o/hMPhy67DRQgAABMEEADARJ8KoFAopBUrVigUClm3Yor9cB774Tz2w3nsh/P60n6IuYsQAABXhz51BgQA6D8IIACACQIIAGCCAAIAmOgzAbRy5Updd911GjhwoIqKivTJJ59YtxR1Tz31lOLi4roto0ePtm6r123fvl133nmn8vPzFRcXp40bN3a7PwgCLV++XHl5eUpOTlZxcbEOHTpk02wvutx+mDdv3gXHx8yZM22a7SXl5eWaOHGiUlNTlZ2drVmzZqmysrLbOufOnVNpaakyMzM1ePBgzZ49W7W1tUYd946vsx+mTp16wfGwcOFCo4571icC6M0339SyZcu0YsUK7d27V+PHj9eMGTN08uRJ69ai7qabbtKJEye6lo8++si6pV7X2Nio8ePHa+XKlT3e/9xzz+mll17SK6+8ol27dmnQoEGaMWNGvxvMern9IEkzZ87sdnysW7cuih32voqKCpWWlmrnzp3asmWL2traNH36dDU2Nnats3TpUr3zzjtav369KioqdPz4cd1zzz2GXUfe19kPkjR//vxux8Nzzz1n1PFFBH3ApEmTgtLS0q7POzo6gvz8/KC8vNywq+hbsWJFMH78eOs2TEkKNmzY0PV5Z2dnkJubGzz//PNdt9XV1QWhUChYt26dQYfR8dX9EARBMHfu3OCuu+4y6cfKyZMnA0lBRUVFEATnH/vExMRg/fr1Xet89tlngaRgx44dVm32uq/uhyAIgu9+97vBT37yE7umvoaYPwNqbW3Vnj17VFxc3HVbfHy8iouLtWPHDsPObBw6dEj5+fkaMWKEHnjgAR05csS6JVPV1dWqqanpdnyEw2EVFRVdlcfHtm3blJ2drVGjRmnRokU6deqUdUu9qr6+XpKUkZEhSdqzZ4/a2tq6HQ+jR4/WsGHD+vXx8NX98B+vv/66srKyNGbMGJWVlampqcmivYuKuWGkX/Xll1+qo6NDOTk53W7PycnR3//+d6OubBQVFWnNmjUaNWqUTpw4oaefflq33XabDh48qNTUVOv2TNTU1EhSj8fHf+67WsycOVP33HOPCgsLVVVVpccff1wlJSXasWOHEhISrNuLuM7OTi1ZskS33HKLxowZI+n88ZCUlKT09PRu6/bn46Gn/SBJ999/v4YPH678/HwdOHBAjz32mCorK/X2228bdttdzAcQ/qukpKTr43HjxqmoqEjDhw/XW2+9pYceesiwM8SCOXPmdH08duxYjRs3TiNHjtS2bds0bdo0w856R2lpqQ4ePHhVvA56KRfbDwsWLOj6eOzYscrLy9O0adNUVVWlkSNHRrvNHsX8n+CysrKUkJBwwVUstbW1ys3NNeoqNqSnp+vGG2/U4cOHrVsx859jgOPjQiNGjFBWVla/PD4WL16sd999Vx9++GG3f9+Sm5ur1tZW1dXVdVu/vx4PF9sPPSkqKpKkmDoeYj6AkpKSNGHCBG3durXrts7OTm3dulWTJ0827Mze2bNnVVVVpby8POtWzBQWFio3N7fb8dHQ0KBdu3Zd9cfHsWPHdOrUqX51fARBoMWLF2vDhg364IMPVFhY2O3+CRMmKDExsdvxUFlZqSNHjvSr4+Fy+6En+/fvl6TYOh6sr4L4Ot54440gFAoFa9asCT799NNgwYIFQXp6elBTU2PdWlT99Kc/DbZt2xZUV1cHf/3rX4Pi4uIgKysrOHnypHVrverMmTPBvn37gn379gWSghdeeCHYt29f8PnnnwdBEAS/+tWvgvT09GDTpk3BgQMHgrvuuisoLCwMmpubjTuPrEvthzNnzgSPPPJIsGPHjqC6ujp4//33g29/+9vBDTfcEJw7d8669YhZtGhREA6Hg23btgUnTpzoWpqamrrWWbhwYTBs2LDggw8+CHbv3h1Mnjw5mDx5smHXkXe5/XD48OHgmWeeCXbv3h1UV1cHmzZtCkaMGBFMmTLFuPPu+kQABUEQvPzyy8GwYcOCpKSkYNKkScHOnTutW4q6e++9N8jLywuSkpKCa6+9Nrj33nuDw4cPW7fV6z788MNA0gXL3LlzgyA4fyn2k08+GeTk5AShUCiYNm1aUFlZadt0L7jUfmhqagqmT58eDBkyJEhMTAyGDx8ezJ8/v9/9ktbT9y8pWL16ddc6zc3NwY9//OPgmmuuCVJSUoK77747OHHihF3TveBy++HIkSPBlClTgoyMjCAUCgXXX3998LOf/Syor6+3bfwr+HcMAAATMf8aEACgfyKAAAAmCCAAgAkCCABgggACAJgggAAAJgggAIAJAggAYIIAAgCYIIAAACYIIACACQIIAGDi/wEHD2SAilqaGwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Interesting test"
      ],
      "metadata": {
        "id": "pVOOE5RMorur"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_image = np.random.randint(0, 256, size=(28, 28), dtype=np.uint8)\n",
        "random_image.reshape(28*28)\n",
        "fwd_prop = my_nn.predict(random_image)\n",
        "print(fwd_prop)\n",
        "pred_label = np.argmax(fwd_prop)\n",
        "print(\"Predicted Label: \",label_to_fashion(pred_label))\n",
        "plt.imshow(random_image, cmap='gray')"
      ],
      "metadata": {
        "id": "RbFpoil4os4X",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "outputId": "dc0e9c7d-86a3-4654-d000-4e48ffa6a62e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]]\n",
            "Predicted Label:  Bag\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x795690771420>"
            ]
          },
          "metadata": {},
          "execution_count": 47
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Sources?\n",
        "https://paperswithcode.com/method/xavier-initialization#:~:text=Xavier%20Initialization%2C%20or%20Glorot%20Initialization,a%20n%20o%20u%20t%20%5D\n",
        "\n",
        "https://www.v7labs.com/blog/cross-entropy-loss-guide#:~:text=Categorical%20Cross%20Entropy%20is%20also,N%20classes%20for%20each%20image.\n",
        "\n",
        "https://www.mldawn.com/back-propagation-with-cross-entropy-and-softmax/"
      ],
      "metadata": {
        "id": "P5xvJ9c_4CWF"
      }
    }
  ]
}