LeNet5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hCcMZ59ImW4B"
   },
   "source": [
    "# LeNet 5\n",
    "\n",
    "Author: Franco Hernández Victor Alfonso\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/VictorFranco/python-lenet-from-scratch/blob/main/LeNet5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "318_FDwkxXpp",
    "outputId": "9363faf6-ac21-4d8c-a620-9a3ef7e3557f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to MNIST_data/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9912422/9912422 [00:00<00:00, 100680989.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/MNIST/raw/train-images-idx3-ubyte.gz to MNIST_data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to MNIST_data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 28881/28881 [00:00<00:00, 71720363.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/MNIST/raw/train-labels-idx1-ubyte.gz to MNIST_data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to MNIST_data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1648877/1648877 [00:00<00:00, 29034090.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/MNIST/raw/t10k-images-idx3-ubyte.gz to MNIST_data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to MNIST_data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4542/4542 [00:00<00:00, 1220952.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting MNIST_data/MNIST/raw/t10k-labels-idx1-ubyte.gz to MNIST_data/MNIST/raw\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import nn\n",
    "import numpy as np\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.Resize(32),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0],[1])\n",
    "])\n",
    "\n",
    "dataset = datasets.MNIST(\n",
    "    \"MNIST_data\",\n",
    "    transform = transform,\n",
    "    download = True\n",
    ")\n",
    "\n",
    "trainset = torch.utils.data.Subset(dataset, list(range(1000)))\n",
    "testset = torch.utils.data.Subset(dataset, list(range(1000, 2000)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "DJ6JDCrM7faL"
   },
   "outputs": [],
   "source": [
    "class LinearLayer():\n",
    "  in_features = 0\n",
    "  out_features = 0\n",
    "  weights = np.array([])\n",
    "  biases = np.array([])\n",
    "  def __init__(self, in_features, out_features):\n",
    "    self.in_features = in_features\n",
    "    self.out_features = out_features\n",
    "    self.weights = np.random.uniform(-0.5, 0.5, size=(in_features, out_features))\n",
    "    self.biases = np.random.uniform(-0.5, 0.5, size=(1, out_features))\n",
    "  def forward(self, input):\n",
    "    return input @ self.weights + self.biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "QmldZxSzWPqT"
   },
   "outputs": [],
   "source": [
    "class ConvolutionalLayer():\n",
    "  kernels = np.array([])\n",
    "  biases = np.array([])\n",
    "  def __init__(self, in_channels, out_channels, kernel_size):\n",
    "    self.in_channels = in_channels\n",
    "    self.out_channels = out_channels\n",
    "    self.kernel_size = kernel_size\n",
    "    self.kernels = np.random.uniform(-0.5, 0.5, size=(out_channels, in_channels, kernel_size, kernel_size))\n",
    "    self.biases = np.random.uniform(-0.5, 0.5, size=(1, out_channels))\n",
    "  def forward(self, image):\n",
    "    if image.ndim == 2:\n",
    "      image = np.expand_dims(image, axis=0)\n",
    "    maps = np.zeros((self.kernels.shape[0], image.shape[1]-4, image.shape[1]-4))\n",
    "    for i in range(self.out_channels):\n",
    "      kernel = self.kernels[i]\n",
    "      bias = self.biases[0,i]\n",
    "      feature_map = []\n",
    "      for j in range(image.shape[1]-4):\n",
    "        row = []\n",
    "        for k in range(image.shape[1]-4):\n",
    "          window = image[:,j:5+j,k:5+k]\n",
    "          maps[i,j,k] = (kernel * window).sum() + bias\n",
    "    return maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "4oAr14L3zeeF"
   },
   "outputs": [],
   "source": [
    "def max_pooling(window_size, stride, i_input):\n",
    "  pool = np.zeros((i_input.shape[0],int(i_input.shape[1]/2),int(i_input.shape[1]/2)))\n",
    "  for i in range(i_input.shape[0]):\n",
    "    for j in range(int(i_input.shape[1]/2)):\n",
    "      for k in range(int(i_input.shape[1]/2)):\n",
    "        pool[i,j,k] = i_input[i,j*2:2+j*2,k*2:2+k*2].max()\n",
    "  return pool\n",
    "def softmax(matrix):\n",
    "  return np.exp(matrix) / np.exp(matrix).sum()\n",
    "def tanh_prime(logit):\n",
    "  return 1 - np.tanh(logit)**2\n",
    "def dataset2numpy(dataset):\n",
    "  result = []\n",
    "  for [img, label] in dataset:\n",
    "    img = img[0].numpy()\n",
    "    result.append([img, label])\n",
    "  return result\n",
    "\n",
    "trainset, testset = dataset2numpy(trainset), dataset2numpy(testset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "xQtmut_C1k41"
   },
   "outputs": [],
   "source": [
    "class LeNet5():\n",
    "  trainset = np.array([])\n",
    "  testset = np.array([])\n",
    "  def __init__(self, trainset, testset):\n",
    "    self.trainset = trainset\n",
    "    self.testset = testset\n",
    "    self.architecture = [\n",
    "        ConvolutionalLayer(1, 6, 5),\n",
    "        \"tanh\",\n",
    "        \"maxpool\",\n",
    "        ConvolutionalLayer(6, 16, 5),\n",
    "        \"tanh\",\n",
    "        \"maxpool\",\n",
    "        \"flatten\",\n",
    "        LinearLayer(400, 120),\n",
    "        \"tanh\",\n",
    "        LinearLayer(120, 84),\n",
    "        \"tanh\",\n",
    "        LinearLayer(84, 10),\n",
    "        \"softmax\"\n",
    "    ]\n",
    "  def forwardpass(self, x):\n",
    "    self.conv_imgs = []\n",
    "    for elm in self.architecture:\n",
    "      match elm:\n",
    "        case \"tanh\":\n",
    "          x = np.tanh(x)\n",
    "          self.conv_imgs.append(x)\n",
    "        case \"softmax\":\n",
    "          x = softmax(x)\n",
    "        case \"maxpool\":\n",
    "          x = max_pooling(2, 2, x)\n",
    "          self.conv_imgs.append(x)\n",
    "        case \"flatten\":\n",
    "          x = np.expand_dims(x.flatten(), axis=0)\n",
    "        case _: # conv layer or linear layer\n",
    "          x = elm.forward(x)\n",
    "    return x\n",
    "  def train(self, lr, epochs, batch_size):\n",
    "    step = 0\n",
    "    loss = 0\n",
    "    for epoch in range(epochs):\n",
    "      d_k, d_w, d_b = [], [], []\n",
    "      for i in range(3):\n",
    "        d_w.append(np.zeros_like(self.architecture[11-2*i].weights))\n",
    "        d_b.append(np.zeros_like(self.architecture[11-2*i].biases))\n",
    "      for i in range(2):\n",
    "        d_k.append(np.zeros_like(self.architecture[3-3*i].kernels))\n",
    "        d_b.append(np.zeros_like(self.architecture[3-3*i].biases))\n",
    "      for current_batch in range(int(len(self.trainset)/batch_size)):\n",
    "        train_batch = self.trainset[batch_size*current_batch:batch_size*(current_batch+1)]\n",
    "        for [img, label] in train_batch:\n",
    "          # forward\n",
    "          c1 = self.architecture[0].forward(img)\n",
    "          z1 = np.tanh(c1)\n",
    "          p1 = max_pooling(2, 2, z1)\n",
    "          c2 = self.architecture[3].forward(p1)\n",
    "          z2 = np.tanh(c2)\n",
    "          p2 = max_pooling(2, 2, z2)\n",
    "          f = np.expand_dims(p2.flatten(), axis=0)\n",
    "          h1 = self.architecture[7].forward(f)\n",
    "          z3 = np.tanh(h1)\n",
    "          h2 = self.architecture[9].forward(z3)\n",
    "          z4 = np.tanh(h2)\n",
    "          h3 = self.architecture[11].forward(z4)\n",
    "          output = softmax(h3)\n",
    "          # backpropagation\n",
    "          # linear\n",
    "          labels = np.zeros_like(output)\n",
    "          labels[0][label-1] = 1 # label to onehot\n",
    "          delta = labels - output\n",
    "          d_w[0] += z4.T @ delta\n",
    "          d_b[0] += delta\n",
    "          delta = delta @ self.architecture[11].weights.T * tanh_prime(h2)\n",
    "          d_w[1] += z3.T @ delta\n",
    "          d_b[1] += delta\n",
    "          delta = delta @ self.architecture[9].weights.T * tanh_prime(h1)\n",
    "          d_w[2] += f.T @ delta\n",
    "          d_b[2] += delta\n",
    "          # convolutional\n",
    "          delta = delta @ self.architecture[7].weights.T\n",
    "          delta = np.reshape(delta, (16,5,5))\n",
    "          for i in range(16):\n",
    "            for j in range(6):\n",
    "              for k in range(10):\n",
    "                for l in range(10):\n",
    "                  conv_delta = delta[i] * tanh_prime(c2[i,k,l])\n",
    "                  d_k[0][i,j] += conv_delta * p1[j,k:k+5,l:l+5]\n",
    "                  d_b[3][0,i] += conv_delta.sum()\n",
    "                  conv_delta = conv_delta * self.architecture[3].kernels[i,j] * tanh_prime(c1[j,k,l])\n",
    "                  d_k[1][j] += conv_delta * img[k:k+5,l:l+5]\n",
    "                  d_b[4][0,j] += conv_delta.sum()\n",
    "          step = step + 1\n",
    "          loss += -np.log(output[0][label - 1])\n",
    "          if step % (4 * batch_size) == 0:\n",
    "            loss = loss / (4 * batch_size)\n",
    "            print(\"epoch: {}/{} batch: {}/{} loss: {}\".format(epoch + 1, epochs, current_batch + 1, int(len(self.trainset)/batch_size), loss))\n",
    "            step = 0\n",
    "            loss = 0\n",
    "      for i in range(3):\n",
    "        self.architecture[11-2*i].weights += lr / len(trainset) * d_w[i]\n",
    "        self.architecture[11-2*i].biases += lr / len(trainset) * d_b[i]\n",
    "      for i in range(2):\n",
    "        self.architecture[3-3*i].kernels += lr / len(trainset) * d_k[i]\n",
    "        self.architecture[3-3*i].biases += lr / len(trainset) * d_b[i+3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AkbBYuuW5lZU",
    "outputId": "9f43db3d-b04f-498d-fce4-3314ad99683a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1/1 batch: 4/40 loss: 3.991047049219241\n",
      "epoch: 1/1 batch: 8/40 loss: 4.134869333515854\n",
      "epoch: 1/1 batch: 12/40 loss: 3.8741763238570273\n",
      "epoch: 1/1 batch: 16/40 loss: 4.3400310005836\n",
      "epoch: 1/1 batch: 20/40 loss: 3.9019658739313092\n",
      "epoch: 1/1 batch: 24/40 loss: 4.154057319741131\n",
      "epoch: 1/1 batch: 28/40 loss: 4.234771437753539\n",
      "epoch: 1/1 batch: 32/40 loss: 4.032134656357156\n",
      "epoch: 1/1 batch: 36/40 loss: 4.0610981881983825\n",
      "epoch: 1/1 batch: 40/40 loss: 4.112046317082615\n"
     ]
    }
   ],
   "source": [
    "# hyperparameters\n",
    "np.random.seed(30)\n",
    "lr = 0.01\n",
    "epochs = 1\n",
    "batch_size = 25\n",
    "\n",
    "lenet = LeNet5(trainset, testset)\n",
    "lenet.train(lr, epochs, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 368
    },
    "id": "dvnYl-Qc2yJq",
    "outputId": "891fd872-e3d3-46b9-88e1-51ef50e0bb9d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00617481 0.05691285 0.08472473 0.11062439 0.40982087 0.12149254\n",
      "  0.04174733 0.04605417 0.06012424 0.06232406]]\n",
      "4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x400 with 80 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = trainset[2][0]\n",
    "outputs = lenet.forwardpass(img)\n",
    "print(outputs)\n",
    "print(np.argmax(outputs))\n",
    "\n",
    "fig, ax = plt.subplots(nrows=5, ncols=16, figsize=(12, 4))\n",
    "for i in range(16):\n",
    "  for j in range(5):\n",
    "    ax[j][i].axis(\"off\")\n",
    "ax[0][0].imshow(img,cmap='gray')\n",
    "for i in range(4):\n",
    "  for j in range(len(lenet.conv_imgs[i])):\n",
    "    ax[i+1][j].axis(\"on\")\n",
    "    ax[i+1][j].set_xticks([])\n",
    "    ax[i+1][j].set_yticks([])\n",
    "    ax[i+1][j].imshow(lenet.conv_imgs[i][j],cmap='gray')"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}