CNN_implementation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "%matplotlib inline\n",
    "from sklearn.preprocessing import MinMaxScaler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Data Preprocessing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Training Data\n",
    "df = pd.read_csv(\"C:\\\\Users\\\\Sameer\\\\Desktop\\\\CNN\\\\mnist_train.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separating Labels and Features\n",
    "x = np.array(df.loc[:, df.columns != 'Label'])\n",
    "x_data = x.transpose()\n",
    "# x_data.shape   >>> (784, 60000)\n",
    "y = np.array(df.loc[:, df.columns == 'Label'])\n",
    "# y.shape        >>> (60000, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One hot Encoding\n",
    "y_label = np.zeros((10,60000),np.float32)\n",
    "for i in range(60000):\n",
    "    for j in range(10):\n",
    "        if y[i,0] == j:\n",
    "            y_label[j,i] = int(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Sameer\\Anaconda3\\envs\\Tensor\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype int64 was converted to float64 by MinMaxScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    }
   ],
   "source": [
    "# Scaling Data\n",
    "scale = MinMaxScaler()\n",
    "x_data_Scaled = scale.fit_transform(x_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv_made(data,kernel,st_h,st_v):\n",
    "    h , w = data.shape\n",
    "    a_ , b_ = kernel.shape\n",
    "    hh = int((h - a_)/st_v +1)\n",
    "    ww = int((w - b_)/st_h+1)\n",
    "    op = np.zeros((hh,ww))\n",
    "    temp = np.arange(b_)\n",
    "    for l in range(hh):   \n",
    "            for m in range(ww):  \n",
    "                for i in range(a_):\n",
    "                    temp[i]= np.matmul(data[st_v*l+i,st_h*m:st_h*m+b_],kernel[i])\n",
    "                op[l,m] = np.sum(temp)\n",
    "    return op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Filters\n",
    "f_1_1  = np.random.random((6,6)) + 0.001\n",
    "f_1_2  = np.random.random((6,6)) + 0.002\n",
    "f_1_3  = np.random.random((6,6)) + 0.003\n",
    "f_1_4  = np.random.random((6,6)) + 0.0022\n",
    "f_1_5  = np.random.random((6,6)) + 0.0025"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_1 = [f_1_1 ,f_1_2 ,f_1_3 ,f_1_4 ,f_1_5]\n",
    "w = np.random.random((10,144,5)) + 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Provides prediction for nth example\n",
    "def predict(n):\n",
    "    i = 0\n",
    "    q_ = np.ones((12,12,5)) \n",
    "    for f in f_1:                 # Operating on nth index example\n",
    "        q_[:,:,i]  =  conv_made(x_data_Scaled[:,n].reshape(28,28),f,2,2)\n",
    "        i += 1 \n",
    "    tempp = np.zeros((10,5))\n",
    "    for i in range(5):\n",
    "        tempp[:,i] = np.matmul(w[:,:,i],q_[:,:,i].reshape(144))\n",
    "    p_hat = np.sum(tempp,axis=1)\n",
    "    \n",
    "    \n",
    "    p_predict = np.argmax(p_hat)      # Grabbing Predicted Number\n",
    "    p_true = np.argmax(y_label[:,n])  # Grabbing True Number\n",
    "    return p_predict , p_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy():\n",
    "    kl=0\n",
    "    for i in range (55000,55500):\n",
    "        p1 , p2 = predict(i)\n",
    "        if (p1==p2):\n",
    "            kl=kl+1\n",
    "    print(\"Accuracy is now\",\"%0.2f\"%(100*(kl/500)),\" %\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def acc_model():\n",
    "    k=0\n",
    "    for i in range (55000,55500):\n",
    "        p1 , p2 = predict(i)\n",
    "        if (p1==p2):\n",
    "            k=k+1\n",
    "    print(\"Accuracy is now\",\"%0.2f\"%(100*(k/500)),\"%\")\n",
    "    return (100*(k/500))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#To be modified for inputs\n",
    "def layer_1(x,f_1):\n",
    "    # x,shape (28,28)\n",
    "    i = 0\n",
    "    q = np.ones((12,12,5)) #To be generalized\n",
    "    for f in f_1:\n",
    "        q[:,:,i]  =  conv_made(x,f,2,2)\n",
    "        i += 1\n",
    "    return q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fully connected\n",
    "def fc(q,w,jv):\n",
    "    #q(144,5)\n",
    "    temp = np.zeros((10,5))  #temp = scorefc\n",
    "    for i in range(5):\n",
    "        temp[:,i] = np.matmul(w[:,:,i],q[:,:,i].reshape(144))\n",
    "    scorefc = np.sum(temp,axis=1)\n",
    "    #scorefc = scorefc/((np.matmul(scorefc,scorefc))**0.5)  # Normalization\n",
    "    scorefc = scorefc/np.max(scorefc)\n",
    "    #print(scorefc)\n",
    "    loss.append(-np.log(np.exp(scorefc[jv])/np.sum(np.exp(scorefc))))\n",
    "    \n",
    "    return scorefc , loss  # , np.argmax(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_update(w,f_1,q,x,jz,scorep,cn):\n",
    "    # jz is true label index\n",
    "    # x.shape (28,28)\n",
    "    if(jz!=8 and jz!=5):\n",
    "        lr = 0.0005 # Learning rate biased for 8 & 5\n",
    "    else:   \n",
    "        lr = 0.0002 \n",
    "    if(cn%2==0):\n",
    "        h = 0\n",
    "        ls = [0,2,4]\n",
    "        for k in ls: \n",
    "            for i in range(144):\n",
    "                w[jz,i,k] += lr*( q[:,:,k].reshape(144)[i] - ((q[:,:,k].reshape(144))[i]*np.exp(scorep[jz]))/np.exp(np.sum(scorep)))\n",
    "        for f in [f_1[0],f_1[2],f_1[4]]:\n",
    "            for qi in range(12):\n",
    "                for qj in range(12):\n",
    "                    for i in range(6):\n",
    "                        for p in range(6):\n",
    "                            #print((w[jz,:,h].reshape(12,12)).shape)\n",
    "                            w_e = (w[jz,:,h].reshape(12,12))[qi,qj]\n",
    "                            x_e = x[2*qi+i,qj*2+p] #Here 2 is stride\n",
    "                            f[i,p] += lr*(w_e*x_e - (w_e*x_e*np.exp(scorep[jz]))/np.exp(np.sum(scorep)) )\n",
    "        h +=2\n",
    "    else:\n",
    "        h = 1\n",
    "        ls = [1,3]\n",
    "        for k in ls: \n",
    "            for i in range(144):\n",
    "                w[jz,i,k] += lr*( q[:,:,k].reshape(144)[i] - ((q[:,:,k].reshape(144))[i]*np.exp(scorep[jz]))/np.exp(np.sum(scorep)))\n",
    "        for f in [f_1[1],f_1[3]]:\n",
    "            for qi in range(12):\n",
    "                for qj in range(12):\n",
    "                    for i in range(6):\n",
    "                        for p in range(6):\n",
    "                            #print((w[jz,:,h].reshape(12,12)).shape)\n",
    "                            w_e = (w[jz,:,h].reshape(12,12))[qi,qj]\n",
    "                            x_e = x[2*qi+i,qj*2+p]\n",
    "                            f[i,p] += lr*(w_e*x_e - (w_e*x_e*np.exp(scorep[jz]))/np.exp(np.sum(scorep)) )\n",
    "        h +=2                            \n",
    "    #f = f/np.max(f)\n",
    "    h +=1\n",
    "    cn = cn+1\n",
    "    return w  , f_1 ,cn\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch = 0\n",
      "Accuracy is now 13.20 %\n",
      "Epoch = 50\n",
      "Accuracy is now 15.60 %\n",
      "Epoch = 100\n",
      "Accuracy is now 15.20 %\n",
      "Epoch = 150\n",
      "Accuracy is now 17.80 %\n",
      "Epoch = 200\n",
      "Accuracy is now 16.60 %\n",
      "Epoch = 250\n",
      "Accuracy is now 22.40 %\n",
      "Epoch = 300\n",
      "Accuracy is now 28.40 %\n",
      "Epoch = 350\n",
      "Accuracy is now 30.20 %\n",
      "Epoch = 400\n",
      "Accuracy is now 30.80 %\n",
      "Epoch = 450\n",
      "Accuracy is now 36.40 %\n",
      "Epoch = 500\n",
      "Accuracy is now 42.80 %\n",
      "Epoch = 550\n",
      "Accuracy is now 48.00 %\n",
      "Epoch = 600\n",
      "Accuracy is now 41.60 %\n",
      "Epoch = 650\n",
      "Accuracy is now 49.00 %\n",
      "Epoch = 700\n",
      "Accuracy is now 52.00 %\n",
      "Epoch = 750\n",
      "Accuracy is now 53.40 %\n",
      "Epoch = 800\n",
      "Accuracy is now 45.60 %\n",
      "Epoch = 850\n",
      "Accuracy is now 56.80 %\n",
      "Epoch = 900\n",
      "Accuracy is now 60.20 %\n",
      "Epoch = 950\n",
      "Accuracy is now 58.60 %\n",
      "Epoch = 1000\n",
      "Accuracy is now 61.60 %\n",
      "Epoch = 1050\n",
      "Accuracy is now 62.40 %\n",
      "Epoch = 1100\n",
      "Accuracy is now 61.80 %\n",
      "Epoch = 1150\n",
      "Accuracy is now 57.60 %\n",
      "Epoch = 1200\n",
      "Accuracy is now 67.20 %\n",
      "Epoch = 1250\n",
      "Accuracy is now 66.20 %\n",
      "Epoch = 1300\n",
      "Accuracy is now 57.20 %\n",
      "Epoch = 1350\n",
      "Accuracy is now 49.60 %\n",
      "Epoch = 1400\n",
      "Accuracy is now 67.40 %\n",
      "Epoch = 1450\n",
      "Accuracy is now 70.60 %\n",
      "Epoch = 1500\n",
      "Accuracy is now 65.20 %\n",
      "Epoch = 1550\n",
      "Accuracy is now 66.40 %\n",
      "Epoch = 1600\n",
      "Accuracy is now 67.00 %\n",
      "Epoch = 1650\n",
      "Accuracy is now 64.40 %\n",
      "Epoch = 1700\n",
      "Accuracy is now 65.60 %\n",
      "Epoch = 1750\n",
      "Accuracy is now 70.20 %\n",
      "Epoch = 1800\n",
      "Accuracy is now 71.40 %\n",
      "Epoch = 1850\n",
      "Accuracy is now 61.00 %\n",
      "Epoch = 1900\n",
      "Accuracy is now 59.80 %\n",
      "Epoch = 1950\n",
      "Accuracy is now 68.80 %\n",
      "Epoch = 2000\n",
      "Accuracy is now 75.40 %\n",
      "Epoch = 2050\n",
      "Accuracy is now 81.40 %\n",
      "Epoch = 2100\n",
      "Accuracy is now 75.40 %\n",
      "Epoch = 2150\n",
      "Accuracy is now 69.40 %\n",
      "Epoch = 2200\n",
      "Accuracy is now 78.40 %\n",
      "Epoch = 2250\n",
      "Accuracy is now 75.80 %\n",
      "Epoch = 2300\n",
      "Accuracy is now 74.60 %\n",
      "Epoch = 2350\n",
      "Accuracy is now 74.20 %\n",
      "Epoch = 2400\n",
      "Accuracy is now 80.00 %\n",
      "Epoch = 2450\n",
      "Accuracy is now 72.40 %\n",
      "Epoch = 2500\n",
      "Accuracy is now 74.60 %\n",
      "Epoch = 2550\n",
      "Accuracy is now 79.20 %\n",
      "Epoch = 2600\n",
      "Accuracy is now 74.00 %\n",
      "Epoch = 2650\n",
      "Accuracy is now 74.80 %\n",
      "Epoch = 2700\n",
      "Accuracy is now 73.40 %\n",
      "Epoch = 2750\n",
      "Accuracy is now 73.20 %\n",
      "Epoch = 2800\n",
      "Accuracy is now 77.00 %\n",
      "Epoch = 2850\n",
      "Accuracy is now 79.40 %\n",
      "Epoch = 2900\n",
      "Accuracy is now 77.20 %\n",
      "Epoch = 2950\n",
      "Accuracy is now 79.40 %\n",
      "Epoch = 3000\n",
      "Accuracy is now 77.80 %\n",
      "Epoch = 3050\n",
      "Accuracy is now 72.40 %\n",
      "Epoch = 3100\n",
      "Accuracy is now 69.20 %\n",
      "Epoch = 3150\n",
      "Accuracy is now 81.60 %\n",
      "Epoch = 3200\n",
      "Accuracy is now 80.40 %\n",
      "Epoch = 3250\n",
      "Accuracy is now 76.40 %\n",
      "Epoch = 3300\n",
      "Accuracy is now 73.80 %\n",
      "Epoch = 3350\n",
      "Accuracy is now 73.00 %\n",
      "Epoch = 3400\n",
      "Accuracy is now 63.60 %\n",
      "Epoch = 3450\n",
      "Accuracy is now 80.60 %\n",
      "Epoch = 3500\n",
      "Accuracy is now 77.20 %\n",
      "Epoch = 3550\n",
      "Accuracy is now 81.40 %\n",
      "Epoch = 3600\n",
      "Accuracy is now 58.80 %\n",
      "Epoch = 3650\n",
      "Accuracy is now 74.80 %\n",
      "Epoch = 3700\n",
      "Accuracy is now 63.20 %\n",
      "Epoch = 3750\n",
      "Accuracy is now 70.80 %\n",
      "Epoch = 3800\n",
      "Accuracy is now 65.60 %\n",
      "Epoch = 3850\n",
      "Accuracy is now 74.60 %\n",
      "Epoch = 3900\n",
      "Accuracy is now 64.80 %\n",
      "Epoch = 3950\n",
      "Accuracy is now 61.00 %\n",
      "Epoch = 4000\n",
      "Accuracy is now 61.20 %\n",
      "Epoch = 4050\n",
      "Accuracy is now 65.80 %\n",
      "Epoch = 4100\n",
      "Accuracy is now 65.60 %\n",
      "Epoch = 4150\n",
      "Accuracy is now 74.80 %\n",
      "Epoch = 4200\n",
      "Accuracy is now 62.40 %\n",
      "Epoch = 4250\n",
      "Accuracy is now 75.00 %\n",
      "Epoch = 4300\n",
      "Accuracy is now 77.20 %\n",
      "Epoch = 4350\n",
      "Accuracy is now 73.60 %\n",
      "Epoch = 4400\n",
      "Accuracy is now 71.20 %\n",
      "Epoch = 4450\n",
      "Accuracy is now 74.60 %\n",
      "Epoch = 4500\n",
      "Accuracy is now 64.80 %\n",
      "Epoch = 4550\n",
      "Accuracy is now 77.40 %\n",
      "Epoch = 4600\n",
      "Accuracy is now 72.40 %\n",
      "Epoch = 4650\n",
      "Accuracy is now 69.80 %\n",
      "Epoch = 4700\n",
      "Accuracy is now 68.80 %\n",
      "Epoch = 4750\n",
      "Accuracy is now 80.00 %\n",
      "Epoch = 4800\n",
      "Accuracy is now 78.00 %\n",
      "Epoch = 4850\n",
      "Accuracy is now 82.60 %\n",
      "Epoch = 4900\n",
      "Accuracy is now 78.20 %\n",
      "Epoch = 4950\n",
      "Accuracy is now 81.00 %\n"
     ]
    }
   ],
   "source": [
    "epochs = 5000\n",
    "loss = []\n",
    "acc_list = []\n",
    "count = 0\n",
    "epoch_50 = 0\n",
    "for i in range(epochs):\n",
    "    x = x_data_Scaled[:,i]  # Took ith sample\n",
    "    y = y_label[:,i]        # Took true label column of ith sample\n",
    "    \n",
    "    jz = np.argmax(y)  #True Label        \n",
    "    q_ = layer_1(x.reshape(28,28),f_1)\n",
    "    score , loss = fc(q_,w,jz)  # , y_predic\n",
    "    #backpropagation\n",
    "    jp , jz = predict(i)\n",
    "    if(jp!=jz):\n",
    "        w , f_1 , count = parameter_update(w,f_1,q_,x.reshape(28,28),jz,score,count)\n",
    "        #alz Learning Threshold\n",
    "    if(i%50==0):\n",
    "        print(\"Epoch = \"+ str(i))#,\"accuracy=\",(lm*100)/(i+1) \n",
    "        acp = acc_model()\n",
    "        acc_list.append(acp)\n",
    "        epoch_50 += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Accuracy')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(list(range(epoch_50)),acc_list) # 50 epoch counting variable\n",
    "plt.xlabel(\"x50 Iterations\")\n",
    "plt.ylabel(\"Accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is now 76.00  %\n"
     ]
    }
   ],
   "source": [
    "accuracy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "468\n",
      "True\n",
      "7 7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a210f63780>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = int(input())\n",
    "zx,zy = predict(c)\n",
    "if (zx==zy):\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"False\")\n",
    "print(zx,zy)\n",
    "plt.imshow(x_data_Scaled[:,c].reshape((28,28)),cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weight 0-9: 5\n",
      "Enter slice 0-4: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a21102f940>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#To Visualize Weight Matrix of FC layer\n",
    "sa = int(input(\"Weight 0-9: \"))\n",
    "ss = int(input(\"Enter slice 0-4: \"))\n",
    "plt.imshow(w[sa,:,ss].reshape(12,12),cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a210fbff98>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(f_1_1,cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a210ff6a58>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(f_1_3,cmap='gray')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}