digit-recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MNIST Prediction with Convolutional Neural Network\n",
    "\n",
    "- MNIST dataset: is a dataset of 60,000 28x28 grayscale images of the 10 digits, along with a test set of 10,000 images. More info can be found at the [MNIST homepage](http://yann.lecun.com/exdb/mnist/).\n",
    "- Goal: build a simple artificial neural network to predict the digit in the images."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# numpy for linear algebra\n",
    "import numpy as np\n",
    "\n",
    "# matplotlib for plotting the images, loss and accuracy\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# dill for saving the model\n",
    "import dill\n",
    "\n",
    "# tqdm for progress bar\n",
    "from tqdm import tqdm\n",
    "\n",
    "# keras for mnist dataset\n",
    "from keras import datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save the model\n",
    "# dill.dump_session(\"model.db\")\n",
    "\n",
    "# load the model\n",
    "# dill.load_session(\"model.db\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Libs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.1. Base Layer class\n",
    "\n",
    "The base layer class is the parent class of all layers in the network. It has the following methods:\n",
    "- `forward`: forward pass of the layer\n",
    "- `backpropagation`: backward pass of the layer to calculate the gradients and update the weights, if necessary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BaseLayer:\n",
    "    def __init__(self) -> None:\n",
    "        \"\"\"\n",
    "        TODO: initialize the parameters of the layer\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param X: input data\n",
    "\n",
    "        TODO: return the output of the layer\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param dZ: gradient of the loss with respect to the output of the layer\n",
    "        :param lr: learning rate\n",
    "\n",
    "        TODO: update parameters and return the gradient of the input\n",
    "        \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.2. Weight Initializer\n",
    "\n",
    "- `zeros`: initialize weights with zeros\n",
    "- `ones`: initialize weights with ones\n",
    "- `random`: initialize weights with random values\n",
    "- `random uniform`: initialize weights with random values from a uniform distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WInit:\n",
    "    def __init__(self, shape: tuple, init_type: str = \"random\", seed: int = 69) -> None:\n",
    "        \"\"\"\n",
    "        :param shape: shape of the weight matrix\n",
    "        :param init_type: type of the activation function to be used (zeros, ones, random, random_uniform)\n",
    "        :param seed: seed for random number generation\n",
    "        \"\"\"\n",
    "        self.shape = shape\n",
    "        self.init_type = init_type\n",
    "        self.seed = seed\n",
    "\n",
    "    def zeros(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        TODO: Generate a matrix of zeros\n",
    "        \"\"\"\n",
    "        np.random.seed(self.seed)\n",
    "        return np.zeros(shape=self.shape)\n",
    "\n",
    "    def ones(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        TODO: Generate a matrix of ones\n",
    "        \"\"\"\n",
    "        np.random.seed(self.seed)\n",
    "        return np.ones(shape=self.shape)\n",
    "\n",
    "    def random(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        TODO: Generate a matrix of random numbers from a normal distribution\n",
    "        \"\"\"\n",
    "        np.random.seed(self.seed)\n",
    "        return np.random.randn(*self.shape)\n",
    "\n",
    "    def random_uniform(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Generate a matrix of random numbers from a uniform distribution\n",
    "        \"\"\"\n",
    "        np.random.seed(self.seed)\n",
    "        return np.random.uniform(-1, 1, size=self.shape)\n",
    "\n",
    "    def get(self) -> np.ndarray:\n",
    "        if self.init_type == \"zeros\":\n",
    "            return self.zeros()\n",
    "        elif self.init_type == \"ones\":\n",
    "            return self.ones()\n",
    "        elif self.init_type == \"random\":\n",
    "            return self.random()\n",
    "        elif self.init_type == \"random_uniform\":\n",
    "            return self.random_uniform()\n",
    "        else:\n",
    "            raise ValueError(\"Valid types are zeros, ones, random, random_uniform\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.3. Cost Function\n",
    "\n",
    "- `mean squared error`: mean squared error cost function: $C = \\frac{1}{2n} \\sum_x ||y - a||^2$\n",
    "- `binary cross entropy`: binary cross entropy cost function: $C = -\\frac{1}{n} \\sum_x [y \\ln a + (1 - y) \\ln (1 - a)]$\n",
    "\n",
    "- `derivative of mean squared error`: derivative of the mean squared error cost function: $\\frac{\\partial C}{\\partial a} = 2(a - y) / n$\n",
    "- `derivative of binary cross entropy`: derivative of the binary cross entropy cost function: $\\frac{\\partial C}{\\partial a} = (\\frac{1 - y}{1 - a} - y/a) / n$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cost:\n",
    "    def __init__(self, cost_type: str = \"mse\") -> None:\n",
    "        \"\"\"\n",
    "        :param cost_type: type of cost function to use (mse, cross_entropy)\n",
    "        \"\"\"\n",
    "        self.cost_type = cost_type\n",
    "\n",
    "    def mse(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param y_true: true values\n",
    "        :param y_pred: predicted values\n",
    "        \"\"\"\n",
    "        return np.mean((y_true - y_pred) ** 2)\n",
    "\n",
    "    def d_mse(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param y_true: true values\n",
    "        :param y_pred: predicted values\n",
    "        \"\"\"\n",
    "        return 2 * (y_pred - y_true) / np.size(y_true)\n",
    "\n",
    "    def cross_entropy(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param y_true: true values\n",
    "        :param y_pred: predicted values\n",
    "        \"\"\"\n",
    "        return -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))\n",
    "\n",
    "    def d_cross_entropy(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        :param y_true: true values\n",
    "        :param y_pred: predicted values\n",
    "        \"\"\"\n",
    "        return ((1 - y_true) / (1 - y_pred) - y_true / y_pred) / np.size(y_true)\n",
    "\n",
    "    def get_cost(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        if self.cost_type == \"mse\":\n",
    "            return self.mse(y_true, y_pred)\n",
    "        elif self.cost_type == \"cross_entropy\":\n",
    "            return self.cross_entropy(y_true, y_pred)\n",
    "        else:\n",
    "            raise ValueError(\"Valid cost types are mse, cross_entropy\")\n",
    "\n",
    "    def get_d_cost(self, y_true: np.ndarray, y_pred: np.ndarray) -> np.ndarray:\n",
    "        if self.cost_type == \"mse\":\n",
    "            return self.d_mse(y_true, y_pred)\n",
    "        elif self.cost_type == \"cross_entropy\":\n",
    "            return self.d_cross_entropy(y_true, y_pred)\n",
    "        else:\n",
    "            raise ValueError(\"Valid cost types are mse, cross_entropy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 1.4. Plotting function\n",
    "The plotting functions is used to plot the images and its true labels and predicted labels (if available)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_data(\n",
    "    X: np.ndarray,\n",
    "    y: np.ndarray,\n",
    "    y_proba: np.ndarray = None,\n",
    "    shape: tuple[int, int] = (2, 4),\n",
    ") -> None:\n",
    "    \"\"\"\n",
    "    :param X: input data (images)\n",
    "    :param y: true labels\n",
    "    :param y_proba: predicted labels\n",
    "    :param shape: shape of the plot (nrows, ncols)\n",
    "\n",
    "    TODO: plot the images with the true and predicted labels (if available)\n",
    "    \"\"\"\n",
    "    nrows, ncols = shape\n",
    "    _, axes = plt.subplots(nrows, ncols, figsize=(10, 5))\n",
    "\n",
    "    len_x = X.shape[0]\n",
    "    for idx in range(nrows * ncols):\n",
    "        ax = axes[idx // ncols, idx % ncols]\n",
    "\n",
    "        img_idx = np.random.randint(0, len_x)\n",
    "\n",
    "        ax.imshow(X[img_idx], cmap=\"gray\")\n",
    "        ax.set(xticks=[], yticks=[])\n",
    "\n",
    "        true_label = f\"True: {y[img_idx]}\"\n",
    "        color = \"black\"\n",
    "\n",
    "        if y_proba is not None:\n",
    "            pred_label = f\"Pred: {y_proba[img_idx]}\"\n",
    "            color = \"green\" if y[img_idx] == y_proba[img_idx] else \"red\"\n",
    "\n",
    "        img_title = true_label if y_proba is None else f\"{true_label}\\n{pred_label}\"\n",
    "        ax.set_xlabel(img_title, color=color)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.1. Convolutional Layer\n",
    "\n",
    "The convolutional layer has the following methods:\n",
    "\n",
    "- `get_roi`: get the region of interest (ROI) of the input image\n",
    "- `forward`: forward pass of the convolutional layer to calculate the output feature map: $z = \\sum_{i=0}^{n} W_i \\cdot X_i + b$\n",
    "- `backpropagation`: backward pass of the convolutional layer to calculate the gradients and update kernels and bias: \n",
    "\n",
    "$\\frac{\\partial C}{\\partial W_i} = \\sum_{j} \\frac{\\partial C}{\\partial z_j} \\cdot \\frac{\\partial z_j}{\\partial W_i}$ and $\\frac{\\partial C}{\\partial b} = \\sum_{j} \\frac{\\partial C}{\\partial z_j} \\cdot \\frac{\\partial z_j}{\\partial b}$\n",
    "\n",
    "![Convolutional Layer](https://pythonandml.github.io/dlbook/_images/cross_correlation.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Conv2D(BaseLayer):\n",
    "    def __init__(\n",
    "        self,\n",
    "        inp_shape: tuple,\n",
    "        kernel_size: int = 3,\n",
    "        depth: int = 1,\n",
    "        p: int = 0,\n",
    "        s: int = 1,\n",
    "        init_type: str = \"random\",\n",
    "        seed: int = 69,\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        :param inp_shape: shape of the input data\n",
    "        :param kernel_size: size of the kernel\n",
    "        :param depth: depth of the output data\n",
    "        :param p: padding\n",
    "        :param s: stride\n",
    "        :param init_type: type of weight initialization (zeros, ones, random, random_uniform)\n",
    "        :param seed: seed for random number generation\n",
    "        \"\"\"\n",
    "        _, inp_height, inp_width = inp_shape\n",
    "        self.inp_shape = inp_shape\n",
    "        self.kernel_size = kernel_size\n",
    "        self.depth = depth\n",
    "        self.p = p\n",
    "        self.s = s\n",
    "\n",
    "        self.out_shape = (\n",
    "            depth,\n",
    "            (inp_height - kernel_size + 2 * p) // s + 1,\n",
    "            (inp_width - kernel_size + 2 * p) // s + 1,\n",
    "        )\n",
    "        self.kernels_shape = (depth, kernel_size, kernel_size)\n",
    "        self.kernels = WInit(\n",
    "            shape=self.kernels_shape, init_type=init_type, seed=seed\n",
    "        ).get()\n",
    "        self.bias = WInit(shape=self.out_shape, init_type=init_type, seed=seed).get()\n",
    "\n",
    "    def get_roi(self, X: np.ndarray):\n",
    "        for row in range(self.out_shape[1]):\n",
    "            for col in range(self.out_shape[2]):\n",
    "                yield row, col, X[\n",
    "                    :, row : row + self.kernel_size, col : col + self.kernel_size\n",
    "                ]\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        self.X = X\n",
    "        self.z = np.copy(self.bias)\n",
    "\n",
    "        for row, col, roi in self.get_roi(X):\n",
    "            self.z[:, row, col] = np.sum(roi * self.kernels, axis=(1, 2))\n",
    "\n",
    "        return self.z\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        dK = WInit(shape=self.kernels_shape, init_type=\"zeros\").get()\n",
    "        dX = WInit(shape=self.inp_shape, init_type=\"zeros\").get()\n",
    "\n",
    "        for row, col, roi in self.get_roi(self.X):\n",
    "            dK += dZ[:, row, col].reshape(-1, 1, 1) * roi\n",
    "            dX[:, row : row + self.kernel_size, col : col + self.kernel_size] += np.sum(\n",
    "                self.kernels * dZ[:, row, col].reshape(-1, 1, 1), axis=0\n",
    "            )\n",
    "\n",
    "        self.kernels -= lr * dK\n",
    "        self.bias -= lr * dZ\n",
    "        return dX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.2. Pooling Layer\n",
    "\n",
    "Using max pooling to reduce the size of the feature map and keep the most important information.\n",
    "\n",
    "The max pooling layer has the following methods:\n",
    "\n",
    "- `get_roi`: get the region of interest (ROI) of the input image\n",
    "- `forward`: forward pass of the max pooling layer to calculate the output feature map: \n",
    "    - `max pooling`: $z = \\max(X_i)$\n",
    "    - `average pooling`: $z = \\frac{1}{n} \\sum_{i=0}^{n} X_i$\n",
    "- `backpropagation`: backward pass of the max pooling layer to calculate the gradients: \n",
    "    - `max pooling`: $\\frac{\\partial C}{\\partial X_i} = \\frac{\\partial C}{\\partial z} \\cdot \\frac{\\partial z}{\\partial X_i}$\n",
    "    - `average pooling`: $\\frac{\\partial C}{\\partial X_i} = \\frac{\\partial C}{\\partial z} \\cdot \\frac{\\partial z}{\\partial X_i}$\n",
    "\n",
    "![Max Pooling](https://pythonandml.github.io/dlbook/_images/maxpool.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pooling2D(BaseLayer):\n",
    "    def __init__(\n",
    "        self, inp_shape: tuple, pool_size: int = 2, pool_type: str = \"max\"\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        :param inp_shape: shape of the input data\n",
    "        :param pool_size: size of the pooling\n",
    "        :param pool_type: type of pooling (max, average)\n",
    "        \"\"\"\n",
    "        inp_depth, inp_height, inp_width = inp_shape\n",
    "        self.inp_shape = inp_shape\n",
    "        self.pool_size = pool_size\n",
    "        self.s = 2\n",
    "        self.pool_type = pool_type\n",
    "\n",
    "        self.out_shape = (\n",
    "            inp_depth,\n",
    "            (inp_height - pool_size) // self.s + 1,\n",
    "            (inp_width - pool_size) // self.s + 1,\n",
    "        )\n",
    "\n",
    "    def get_roi(self, X: np.ndarray):\n",
    "        for row in range(0, self.inp_shape[1] - self.pool_size + 1, self.s):\n",
    "            for col in range(0, self.inp_shape[2] - self.pool_size + 1, self.s):\n",
    "                yield row, col, X[\n",
    "                    :, row : row + self.pool_size, col : col + self.pool_size\n",
    "                ]\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        self.X = X\n",
    "        self.z = WInit(shape=self.out_shape, init_type=\"zeros\").get()\n",
    "\n",
    "        for row, col, roi in self.get_roi(X):\n",
    "            if self.pool_type == \"average\":\n",
    "                self.z[:, row // self.s, col // self.s] = np.mean(roi, axis=(1, 2))\n",
    "            elif self.pool_type == \"max\":\n",
    "                self.z[:, row // self.s, col // self.s] = np.max(roi, axis=(1, 2))\n",
    "            else:\n",
    "                raise ValueError(\"Valid pool types are max, average\")\n",
    "\n",
    "        return self.z\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        dX = WInit(shape=self.inp_shape, init_type=\"zeros\").get()\n",
    "\n",
    "        for row, col, roi in self.get_roi(self.X):\n",
    "            if self.pool_type == \"average\":\n",
    "                dX[:, row : row + self.pool_size, col : col + self.pool_size] += (\n",
    "                    dZ[:, row // self.s, col // self.s][:, None, None]\n",
    "                    / self.pool_size**2\n",
    "                )\n",
    "            elif self.pool_type == \"max\":\n",
    "                mask = np.max(roi, axis=(1, 2), keepdims=True) == roi\n",
    "                dX[:, row : row + self.pool_size, col : col + self.pool_size] += (\n",
    "                    mask * dZ[:, row // self.s, col // self.s][:, None, None]\n",
    "                )\n",
    "            else:\n",
    "                raise ValueError(\"Valid pool types are max, average\")\n",
    "\n",
    "        return dX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.3. Flatten Layer class\n",
    "\n",
    "Unroll the 2D image to a 1D array.\n",
    "\n",
    "The flatten layer has the following methods:\n",
    "\n",
    "- `forward`: forward pass of the flatten layer to flatten the input image to a 1D array\n",
    "- `backpropagation`: backward pass of the flatten layer to reshape the 1D array to the original shape of the input image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Flatten(BaseLayer):\n",
    "    def __init__(self, inp_shape: tuple) -> None:\n",
    "        \"\"\"\n",
    "        :param inp_shape: shape of the input data\n",
    "        \"\"\"\n",
    "        self.inp_shape = inp_shape\n",
    "        self.out_shape = (np.prod(inp_shape), 1)\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        return np.reshape(X, self.out_shape)\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        return np.reshape(dZ, self.inp_shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.4. Dropout Layer class\n",
    "\n",
    "Using dropout is a technique to prevent overfitting by randomly setting some neurons to zero during training.\n",
    "\n",
    "The dropout layer has the following methods:\n",
    "\n",
    "- `forward`: forward pass of the dropout layer to randomly set some neurons to zero\n",
    "- `backpropagation`: backward pass of the dropout layer to set the gradients of the dropped neurons to zero\n",
    "\n",
    "![dropout](https://miro.medium.com/max/1400/1*iWQzxhVlvadk6VAJjsgXgg.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dropout(BaseLayer):\n",
    "    def __init__(self, p: float = 0.5) -> None:\n",
    "        \"\"\"\n",
    "        :param p: probability of dropout\n",
    "        \"\"\"\n",
    "        self.p = p\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        self.mask = (np.random.rand(*X.shape) < self.p) / self.p\n",
    "        return X * self.mask\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        return dZ * self.mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.5. Dense Layer class\n",
    "\n",
    "Using the dense layer to connect the convolutional and max pooling layers to the output layer.\n",
    "\n",
    "The dense layer has the following methods:\n",
    "\n",
    "- `forward`: forward pass of the dense layer to calculate the output: $z = w \\cdot a + b$\n",
    "- `backpropagation`: backward pass of the dense layer to calculate the gradients and update weights and bias: $\\frac{\\partial C}{\\partial w} = \\frac{\\partial C}{\\partial z} \\cdot a^T$, $\\frac{\\partial C}{\\partial b} = \\frac{\\partial C}{\\partial z}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dense(BaseLayer):\n",
    "    def __init__(\n",
    "        self, inp_size: int, out_size: int, init_type: str = \"random\", seed: int = 69\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        :param inp_size: input size of the layer\n",
    "        :param out_size: output size of the layer\n",
    "        :param init_type: type of weight initialization (zeros, ones, random, random_uniform)\n",
    "        :param seed: seed for random number generation\n",
    "        \"\"\"\n",
    "        self.weights = WInit(\n",
    "            shape=(out_size, inp_size), init_type=init_type, seed=seed\n",
    "        ).get()\n",
    "        self.bias = WInit(shape=(out_size, 1), init_type=init_type, seed=seed).get()\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        self.X = X\n",
    "        return np.dot(self.weights, self.X) + self.bias\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        dW = np.dot(dZ, self.X.T)\n",
    "        self.weights -= lr * dW\n",
    "        self.bias -= lr * dZ\n",
    "        return np.dot(self.weights.T, dZ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.6. Activation Layer class\n",
    "\n",
    "Use the activation layer to apply an activation function to the output of the previous layer. The activation layer has the following methods:\n",
    "\n",
    "- `linear`: linear activation function $f(x) = x$\n",
    "- `reLU`: rectified linear unit activation function $f(x) = max(0, x)$\n",
    "- `sigmoid`: sigmoid activation function $f(x) = \\frac{1}{1 + e^{-x}}$\n",
    "- `tanh`: hyperbolic tangent activation function $f(x) = \\frac{e^x - e^{-x}}{e^x + e^{-x}}$\n",
    "\n",
    "- `derivative of linear`: derivative of the linear activation function $f'(x) = 1$\n",
    "- `derivative of reLU`: derivative of the reLU activation function $f'(x) = 1$ if $x > 0$ and $0$ otherwise\n",
    "- `derivative of sigmoid`: derivative of the sigmoid activation function $f'(x) = sigmoid(x) \\cdot (1 - sigmoid(x))$\n",
    "- `derivative of tanh`: derivative of the tanh activation function $f'(x) = 1 - tanh(x)^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Activation(BaseLayer):\n",
    "    def __init__(self, act_type: str = \"reLU\") -> None:\n",
    "        \"\"\"\n",
    "        :param act_type: type of the activation function to be used (linear, reLU, sigmoid, tanh)\n",
    "        \"\"\"\n",
    "        self.act_type = act_type\n",
    "\n",
    "    def linear(self, X: np.ndarray) -> np.ndarray:\n",
    "        return X\n",
    "\n",
    "    def d_linear(self, X: np.ndarray) -> np.ndarray:\n",
    "        return 1\n",
    "\n",
    "    def reLU(self, X: np.ndarray) -> np.ndarray:\n",
    "        return np.maximum(0, X)\n",
    "\n",
    "    def d_reLU(self, X: np.ndarray) -> np.ndarray:\n",
    "        return np.where(X > 0, 1, 0)\n",
    "\n",
    "    def sigmoid(self, X: np.ndarray) -> np.ndarray:\n",
    "        return 1 / (1 + np.exp(-X))\n",
    "\n",
    "    def d_sigmoid(self, X: np.ndarray) -> np.ndarray:\n",
    "        return self.sigmoid(X) * (1 - self.sigmoid(X))\n",
    "\n",
    "    def tanh(self, X: np.ndarray) -> np.ndarray:\n",
    "        return np.tanh(X)\n",
    "\n",
    "    def d_tanh(self, X: np.ndarray) -> np.ndarray:\n",
    "        return 1 - np.tanh(X) ** 2\n",
    "\n",
    "    def get_activation(self, X: np.ndarray) -> np.ndarray:\n",
    "        if self.act_type == \"linear\":\n",
    "            return self.linear(X)\n",
    "        elif self.act_type == \"reLU\":\n",
    "            return self.reLU(X)\n",
    "        elif self.act_type == \"sigmoid\":\n",
    "            return self.sigmoid(X)\n",
    "        elif self.act_type == \"tanh\":\n",
    "            return self.tanh(X)\n",
    "        else:\n",
    "            raise ValueError(\"Invalid activation type\")\n",
    "\n",
    "    def get_d_activation(self, X: np.ndarray) -> np.ndarray:\n",
    "        if self.act_type == \"linear\":\n",
    "            return self.d_linear(X)\n",
    "        elif self.act_type == \"reLU\":\n",
    "            return self.d_reLU(X)\n",
    "        elif self.act_type == \"sigmoid\":\n",
    "            return self.d_sigmoid(X)\n",
    "        elif self.act_type == \"tanh\":\n",
    "            return self.d_tanh(X)\n",
    "        else:\n",
    "            raise ValueError(\"Invalid activation type\")\n",
    "\n",
    "    def forward(self, X: np.ndarray) -> np.ndarray:\n",
    "        self.X = X\n",
    "        return self.get_activation(self.X)\n",
    "\n",
    "    def backpropagation(self, dZ: np.ndarray, lr: float) -> np.ndarray:\n",
    "        dA = self.get_d_activation(self.X)\n",
    "        return np.multiply(dZ, dA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Convolutional Neural Network (CNN) Model class\n",
    "\n",
    "The CNN model class has the following methods:\n",
    "\n",
    "- `summary`: print the summary of the model including the layers and the number of parameters\n",
    "- `fit`: train the model using the training data and labels\n",
    "- `plot_history`: plot the training history including the loss and accuracy\n",
    "- `predict`: predict the labels of the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN:\n",
    "    def __init__(self, layers: list[BaseLayer]) -> None:\n",
    "        if not layers:\n",
    "            raise ValueError(\"No layers provided\")\n",
    "        else:\n",
    "            self.layers = layers\n",
    "\n",
    "        # Initialize the network architecture\n",
    "        self.layer_name = []\n",
    "        self.architecture = []\n",
    "\n",
    "    def create_network_architecture(self):\n",
    "        \"\"\"\n",
    "        TODO: Create the architecture of the network based on the layers\n",
    "        \"\"\"\n",
    "        for layer in self.layers:\n",
    "            layer_name = layer.__class__.__name__\n",
    "            if layer_name in [\"Conv2D\", \"Pooling2D\", \"Flatten\"]:\n",
    "                self.layer_name.append(layer_name)\n",
    "                if layer_name == \"Flatten\":\n",
    "                    self.architecture.append(layer.out_shape)\n",
    "                else:\n",
    "                    self.architecture.append(layer.out_shape)\n",
    "            elif layer_name == \"Dense\":\n",
    "                self.layer_name.append(\"Dense\")\n",
    "                self.architecture.append(layer.weights.shape)\n",
    "            elif layer_name == \"Dropout\":\n",
    "                self.layer_name.append(\"Dropout\")\n",
    "                self.architecture.append(self.architecture[-1])\n",
    "            elif layer_name == \"Activation\":\n",
    "                continue\n",
    "\n",
    "    def compile(self, loss: str, verbose: bool = True) -> None:\n",
    "        \"\"\"\n",
    "        :param cost_type: type of cost function to use (mse, cross_entropy)\n",
    "        :param verbose: whether to print the cost and accuracy after each epoch\n",
    "\n",
    "        TODO: compile the model with the cost function and verbose\n",
    "        \"\"\"\n",
    "        self.cost = Cost(cost_type=loss)\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def summary(self) -> None:\n",
    "        \"\"\"\n",
    "        TODO: print the summary of the model\n",
    "        \"\"\"\n",
    "        self.create_network_architecture()\n",
    "        len_assigned = [45, 26, 15]\n",
    "        count = {\n",
    "            \"Conv2D\": 1,\n",
    "            \"Pooling2D\": 1,\n",
    "            \"Flatten\": 1,\n",
    "            \"Dropout\": 1,\n",
    "            \"Dense\": 1,\n",
    "            \"Activation\": 1,\n",
    "        }\n",
    "        col_names = [\"Layer (type)\", \"Output Shape\", \"Param #\"]\n",
    "        print(\"Model: Convolutional Neural Network\")\n",
    "        print(\"-\" * sum(len_assigned))\n",
    "\n",
    "        text = \"\"\n",
    "        for i in range(3):\n",
    "            text += col_names[i] + \" \" * (len_assigned[i] - len(col_names[i]))\n",
    "        print(text)\n",
    "        print(\"=\" * sum(len_assigned))\n",
    "\n",
    "        total_params = 0\n",
    "        for i in range(len(self.layer_name)):\n",
    "            layer_name = self.layer_name[i]\n",
    "            name = f\"{layer_name.lower()}_{count[layer_name]} ({layer_name})\"\n",
    "\n",
    "            count[layer_name] += 1\n",
    "            if self.architecture[i] is None:\n",
    "                print(\n",
    "                    f\"{name}{' ' * (len_assigned[0] - len(name))}{' ' * (len_assigned[1] - 2)}{' ' * (len_assigned[2] - 2)}\"\n",
    "                )\n",
    "                continue\n",
    "\n",
    "            output_shape = self.architecture[i]\n",
    "            if layer_name in [\"Flatten\", \"Dropout\", \"Dense\"]:\n",
    "                output_shape = f\"(None, {', '.join(map(str, output_shape[:-1]))})\"\n",
    "            else:\n",
    "                output_shape = f\"(None, {', '.join(map(str, output_shape))})\"\n",
    "\n",
    "            if layer_name in [\"Pooling2D\", \"Flatten\", \"Dropout\"]:\n",
    "                params = 0\n",
    "            else:\n",
    "                total_params += np.prod(self.architecture[i])\n",
    "                params = np.prod(self.architecture[i])\n",
    "\n",
    "            print(\n",
    "                f\"{name}{' ' * (len_assigned[0] - len(name))}{output_shape}{' ' * (len_assigned[1] - len(output_shape))}{params}\"\n",
    "            )\n",
    "\n",
    "        print(\"=\" * sum(len_assigned))\n",
    "\n",
    "        print(f\"Total layers: {len(self.layer_name)}\")\n",
    "        print(f\"Total params: {total_params}\")\n",
    "        print(f\"Cost function: {self.cost.cost_type}\")\n",
    "        print(f\"Verbose: {self.verbose}\")\n",
    "        print(\"-\" * sum(len_assigned))\n",
    "\n",
    "    def fit(\n",
    "        self,\n",
    "        X: np.ndarray,\n",
    "        y: np.ndarray,\n",
    "        lr: float,\n",
    "        epochs: int = 1000,\n",
    "        X_val: np.ndarray = None,\n",
    "        y_val: np.ndarray = None,\n",
    "    ) -> None:\n",
    "        \"\"\"\n",
    "        :param X: input data\n",
    "        :param y: true labels\n",
    "        :param lr: learning rate\n",
    "        :param epochs: number of epochs to train the model\n",
    "        :param X_val: validation data\n",
    "        :param y_val: validation labels\n",
    "\n",
    "        TODO: loop through the epochs and train the model with the given data and update the history\n",
    "        \"\"\"\n",
    "        self.lr = lr\n",
    "        self.epochs = epochs\n",
    "        # Initialize the history dictionary\n",
    "        self.history = {\"loss\": [], \"val_loss\": [], \"accuracy\": [], \"val_accuracy\": []}\n",
    "\n",
    "        for epoch in range(epochs):\n",
    "            # Initialize the error and correct predictions\n",
    "            error = 0\n",
    "            correct = 0\n",
    "\n",
    "            for i in tqdm(\n",
    "                range(len(X)),\n",
    "                colour=\"GREEN\",\n",
    "                ascii=\"░▒█\",\n",
    "                desc=f\"Epoch {'0' if epoch+1 < 10 else ''}{epoch+1}/{epochs}\",\n",
    "            ):\n",
    "                z = np.copy(X[i])\n",
    "                for layer in self.layers:\n",
    "                    z = layer.forward(z)\n",
    "\n",
    "                error += self.cost.get_cost(y[i], z)\n",
    "                correct += int(np.argmax(z) == np.argmax(y[i]))\n",
    "\n",
    "                dZ = self.cost.get_d_cost(y[i], z)\n",
    "                for layer in reversed(self.layers):\n",
    "                    dZ = layer.backpropagation(dZ, self.lr)\n",
    "\n",
    "            self.history[\"loss\"].append(error / len(X))\n",
    "            self.history[\"accuracy\"].append(correct / len(X))\n",
    "\n",
    "            if X_val is not None and y_val is not None:\n",
    "                val_error, val_correct = self.evaluate(X_val, y_val)\n",
    "                self.history[\"val_loss\"].append(val_error)\n",
    "                self.history[\"val_accuracy\"].append(val_correct)\n",
    "\n",
    "            if self.verbose and X_val is not None and y_val is not None:\n",
    "                print(\n",
    "                    f\"Loss: {self.history['loss'][-1]:.4f} - Validation Loss: {self.history['val_loss'][-1]:.4f} - Accuracy: {self.history['accuracy'][-1]:.4f} - Validation Accuracy: {self.history['val_accuracy'][-1]:.4f}\"\n",
    "                )\n",
    "            elif self.verbose:\n",
    "                print(\n",
    "                    f\"Loss: {self.history['loss'][-1]:.4f} - Accuracy: {self.history['accuracy'][-1]:.4f}\"\n",
    "                )\n",
    "\n",
    "    def evaluate(self, X: np.ndarray, y: np.ndarray) -> tuple[float, float]:\n",
    "        \"\"\"\n",
    "        :param X: input data\n",
    "        :param y: true labels\n",
    "\n",
    "        TODO: return the loss and accuracy of the model\n",
    "        \"\"\"\n",
    "\n",
    "        error = 0\n",
    "        correct = 0\n",
    "\n",
    "        for i in tqdm(range(len(X)), colour=\"GREEN\", ascii=\"░▒█\", desc=\"Evaluating\"):\n",
    "            z = np.copy(X[i])\n",
    "            for layer in self.layers:\n",
    "                z = layer.forward(z)\n",
    "\n",
    "            error += self.cost.get_cost(y[i], z)\n",
    "            correct += int(np.argmax(z) == np.argmax(y[i]))\n",
    "\n",
    "        return error / len(X), correct / len(X)\n",
    "\n",
    "    def plot_loss(self) -> None:\n",
    "        \"\"\"\n",
    "        TODO: plot the loss and validation loss\n",
    "        \"\"\"\n",
    "        plt.plot(self.history[\"loss\"], label=\"Loss\")\n",
    "        plt.plot(self.history[\"val_loss\"], label=\"Validation Loss\")\n",
    "        plt.xlabel(\"Epochs\")\n",
    "        plt.ylabel(\"Loss\")\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "    def plot_accuracy(self) -> None:\n",
    "        \"\"\"\n",
    "        TODO: plot the accuracy and validation accuracy\n",
    "        \"\"\"\n",
    "        plt.plot(self.history[\"accuracy\"], label=\"Accuracy\")\n",
    "        plt.plot(self.history[\"val_accuracy\"], label=\"Validation Accuracy\")\n",
    "        plt.xlabel(\"Epochs\")\n",
    "        plt.ylabel(\"Accuracy\")\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "    def predict(self, X: np.ndarray) -> np.ndarray:\n",
    "        predictions = []\n",
    "        for i in tqdm(range(len(X)), colour=\"GREEN\", ascii=\"░▒█\", desc=\"Predicting\"):\n",
    "            output = np.copy(X[i])\n",
    "            for layer in self.layers:\n",
    "                output = layer.forward(output)\n",
    "            predictions.append(output)\n",
    "\n",
    "        return np.array(predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Training the model with MNIST dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.1. Preprocessing the data\n",
    "\n",
    "- Load the MNIST dataset\n",
    "- Normalize the data by reshaping the images to 1x28x28 and dividing by 255 to scale the pixel values to the range [0, 1]\n",
    "- One-hot encode the labels to convert the labels to a binary matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(X_train, y_train), (X_test, y_test) = datasets.mnist.load_data()\n",
    "plot_data(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalize the data\n",
    "X_train = X_train.reshape(len(X_train), 1, 28, 28)\n",
    "X_test = X_test.reshape(len(X_test), 1, 28, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.astype(\"float32\") / 255\n",
    "X_test = X_test.astype(\"float32\") / 255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 1, 28, 28), (10000, 1, 28, 28))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One-hot encode the labels\n",
    "y_train = np.eye(10)[y_train]\n",
    "y_test = np.eye(10)[y_test]\n",
    "\n",
    "# Reshape the labels\n",
    "y_train = y_train.reshape(len(y_train), 10, 1)\n",
    "y_test = y_test.reshape(len(y_test), 10, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 10, 1), (10000, 10, 1))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.2. Training the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CNN(\n",
    "    [\n",
    "        Conv2D(\n",
    "            (1, 28, 28), kernel_size=5, depth=16, p=4, s=2, init_type=\"random\", seed=69\n",
    "        ),  # output shape = (input_size + 2 * p - kernel_size) / s + 1 = (28 + 2 * 4 - 5) / 2 + 1 = 16\n",
    "        Activation(act_type=\"sigmoid\"),\n",
    "        Pooling2D(\n",
    "            (16, 16, 16), pool_size=2, pool_type=\"max\"\n",
    "        ),  # output shape = (input_size - pool_size) / s + 1 = (16 - 2) / 2 + 1 = 8\n",
    "        Flatten((16, 8, 8)),\n",
    "        Dropout(p=0.4),\n",
    "        Dense(16 * 8 * 8, 100, init_type=\"random\", seed=69),\n",
    "        Activation(act_type=\"sigmoid\"),\n",
    "        Dense(100, 10, init_type=\"random\", seed=69),\n",
    "        Activation(act_type=\"sigmoid\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "\n",
    "model.compile(loss=\"cross_entropy\", verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: Convolutional Neural Network\n",
      "--------------------------------------------------------------------------------------\n",
      "Layer (type)                                 Output Shape              Param #        \n",
      "======================================================================================\n",
      "conv2d_1 (Conv2D)                            (None, 16, 16, 16)        4096\n",
      "pooling2d_1 (Pooling2D)                      (None, 16, 8, 8)          0\n",
      "flatten_1 (Flatten)                          (None, 1024)              0\n",
      "dropout_1 (Dropout)                          (None, 1024)              0\n",
      "dense_1 (Dense)                              (None, 100)               102400\n",
      "dense_2 (Dense)                              (None, 10)                1000\n",
      "======================================================================================\n",
      "Total layers: 6\n",
      "Total params: 107496\n",
      "Cost function: cross_entropy\n",
      "Verbose: True\n",
      "--------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_X_train, new_y_train = X_train[:40000], y_train[:40000]\n",
    "X_val, y_val = X_train[40000:], y_train[40000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 01/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:46<00:00, 176.79it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:37<00:00, 529.98it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.2626 - Validation Loss: 0.1916 - Accuracy: 0.4783 - Validation Accuracy: 0.6339\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 02/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:58<00:00, 167.77it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:35<00:00, 563.56it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1726 - Validation Loss: 0.1523 - Accuracy: 0.6821 - Validation Accuracy: 0.7341\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 03/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:38<00:00, 182.68it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:37<00:00, 536.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1446 - Validation Loss: 0.1330 - Accuracy: 0.7454 - Validation Accuracy: 0.7749\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 04/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:39<00:00, 182.05it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:34<00:00, 579.89it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1288 - Validation Loss: 0.1209 - Accuracy: 0.7794 - Validation Accuracy: 0.7997\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 05/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:38<00:00, 183.35it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:33<00:00, 589.71it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1178 - Validation Loss: 0.1122 - Accuracy: 0.8024 - Validation Accuracy: 0.8151\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 06/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:37<00:00, 183.94it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:32<00:00, 609.18it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1094 - Validation Loss: 0.1052 - Accuracy: 0.8205 - Validation Accuracy: 0.8283\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 07/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:36<00:00, 184.60it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:35<00:00, 564.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.1026 - Validation Loss: 0.0998 - Accuracy: 0.8337 - Validation Accuracy: 0.8404\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 08/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:41<00:00, 180.58it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:33<00:00, 588.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0970 - Validation Loss: 0.0951 - Accuracy: 0.8444 - Validation Accuracy: 0.8494\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 09/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:34<00:00, 186.54it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:31<00:00, 636.74it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0921 - Validation Loss: 0.0909 - Accuracy: 0.8537 - Validation Accuracy: 0.8562\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:36<00:00, 184.39it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:35<00:00, 555.57it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0878 - Validation Loss: 0.0873 - Accuracy: 0.8618 - Validation Accuracy: 0.8625\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:35<00:00, 185.72it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:36<00:00, 551.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0841 - Validation Loss: 0.0842 - Accuracy: 0.8687 - Validation Accuracy: 0.8694\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:32<00:00, 188.62it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:34<00:00, 580.10it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0808 - Validation Loss: 0.0814 - Accuracy: 0.8745 - Validation Accuracy: 0.8736\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:41<00:00, 180.68it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:36<00:00, 548.25it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0779 - Validation Loss: 0.0788 - Accuracy: 0.8792 - Validation Accuracy: 0.8777\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:35<00:00, 185.86it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:33<00:00, 590.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0751 - Validation Loss: 0.0764 - Accuracy: 0.8843 - Validation Accuracy: 0.8817\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15/15: 100%|\u001b[32m██████████\u001b[0m| 40000/40000 [03:41<00:00, 180.43it/s]\n",
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 20000/20000 [00:35<00:00, 558.07it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0727 - Validation Loss: 0.0743 - Accuracy: 0.8875 - Validation Accuracy: 0.8850\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "model.fit(new_X_train, new_y_train, lr=0.01, epochs=15, X_val=X_val, y_val=y_val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.3. Model results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.plot_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.plot_accuracy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.4. Predicting the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Evaluating: 100%|\u001b[32m██████████\u001b[0m| 10000/10000 [00:18<00:00, 549.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.0699 - Accuracy: 0.8950\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(X_test, y_test)\n",
    "\n",
    "print(f\"Loss: {loss:.4f} - Accuracy: {accuracy:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Predicting: 100%|\u001b[32m██████████\u001b[0m| 10000/10000 [00:16<00:00, 607.19it/s]\n"
     ]
    }
   ],
   "source": [
    "y_pred = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_data(\n",
    "    X_test.reshape(len(X_test), 28, 28),\n",
    "    np.argmax(y_test, axis=1),\n",
    "    np.argmax(y_pred, axis=1),\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "digit-recognition",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}