mnistNN_3HL.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 59999 entries, 0 to 59998\n",
      "Columns: 785 entries, 5 to 0.617\n",
      "dtypes: int64(785)\n",
      "memory usage: 359.3 MB\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 9999 entries, 0 to 9998\n",
      "Columns: 785 entries, 7 to 0.667\n",
      "dtypes: int64(785)\n",
      "memory usage: 59.9 MB\n"
     ]
    }
   ],
   "source": [
    "trainData = pd.read_csv(\"mnist_train.csv\")\n",
    "testData = pd.read_csv(\"mnist_test.csv\")\n",
    "trainData.info(), testData.info();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59999, 785), (9999, 785))"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to access the data\n",
    "\n",
    "trainData = np.array(trainData)\n",
    "testData = np.array(testData)\n",
    "trainData.shape, testData.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainY = trainData[:,0]\n",
    "trainX = trainData[:,1:]/255.0   # normalizing\n",
    "\n",
    "testY = testData[:,0]\n",
    "testX = testData[:,1:]/255.0   # normalizing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59999,), (59999, 784))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainY.shape, trainX.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((9999,), (9999, 784))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "testY.shape, testX.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining activation func\n",
    "\n",
    "def sigmoid(x):\n",
    "    res = 1/(1+np.exp(-x))\n",
    "    return res\n",
    "\n",
    "def sigmoid_prime(x):\n",
    "    res = np.exp(-x)/(1+np.exp(-x))**2\n",
    "    return res\n",
    "\n",
    "def relu(x):\n",
    "    return np.maximum(0, x)\n",
    "\n",
    "def relu_prime(x):\n",
    "    return np.where(x > 0, 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# performing the activation\n",
    "\n",
    "def activation(A,W,B):\n",
    "    Z = np.matmul(W,A) + B\n",
    "    Af = relu(Z) if W.shape[0] != 10 else sigmoid(Z)  # Use ReLU in hidden layers, sigmoid in output layer\n",
    "    return Af,Z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for forward propagation\n",
    "\n",
    "def predict(X):\n",
    "    global W0, W1, W2, W3, B0, B1, B2, B3\n",
    "    H0, Z0 = activation(X, W0, B0)\n",
    "    H1, Z1 = activation(H0, W1, B1)\n",
    "    H2, Z2 = activation(H1, W2, B2)\n",
    "    Y, Z3 = activation(H2, W3, B3)\n",
    "    return Y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# req prediction for Y\n",
    "\n",
    "def reqY(n):\n",
    "    res = np.zeros([10])\n",
    "    res[n] = 1.0\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialising weights and biases for NN with two hidden layers with 16 neurons in each\n",
    "\n",
    "'''\n",
    "Random initialization might not be effective, especially with certain \n",
    "activation functions. Fix: Use a better weight initialization strategy, \n",
    "like Xavier initialization (for sigmoid or tanh) or He initialization (for ReLU)\n",
    "'''\n",
    "\n",
    "W0 = np.random.randn(56, 784) * np.sqrt(2. / 784)\n",
    "B0 = np.zeros(56)\n",
    "\n",
    "W1 = np.random.randn(16, 56) * np.sqrt(2. / 56)\n",
    "B1 = np.zeros(16)\n",
    "\n",
    "W2 = np.random.randn(16, 16) * np.sqrt(2. / 16)\n",
    "B2 = np.zeros(16)\n",
    "\n",
    "W3 = np.random.randn(10, 16) * np.sqrt(2. / 16)\n",
    "B3 = np.zeros(10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nW0 = np.load('W0.npy')\\nW1 = np.load('W1.npy')\\nW2 = np.load('W2.npy')\\nW3 = np.load('W3.npy')\\nB0 = np.load('B0.npy')\\nB1 = np.load('B1.npy')\\nB2 = np.load('B2.npy')\\nB3 = np.load('B3.npy')\\n\""
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# loading the saved Ws and Bs\n",
    "\n",
    "'''\n",
    "W0 = np.load('W0.npy')\n",
    "W1 = np.load('W1.npy')\n",
    "W2 = np.load('W2.npy')\n",
    "W3 = np.load('W3.npy')\n",
    "B0 = np.load('B0.npy')\n",
    "B1 = np.load('B1.npy')\n",
    "B2 = np.load('B2.npy')\n",
    "B3 = np.load('B3.npy')\n",
    "'''    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# getting the cost\n",
    "\n",
    "def calcCost():\n",
    "    global trainY,trainX,W0,W1,W2,W3,B0,B1,B2,B3\n",
    "    cost = []\n",
    "    for i in range(trainY.shape[0]):\n",
    "        X = trainX[i,:]\n",
    "        Y = predict(X)\n",
    "        costt = (Y-reqY(trainY[i]))**2\n",
    "        cost.append(costt.sum()/2)\n",
    "    \n",
    "    cost = np.array(cost)\n",
    "    return cost.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The backpropagation algorithm to compute Cost gradient\n",
    "\n",
    "def backProp(trainY,trainX):\n",
    "    \n",
    "    global W0,W1,W2,W3,B0,B1,B2,B3,dB3,dB2,dB1,dB0,dW3,dW2,dW1,dW0\n",
    "    \n",
    "    dB3 = dB2 = dB1 = dB0 = dW3 = dW2 = dW1 = dW0 = 0.0\n",
    "    \n",
    "    for i in range(trainY.shape[0]):\n",
    "        X = trainX[i,:]\n",
    "        Y_expected = reqY(trainY[i])\n",
    "        H0,Z0 = activation(X, W0, B0)\n",
    "        H1,Z1 = activation(H0, W1, B1)\n",
    "        H2,Z2 = activation(H1,W2,B2)\n",
    "        Y,Z3 = activation(H2,W3,B3)\n",
    "        \n",
    "        # getting deltas\n",
    "        delta_Y = (Y-Y_expected)*sigmoid_prime(Z3)\n",
    "        delta_H2 = np.matmul(W3.T,delta_Y)*relu_prime(Z2)\n",
    "        delta_H1 = np.matmul(W2.T,delta_H2)*relu_prime(Z1)\n",
    "        delta_H0 = np.matmul(W1.T,delta_H1)*relu_prime(Z0)\n",
    "        \n",
    "        # getting the delWs and delBs\n",
    "        \n",
    "        dB3 += delta_Y\n",
    "        dB2 += delta_H2\n",
    "        dB1 += delta_H1\n",
    "        dB0 += delta_H0\n",
    "        \n",
    "        dW3 += np.outer(delta_Y,H2)\n",
    "        dW2 += np.outer(delta_H2,H1)\n",
    "        dW1 += np.outer(delta_H1,H0)\n",
    "        dW0 += np.outer(delta_H0,X)\n",
    "    \n",
    "    \n",
    "    dB3 = dB3/trainY.shape[0]\n",
    "    dB2 = dB2/trainY.shape[0]\n",
    "    dB1 = dB1/trainY.shape[0]\n",
    "    dB0 = dB0/trainY.shape[0]\n",
    "    \n",
    "    dW3 = dW3/trainY.shape[0]\n",
    "    dW2 = dW2/trainY.shape[0]\n",
    "    dW1 = dW1/trainY.shape[0]\n",
    "    dW0 = dW0/trainY.shape[0]\n",
    "\n",
    "    return dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# updating the Ws and Bs\n",
    "\n",
    "def updateParams(learning_rate, dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3):\n",
    "    global W0,W1,W2,W3,B0,B1,B2,B3\n",
    "    \n",
    "    W3 -= learning_rate * dW3\n",
    "    B3 -= learning_rate * dB3\n",
    "    \n",
    "    W2 -= learning_rate * dW2\n",
    "    B2 -= learning_rate * dB2\n",
    "    \n",
    "    W1 -= learning_rate * dW1\n",
    "    B1 -= learning_rate * dB1\n",
    "\n",
    "    W0 -= learning_rate * dW0\n",
    "    B0 -= learning_rate * dB0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving current Ws and Bs\n",
    "def saveParams():\n",
    "    global W0,W1,W2,W3,B0,B1,B2,B3\n",
    "    np.save('W0.npy', W0)\n",
    "    np.save('W1.npy', W1)\n",
    "    np.save('W2.npy', W2)\n",
    "    np.save('W3.npy', W3)\n",
    "    np.save('B0.npy', B0)\n",
    "    np.save('B1.npy', B1)\n",
    "    np.save('B2.npy', B2)\n",
    "    np.save('B3.npy', B3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.49458611375448447\n",
      "0.49237575270539324\n",
      "0.49136399219423416\n"
     ]
    }
   ],
   "source": [
    "# for learning/training the model using all the data at once\n",
    "\n",
    "learningRate = 2\n",
    "\n",
    "for epoch in range(3):   # no of epoch\n",
    "    dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3 = backProp(trainY,trainX)\n",
    "    updateParams(learningRate, dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3)\n",
    "    cost = calcCost()\n",
    "    print(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Cost: 0.020685184856967447\n",
      "Epoch 11, Cost: 0.019655224129185796\n",
      "Epoch 21, Cost: 0.0187174328317083\n",
      "Epoch 31, Cost: 0.017857917195570724\n",
      "Epoch 41, Cost: 0.01707015721679957\n"
     ]
    }
   ],
   "source": [
    "# # for learning/training the model using Mini-Batch Stochastic Gradient Descent (SGD)\n",
    "\n",
    "batch_size = 500\n",
    "learning_rate = 0.1\n",
    "\n",
    "prev_cost = 999999   # default high cost \n",
    "\n",
    "for epoch in range(50):   # no of epoch\n",
    "    for i in range(0, trainX.shape[0], batch_size):\n",
    "        X_batch = trainX[i:i+batch_size, :]\n",
    "        Y_batch = trainY[i:i+batch_size]\n",
    "        dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3 = backProp(Y_batch,X_batch)\n",
    "        updateParams(learning_rate, dW0, dW1, dW2, dW3, dB0, dB1, dB2, dB3)\n",
    "    cost = calcCost()\n",
    "    \n",
    "    if prev_cost<cost:\n",
    "        break\n",
    "    \n",
    "    prev_cost = cost\n",
    "    if epoch%10==0:\n",
    "        saveParams()\n",
    "        print(f\"Epoch {epoch+1}, Cost: {cost}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To test the performance on test data and plotting the confusion matrix\n",
    "\n",
    "# Function to test on test data\n",
    "def testAccuracy():\n",
    "    global testX, testY\n",
    "    correct_guesses = 0\n",
    "    for i in range(testX.shape[0]):\n",
    "        X = testX[i, :]\n",
    "        Y_pred = predict(X)\n",
    "        predicted_label = np.argmax(Y_pred)  # Get the index of the highest value\n",
    "        if predicted_label == testY[i]:\n",
    "            correct_guesses += 1\n",
    "    \n",
    "    accuracy = correct_guesses / testX.shape[0] * 100\n",
    "    return correct_guesses, accuracy\n",
    "\n",
    "\n",
    "# For Ploting the confusion matrix\n",
    "def plot_confusion_matrix(cm, num_classes):\n",
    "    fig, ax = plt.subplots(figsize=(8, 6))\n",
    "    cax = ax.matshow(cm, cmap=plt.cm.Blues)\n",
    "    plt.title('Confusion Matrix')\n",
    "    plt.colorbar(cax)\n",
    "    \n",
    "    # Set axis labels\n",
    "    ax.set_xticks(np.arange(num_classes))\n",
    "    ax.set_yticks(np.arange(num_classes))\n",
    "    \n",
    "    ax.set_xticklabels(range(num_classes))\n",
    "    ax.set_yticklabels(range(num_classes))\n",
    "    \n",
    "    plt.xlabel('Predicted Label')\n",
    "    plt.ylabel('True Label')\n",
    "\n",
    "    for i in range(num_classes):\n",
    "        for j in range(num_classes):\n",
    "            ax.text(j, i, str(cm[i, j]), va='center', ha='center', color='red')\n",
    "            \n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct guesses: 9652\n",
      "Accuracy: 96.53%\n"
     ]
    }
   ],
   "source": [
    "# Test the accuracy after training\n",
    "\n",
    "correct_guesses, accuracy = testAccuracy()\n",
    "print(f\"Correct guesses: {correct_guesses}\")\n",
    "print(f\"Accuracy: {accuracy:.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the confusion matrix\n",
    "\n",
    "y_pred = np.array([np.argmax(predict(testX[i, :])) for i in range(testX.shape[0])])\n",
    "\n",
    "num_classes = 10  # For MNIST, we have 10 classes (0-9)\n",
    "conf_matrix = np.zeros((num_classes, num_classes), dtype=int)\n",
    "\n",
    "# generating the confusion matrix\n",
    "for i in range(len(testY)):\n",
    "    true_label = testY[i]\n",
    "    predicted_label = y_pred[i]\n",
    "    conf_matrix[true_label, predicted_label] += 1\n",
    "\n",
    "plot_confusion_matrix(conf_matrix, num_classes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}