RNN_BinaryAdditionTask.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building a RNN model from scratch\n",
    "In this task, I'm going to build a recurrent neural network from scratch using only numpy for calculation and matplotlib for plotting. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the packages that I need\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two Functions needed for this task\n",
    "When we do the backpropagation through time (BPTT), which is the most important thing in RNN tasks, we have to calculate the gradient. Because I chose sigmoid function as my activation function, it is much better that we define the sigmoid function itself and its derivative function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sigmoid function and its derivative \n",
    "def sigmoid(x):\n",
    "    output = 1/(1+np.exp(-x))\n",
    "    return output\n",
    "\n",
    "def sigmoid_derivative(output):\n",
    "    return output*(1-output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate a lookup table for number to binary code\n",
    "Before building the RNN model, let's generate our training data, that is the binary code of every number. Thanks for the built-in function of numpy, the 'np.unpackbits' function can help us deal with this problem : )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let the randomization different every time\n",
    "a = np.random.randint(1,100)\n",
    "np.random.seed(a)\n",
    "\n",
    "# training dataset generation\n",
    "int2binary = {}\n",
    "binary_dim = 8\n",
    "\n",
    "largest_number = pow(2,binary_dim)\n",
    "binary = np.unpackbits(np.array([range(largest_number)],dtype=np.uint8).T,axis=1)\n",
    "for i in range(largest_number):\n",
    "    int2binary[i] = binary[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameters and Weights initialization\n",
    "The following instance are the hyperparameters, including epoch, learning rate, input dimension, hidden dimension and output dimension. Because our task is binary addition (say, A + B = C) , and we want the model to see just one single digit from A and B at one time. Thus the input dimension is 2 (one from the A, and the other from B). The hidden dimension is randomly set to be 16. Lastly, the output dimension is 1. \n",
    "\n",
    "\n",
    "# The three weights matter in this task !!!\n",
    "1. The weight from input layer to hidden layer is called W_inputtohidden, which the shape is (2,16)\n",
    "2. The weight from hidden layer to output layer is called W_hiddenToOutput, which the shape is (16,1)\n",
    "3. The weight from hidden layer to hidden layer is called W_hiddentohidden, which the shape is (16,16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hyperparameters\n",
    "epoch = 20000\n",
    "lr = 0.1\n",
    "input_dim = 2\n",
    "hidden_dim = 16\n",
    "output_dim = 1\n",
    "\n",
    "# initialize neural network weights\n",
    "W_inputtohidden = 2*np.random.random((input_dim,hidden_dim)) - 1\n",
    "W_hiddenToOutput = 2*np.random.random((hidden_dim,output_dim)) - 1\n",
    "W_hiddenTohidden = 2*np.random.random((hidden_dim,hidden_dim)) - 1\n",
    "\n",
    "# generate 3 lists to store the upcoming gradients\n",
    "W_inputtohidden_update = np.zeros_like(W_inputtohidden)\n",
    "W_hiddenToOutput_update = np.zeros_like(W_hiddenToOutput)\n",
    "W_hiddenTohidden_update = np.zeros_like(W_hiddenTohidden)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training\n",
    "\n",
    "Because the binary dimension is 8, so there are 8 positions in every binary code of numbers. For example the binary code of 2 is [0,0,0,0,0,0,1,0], and binary code of 15 is [0,0,0,0,1,1,1,1], and so on. Let's assume that we want to do the addition of 2 and 15. We hope that the machine is fed with two digits in one time, one is from the binary code of 2, and the other one is from the binary code of 15 (both from right to left) For instance, the first time, the machine is fed with array(0,1), and then (1,1), (0,1), (0,1), (0,0), (0,0), (0,0), and (0,0). We hope that the output is [0,0,0,1,0,0,0,1].\n",
    "\n",
    "# Back Propagation Through Time (BPTT)\n",
    "The core of this task is the Back Propagation Through Time (BPTT). The mathematical derivation is written in this article (https://medium.com/vincents-blog/recurrent-neural-network-from-scratch-binary-addition-task-e2c7fb5ca37b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 0\n",
      "Pred: [0 0 0 0 0 0 0 0]\n",
      "True: [1 0 0 0 0 1 1 0]\n",
      "67  +  67  =  0\n",
      "Error: 37.5\n",
      "accuracy = 62.5 %\n",
      "------------\n",
      "epoch 1000\n",
      "Pred: [1 1 1 0 0 0 0 0]\n",
      "True: [1 1 0 0 1 0 1 0]\n",
      "116  +  86  =  224\n",
      "Error: 37.5\n",
      "accuracy = 62.5 %\n",
      "------------\n",
      "epoch 2000\n",
      "Pred: [1 1 1 1 1 1 1 1]\n",
      "True: [1 0 1 0 1 0 0 0]\n",
      "100  +  68  =  255\n",
      "Error: 62.5\n",
      "accuracy = 37.5 %\n",
      "------------\n",
      "epoch 3000\n",
      "Pred: [1 1 1 1 1 1 0 1]\n",
      "True: [1 0 0 1 0 1 0 1]\n",
      "119  +  30  =  253\n",
      "Error: 37.5\n",
      "accuracy = 62.5 %\n",
      "------------\n",
      "epoch 4000\n",
      "Pred: [1 1 1 1 1 0 1 1]\n",
      "True: [0 1 1 1 1 0 1 1]\n",
      "59  +  64  =  251\n",
      "Error: 12.5\n",
      "accuracy = 87.5 %\n",
      "------------\n",
      "epoch 5000\n",
      "Pred: [1 1 1 0 0 0 0 1]\n",
      "True: [0 1 1 1 0 0 1 1]\n",
      "21  +  94  =  225\n",
      "Error: 37.5\n",
      "accuracy = 62.5 %\n",
      "------------\n",
      "epoch 6000\n",
      "Pred: [0 1 0 1 1 1 0 0]\n",
      "True: [0 1 0 1 1 1 1 0]\n",
      "67  +  27  =  92\n",
      "Error: 12.5\n",
      "accuracy = 87.5 %\n",
      "------------\n",
      "epoch 7000\n",
      "Pred: [1 0 1 1 0 0 1 0]\n",
      "True: [1 0 1 1 0 0 1 0]\n",
      "61  +  117  =  178\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 8000\n",
      "Pred: [0 1 0 1 0 0 0 1]\n",
      "True: [0 1 0 1 0 0 0 1]\n",
      "75  +  6  =  81\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 9000\n",
      "Pred: [1 0 0 1 1 0 0 0]\n",
      "True: [1 0 0 1 1 0 0 0]\n",
      "63  +  89  =  152\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 10000\n",
      "Pred: [0 1 1 0 1 0 1 1]\n",
      "True: [0 1 1 0 1 0 1 1]\n",
      "17  +  90  =  107\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 11000\n",
      "Pred: [0 1 0 1 1 1 0 1]\n",
      "True: [0 1 0 1 1 1 0 1]\n",
      "19  +  74  =  93\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 12000\n",
      "Pred: [1 0 0 1 0 1 1 1]\n",
      "True: [1 0 0 1 0 1 1 1]\n",
      "58  +  93  =  151\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 13000\n",
      "Pred: [1 0 0 1 1 1 0 1]\n",
      "True: [1 0 0 1 1 1 0 1]\n",
      "64  +  93  =  157\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 14000\n",
      "Pred: [1 0 1 0 0 1 0 1]\n",
      "True: [1 0 1 0 0 1 0 1]\n",
      "108  +  57  =  165\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 15000\n",
      "Pred: [1 0 1 0 1 0 1 1]\n",
      "True: [1 0 1 0 1 0 1 1]\n",
      "91  +  80  =  171\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 16000\n",
      "Pred: [1 0 1 1 1 1 0 1]\n",
      "True: [1 0 1 1 1 1 0 1]\n",
      "72  +  117  =  189\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 17000\n",
      "Pred: [0 1 1 0 1 0 0 1]\n",
      "True: [0 1 1 0 1 0 0 1]\n",
      "2  +  103  =  105\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 18000\n",
      "Pred: [1 1 0 0 1 0 1 0]\n",
      "True: [1 1 0 0 1 0 1 0]\n",
      "126  +  76  =  202\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n",
      "epoch 19000\n",
      "Pred: [0 1 0 0 0 0 0 0]\n",
      "True: [0 1 0 0 0 0 0 0]\n",
      "22  +  42  =  64\n",
      "Error: 0.0\n",
      "accuracy = 100.0 %\n",
      "------------\n"
     ]
    }
   ],
   "source": [
    "allError=[]\n",
    "Acc = []\n",
    "# training logic\n",
    "for j in range(epoch):\n",
    "    # generate a simple addition problem (a + b = c)\n",
    "    a_int = np.random.randint(largest_number/2) # int version\n",
    "    a = int2binary[a_int] # binary version of a\n",
    "    b_int = np.random.randint(largest_number/2) # int version\n",
    "    b = int2binary[b_int] # binary verions of b\n",
    "\n",
    "    # true answer\n",
    "    c_int = a_int + b_int # int version of c\n",
    "    c = int2binary[c_int] # binary version of c\n",
    "\n",
    "    # i generate an array d for the best answer given by the machine (binary version)\n",
    "    d = np.zeros_like(c)\n",
    "    overallError = 0\n",
    "    \n",
    "\n",
    "    outputlayer_deltas = list()\n",
    "    hidden_values = list()\n",
    "    hidden_values.append(np.zeros(hidden_dim))\n",
    "\n",
    "    # moving along the positions in the binary encoding\n",
    "    for position in range(binary_dim):\n",
    "        # generate input and output , move from right to left\n",
    "        X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]]) \n",
    "        y = np.array([[c[binary_dim - position - 1]]]).T \n",
    "        \n",
    "        # forward propagation\n",
    "        hidden=sigmoid(np.dot(X,W_inputtohidden) + np.dot(hidden_values[-1],W_hiddenTohidden))\n",
    "        # output layer (new binary representation)\n",
    "        outputlayer = sigmoid(np.dot(hidden,W_hiddenToOutput))\n",
    "\n",
    "\n",
    "        # calculate the loss value\n",
    "        outputlayer_error = y - outputlayer\n",
    "        outputlayer_deltas.append((outputlayer_error)*sigmoid_derivative(outputlayer)*(-1))\n",
    "        Error = ((outputlayer_error)**2)/2\n",
    "        \n",
    "        \n",
    "\n",
    "        # decode estimate \n",
    "        # print(\"The OutputLayer (binary version): \",outputlayer[0][0])\n",
    "        d[binary_dim - position - 1] = np.round(outputlayer[0][0])\n",
    "        \n",
    "        # store hidden layer foro BPTT\n",
    "        hidden_values.append(hidden)\n",
    "\n",
    "    # generate an array to store the hidden and hidden_delta at t + 1 for BPTT\n",
    "    future_hidden_delta = np.zeros(hidden_dim)\n",
    "    future_hidden = np.zeros(hidden_dim)\n",
    "\n",
    "    for position in range(binary_dim):\n",
    "        X = np.array([[a[position],b[position]]])\n",
    "        hidden = hidden_values[-position-1]\n",
    "        prev_hidden = hidden_values[-position-2]\n",
    "        \n",
    "        # error at output layer\n",
    "        outputlayer_delta = outputlayer_deltas[-position-1]\n",
    "        \n",
    "        # error at hidden layer * sigmoid_derivative(future_hidden)\n",
    "        hidden_delta = (future_hidden_delta.dot(W_hiddenTohidden.T) * sigmoid_derivative(future_hidden) + outputlayer_delta.dot(W_hiddenToOutput.T)) * sigmoid_derivative(hidden)\n",
    "\n",
    "        # update all weights \n",
    "        W_hiddenToOutput_update += np.atleast_2d(hidden).T.dot(outputlayer_delta)\n",
    "        W_hiddenTohidden_update += np.atleast_2d(prev_hidden).T.dot(hidden_delta) \n",
    "        W_inputtohidden_update += X.T.dot(hidden_delta) \n",
    "        future_hidden_delta = hidden_delta\n",
    "        future_hidden = hidden\n",
    "    \n",
    "    W_inputtohidden -= W_inputtohidden_update * lr\n",
    "    W_hiddenToOutput -= W_hiddenToOutput_update * lr\n",
    "    W_hiddenTohidden -= W_hiddenTohidden_update * lr\n",
    "\n",
    "    W_inputtohidden_update *= 0\n",
    "    W_hiddenToOutput_update *= 0\n",
    "    W_hiddenTohidden_update *= 0\n",
    "\n",
    "\n",
    "    correct = 0\n",
    "    wrong = 0\n",
    "    for i in range(binary_dim):\n",
    "        if d[i]==c[i]:\n",
    "            correct += 1\n",
    "        else:\n",
    "            wrong += 1\n",
    "    accuracy = correct / binary_dim *100\n",
    "    overallError = wrong / binary_dim * 100\n",
    "    if j%100 == 0:\n",
    "        Acc.append(accuracy)\n",
    "        allError.append(overallError)\n",
    "\n",
    "\n",
    "\n",
    "    # print out result\n",
    "    if(j %1000 == 0):\n",
    "        print(\"epoch\",j)\n",
    "        print(\"Pred:\" , d)\n",
    "        print(\"True:\" ,c)\n",
    "        out = 0\n",
    "        for index,x in enumerate(reversed(d)):\n",
    "            out += x*pow(2,index)\n",
    "        print(a_int, \" + \",b_int,\" = \",out)\n",
    "        print(\"Error:\",overallError)\n",
    "        print(\"accuracy =\", accuracy,\"%\")\n",
    "        print(\"------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting\n",
    "\n",
    "Let's plot our result : Loss and Accuracy during training process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7,5))\n",
    "epoch = np.arange(0,20000,100)\n",
    "plt.plot(epoch,Acc,linestyle=\"solid\")\n",
    "plt.xlabel(\"Epoch\",fontsize=16)\n",
    "plt.ylabel(\"Accuracy (%)\",fontsize=16)\n",
    "plt.title(\"\\nRecurrent Neural Network\",fontsize=18)\n",
    "plt.savefig('/Users/vincent/Desktop/RNN_Acc.png')\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure(figsize=(7,5))\n",
    "epoch = np.arange(0,20000,100)\n",
    "plt.plot(epoch,allError,linestyle=\"solid\")\n",
    "plt.xlabel(\"Epoch\",fontsize=16)\n",
    "plt.ylabel(\"loss (%)\",fontsize=16)\n",
    "plt.title(\"\\nRecurrent Neural Network\",fontsize=18)\n",
    "plt.savefig('/Users/vincent/Desktop/RNN_Loss.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75  +  71  =  146\n",
      "85  +  45  =  130\n",
      "105  +  38  =  143\n",
      "0  +  50  =  50\n",
      "64  +  59  =  123\n",
      "25  +  12  =  37\n",
      "54  +  80  =  134\n",
      "72  +  46  =  118\n",
      "125  +  17  =  142\n",
      "28  +  95  =  123\n"
     ]
    }
   ],
   "source": [
    "# testing for 10 calculation !!!\n",
    "for i in range(10):\n",
    "    \n",
    "    a_int = np.random.randint(largest_number/2) \n",
    "    a = int2binary[a_int] \n",
    "    b_int = np.random.randint(largest_number/2) \n",
    "    b = int2binary[b_int] \n",
    "\n",
    "    # true answer\n",
    "    c_int = a_int + b_int \n",
    "    c = int2binary[c_int] \n",
    "    d = np.zeros_like(c)\n",
    "    \n",
    "    hidden_values = list()\n",
    "    hidden_values.append(np.zeros(hidden_dim))\n",
    "    for position in range(binary_dim):\n",
    "        # generate input and output , move from right to left\n",
    "        X = np.array([[a[binary_dim - position - 1],b[binary_dim - position - 1]]]) \n",
    "        y = np.array([[c[binary_dim - position - 1]]]).T \n",
    "        \n",
    "        # forward propagation\n",
    "        hidden=sigmoid(np.dot(X,W_inputtohidden) + np.dot(hidden_values[-1],W_hiddenTohidden))\n",
    "        # output layer (new binary representation)\n",
    "        outputlayer = sigmoid(np.dot(hidden,W_hiddenToOutput))\n",
    "        d[binary_dim - position - 1] = np.round(outputlayer[0][0])\n",
    "        # store hidden layer foro BPTT\n",
    "        hidden_values.append(hidden)\n",
    "        \n",
    "        \n",
    "    out = 0\n",
    "    for index,x in enumerate(reversed(d)):\n",
    "        out += x*pow(2,index)\n",
    "    \n",
    "    # msg = '{:<5}{:^3}{:<5}{:^3}{:<5}'.format( a_int,\"+\", b_int,\"=\", out)\n",
    "    # print(msg)\n",
    "    # print(\"%-.5s + %-.5s = %-.5s\" % (a_int, b_int, out))\n",
    "    print(a_int, \" + \",b_int,\" = \",out)\n"
   ]
  },
  {
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}