mnistNN_2HL.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": 7,
   "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": 8,
   "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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for forward propagation\n",
    "\n",
    "def predict(X):\n",
    "    global W1, W2, W3, B1, B2, B3\n",
    "    H1, Z1 = activation(X, 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": 10,
   "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": 12,
   "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",
    "W1 = np.random.randn(16, 784) * np.sqrt(2. / 784)\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading the saved Ws and Bs\n",
    "\n",
    "'''\n",
    "W1 = np.load('W1.npy')\n",
    "W2 = np.load('W2.npy')\n",
    "W3 = np.load('W3.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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# getting the cost\n",
    "\n",
    "def calcCost():\n",
    "    global trainY,trainX,W1,W2,W3,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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The backpropagation algorithm to compute Cost gradient\n",
    "\n",
    "def backProp(trainY,trainX):\n",
    "    \n",
    "    global W1,W2,W3,B1,B2,B3,dB3,dB2,dB1,dW3,dW2,dW1\n",
    "    \n",
    "    dB3 = dB2 = dB1 = dW3 = dW2 = dW1 = 0.0\n",
    "    \n",
    "    for i in range(trainY.shape[0]):\n",
    "        X = trainX[i,:]\n",
    "        Y_expected = reqY(trainY[i])\n",
    "        H1,Z1 = activation(X, 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",
    "        \n",
    "        # getting the delWs and delBs\n",
    "        \n",
    "        dB3 += delta_Y\n",
    "        dB2 += delta_H2\n",
    "        dB1 += delta_H1\n",
    "        \n",
    "        dW3 += np.outer(delta_Y,H2)\n",
    "        dW2 += np.outer(delta_H2,H1)\n",
    "        dW1 += np.outer(delta_H1,X)\n",
    "    \n",
    "    \n",
    "    dB3 = dB3/trainY.shape[0]\n",
    "    dB2 = dB2/trainY.shape[0]\n",
    "    dB1 = dB1/trainY.shape[0]\n",
    "    \n",
    "    dW3 = dW3/trainY.shape[0]\n",
    "    dW2 = dW2/trainY.shape[0]\n",
    "    dW1 = dW1/trainY.shape[0]\n",
    "\n",
    "    return dW1, dW2, dW3, dB1, dB2, dB3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# updating the Ws and Bs\n",
    "\n",
    "def updateParams(learning_rate, dW1, dW2, dW3, dB1, dB2, dB3):\n",
    "    global W1,W2,W3,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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving current Ws and Bs\n",
    "def saveParams():\n",
    "    global W1,W2,W3,B1,B2,B3\n",
    "    np.save('W1.npy', W1)\n",
    "    np.save('W2.npy', W2)\n",
    "    np.save('W3.npy', W3)\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": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.11646799126319972\n",
      "0.11645374760673322\n",
      "0.11644157078763899\n"
     ]
    }
   ],
   "source": [
    "# for learning/training the model using all the data at once\n",
    "\n",
    "learningRate = 0.1\n",
    "\n",
    "for epoch in range(3):   # no of epoch\n",
    "    dW1, dW2, dW3, dB1, dB2, dB3 = backProp(trainY,trainX)\n",
    "    updateParams(learningRate, dW1, dW2, dW3, dB1, dB2, dB3)\n",
    "    cost = calcCost()\n",
    "    print(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Cost: 0.0781810334044968\n"
     ]
    }
   ],
   "source": [
    "# # for learning/training the model using Mini-Batch Stochastic Gradient Descent (SGD)\n",
    "\n",
    "batch_size = 1000\n",
    "learning_rate = 0.05\n",
    "\n",
    "prev_cost = 999999   # default high cost \n",
    "\n",
    "for epoch in range(100):   # 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",
    "        dW1, dW2, dW3, dB1, dB2, dB3 = backProp(Y_batch,X_batch)\n",
    "        updateParams(learning_rate, dW1, dW2, dW3, 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": 16,
   "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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct guesses: 8598\n",
      "Accuracy: 85.99%\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": 18,
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}