MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import requests, gzip, os, hashlib\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fetch data\n",
    "path='/mnt/e/ADITYA/EDUCATION/ML/Jupyter Lab/MNIST/mnist-from-numpy/data'\n",
    "def fetch(url):\n",
    "    fp = os.path.join(path, hashlib.md5(url.encode('utf-8')).hexdigest())\n",
    "    if os.path.isfile(fp):\n",
    "        with open(fp, \"rb\") as f:\n",
    "            data = f.read()\n",
    "    else:\n",
    "        with open(fp, \"wb\") as f:\n",
    "            data = requests.get(url).content\n",
    "            f.write(data)\n",
    "    return np.frombuffer(gzip.decompress(data), dtype=np.uint8).copy()\n",
    "\n",
    "X = fetch(\"http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\")[0x10:].reshape((-1, 28, 28))\n",
    "Y = fetch(\"http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\")[8:]\n",
    "X_test = fetch(\"http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\")[0x10:].reshape((-1, 28*28))\n",
    "Y_test = fetch(\"http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\")[8:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validation split\n",
    "rand=np.arange(60000)\n",
    "np.random.shuffle(rand)\n",
    "train_no=rand[:50000]\n",
    "\n",
    "val_no=np.setdiff1d(rand,train_no)\n",
    "\n",
    "X_train,X_val=X[train_no,:,:],X[val_no,:,:]\n",
    "Y_train,Y_val=Y[train_no],Y[val_no]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sigmoid funstion\n",
    "def sigmoid(x):\n",
    "    return 1/(np.exp(-x)+1)    \n",
    "\n",
    "#derivative of sigmoid\n",
    "def d_sigmoid(x):\n",
    "    return (np.exp(-x))/((np.exp(-x)+1)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Softmax\n",
    "def softmax(x):\n",
    "    exp_element=np.exp(x-x.max())\n",
    "    return exp_element/np.sum(exp_element,axis=0)\n",
    "\n",
    "#derivative of softmax\n",
    "def d_softmax(x):\n",
    "    exp_element=np.exp(x-x.max())\n",
    "    return exp_element/np.sum(exp_element,axis=0)*(1-exp_element/np.sum(exp_element,axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init(x,y):\n",
    "    layer=np.random.uniform(-1.,1.,size=(x,y))/np.sqrt(x*y)\n",
    "    return layer.astype(np.float32)\n",
    "\n",
    "np.random.seed(42)\n",
    "l1=init(28*28,128)\n",
    "l2=init(128,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 4, 9, ..., 3, 3, 8], dtype=uint8)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4]], dtype=uint8)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ex=np.array(Y_train[1]).reshape(1,1)\n",
    "ex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_out = np.zeros((len(ex),10), np.float32)\n",
    "example_out[range(example_out.shape[0]),ex] = 1\n",
    "example_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#forward and backward pass\n",
    "def forward_backward_pass(x,y):\n",
    "    targets = np.zeros((len(y),10), np.float32)\n",
    "    targets[range(targets.shape[0]),y] = 1\n",
    " \n",
    "    \n",
    "    x_l1=x.dot(l1)\n",
    "    x_sigmoid=sigmoid(x_l1)\n",
    "    x_l2=x_sigmoid.dot(l2)\n",
    "    out=softmax(x_l2)\n",
    "   \n",
    " \n",
    "    error=2*(out-targets)/out.shape[0]*d_softmax(x_l2)\n",
    "    update_l2=x_sigmoid.T@error\n",
    "    \n",
    "    \n",
    "    error=((l2).dot(error.T)).T*d_sigmoid(x_l1)\n",
    "    update_l1=x.T@error\n",
    "\n",
    "    return out,update_l1,update_l2 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For 0th epoch: train accuracy: 0.062 | validation accuracy:0.068\n",
      "For 500th epoch: train accuracy: 0.672 | validation accuracy:0.652\n",
      "For 1000th epoch: train accuracy: 0.773 | validation accuracy:0.745\n",
      "For 1500th epoch: train accuracy: 0.789 | validation accuracy:0.771\n",
      "For 2000th epoch: train accuracy: 0.766 | validation accuracy:0.785\n",
      "For 2500th epoch: train accuracy: 0.750 | validation accuracy:0.795\n",
      "For 3000th epoch: train accuracy: 0.797 | validation accuracy:0.803\n",
      "For 3500th epoch: train accuracy: 0.828 | validation accuracy:0.810\n",
      "For 4000th epoch: train accuracy: 0.836 | validation accuracy:0.814\n",
      "For 4500th epoch: train accuracy: 0.875 | validation accuracy:0.815\n",
      "For 5000th epoch: train accuracy: 0.727 | validation accuracy:0.818\n",
      "For 5500th epoch: train accuracy: 0.828 | validation accuracy:0.821\n",
      "For 6000th epoch: train accuracy: 0.906 | validation accuracy:0.824\n",
      "For 6500th epoch: train accuracy: 0.867 | validation accuracy:0.825\n",
      "For 7000th epoch: train accuracy: 0.852 | validation accuracy:0.825\n",
      "For 7500th epoch: train accuracy: 0.859 | validation accuracy:0.826\n",
      "For 8000th epoch: train accuracy: 0.859 | validation accuracy:0.826\n",
      "For 8500th epoch: train accuracy: 0.852 | validation accuracy:0.827\n",
      "For 9000th epoch: train accuracy: 0.797 | validation accuracy:0.828\n",
      "For 9500th epoch: train accuracy: 0.867 | validation accuracy:0.828\n"
     ]
    }
   ],
   "source": [
    "epochs=10000\n",
    "lr=0.001\n",
    "batch=128\n",
    "\n",
    "losses,accuracies,val_accuracies=[],[],[]\n",
    "\n",
    "for i in range(epochs):\n",
    "    sample=np.random.randint(0,X_train.shape[0],size=(batch))\n",
    "    x=X_train[sample].reshape((-1,28*28))\n",
    "    y=Y_train[sample]\n",
    " \n",
    "\n",
    "    out,update_l1,update_l2=forward_backward_pass(x,y)\n",
    "  \n",
    "    category=np.argmax(out,axis=1)\n",
    "    accuracy=(category==y).mean()\n",
    "    accuracies.append(accuracy)\n",
    "    \n",
    "    loss=((category-y)**2).mean()\n",
    "    losses.append(loss.item())\n",
    "    \n",
    "    l1=l1-lr*update_l1\n",
    "    l2=l2-lr*update_l2\n",
    "    \n",
    "    if(i%20==0):    \n",
    "        X_val=X_val.reshape((-1,28*28))\n",
    "        val_out=np.argmax(softmax(sigmoid(X_val.dot(l1)).dot(l2)),axis=1)\n",
    "        val_acc=(val_out==Y_val).mean()\n",
    "        val_accuracies.append(val_acc.item())\n",
    "    if(i%500==0): print(f'For {i}th epoch: train accuracy: {accuracy:.3f} | validation accuracy:{val_acc:.3f}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7ab1938e80>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.ylim(-0.1, 1.1)\n",
    "plot(accuracies)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7a9174d610>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(val_accuracies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy = 83.67%\n"
     ]
    }
   ],
   "source": [
    "test_out=np.argmax(softmax(sigmoid(X_test.dot(l1)).dot(l2)),axis=1)\n",
    "test_acc=(test_out==Y_test).mean().item()\n",
    "print(f'Test accuracy = {test_acc*100:.2f}%')\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = [[0,0,0,0,0,0,0],\n",
    "     [0,0,10,10,10,0,0],\n",
    "     [0,0,0,0,10,0,0],\n",
    "     [0,0,0,0,10,0,0],\n",
    "     [0,0,0,0,10,0,0],\n",
    "     [0,0,0,0,10,0,0],\n",
    "     [0,0,0,0,0,0,0]]\n",
    "\n",
    "m = np.concatenate([np.concatenate([[x]*4 for x in y]*4) for y in m])\n",
    "m=m.reshape(1,-1)\n",
    "imshow(m.reshape(28,28))\n",
    "x = np.argmax(sigmoid(m.dot(l1)).dot(l2),axis=1)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "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": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = [[0,0,0,0,0,0,0],\n",
    "     [0,0,0,10,0,0,0],\n",
    "     [0,0,0,10,0,0,0],\n",
    "     [0,0,0,10,0,0,0],\n",
    "     [0,0,0,10,0,0,0],\n",
    "     [0,0,0,10,0,0,0],\n",
    "     [0,0,0,0,0,0,0]]\n",
    "\n",
    "n = np.concatenate([np.concatenate([[x]*4 for x in y]*4) for y in n])\n",
    "n=n.reshape(1,-1)\n",
    "imshow(n.reshape(28,28))\n",
    "x = np.argmax(sigmoid(n.dot(l1)).dot(l2),axis=1)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "if (window.IPython && IPython.notebook.kernel) IPython.notebook.kernel.execute('jovian.utils.jupyter.get_notebook_name_saved = lambda: \"' + IPython.notebook.notebook_name + '\"')"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Update Available: 0.2.26 --> 0.2.28\n",
      "[jovian] Run `!pip install jovian --upgrade` to upgrade\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "window.require && require([\"base/js/namespace\"],function(Jupyter){Jupyter.notebook.save_checkpoint()})"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Attempting to save notebook..\n",
      "[jovian] Updating notebook \"karynaur/mnist\" on https://jovian.ai/\n",
      "[jovian] Uploading notebook..\n",
      "[jovian] Capturing environment..\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[jovian] Error: Failed to read Anaconda environment using command: \"conda env export -n base --no-builds\"\n",
      "[jovian] Error: Failed to read pip environment using command: \"pip --disable-pip-version-check freeze\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[jovian] Committed successfully! https://jovian.ai/karynaur/mnist\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'https://jovian.ai/karynaur/mnist'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import jovian\n",
    "jovian.commit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}