RecurrentNeuralNet(LSTM).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Implementing LSTM Neural Network from Scratch\n",
    "**Dataset = Us Baby's First Names <br>\n",
    "Link = https://www.kaggle.com/chr7stos/us-names-babies-and-presindent-names/data**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Required Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np               #for maths\n",
    "import pandas as pd              #for data manipulation\n",
    "import matplotlib.pyplot as plt  #for visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data \n",
    "path = r'E:\\Study n Work\\Neural Networks\\Recurrent Neural Network\\Data\\Names\\NationalNames.csv'\n",
    "data = pd.read_csv(path)\n",
    "\n",
    "#get names from the dataset\n",
    "data['Name'] = data['Name']\n",
    "\n",
    "#get first 10000 names\n",
    "data = np.array(data['Name'][:10000]).reshape(-1,1)\n",
    "\n",
    "#covert the names to lowee case\n",
    "data = [x.lower() for x in data[:,0]]\n",
    "\n",
    "data = np.array(data).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data Shape = (10000, 1)\n",
      "\n",
      "Lets see some names : \n",
      "[['anna']\n",
      " ['emma']\n",
      " ['elizabeth']\n",
      " ['minnie']\n",
      " ['margaret']\n",
      " ['ida']\n",
      " ['alice']\n",
      " ['bertha']\n",
      " ['sarah']]\n"
     ]
    }
   ],
   "source": [
    "print(\"Data Shape = {}\".format(data.shape))\n",
    "print()\n",
    "print(\"Lets see some names : \")\n",
    "print(data[1:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transform the names to equal length by adding -- > ('.')  dots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#to store the transform data\n",
    "transform_data = np.copy(data)\n",
    "\n",
    "#find the max length name\n",
    "max_length = 0\n",
    "for index in range(len(data)):\n",
    "    max_length = max(max_length,len(data[index,0]))\n",
    "\n",
    "#make every name of max length by adding '.'\n",
    "for index in range(len(data)):\n",
    "    length = (max_length - len(data[index,0]))\n",
    "    string = '.'*length\n",
    "    transform_data[index,0] = ''.join([transform_data[index,0],string])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformed Data\n",
      "[['anna........']\n",
      " ['emma........']\n",
      " ['elizabeth...']\n",
      " ['minnie......']\n",
      " ['margaret....']\n",
      " ['ida.........']\n",
      " ['alice.......']\n",
      " ['bertha......']\n",
      " ['sarah.......']]\n"
     ]
    }
   ],
   "source": [
    "print(\"Transformed Data\")\n",
    "print(transform_data[1:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lets Make Vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocab size = 27\n",
      "Vocab      = {'y', 'c', 'd', 'x', 'e', 'o', 'g', 'f', 'w', 'i', 'z', 'u', 'l', 'q', '.', 's', 'm', 'j', 'a', 'k', 'b', 'v', 'n', 'p', 't', 'r', 'h'}\n"
     ]
    }
   ],
   "source": [
    "#to store the vocabulary\n",
    "vocab = list()\n",
    "for name in transform_data[:,0]:\n",
    "    vocab.extend(list(name))\n",
    "\n",
    "vocab = set(vocab)\n",
    "vocab_size = len(vocab)\n",
    "\n",
    "print(\"Vocab size = {}\".format(len(vocab)))\n",
    "print(\"Vocab      = {}\".format(vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map characters to ids and ids to characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a-18, 22-n\n"
     ]
    }
   ],
   "source": [
    "#map char to id and id to chars\n",
    "char_id = dict()\n",
    "id_char = dict()\n",
    "\n",
    "for i,char in enumerate(vocab):\n",
    "    char_id[char] = i\n",
    "    id_char[i] = char\n",
    "\n",
    "print('a-{}, 22-{}'.format(char_id['a'],id_char[22]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make the Train dataset\n",
    "\n",
    "Example - names - [['mary.'], ['anna.'] <br>\n",
    "m - [0,0,0,1,0,0] <br>\n",
    "a - [0,0,1,0,0,0] <br>\n",
    "r - [0,1,0,0,0,0] <br>\n",
    "y - [0,0,0,0,1,0] <br>\n",
    "**.** - [1,0,0,0,0,0] <br>\n",
    "\n",
    "'mary.' = [[0,0,0,1,0,0], [0,0,1,0,0,0], [0,1,0,0,0,0], [0,0,0,0,1,0], [1,0,0,0,0,0]] <br>\n",
    "'anna.' = [[0,0,1,0,0,0], [0,0,0,0,0,1], [0,0,0,0,0,1], [0,0,1,0,0,0], [1,0,0,0,0,0]] <br>\n",
    "\n",
    "batch_dataset = [ [[0,0,0,1,0,0],[0,0,1,0,0,0]] , [[0,0,1,0,0,0], [0,0,0,0,0,1]], [[0,1,0,0,0,0], [0,0,0,0,0,1]], [[0,0,0,0,1,0], [0,0,1,0,0,0]] , [ [1,0,0,0,0,0], [1,0,0,0,0,0]] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list of batches of size = 20\n",
    "train_dataset = []\n",
    "\n",
    "batch_size = 20\n",
    "\n",
    "#split the trasnform data into batches of 20\n",
    "for i in range(len(transform_data)-batch_size+1):\n",
    "    start = i*batch_size\n",
    "    end = start+batch_size\n",
    "    \n",
    "    #batch data\n",
    "    batch_data = transform_data[start:end]\n",
    "    \n",
    "    if(len(batch_data)!=batch_size):\n",
    "        break\n",
    "        \n",
    "    #convert each char of each name of batch data into one hot encoding\n",
    "    char_list = []\n",
    "    for k in range(len(batch_data[0][0])):\n",
    "        batch_dataset = np.zeros([batch_size,len(vocab)])\n",
    "        for j in range(batch_size):\n",
    "            name = batch_data[j][0]\n",
    "            char_index = char_id[name[k]]\n",
    "            batch_dataset[j,char_index] = 1.0\n",
    "     \n",
    "        #store the ith char's one hot representation of each name in batch_data\n",
    "        char_list.append(batch_dataset)\n",
    "    \n",
    "    #store each char's of every name in batch dataset into train_dataset\n",
    "    train_dataset.append(char_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#number of input units or embedding size\n",
    "input_units = 100\n",
    "\n",
    "#number of hidden neurons\n",
    "hidden_units = 256\n",
    "\n",
    "#number of output units i.e vocab size\n",
    "output_units = vocab_size\n",
    "\n",
    "#learning rate\n",
    "learning_rate = 0.005\n",
    "\n",
    "#beta1 for V parameters used in Adam Optimizer\n",
    "beta1 = 0.90\n",
    "\n",
    "#beta2 for S parameters used in Adam Optimizer\n",
    "beta2 = 0.99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Activation Functions\n",
    "* **Sigmoid =  1/(1+exp(-X))** <br>\n",
    "* **Tanh    =  (exp(X) - exp(-X)) / (exp(X) + exp(X)) **\n",
    "* **Softmax =  exp(X)/(sum(exp(X),1))**\n",
    "<br>\n",
    "![](https://i.stack.imgur.com/o0JA0.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Activation Functions\n",
    "#sigmoid\n",
    "def sigmoid(X):\n",
    "    return 1/(1+np.exp(-X))\n",
    "\n",
    "#tanh activation\n",
    "def tanh_activation(X):\n",
    "    return np.tanh(X)\n",
    "\n",
    "#softmax activation\n",
    "def softmax(X):\n",
    "    exp_X = np.exp(X)\n",
    "    exp_X_sum = np.sum(exp_X,axis=1).reshape(-1,1)\n",
    "    exp_X = exp_X/exp_X_sum\n",
    "    return exp_X\n",
    "\n",
    "#derivative of tanh\n",
    "def tanh_derivative(X):\n",
    "    return 1-(X**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize Parameters\n",
    "Embeddings Size = 100  <br>\n",
    "Hidden Units = 256  <br>\n",
    "Total INPUT Weights = 100 + 256 = 356 <br>\n",
    "\n",
    "* **LSTM CELL Weights ** <br>\n",
    "    * Forget Gate Weights = {356,256}  <br>\n",
    "    * Input Gate Weights  = {356,256}  <br>\n",
    "    * Gate Gate Weights   = {356,256}  <br>\n",
    "    * Output Gate Weights = {356,256}  <br>\n",
    "<br>\n",
    "\n",
    "* **Output CELL Weights ** <br>\n",
    "    * Output Weights = {256,27} <br>\n",
    "\n",
    "Store these weights in parameters dictionary!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#initialize parameters\n",
    "def initialize_parameters():\n",
    "    #initialize the parameters with 0 mean and 0.01 standard deviation\n",
    "    mean = 0\n",
    "    std = 0.01\n",
    "    \n",
    "    #lstm cell weights\n",
    "    forget_gate_weights = np.random.normal(mean,std,(input_units+hidden_units,hidden_units))\n",
    "    input_gate_weights  = np.random.normal(mean,std,(input_units+hidden_units,hidden_units))\n",
    "    output_gate_weights = np.random.normal(mean,std,(input_units+hidden_units,hidden_units))\n",
    "    gate_gate_weights   = np.random.normal(mean,std,(input_units+hidden_units,hidden_units))\n",
    "    \n",
    "    #hidden to output weights (output cell)\n",
    "    hidden_output_weights = np.random.normal(mean,std,(hidden_units,output_units))\n",
    "    \n",
    "    parameters = dict()\n",
    "    parameters['fgw'] = forget_gate_weights\n",
    "    parameters['igw'] = input_gate_weights\n",
    "    parameters['ogw'] = output_gate_weights\n",
    "    parameters['ggw'] = gate_gate_weights\n",
    "    parameters['how'] = hidden_output_weights\n",
    "    \n",
    "    return parameters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM CELL\n",
    "\n",
    "![](https://github.com/Ahmadkhan02/Neural-Network-from-scratch/blob/main/images/LSTM.JPG?raw=true) <br>\n",
    "\n",
    "**Equations**\n",
    "* fa = sigmoid(Wf x [xt,at-1]) <br>\n",
    "* ia = sigmoid(Wi x [xt,at-1]) <br>\n",
    "* ga = tanh(Wg x [xt,at-1]) \n",
    "* oa = sigmoid(Wo x [xt,at-1]) \n",
    "* ct = (fa x ct-1) + (ia x ga) \n",
    "* at = oa x tanh(ct) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#single lstm cell\n",
    "def lstm_cell(batch_dataset, prev_activation_matrix, prev_cell_matrix, parameters):\n",
    "    #get parameters\n",
    "    fgw = parameters['fgw']\n",
    "    igw = parameters['igw']\n",
    "    ogw = parameters['ogw']\n",
    "    ggw = parameters['ggw']\n",
    "    \n",
    "    #concat batch data and prev_activation matrix\n",
    "    concat_dataset = np.concatenate((batch_dataset,prev_activation_matrix),axis=1)\n",
    "    \n",
    "    #forget gate activations\n",
    "    fa = np.matmul(concat_dataset,fgw)\n",
    "    fa = sigmoid(fa)\n",
    "    \n",
    "    #input gate activations\n",
    "    ia = np.matmul(concat_dataset,igw)\n",
    "    ia = sigmoid(ia)\n",
    "    \n",
    "    #output gate activations\n",
    "    oa = np.matmul(concat_dataset,ogw)\n",
    "    oa = sigmoid(oa)\n",
    "    \n",
    "    #gate gate activations\n",
    "    ga = np.matmul(concat_dataset,ggw)\n",
    "    ga = tanh_activation(ga)\n",
    "    \n",
    "    #new cell memory matrix\n",
    "    cell_memory_matrix = np.multiply(fa,prev_cell_matrix) + np.multiply(ia,ga)\n",
    "    \n",
    "    #current activation matrix\n",
    "    activation_matrix = np.multiply(oa, tanh_activation(cell_memory_matrix))\n",
    "    \n",
    "    #lets store the activations to be used in back prop\n",
    "    lstm_activations = dict()\n",
    "    lstm_activations['fa'] = fa\n",
    "    lstm_activations['ia'] = ia\n",
    "    lstm_activations['oa'] = oa\n",
    "    lstm_activations['ga'] = ga\n",
    "    \n",
    "    return lstm_activations,cell_memory_matrix,activation_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output Cell\n",
    "\n",
    "Equations \n",
    "* ot = W x at\n",
    "* ot = softmax(ot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def output_cell(activation_matrix,parameters):\n",
    "    #get hidden to output parameters\n",
    "    how = parameters['how']\n",
    "    \n",
    "    #get outputs \n",
    "    output_matrix = np.matmul(activation_matrix,how)\n",
    "    output_matrix = softmax(output_matrix)\n",
    "    \n",
    "    return output_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get corresponding embeddings for the batch dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_embeddings(batch_dataset,embeddings):\n",
    "    embedding_dataset = np.matmul(batch_dataset,embeddings)\n",
    "    return embedding_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward Propagation\n",
    "![](https://github.com/Ahmadkhan02/Neural-Network-from-scratch/blob/main/images/LSTMForward.JPG?raw=true)\n",
    "\n",
    "Function returns the intermediate ativations in the respective caches:\n",
    "* LSTM Cache :- All lstm cell activation in every cell (fa,ia,ga,oa)\n",
    "* Activation Cache : All activation (a0,a1,a2..)\n",
    "* Cell Cache : All cell activations (c0,c1,c2..\n",
    "* Embedding cache : Embeddings of each batch (e0,e1,e2..)\n",
    "* Output Cache : All output (o1,o2,o3... )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#forward propagation\n",
    "def forward_propagation(batches,parameters,embeddings):\n",
    "    #get batch size\n",
    "    batch_size = batches[0].shape[0]\n",
    "    \n",
    "    #to store the activations of all the unrollings.\n",
    "    lstm_cache = dict()                 #lstm cache\n",
    "    activation_cache = dict()           #activation cache \n",
    "    cell_cache = dict()                 #cell cache\n",
    "    output_cache = dict()               #output cache\n",
    "    embedding_cache = dict()            #embedding cache \n",
    "    \n",
    "    #initial activation_matrix(a0) and cell_matrix(c0)\n",
    "    a0 = np.zeros([batch_size,hidden_units],dtype=np.float32)\n",
    "    c0 = np.zeros([batch_size,hidden_units],dtype=np.float32)\n",
    "    \n",
    "    #store the initial activations in cache\n",
    "    activation_cache['a0'] = a0\n",
    "    cell_cache['c0'] = c0\n",
    "    \n",
    "    #unroll the names\n",
    "    for i in range(len(batches)-1):\n",
    "        #get first first character batch\n",
    "        batch_dataset = batches[i]\n",
    "        \n",
    "        #get embeddings \n",
    "        batch_dataset = get_embeddings(batch_dataset,embeddings)\n",
    "        embedding_cache['emb'+str(i)] = batch_dataset\n",
    "        \n",
    "        #lstm cell\n",
    "        lstm_activations,ct,at = lstm_cell(batch_dataset,a0,c0,parameters)\n",
    "        \n",
    "        #output cell\n",
    "        ot = output_cell(at,parameters)\n",
    "        \n",
    "        #store the time 't' activations in caches\n",
    "        lstm_cache['lstm' + str(i+1)]  = lstm_activations\n",
    "        activation_cache['a'+str(i+1)] = at\n",
    "        cell_cache['c' + str(i+1)] = ct\n",
    "        output_cache['o'+str(i+1)] = ot\n",
    "        \n",
    "        #update a0 and c0 to new 'at' and 'ct' for next lstm cell\n",
    "        a0 = at\n",
    "        c0 = ct\n",
    "        \n",
    "    return embedding_cache,lstm_cache,activation_cache,cell_cache,output_cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the Loss, Perplexity, and Accuracy\n",
    "**Loss**\n",
    "* Loss at time t = -sum(Y x log(d) + (1-Y) x log(1-pred)))/m\n",
    "* Overall Loss = **∑**(Loss(t)) sum of all losses at each time step 't'\n",
    "\n",
    "**Perplexity **\n",
    "* Probability Product = **∏**(prob(pred_char)) for each char in name\n",
    "* Perplexity = (1/probability_product) ^ (1/n) where n in number of chars in name\n",
    "\n",
    "**Accuracy**\n",
    "* Accuracy(t) = (Y==predictions,axis=1) for all time steps\n",
    "* Accuracy = ((**∑**Acc(t))/batch_size)/n for all time steps, n is number of chars in name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#calculate loss, perplexity and accuracy\n",
    "def cal_loss_accuracy(batch_labels,output_cache):\n",
    "    loss = 0  #to sum loss for each time step\n",
    "    acc  = 0  #to sum acc for each time step \n",
    "    prob = 1  #probability product of each time step predicted char\n",
    "    \n",
    "    #batch size\n",
    "    batch_size = batch_labels[0].shape[0]\n",
    "    \n",
    "    #loop through each time step\n",
    "    for i in range(1,len(output_cache)+1):\n",
    "        #get true labels and predictions\n",
    "        labels = batch_labels[i]\n",
    "        pred = output_cache['o'+str(i)]\n",
    "        \n",
    "        prob = np.multiply(prob,np.sum(np.multiply(labels,pred),axis=1).reshape(-1,1))\n",
    "        loss += np.sum((np.multiply(labels,np.log(pred)) + np.multiply(1-labels,np.log(1-pred))),axis=1).reshape(-1,1)\n",
    "        acc  += np.array(np.argmax(labels,1)==np.argmax(pred,1),dtype=np.float32).reshape(-1,1)\n",
    "    \n",
    "    #calculate perplexity loss and accuracy\n",
    "    perplexity = np.sum((1/prob)**(1/len(output_cache)))/batch_size\n",
    "    loss = np.sum(loss)*(-1/batch_size)\n",
    "    acc  = np.sum(acc)/(batch_size)\n",
    "    acc = acc/len(output_cache)\n",
    "    \n",
    "    return perplexity,loss,acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Output Cell Errors for each time step\n",
    "* Output Error Cache :- to store output error for each time step\n",
    "* Activation Error Cache : to store activation error for each time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#calculate output cell errors\n",
    "def calculate_output_cell_error(batch_labels,output_cache,parameters):\n",
    "    #to store the output errors for each time step\n",
    "    output_error_cache = dict()\n",
    "    activation_error_cache = dict()\n",
    "    how = parameters['how']\n",
    "    \n",
    "    #loop through each time step\n",
    "    for i in range(1,len(output_cache)+1):\n",
    "        #get true and predicted labels\n",
    "        labels = batch_labels[i]\n",
    "        pred = output_cache['o'+str(i)]\n",
    "        \n",
    "        #calculate the output_error for time step 't'\n",
    "        error_output = pred - labels\n",
    "        \n",
    "        #calculate the activation error for time step 't'\n",
    "        error_activation = np.matmul(error_output,how.T)\n",
    "        \n",
    "        #store the output and activation error in dict\n",
    "        output_error_cache['eo'+str(i)] = error_output\n",
    "        activation_error_cache['ea'+str(i)] = error_activation\n",
    "        \n",
    "    return output_error_cache,activation_error_cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Single LSTM CELL Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#calculate error for single lstm cell\n",
    "def calculate_single_lstm_cell_error(activation_output_error,next_activation_error,next_cell_error,parameters,lstm_activation,cell_activation,prev_cell_activation):\n",
    "    #activation error =  error coming from output cell and error coming from the next lstm cell\n",
    "    activation_error = activation_output_error + next_activation_error\n",
    "    \n",
    "    #output gate error\n",
    "    oa = lstm_activation['oa']\n",
    "    eo = np.multiply(activation_error,tanh_activation(cell_activation))\n",
    "    eo = np.multiply(np.multiply(eo,oa),1-oa)\n",
    "    \n",
    "    #cell activation error\n",
    "    cell_error = np.multiply(activation_error,oa)\n",
    "    cell_error = np.multiply(cell_error,tanh_derivative(tanh_activation(cell_activation)))\n",
    "    #error also coming from next lstm cell \n",
    "    cell_error += next_cell_error\n",
    "    \n",
    "    #input gate error\n",
    "    ia = lstm_activation['ia']\n",
    "    ga = lstm_activation['ga']\n",
    "    ei = np.multiply(cell_error,ga)\n",
    "    ei = np.multiply(np.multiply(ei,ia),1-ia)\n",
    "    \n",
    "    #gate gate error\n",
    "    eg = np.multiply(cell_error,ia)\n",
    "    eg = np.multiply(eg,tanh_derivative(ga))\n",
    "    \n",
    "    #forget gate error\n",
    "    fa = lstm_activation['fa']\n",
    "    ef = np.multiply(cell_error,prev_cell_activation)\n",
    "    ef = np.multiply(np.multiply(ef,fa),1-fa)\n",
    "    \n",
    "    #prev cell error\n",
    "    prev_cell_error = np.multiply(cell_error,fa)\n",
    "    \n",
    "    #get parameters\n",
    "    fgw = parameters['fgw']\n",
    "    igw = parameters['igw']\n",
    "    ggw = parameters['ggw']\n",
    "    ogw = parameters['ogw']\n",
    "    \n",
    "    #embedding + hidden activation error\n",
    "    embed_activation_error = np.matmul(ef,fgw.T)\n",
    "    embed_activation_error += np.matmul(ei,igw.T)\n",
    "    embed_activation_error += np.matmul(eo,ogw.T)\n",
    "    embed_activation_error += np.matmul(eg,ggw.T)\n",
    "    \n",
    "    input_hidden_units = fgw.shape[0]\n",
    "    hidden_units = fgw.shape[1]\n",
    "    input_units = input_hidden_units - hidden_units\n",
    "    \n",
    "    #prev activation error\n",
    "    prev_activation_error = embed_activation_error[:,input_units:]\n",
    "    \n",
    "    #input error (embedding error)\n",
    "    embed_error = embed_activation_error[:,:input_units]\n",
    "    \n",
    "    #store lstm error\n",
    "    lstm_error = dict()\n",
    "    lstm_error['ef'] = ef\n",
    "    lstm_error['ei'] = ei\n",
    "    lstm_error['eo'] = eo\n",
    "    lstm_error['eg'] = eg\n",
    "    \n",
    "    return prev_activation_error,prev_cell_error,embed_error,lstm_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Output Cell Derivatives for each time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#calculate output cell derivatives\n",
    "def calculate_output_cell_derivatives(output_error_cache,activation_cache,parameters):\n",
    "    #to store the sum of derivatives from each time step\n",
    "    dhow = np.zeros(parameters['how'].shape)\n",
    "    \n",
    "    batch_size = activation_cache['a1'].shape[0]\n",
    "    \n",
    "    #loop through the time steps \n",
    "    for i in range(1,len(output_error_cache)+1):\n",
    "        #get output error\n",
    "        output_error = output_error_cache['eo' + str(i)]\n",
    "        \n",
    "        #get input activation\n",
    "        activation = activation_cache['a'+str(i)]\n",
    "        \n",
    "        #cal derivative and summing up!\n",
    "        dhow += np.matmul(activation.T,output_error)/batch_size\n",
    "        \n",
    "    return dhow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate LSTM CELL Derivatives for each time step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#calculate derivatives for single lstm cell\n",
    "def calculate_single_lstm_cell_derivatives(lstm_error,embedding_matrix,activation_matrix):\n",
    "    #get error for single time step\n",
    "    ef = lstm_error['ef']\n",
    "    ei = lstm_error['ei']\n",
    "    eo = lstm_error['eo']\n",
    "    eg = lstm_error['eg']\n",
    "    \n",
    "    #get input activations for this time step\n",
    "    concat_matrix = np.concatenate((embedding_matrix,activation_matrix),axis=1)\n",
    "    \n",
    "    batch_size = embedding_matrix.shape[0]\n",
    "    \n",
    "    #cal derivatives for this time step\n",
    "    dfgw = np.matmul(concat_matrix.T,ef)/batch_size\n",
    "    digw = np.matmul(concat_matrix.T,ei)/batch_size\n",
    "    dogw = np.matmul(concat_matrix.T,eo)/batch_size\n",
    "    dggw = np.matmul(concat_matrix.T,eg)/batch_size\n",
    "    \n",
    "    #store the derivatives for this time step in dict\n",
    "    derivatives = dict()\n",
    "    derivatives['dfgw'] = dfgw\n",
    "    derivatives['digw'] = digw\n",
    "    derivatives['dogw'] = dogw\n",
    "    derivatives['dggw'] = dggw\n",
    "    \n",
    "    return derivatives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backward Propagation\n",
    "\n",
    "* Apply chain rule and calculate the errors for each time step\n",
    "* Store the deivatives in **derivatives** dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#backpropagation\n",
    "def backward_propagation(batch_labels,embedding_cache,lstm_cache,activation_cache,cell_cache,output_cache,parameters):\n",
    "    #calculate output errors \n",
    "    output_error_cache,activation_error_cache = calculate_output_cell_error(batch_labels,output_cache,parameters)\n",
    "    \n",
    "    #to store lstm error for each time step\n",
    "    lstm_error_cache = dict()\n",
    "    \n",
    "    #to store embeding errors for each time step\n",
    "    embedding_error_cache = dict()\n",
    "    \n",
    "    # next activation error \n",
    "    # next cell error  \n",
    "    #for last cell will be zero\n",
    "    eat = np.zeros(activation_error_cache['ea1'].shape)\n",
    "    ect = np.zeros(activation_error_cache['ea1'].shape)\n",
    "    \n",
    "    #calculate all lstm cell errors (going from last time-step to the first time step)\n",
    "    for i in range(len(lstm_cache),0,-1):\n",
    "        #calculate the lstm errors for this time step 't'\n",
    "        pae,pce,ee,le = calculate_single_lstm_cell_error(activation_error_cache['ea'+str(i)],eat,ect,parameters,lstm_cache['lstm'+str(i)],cell_cache['c'+str(i)],cell_cache['c'+str(i-1)])\n",
    "        \n",
    "        #store the lstm error in dict\n",
    "        lstm_error_cache['elstm'+str(i)] = le\n",
    "        \n",
    "        #store the embedding error in dict\n",
    "        embedding_error_cache['eemb'+str(i-1)] = ee\n",
    "        \n",
    "        #update the next activation error and next cell error for previous cell\n",
    "        eat = pae\n",
    "        ect = pce\n",
    "    \n",
    "    \n",
    "    #calculate output cell derivatives\n",
    "    derivatives = dict()\n",
    "    derivatives['dhow'] = calculate_output_cell_derivatives(output_error_cache,activation_cache,parameters)\n",
    "    \n",
    "    #calculate lstm cell derivatives for each time step and store in lstm_derivatives dict\n",
    "    lstm_derivatives = dict()\n",
    "    for i in range(1,len(lstm_error_cache)+1):\n",
    "        lstm_derivatives['dlstm'+str(i)] = calculate_single_lstm_cell_derivatives(lstm_error_cache['elstm'+str(i)],embedding_cache['emb'+str(i-1)],activation_cache['a'+str(i-1)])\n",
    "    \n",
    "    #initialize the derivatives to zeros \n",
    "    derivatives['dfgw'] = np.zeros(parameters['fgw'].shape)\n",
    "    derivatives['digw'] = np.zeros(parameters['igw'].shape)\n",
    "    derivatives['dogw'] = np.zeros(parameters['ogw'].shape)\n",
    "    derivatives['dggw'] = np.zeros(parameters['ggw'].shape)\n",
    "    \n",
    "    #sum up the derivatives for each time step\n",
    "    for i in range(1,len(lstm_error_cache)+1):\n",
    "        derivatives['dfgw'] += lstm_derivatives['dlstm'+str(i)]['dfgw']\n",
    "        derivatives['digw'] += lstm_derivatives['dlstm'+str(i)]['digw']\n",
    "        derivatives['dogw'] += lstm_derivatives['dlstm'+str(i)]['dogw']\n",
    "        derivatives['dggw'] += lstm_derivatives['dlstm'+str(i)]['dggw']\n",
    "    \n",
    "    return derivatives,embedding_error_cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adam Optimizer\n",
    "Using Exponentially Weighted Averages <br>\n",
    "* Vdw = beta1 x Vdw + (1-beta1) x (dw)   \n",
    "* Sdw = beta2 x Sdw + (1-beta2) x dw^2\n",
    "* W = W - learning_rate x ( Vdw/ (sqrt(Sdw)+1e-7) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#update the parameters using adam optimizer\n",
    "#adam optimization\n",
    "def update_parameters(parameters,derivatives,V,S,t):\n",
    "    #get derivatives\n",
    "    dfgw = derivatives['dfgw']\n",
    "    digw = derivatives['digw']\n",
    "    dogw = derivatives['dogw']\n",
    "    dggw = derivatives['dggw']\n",
    "    dhow = derivatives['dhow']\n",
    "    \n",
    "    #get parameters\n",
    "    fgw = parameters['fgw']\n",
    "    igw = parameters['igw']\n",
    "    ogw = parameters['ogw']\n",
    "    ggw = parameters['ggw']\n",
    "    how = parameters['how']\n",
    "    \n",
    "    #get V parameters\n",
    "    vfgw = V['vfgw']\n",
    "    vigw = V['vigw']\n",
    "    vogw = V['vogw']\n",
    "    vggw = V['vggw']\n",
    "    vhow = V['vhow']\n",
    "    \n",
    "    #get S parameters\n",
    "    sfgw = S['sfgw']\n",
    "    sigw = S['sigw']\n",
    "    sogw = S['sogw']\n",
    "    sggw = S['sggw']\n",
    "    show = S['show']\n",
    "    \n",
    "    #calculate the V parameters from V and current derivatives\n",
    "    vfgw = (beta1*vfgw + (1-beta1)*dfgw)\n",
    "    vigw = (beta1*vigw + (1-beta1)*digw)\n",
    "    vogw = (beta1*vogw + (1-beta1)*dogw)\n",
    "    vggw = (beta1*vggw + (1-beta1)*dggw)\n",
    "    vhow = (beta1*vhow + (1-beta1)*dhow)\n",
    "    \n",
    "    #calculate the S parameters from S and current derivatives\n",
    "    sfgw = (beta2*sfgw + (1-beta2)*(dfgw**2))\n",
    "    sigw = (beta2*sigw + (1-beta2)*(digw**2))\n",
    "    sogw = (beta2*sogw + (1-beta2)*(dogw**2))\n",
    "    sggw = (beta2*sggw + (1-beta2)*(dggw**2))\n",
    "    show = (beta2*show + (1-beta2)*(dhow**2))\n",
    "    \n",
    "    #update the parameters\n",
    "    fgw = fgw - learning_rate*((vfgw)/(np.sqrt(sfgw) + 1e-6))\n",
    "    igw = igw - learning_rate*((vigw)/(np.sqrt(sigw) + 1e-6))\n",
    "    ogw = ogw - learning_rate*((vogw)/(np.sqrt(sogw) + 1e-6))\n",
    "    ggw = ggw - learning_rate*((vggw)/(np.sqrt(sggw) + 1e-6))\n",
    "    how = how - learning_rate*((vhow)/(np.sqrt(show) + 1e-6))\n",
    "    \n",
    "    #store the new weights\n",
    "    parameters['fgw'] = fgw\n",
    "    parameters['igw'] = igw\n",
    "    parameters['ogw'] = ogw\n",
    "    parameters['ggw'] = ggw\n",
    "    parameters['how'] = how\n",
    "    \n",
    "    #store the new V parameters\n",
    "    V['vfgw'] = vfgw \n",
    "    V['vigw'] = vigw \n",
    "    V['vogw'] = vogw \n",
    "    V['vggw'] = vggw\n",
    "    V['vhow'] = vhow\n",
    "    \n",
    "    #store the s parameters\n",
    "    S['sfgw'] = sfgw \n",
    "    S['sigw'] = sigw \n",
    "    S['sogw'] = sogw \n",
    "    S['sggw'] = sggw\n",
    "    S['show'] = show\n",
    "    \n",
    "    return parameters,V,S    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update the embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#update the Embeddings\n",
    "def update_embeddings(embeddings,embedding_error_cache,batch_labels):\n",
    "    #to store the embeddings derivatives\n",
    "    embedding_derivatives = np.zeros(embeddings.shape)\n",
    "    \n",
    "    batch_size = batch_labels[0].shape[0]\n",
    "    \n",
    "    #sum the embedding derivatives for each time step\n",
    "    for i in range(len(embedding_error_cache)):\n",
    "        embedding_derivatives += np.matmul(batch_labels[i].T,embedding_error_cache['eemb'+str(i)])/batch_size\n",
    "    \n",
    "    #update the embeddings\n",
    "    embeddings = embeddings - learning_rate*embedding_derivatives\n",
    "    return embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to Initialize the V and S parameters for Adam Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def initialize_V(parameters):\n",
    "    Vfgw = np.zeros(parameters['fgw'].shape)\n",
    "    Vigw = np.zeros(parameters['igw'].shape)\n",
    "    Vogw = np.zeros(parameters['ogw'].shape)\n",
    "    Vggw = np.zeros(parameters['ggw'].shape)\n",
    "    Vhow = np.zeros(parameters['how'].shape)\n",
    "    \n",
    "    V = dict()\n",
    "    V['vfgw'] = Vfgw\n",
    "    V['vigw'] = Vigw\n",
    "    V['vogw'] = Vogw\n",
    "    V['vggw'] = Vggw\n",
    "    V['vhow'] = Vhow\n",
    "    return V\n",
    "\n",
    "def initialize_S(parameters):\n",
    "    Sfgw = np.zeros(parameters['fgw'].shape)\n",
    "    Sigw = np.zeros(parameters['igw'].shape)\n",
    "    Sogw = np.zeros(parameters['ogw'].shape)\n",
    "    Sggw = np.zeros(parameters['ggw'].shape)\n",
    "    Show = np.zeros(parameters['how'].shape)\n",
    "    \n",
    "    S = dict()\n",
    "    S['sfgw'] = Sfgw\n",
    "    S['sigw'] = Sigw\n",
    "    S['sogw'] = Sogw\n",
    "    S['sggw'] = Sggw\n",
    "    S['show'] = Show\n",
    "    return S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Function\n",
    "\n",
    "1. Initialize Parameters\n",
    "2. Forward Propagation\n",
    "3. Calculate Loss, Perplexity and Accuracy\n",
    "4. Backward Propagation\n",
    "5. Update the Parameters and Embeddings\n",
    "\n",
    "Batch Size = 20\n",
    "Repeat the steps 2-5 for each batch!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#train function\n",
    "def train(train_dataset,iters=1000,batch_size=20):\n",
    "    #initalize the parameters\n",
    "    parameters = initialize_parameters()\n",
    "    \n",
    "    #initialize the V and S parameters for Adam\n",
    "    V = initialize_V(parameters)\n",
    "    S = initialize_S(parameters)\n",
    "    \n",
    "    #generate the random embeddings\n",
    "    embeddings = np.random.normal(0,0.01,(len(vocab),input_units))\n",
    "    \n",
    "    #to store the Loss, Perplexity and Accuracy for each batch\n",
    "    J = []\n",
    "    P = []\n",
    "    A = []\n",
    "    \n",
    "    \n",
    "    for step in range(iters):\n",
    "        #get batch dataset\n",
    "        index = step%len(train_dataset)\n",
    "        batches = train_dataset[index]\n",
    "        \n",
    "        #forward propagation\n",
    "        embedding_cache,lstm_cache,activation_cache,cell_cache,output_cache = forward_propagation(batches,parameters,embeddings)\n",
    "        \n",
    "        #calculate the loss, perplexity and accuracy\n",
    "        perplexity,loss,acc = cal_loss_accuracy(batches,output_cache)\n",
    "        \n",
    "        #backward propagation\n",
    "        derivatives,embedding_error_cache = backward_propagation(batches,embedding_cache,lstm_cache,activation_cache,cell_cache,output_cache,parameters)\n",
    "        \n",
    "        #update the parameters\n",
    "        parameters,V,S = update_parameters(parameters,derivatives,V,S,step)\n",
    "        \n",
    "        #update the embeddings\n",
    "        embeddings = update_embeddings(embeddings,embedding_error_cache,batches)\n",
    "        \n",
    "        \n",
    "        J.append(loss)\n",
    "        P.append(perplexity)\n",
    "        A.append(acc)\n",
    "        \n",
    "        #print loss, accuracy and perplexity\n",
    "        if(step%1000==0):\n",
    "            print(\"For Single Batch :\")\n",
    "            print('Step       = {}'.format(step))\n",
    "            print('Loss       = {}'.format(round(loss,2)))\n",
    "            print('Perplexity = {}'.format(round(perplexity,2)))\n",
    "            print('Accuracy   = {}'.format(round(acc*100,2)))\n",
    "            print()\n",
    "    \n",
    "    return embeddings, parameters,J,P,A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's Train\n",
    "* Will take around 5-10 mins on CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Single Batch :\n",
      "Step       = 0\n",
      "Loss       = 47.05\n",
      "Perplexity = 27.0\n",
      "Accuracy   = 2.27\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 1000\n",
      "Loss       = 11.94\n",
      "Perplexity = 2.08\n",
      "Accuracy   = 75.0\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 2000\n",
      "Loss       = 8.49\n",
      "Perplexity = 1.63\n",
      "Accuracy   = 83.18\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 3000\n",
      "Loss       = 8.0\n",
      "Perplexity = 1.59\n",
      "Accuracy   = 82.27\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 4000\n",
      "Loss       = 8.04\n",
      "Perplexity = 1.58\n",
      "Accuracy   = 83.64\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 5000\n",
      "Loss       = 8.08\n",
      "Perplexity = 1.58\n",
      "Accuracy   = 84.09\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 6000\n",
      "Loss       = 7.86\n",
      "Perplexity = 1.56\n",
      "Accuracy   = 84.09\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 7000\n",
      "Loss       = 7.85\n",
      "Perplexity = 1.56\n",
      "Accuracy   = 84.09\n",
      "\n",
      "For Single Batch :\n",
      "Step       = 8000\n",
      "Loss       = 7.83\n",
      "Perplexity = 1.56\n",
      "Accuracy   = 84.55\n",
      "\n"
     ]
    }
   ],
   "source": [
    "embeddings,parameters,J,P,A = train(train_dataset,iters=8001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's Plot some graphs\n",
    "\n",
    "*  Plotted average loss of 30 batches, average perplexity of 30 batches, and average accuracy of 30 batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xd4XOWV+PHvmdFIo94ly5YsdxuDwTY2pjcDARJayCYB\nQghk0zYJySabhGyy6WFhk5CGk10IBMKPEjqEEoptMKYY995tyeq9jtqU9/fHvXMtGUkeG43K6Hye\nZx7P3GnnamDOvO95ixhjUEopNX65RjoApZRSI0sTgVJKjXOaCJRSapzTRKCUUuOcJgKllBrnNBEo\npdQ4p4lAqTFERIyIzBjpOFRs0USgxjQRKRGRi0bovQtE5F4RqRSRdhE5ICIPiMickYhHqeOliUCp\n4yAi2cA7QBJwDpAKLATeBC4e4DlxwxagUsdAE4GKWSLyBRHZJyKNIvK8iEy0j4uI/FZEakWkVUS2\nishJ9n2Xi8gOEWkTkQoR+Y8BXv7fgVbgRmPMfmNpNsb81RjzR/u1pthdOZ8XkUPACvv4EyJSLSIt\nIrJKRE7sFfMDIvK/IvKaHcObIlJ8xHtfJCJ7RaRZRJaJiAzxn06NM5oIVEwSkQuB/wY+CRQApcBj\n9t2XAOcCs4B0+zEN9n33AV8yxqQCJ2F/effjIuAZY0wognDOA04APmLffhmYCeQBG4CHj3j8DcDP\ngRxgUz/3fwxYDJxsx/4RlPoQNBGoWHUDcL8xZoMxphv4PnCGiEwB/FhdOXMAMcbsNMZU2c/zA3NF\nJM0Y02SM2TDA6+cA1eEbInKl/Qu9TURePeKxPzHG+IwxnQDGmPuNMW12XD8BThGR9F6Pf9EYs8q+\n/wd23EW97r/Dbn0cAlYC84/xb6NUH5oIVKyaiNUKAMAY0471q3+SMWYFcDewDKgVkXtEJM1+6LXA\n5UCp3S1zxgCv34DV0gi//vPGmAysLqP4Ix5bFr4iIm4RuUNE9otIK1Bi35XT3+PtuBvt8wmr7nW9\nA0gZIEalIqKJQMWqSsDpWxeRZCAbqAAwxvzBGHMqMBeri+g79vG1xpirsLptngUeH+D1lwNXi0gk\n/w/1XuL3euAqrK6ldGBKOMRej3F+/YtICpBln49SUaGJQMUCj4h4e13igEeBm0VkvogkALcDa4wx\nJSKyWESWiIgH8AFdQEhE4kXkBhFJN8b4sYrBA9UA7gIygYdEZLpdgE7l6N00qUA3VosiyY7rSJeL\nyNkiEo9VK3jPGFPWz+OUGhKaCFQseAno7HX5iTHmdeC/gKeAKmA68Gn78WnAvUATVvdRA/Ar+74b\ngRK72+bLWLWGDzDG1AOnYyWR1UAbVmE3FfjKILH+zX7PCmAH8F4/j3kE+DFWl9CpwGcGO3mlPizR\njWmUGj1E5AGg3Bjzw5GORY0f2iJQSqlxThOBUkqNc9o1pJRS41zUWgT26I33RWSziGwXkZ/ax7Ps\n6fN77X8zoxWDUkqpo4tai8Be/yTZGNNuD9NbDXwD+DjQaIy5Q0RuAzKNMd8b7LVycnLMlClTohKn\nUkrFqvXr19cbY3KP9riorYZorAzTbt/02BeDNZnmfPv4g8AbwKCJYMqUKaxbty4qcSqlVKwSkdKj\nPyrKxWJ7Ov0moBZ4zRizBsjvta5LNZA/wHO/KCLrRGRdXV1dNMNUSqlxLaqJwBgTNMbMBwqB08JL\n/fa639B3+n3v++4xxiwyxizKzT1qy0YppdRxGpbho8aYZqxVEi8FakSkAKwdnrBaC0oppUZINEcN\n5YpIhn09EWvXpl3A88BN9sNuAp6LVgxKKaWOLppb5xUAD4qIGyvhPG6MeUFE3gUeF5HPY6258sko\nxqCUUuooojlqaAuwoJ/jDcDSaL2vUkqpY6NLTCil1DgX04lg+c4a/vzG/pEOQymlRrWYTgRv7K7j\nnlWaCJRSajAxnQji3EIgqIvqKaXUYGI7EbiEQEgTgVJKDSa2E4HbRSA00JazSimlIMYTgccl+IMG\n3XNBKaUGFtOJIM5tnV5Qu4eUUmpAMZ4IBEDrBEopNYiYTgQel3V6mgiUUmpgMZ0I3C67RRDUgrFS\nSg0kphOBx+4a8utcAqWUGlBMJ4JwsViHkCql1MBiOxE4XUPaIlBKqYHEdCLw2C0Cv9YIlFJqQDGd\nCMLFYp1HoJRSA4vpRKDFYqWUOrqYTgRxLi0WK6XU0cR2ItAWgVJKHVVMJ4JwsVgnlCml1MBiOhFo\nsVgppY4uphOBUyzWRKCUUgOK6UTgFIu1a0gppQYU24lAi8VKKXVUMZ0IPLrWkFJKHVVMJwItFiul\n1NHFdCIIb0yjXUNKKTWwmE4EzlaVWixWSqkBjYtEoMNHlVJqYDGdCDw6fFQppY4qphOB263FYqWU\nOpqYTgRaLFZKqaOL6USgxWKllDq62E4ELi0WK6XU0cR0IhAR4lyiLQKllBpETCcCsGYXB7RFoJRS\nA4r5ROBxuwhosVgppQYU84kgzi266JxSSg0iaolARIpEZKWI7BCR7SLyDfv4T0SkQkQ22ZfLoxUD\nWHsS6PBRpZQaWFwUXzsAfNsYs0FEUoH1IvKafd9vjTG/juJ7OzxuLRYrpdRgopYIjDFVQJV9vU1E\ndgKTovV+A9FisVJKDW5YagQiMgVYAKyxD31dRLaIyP0ikhnN9/a4XZoIlFJqEEdNBCKSJyLXiMhX\nReQWETlNRCJOICKSAjwFfNMY0wr8GZgGzMdqMfxmgOd9UUTWici6urq6SN/uA3QegVJKDW7AL3QR\nuUBEXgFeBC4DCoC5wA+BrSLyUxFJG+zFRcSDlQQeNsY8DWCMqTHGBI0xIeBe4LT+nmuMuccYs8gY\nsyg3N/d4zg2AOLcWi5VSajCD1QguB75gjDl05B0iEgd8DLgY64v+A0REgPuAncaYu3odL7DrBwDX\nANuOM/aIeHT4qFJKDWrARGCM+c4g9wWAZ4/y2mcBN2K1HjbZx/4TuE5E5gMGKAG+dCwBHyura0hb\nBEopNZCjjhqyx///FWgD/oJV9L3NGPPqYM8zxqwGpJ+7XjqOOI9bnMulLQKllBpEJEXfW+wi7yVA\nJtav/DuiGtUQinNri0AppQYTSSII/6q/HHjIGLOd/n/pj0pxbpcuQ62UUoOIJBGsF5FXsRLBK/Ys\n4THT1+LR4aNKKTWoSGYWfx5rzP8BY0yHiGQDN0c3rKGjXUNKKTW4SFoEBmv+wK327WTAG7WIhlic\ny4Vfi8VKKTWgSBLBn4AzgOvs223AsqhFNMTi3EJQawRKKTWgSLqGlhhjForIRgBjTJOIxEc5riET\n59KNaZRSajCRtAj8IuLG6iJCRHIZS8Vit+DXYrFSSg0okkTwB+AZIE9EfgmsBm6PalRDyNqhTFsE\nSik1kKN2DRljHhaR9cBSrPkDVxtjdkY9siFi7VCmLQKllBpIpBvT7AVaw48Xkcn9LUY3GsW5tFis\nlFKDiWStoa8DPwZqgCBWq8AAJ0c3tKER59ZisVJKDSaSFsE3gNnGmIZoBxMNHrfoPAKllBpEJMXi\nMqAl2oFES5zLhTFo95BSSg1gwBaBiHzLvnoAeENEXgS6w/f33mxmNItzW+vj+YMh3C73CEejlFKj\nz2BdQ6n2v4fsS7x9GVPiXFYi0BaBUkr1b7Adyn46nIFEi9djtQI6eoIkJ0Q6SEoppcaPo9YIROQ1\nEcnodTvT3tR+TMhOsRoxjb6eEY5EKaVGp0iKxbnGmObwDWNME5AXvZCGVnZyAgAN7d1HeaRSSo1P\nkSSCoIhMDt8QkWLsdYfGgtxUq0VQp4lAKaX6FUmn+Q+A1SLyJtZksnOAL0U1qiF0uEWgXUNKKdWf\nSNYa+qeILAROtw990xhTH92whk56oge3S2jwaYtAKaX6E0mxeLkxpt4Y84J9qReR5cMR3FBwuYTs\n5HhtESil1AAGm1DmBZKAHBHJxOoWAkgDJg1DbEMmOyWBeq0RKKVUvwbrGvoS8E1gIrCew4mgFbg7\nynENqZyUeOq1RaCUUv0abELZ74Hfi8jXjTF/HMaYhlxOSgIlDb6RDkMppUalSIrFfxSRk4C5gLfX\n8b9FM7ChlJ0cT32btgiUUqo/kexH8GPgfKxE8BJwGdZ2lWMnEaQk0OkP0tETIClel5lQSqneIplQ\n9gmsbSqrjTE3A6cA6VGNaojl2MtM6MghpZT6oEgSQacxJgQERCQNqAWKohvW0MpJsSaV1bbpyCGl\nlDpSJP0k6+xF5+7FGj3UDrwb1aiGWF6alQjq2rpGOBKllBp9IikW/5t99X9F5J9AmjFmS3TDGlr5\naVaNu6ZVWwRKKXWkiCqnIvJx4GysxeZWA2MqEWQlxRPnEmpatUWglFJHimSJiT8BXwa2AtuAL4nI\nsmgHNpRcLiEvNUFbBEop1Y9IWgQXAicYYwyAiDwIbI9qVFGQl+alVmsESin1AZGMGtoHTO51u8g+\nNqbkpyVo15BSSvVjsEXn/oFVE0gFdorI+/btJcD7wxPe0MlP8/LegcaRDkMppUadwbqGfj1sUQyD\n/DQvLZ1+uvxBZ0N7pZRSgy869+ZwBhJtean2pLLWbiZnJ41wNEopNXpEUiM4LiJSJCIrRWSHiGwX\nkW/Yx7NE5DUR2Wv/mxmtGHpz5hJowVgppfqIWiIAAsC3jTFzsba5/KqIzAVuA5YbY2YCy+3bURdO\nBJXNncPxdkopNWZELREYY6qMMRvs623ATqydza4CHrQf9iBwdbRi6K04OwmXwP7a9uF4O6WUGjMG\nTAQiki4id4jILhFpFJEGEdlpH8s4ljcRkSnAAmANkG+MqbLvqgbyB3jOF0VknYisq6urO5a365fX\n42ZKTjK7a9q45YG13L1i74d+TaWUigWDtQgeB5qA840xWcaYbOAC+9jjkb6BiKQATwHfNMa09r7P\nnqRm+nueMeYeY8wiY8yi3NzcSN9uULPzU1lX0sSKXbWsOahDSZVSCgZPBFOMMXcaY6rDB4wx1caY\nO4HiSF5cRDxYSeBhY8zT9uEaESmw7y/AWtZ6WMyekEqDz9qToLpFi8ZKKQWDJ4JSEfmuiDhdNyKS\nLyLfA8qO9sIiIsB9wE5jzF297noeuMm+fhPw3LGHfXxm56c61zURKKWUZbBE8CkgG3jTrhE0Am8A\nWcAnI3jts4AbgQtFZJN9uRy4A7hYRPYCF9m3h8XsCYcTQVt3gPbuwHC9tVJKjVqDTShrAr5nX46Z\nMWY1IAPcvfR4XvPDKs5OZs6EVPLSvKzaU0d1Sxcz8lJGIhSllBo1Bh0+KiKnichi+/pcEfmW/at+\nTHK7hH9+81y+ct50AF2ETimlGHzRuR8DlwFxIvIa1mJzK4HbRGSBMeaXwxTjkCtItyaXVWmdQCml\nBl107hPAfCABa7x/oTGmVUR+jTUfYMwmggnp4a0rNREopdRgXUMBY0zQGNMB7A/PATDGdAKhYYku\nSrweNxlJHqpadLkJpZQaLBH0iEh4mc5TwwdFJJ0xnggAJqR5qW7RrSuVUmqwrqFzjTHdAMaY3l/8\nHg7PAxizCtK9ugCdUkoxSIsgnAT6OV5vjNkavZCGR1FWEuVNHVS1dPKXtw5gb8mslFLjTjSXoR7V\nijKTaO0KcO+qg/zixZ1srWgZ6ZCUUmpEDLb6aMJwBjLcirISAVi521rqaMWuYVvySCmlRpXBWgTv\nAojIQ8MUy7AqzLTq4AfrfQCs3P3hl7pWSqmxaLBicbyIXA+cKSIfP/LOXquJjklFWYf3LU70uNlS\n3kx9ezc5KTHdEFJKqQ8YrEXwZeAcIAO44ojLx6IfWnSlJ3pI81p58CMn5mMM7K3R3cuUUuPPYIvO\nrQZWi8g6Y8x9wxjTsCnKSmJ7ZSuLp2bx7KZKmjt6RjokpZQadpGMGnpIRG4VkSfty9ftDWfGvCK7\nTrB4ShYATR3+kQxHKaVGxGA1grA/YU0i+5N9+0bgz8C/Riuo4XLurFw6/UEnITTZLYKXt1aRn+5l\n4eTMkQxPKaWGRSSJYLEx5pRet1eIyOZoBTScrl8ymeuXTAYgIc7ldA395B/bmTcpg7/ctGgkw1NK\nqWERSddQUESmh2+IyDQgGL2QRkZWcjxNHX78wRC1bd26IJ1SatyIpEXwHWCliBzA2nGsGLg5qlGN\ngIykeJo7eqhr68YY3atAKTV+HDURGGOWi8hMYLZ9aPdA6xCNZZlJHpo6/E4CaPT10OUP4vW4Rzgy\npZSKrojWGjLGdBtjttiXmEsCAJlJ8TR19PTZrEZbBUqp8WDcLjp3pIwkD829WgSA1gmUUuOCJgJb\npl0jqOq1R0FVc/8tgkAwpMtWK6VixlETgYgs7OcyXUQiKTSPGRlJHkIG9tS2MyEtvLl9J92BILuq\nW53HBUOGE370T3747LaRClUppYZUJC2CPwHvAfcA92KtSvoEsFtELolibMMqMykegJ1VrRRnJ5GV\nHE9lSxd/X1vGpb97i4fXlALw3KYK/EHDw2sOjWS4Sik1ZCJJBJXAAmPMImPMqcAC4ABwMfA/0Qxu\nOGUmW6tm1LV1U5DuZUKal6rmTsoaOwD4r2e3Udrg448r9gGwqFhnHSulYkMk3TuzjDHbwzeMMTtE\nZI4x5oCIRDG04ZVhtwgAJmYk0t4doLyp01mWOmRgU1mzs39Be3dgROJUSqmhFkmLYLuI/FlEzrMv\nfwJ22DuYxcwqbRPTrR3LspLjufGMYgrSE6lq6aK2rZvcVCsZbC23trN0u4S2LisRBIIhdle3jUzQ\nSik1BCJJBJ8D9gHftC8H7GN+4IJoBTbcJqR7eeu7F7DmP5dSkJ5IQYaXlk4/hxo7OKEgDRHYVmkl\ngum5ybR1WTnwsbVlXP6Ht2j06RLWSqmxKZKuocuAu40xv+nnvpjayaX3rmUF6dbIoYP1PpZMzSIr\nKZ7tFdbooem5KeyrbccYw6ayZoIhQ3VLF1nJ8f2+rlJKjWaRtAiuAPaIyEMi8rFYGzY6kAK7qwgg\nLzWB3NQE2uy6wPTcFEIGOnqC7Ki0kkODLyYnXCulxoGjJgJjzM3ADKwho9cB+0XkL9EObKRN7JUI\nclMTyLPnFiTEuSjIsK43+nrYW2vVBxratWtIKTU2RfTr3hjjF5GXAQMkAlcTAxvTDCY//fAm9rmp\nCeTZBeP8NC+pXmuo6YZDTfiD1gzj+narRfC71/fgcbu4/rTJZGpXkVJqDIhkZvFlIvIAsBe4FvgL\nMCHKcY24hDg3OSnWF3luqtdJBHmpCaTam96vOdjoPL7R10Nbl5/fvb6XX72ym5/+wxpx2xMIOaON\nlFJqNIqkRvBZ4FlgtjHmc8aYl4wx42IQfbhOkNerRZCXlkBqgpUI1pU04vW4yElJoKG9h5L6Due5\n1fYqps9sLOeqZaudFoNSSo02kdQIrjPGPBteflpEzhaRZdEPbeSFRw71rhHkpR7uGtpf52NyVhK5\nqQk0+Lo52GBNNpuak+wMJz1Y30HIQG2rJgKl1OgU0eqjIrJARH4lIiXAz4FdUY1qlJiZn0JBuhev\nx92nRZBidw0FQ4ZJGYnkpMRT395DiT3reEFRBo0+a55Bpb2aaXg/ZKWUGm0GLBaLyCysUULXAfXA\n3wExxsTMJLKj+fqFM7npzCkATM5KwuMWpuemODUCgMLMJNq6/JQ0+DhY72NiupeCDC9NHT2EQsbZ\n06CpI2YmYSulYsxgo4Z2AW8BHzPG7AMQkX8flqhGCa/H7WxVmZfm5a3vXkh+WgKhXlsRTMpMpK7N\nRUN7DwfrfUzNTSYrOYFgyNDWFaDS3tOgSVsESqlRarCuoY8DVVgb198rIkuxNq+PiIjcLyK1IrKt\n17GfiEiFiGyyL5cff+jDb0K6FxHB7RJS7IJxYWYi2SnxdPQE2VnVypTsZLLCK5m2dzlF4yZdgkIp\nNUoNmAjsAvGngTnASqx1hvLsBegi2YfgAeDSfo7/1hgz3768dDxBjwbhRDApI5Fse75AdyDE1Byr\nRQCwq7qNoN180K4hpdRoFcmoIZ8x5hFjzBVAIbAR+F4Ez1sFNB7tcWNVuE5QmJlEdvLhyWeXnjSB\nLHtJ6+2Vh3c2669Y3B0IUtemo4mUUiNrwEQgIilHHjPGNBlj7jHGLB3oMRH4uohssbuOBtzdRUS+\nKCLrRGRdXV3dcbxNdKV640iIc5GTEs+SaVl89YLprPnPpRRmJpFlT0TbVmFNJPN6XE6N4LH3D7G3\nxlqW4qf/2MHiX76uexsopUbUYC2C50TkNyJyrogkhw+KyDQRuUVEXqH/rp/B/BmYBszHqj/0t6Ip\nAHbCWWSMWZSbm3uMbxN9aYkeJmUmIiKkej185yNzyLfnGhzZIpg9IY3GDj8dPQFue3orf3vX2vZy\nzYEGAF7eWjUCZ6CUUpbBagRLgeXAl7A2p2kRkQbg/wEFwE3GmCeP5c2MMTXGmKAxJoS1//Fpxx/6\nyPrG0pn87MqT+r0vMd5NosdNo6+HzCQPk7OSaO7o4UCdNc+gwp5bMCXbyq9PbSgfnqCVUqofgy46\nZxdzh6ygKyIFxpjwz99rgG2DPX40WzB58D2LU7xxdPqDLD0hn+R4N02+HvbXWds3VDSF5xZY3UXv\nHWik0dej+xkopUZE1PYWEJFHgfOBHBEpB34MnC8i87FWMS3Bam3EpHAR+KPzCthU1kxrV8DZ0rKi\nuRNjDE0dftwuIRgy1LV1ayJQSo2IqCUCY8x1/Ry+L1rvN1qdNSOHUnsNovWlTYC18X1rZ4CG9m6m\n5iSzr7bdGVW0YlcNs/JTKcxMGvA1lVJqKEW01pA6dk98+QzuufFU4uNczr4E60qb8LitOXmljT5a\nuwJMzbHqBM2dfroDQb74t/U88HbJSIWtlBqHItmPYLqIJNjXzxeRW0UkI/qhjW2Lp2RxyYnWtg25\nKdY8g2DIsKg4Czg8omianQhaOvwcrPcRCBmdfKaUGlaRtAieAoIiMgO4BygCHolqVDHm9GnZfPaM\nYgCuXjARgK32HINpueEWQQ97aqxicmuXJgKl1PCJJBGE7I1orgH+aIz5DtbwURUhl0v42VUnsecX\nl/HJRUUkxLmcXcsKM5OIcwktnX5nollrpyYCpdTwiaRY7BeR64CbgCvsY57ohRS74uOsvDspM9EZ\nQZSVHE9GkofmDj8N7VbBuLVLZxorpYZPJC2Cm4EzgF8aYw6KyFTgoeiGFdsWFGXSEwwBViJIT/TQ\n3OlnT23fFkEwZOjo0aSglIquSBad22GMudUY86i9NlCqMebOYYgtZp09M9u5nplkJYK61m5KG6w9\nj8OJYNnKfZz7P2/QEwiNSJxKqfEhklFDb4hImohkARuAe0XkruiHFrvOnJ4DQGpCHPFxLjKS4tlS\n0UwwZJiWm0xbd4BgyPDcpgrq27vZXN7sPLel048/qIlBKTV0IukaSjfGtGJtVPM3Y8wS4KLohhXb\n8tO8zMhLceYXZCR66PJbX+6Liq2lKzaXN7PfXpto9d56AIwxXPq7Vdyz6sAIRK2UilWRJII4ESkA\nPgm8EOV4xo1bl87kc/Z+yOlJVu3dJXBKkTVF48n11kJ0kzISeXuflQhqWrupaumipN43/AErpWJW\nJKOGfga8ArxtjFkrItOAvdENK/ZdecpE53pGotUymJKd7Ew+e21HDbPyU7johHzuWXUAX3eAfbXW\nPINmHV6qlBpCR00ExpgngCd63T4AXBvNoMabDLtFMCMvhbREe7/jtm4WT8nk5MIMAiHDgTqfs3pp\niyYCpdQQiqRYXCgiz9gb0deKyFMiUjgcwY0X4UQwKz+VNO/hKRpTspMpykoEoKypw2kRtOgSFEqp\nIRRJjeCvwPPARPvyD/uYGiLpditgZn6KUy8AmJKTTFGWtQppWWOvRKAtAqXUEIokEeQaY/5qjAnY\nlweA0bd35Bi2YHIm1yyYxLkzc0nzHu6tm5qTTJrXQ3qih7KmDqdrqLmzZ6RCVUrFoEgSQYOIfEZE\n3PblM0BDtAMbT9ITPfz2U/PJTI4nOT4Ol7VStbOVZVFWItsqWqlt6ybNG0eXP0SXPziCESulYkkk\nieAWrKGj1Vgbzn8C+FwUYxrXXC4h1eshJSGOnBRrNFFRZhKbyqxJZRfOyQOs2cehkBmxOJVSsSOS\nJSZKjTFXGmNyjTF5xpir0VFDUZWWGEdxdhIiVtMgXCdI88Zx/mwrEXznyS2cfecKfN2H1yJq7fJj\njCYHpdSxOd4dyr41pFGoPhZPyeK8WYfLMEWZ1sihc2blkm23Et7cU0dlSxc/em47YI0kWvLL5Ty8\n5tDwB6yUGtOONxHIkEah+rjrk/P57qVznNuT7VrB+bNynRFGYU9vLKc7EGRHVSud/iAPvlMyYKvg\nvQMNfVoQSikFx58ItP9hGJ05PZufXnkiV5wy0ZmFDDC3IA1joLa1mz32pjZ7a9vZcKjpA69R19bN\ndfe+x1MbyoctbqXU2DBgIhCRNhFp7efShjWfQA0Tj9vFTWdOwetx92kRnDXDWs66qqWL3TVtpHrj\n8HpcvLilGoBAMORMPitt8GGMlRAisXpvPQ+9VzrEZ6KUGo0GTATGmFRjTFo/l1RjTCRrFKkoSPXG\nYdeQOXOGtZx1VUsne6rbOKEgjem5KRyot+Yb3Lf6IBf85g2CIUNZk7XXQVNHZHMQHnm/lGUr9g39\nCSilRp3j7RpSI8TlEtK8HhLiXCycbC1ZHW4RzM5PZUp2srPBzdv7G2j09VDX1s2hhk4AmiJcnqKl\n06/1BKXGCU0EY1BGkoepOcmkJ1rzDTYeaqKtK8CsCakUZydR1tiBPxhii72hTWVLp9MiiHSdouYO\nP76egA5HVWoc0C6eMWjh5ExnsllBupe37I1r5hakkhDnIhAyvLu/gWb7S7+quYuyxmPrGmru8BMy\n0OkPkhSv/5koFcv0//Ax6Lefmu9cn5DuZW9tO0nxbuZNyiC8i+Vzmyqdx1S1dFLeZHUNNfdqEWyv\nbOH1HbV846KZH3iP8L7J7d0BTQRKxTjtGhrjCtK9gDUJLT7OxZRsaxby0xvLSYhz4fW4ONTYQVVL\nOBEcbhH8fW0Zv319DzWtXfzHE5upb7dGFPmDIdrs+oCvW9c0UirWaSIY4yakW7OOw0NJc1OtHc6M\ngYvm5jMm6e8iAAAfY0lEQVQxI5H1pU2EDEzOSsLXE6QnYDUbDth7Ir+0tYon15c7W2K29lrmWgvG\nSsU+TQRjXKG9/MSZ062hpCJCpr2nwS+vPomJ6YnsqGoFrFYDHG4VhJe13njIKirXtHYBffc7aB8g\nEby8tYq7XtszpOeilBoZ2vk7xl15ykTyUhM4aVK6c+z5r52Nx+0iIymegnQvxsCENC/nzc7lqQ3l\nfOXhDczMS6Gqxfri31hmzUSubrG6hnrvidzR038ieG5TJe/sr+dbF8+KKM59te1Mz012FtJTSo0e\n2iIY47wet7MiaVhRVhIT7NpBQYbVYrj0pAlkJVkjjdaXNvHY2jLn8WWNVv2gps1uEXT0bhH0XyOo\nb++mtSsQ0b4IB+t9XHTXm7y5py7S01JKDSNNBDEuvHLp5fMKnL2RB1LT8sGuoYFqBHV2YTmSJSsq\nm61EU2aPXFJKjS7aNRTjrjhlIhlJ8SyekklF8+EvYo9bnALywXqraFxt1wh6jywaKBHU2wmgtq3b\n2S9hII0+6/Ua23WLTaVGI20RxDivx83Fc/PtIrLVNZSZ5OETpxZx0qR0p9gM1iqmxpg+NYL+isUd\nPQF8PVaXUCQtgvAktkgnsymlhpe2CMaRpHg38W4X84sy+PlVJxI0hh88sw2w9kUua+yk0ddDc4ef\n1IQ4AiHTb4ugvu3wF3qdXVcYTJPPSiwNPk0ESo1G2iIYR0SEG88o5volxcS5XSTEuZmQZhWVFxRZ\nC9jVtHbT2uknPclDckLcB4rF9e3dlDd3OLePpUXQ6LMeu6emzdk/YTBv7qnjqmVv4w9Pl1ZKRYW2\nCMaZ//rY3D6389OsCWgLJmfw/OZKalq7aO70k57oIc4VoLXTz69e2cUzGyqYnJ3E2pImJmZ4nefX\nHpEIfvf6Hk4uTOfCOfnOsXCNoMGuEfzgma0APPHlMwEwxvDG7jrOnpmDx334t8nag41sLmumprWL\nwszB6xDHo6XDz6q9dVxxim6vocY3bRGMcxfMyeMTpxY6Q1Afff8QGw81kZuaQHJCHC9urWLZyv1M\ny02htq2bjESPM9w0JyWeV3fUcOGv36C0wce2ihZ+9/pefv7CTkKhw6uWHm4RWP8eauygotcIog2H\nmrn5gbV91kcCaPAdLkhHw9/XHeLrj26kNoLuLaViWdQSgYjcLyK1IrKt17EsEXlNRPba/2ZG6/1V\nZAozk/j1v5zClOwkPr24iNd31pCZFM/3LzuB5ASrwej1uHjwltNY8e3zufmsKc5z50xIo9HXw4F6\nH3e8vIs/v7kfsOYNrLaXq4C+xeKeQIjatm5q27qdZLHmYANgzW8A+PUru/nvl3dSb7cgalsjTwTf\neWIzD75T8oHjxhiu/fM7vLDlcLIJJ7TeNY8P41ev7GJtSeOQvJZSwymaLYIHgEuPOHYbsNwYMxNY\nbt9Wo4CIcMe1J7P+hxfzz2+ey+wJqaTYiWB2fipulzUj+NRia5mKrOR4Ur3W/ZlJHl7eVs2LW6q4\n+awpZCfH89jaQ85rh4vF/qBhb20bxkAgZHhjTy3ff3or7+63EsFGe6/lZzdV8NqOGhrCcxXaB04E\nDe3d3PbUFtq7rcltz2ysYPmuWrZVtPDEusOT5uraullf2uS8F0D5UXZte2dfPR/57aoBZ1f31h0I\nsmzlfp4+jj2ht1W06L4PakRFrUZgjFklIlOOOHwVcL59/UHgDeB70YpBHbvM5HjnelK8G7B++YfN\nL8ogziXkpMTT1mV9QS67YSFv76tnWk4KV86fSHtXgBW7aunoCbC/1kejr4eclHjq23vYVtHivNY9\nqw7w3gHrF7TbJeypaaOmtYvypk4SPW4CQevLsa61b9fNj5/bRncgxB3Xnswbu+t4bG0Z583KpSAj\nkUDIUNncyf2rD/LCliquXVhIa5ff2ZgnvKwG4MyrGGg00zv7G9hd08aemnbmF2UM+ncLt14ONXYM\n+rgjbSpr5uplb/P4l87gtKlZx/RcpYbKcNcI8o0xVfb1aiB/oAeKyBdFZJ2IrKur06UJRkKnPVdg\nTkGqcywx3s3C4kwmZyXzkytP5Dsfmc0Z07L5zkfmcO2phXjcLuZPzqDB18N3n9zCFXevptMfZFpu\nCgDbKlqd19pQ2uxc/+i8AkIGnlxv/aLu9AedL+reNYLOniB/X1fGs5sq6A4EKbW/eDeVNztJprK5\nk9LGDnqCIV7ZXs3Cn7/G8p21zn1gdRWF92hoHKDFEf5S31/b3ud4R0+A1q6+O72FR0+Fu5vCuvxB\n7np1N509QV7YUulM3gsrsW+XNPQ9rtRwGrFisbHawgO2h40x9xhjFhljFuXm5g5jZCos/EU5e0Jq\nn+P/95lT+c2/nMKMvBS+esGMDywkFx6K+sKWKufYjDw7EVQebhH0BEPMzk/lhII0bl06AxF4+L1S\n5/6gXUPoPUT1zT11dPlDdPlDbDrUTKn9Bbq57HAi6OgJstNecfWlbdWEzOGNesItguYOPx12omsc\nYPtOJxHU9U0Etz66iavvfttZzrt3jJXNnQRDhrf21vHj57axem89f1ixj39ur+Ibj23i16/s7vNa\n4XhqWiIvWD/0Xik/+8eOfu97fG1ZnzpIS4efWx5Y6+xHcaTOniD/+cxWZy8KNT4NdyKoEZECAPvf\n2mF+f3UMwjWA3l1DYHUfpQ+ybtGs/BQSPe4+x2Y4LYIW0rxx2CUHLps3gZe/cQ4z8lI5f1Yulf18\nIYYLy99+fDP/88ouUu3nv7O/gdIG68t6a3kLm8tbnFpG+Es+vMdCuHXR0umnoyfgJDk4PL8BrJZC\nRXMnLR1+Z3vPXdVt/PfLO6lo7qS+vZuVu2s5UO/j70fUIMCqfVS1dPLsxkoefLfUSUgvbqkmGDK8\nuaeOnkCIYMjQ0ul3lv6uao0sERhjuGfVfh55v9RJlL397vU93LvqgHN7/aFGVuyq5b0DDR94LMC6\n0kYeWXOIFbsi+19x5e7a41o88IUtldRGeI5q+A13IngeuMm+fhPw3DC/vzoGd1+/kGXXLySrV90g\nEnFuFycXWstiJ8RZ/4kVZycR73bhDxqKspKcDXSm2wkC4MYzigGYlHF42Yvs5Hhq27pYW9LIUxvK\nOVjv45oFk5g3KZ139tdzqLGDNG8cPrsVcMa07D6xNPbT/1/Z3EWFPSnOJX0f86WH1nPWHSv4+J/f\ndmoHK3fX8n9vHuDBd0p4cUsVwZBhak4yd6/Y64x86j0EtayxkwP1ViviLTsRrbK/PNu7A6w52MBd\nr+1m6W/ecBLSkS2CB94+yFl3rCBgT6br7AlijGFfbTtljZ10+UPsqGzliXVlTqG5uaOHypYuShoO\n1ykO2dfDS4wfKdyVFd6k6Gh+8+pu7nx514D3P/b+IR5Zc6jPseaOHr72yEYefLckovdQwy+aw0cf\nBd4FZotIuYh8HrgDuFhE9gIX2bfVKDUh3ctHTy44rufeeEYxXzhnKn+8bgEAcyem8bULZwDWxLJ8\ne0ZzuMsI4LxZecyZkMoVp0wkzv5lf0JBGvXtPTy/uRKvx8X6H17Mj684kXNm5rK+tIlGXw9XzZ9E\nvNvFhXPy+PEVcxlIeBZ17z2cZ+SlUN3SxQ+e2cqqPXW8uqOGoqxE9ttfjMXZSYQH9LyyvZrH15Ux\nZ0IqXzlvOjWt3aw/1MSPntvW54u0rKnDqQVssIfE9gRDxLutrUOf3VjJY++XUd/ew/pSq1hefcSv\n5Re3VlHR3MnOqjaafD0s+sVrPLXBGhEV9sPntvGdJ7ewvrSJzz+wloftL+CWTj9NzpwN6zyrB+ga\nCnd/HTii+8sY02c58rCq5i4O1vv6zBMBWLmrliZfD/e8dYA/LN/bZxRU+D1K6o+tkD6QVXvq+M2r\nu4/+QJsxhu88sZnVe+uP/uBxKmqJwBhznTGmwBjjMcYUGmPuM8Y0GGOWGmNmGmMuMsbooOsY9bGT\nJ/KDj87lkhMnUHLHRylIT+Qr509n6Zw8bl06k/w0LyIwNSfZeY7bJbx06zncdtkcJ1GcUJBKMGR4\nakM5F87JIys5HrdLuGr+RMLfRWfNyGb9f13EfTctYnpuCvF2KyTcsgj/Gx6VU9XcxfsHG0lP9DAl\nO5mNZc08vOYQX3xoHQC/uHqeE9MF9kS74uwkShs62F7ZyufPnspi+7V++Mw2/vZuKS9trWJabjIu\ngS3lzTTbX6KBXl+Y0/NSuHZhIU9tKHdaG03246p7tQjauwPOrnHvlzSyrrQJX0+QJ9eX8fK2aqbl\nJiNi1UUAHninhOW7avn963ud1zho107CX8JVR7Q42rsD7Kttc0ZTHaj38Ze3DjhdSHf8cxen3f46\nW8sP13S6/EEafD10+oNO4qpv76bR18PND6zl7pX7KKn3Ud3a1Wel23AMRxbKB7PhUBNfe2SD0yLq\n7dH3D7Fs5b4+NZpH3z/kFN6P1NTh54n15Ty7qSKi935zj1XfOVb//fJO/vr2wWN+3migM4vVsPG4\nXdz3ucVcv2QyZ07P5oLZeXiPqCW47JZAgb2xzrxCa9hmdyDEpxdPdh43Mz/V6X6anJVMqteDiOBy\nCQXpXlIT4phn79r2MbtVs2Sa9eX9jy2VvLqjxprzkBLv/OLv8oeYNymd82blOgnq+iWTOW9WLsuu\nX4gInFqcybULC5mSnUROSjy77TWTAiHDxPRECtITeWN33z70PLsbbM6EVH7w0ROYnptMQbqVCK2/\ni9Dg66E7EOR/39zP957aQiBkcLuEdSWNrLNbDe8dsJbc+OzpxUzNPpxAX9pqFeV7giGn9hIuoofr\nHNWtXfz6ld2s3FVLXVs3n/jzO1z++9VOgf1gvY9fvrSTP67YS0m9j/tXH6Q7EOLfHlnvzKOo6dVq\nOVDnY+WuWpbcvpzXdlQD8NymCic5ry9tIhAMsbOq9XCLoMEX8XyJ/3tzPy9sqWJLRQt3vLyL2rYu\nSup9NLR3s7umjZCBQ43WObZ0+Pn+01sH7HoK/y32HjH6ayAvbLbqO0eODAt7ZM0hrvjj6g+0ip5c\nV/6B2fHHq6XDz/2rDw7b/BJNBGpE3HzWVO7/3OIB7y/ISCQ53s1lJ03g7usX8MZ/nM+5s/qOHvvs\nGVPITPL0aVWAtcfC1NxkirKslsBl8wq497OLuHZhITkpCby1t56CdC9fPHeaszT3hDQvs/JTuH6J\nlWyumj+R4uwkZuWn8uAtp3HSpHT+8tlF3H39AlwuQURYVNx33H9eagJnTM92up3C6zgtPcFqVczM\nTyEpPo5nv3oWz371LKbYX+ZzC6xi/Itbqrjj5V28uKUKr8fFpSdOYG1JI+tLmshJseLMSYnn06dN\ndkZyZSfHEzLW7G+ARcVZuAQO1ndgjOnza3zZG/v47et7+OGzW9lb205PMERpQwfJ8W6CIYMxsPZg\nE7e/tBOP28Wd186jrLHTaSX0blUcqG/nzT11BEPG2e0uPJdCBN4/2Mi3n9jMZb9/i+ftL8eOnmCf\nEWDrSxuZ/7NX2Wsn02Ur9/HPbVW0dPpZuctKpnev2Mf/vrmfpzdUcN297/HdJ7c4AwTC3XF7a9v6\n3O6t999gX00b3YEg3YGg/fh2bnlgrZMsw8LneeSw4bDlO2vYWtHC5vLDw59bu/w0+Ho4UNce8Ze3\nPxji8XVlfVo2YU9uKOdnL+xge2VrP88cerronBqVrltcxLxJaXjcLj52cv+Lwn3i1EKuWTDJGSkU\n9ourT8IfNGyraCElIY7pucnOhLDvXjqbyuZOrl1YSFJ8nFMIP3VKJsuuX+i8xq0XzuSrF8zo87pL\nT+g77eX0aVn8c3s1V5wykX9sriQ3NYFLT5rAk+vLcbuEs2fk2l1a+UzPTeGq+ZMASPV6SPV6mJWf\nwsF6HwsmZ7K5vIVvPb6ZSRmJfOm8aYgICW4XL26tosHXw7+ePZXKli4utFtRp0/LZsOhJj61qIg/\nrNjHxxcW8s6+es6ZmUNVaycl9T7q261unMwkj9MFtaW8hW0VLdxy1lQeff8Qvp4gZ87I4bUdNSTE\nuegOhHh1Rw3/evZUrpo/if96djtrDjQyvyizz/pQ+2vbWW/PBA93YwHEu12cWpzp1CvAGnXlEggZ\nKyHl2d1+j75fRnOHnz+/uZ/br5nH717fQ0F6Iv92/nR6giE8bnFGMz21vpyqli6qW7ucFly4qyn8\nSz9coA97bUcN3358k/O5+XqCfPqe94hzCU98+Ux++eJOVuyqxetx8acbTnWeV2nXU/bVtrNg8uFV\ncL7wt3VMzkpyhkCv3FXLgsmZ7KpudebctHYFaOrwRzTA4vlNlXz3yS0kxLkobejgtKlZpCTEUd/e\nzQ47AZQ0+PrsRx4tmgjUqHTmjBzOnJFz1McdmQQAiu1f2tNykll6Qh6p3sNDXT+5qKjPY7PtX9rz\nC/vOHHa5BBcffO3erl9SzMLiTNq6Ak4imF+UwdyCNLoCQWbmp9jxJHHx3A/OnZw9IY1Xttf0mbV8\n57Unc/ZM67z9wRBv7q3jxS1VLJmazUW9XuOzZxRzw5LJrDnYCCv2ceb0bH525Ym4XcL7JY28s7+e\n21/aCcDiKVm8uqPGeW7IWMX8g/U+lu+q5YLZeazcVcu/njOV+1YfpCcQ4qYzp+D1uDmlKJ2XtlXx\n4LslZCdbLZwZeSlsqWhxvqwAMpI8NHf4mZ6Xwr9dMJ3CzETOnpnDvW8dYFtFK6cUZbDxUDOlDR0s\nmZZNlz/IK9uqiXe7eH5TJRfMzsMftH69//LFnczKT2FyVhKv2xMBw1/24SQg0qtFUGPdV97USWVz\nJ26X0BMI8a3HNzmfTVg4aT2xrozlu2qZlpvMS1ur2VTWzPyiDIwxzqTDfXXtNLR3c9Wyt/nplSey\nclct8XEuZ2jyit21LJ6axY33vc+SXrPCD9a3k5Vs3fZ1B/jC39bx9Qtncsb0bB5fW8aBeh+3XTaH\nZzZaNYsn15fz1t56LpmbT3t3gK3lLUy061oD1T2GmiYCFbNcLumTBPoz2d5m83iWd4iPc3FyYQZd\n/iAfPbmAc2flIiL86YaF+HoCZCTFW1+OvYbI9vaRE/PZeKiJ82fncnJhOp89Y4qTBMCqqfzh0wu4\n5awpLJzcd31GESHOLZw5PZv7P7eI82blOUnxE6cWsmzlPucL8KwZOc5oqMlZSXjj3BRnJ3PWjByW\n76rl5MJ0Xrj1bKblpOCz958o6vV3WbbSWkywormT9EQP84synBngM/JS2Ffbzvmzclm1t565BWmc\nMzOXc2Za3Xg7KlvZVtHK6dOy2VrewoF6H796ZRd/fbuEjp4gt18zjx8+u5Wf/mM7YC1r0tYd4L6r\n57G2pJHXd9YyKz+FPTXtpHnjaO0KEOcSTpqU3qtFYHUNGQMf/9M7xLmFRcWZBIKG/LQEalq7mZ2f\n6tRzAL7/9FYmpHl54ktncNadK3hmQznzizJo7vDT5be6avbXtvPqjhrKmzr51Su7CYQMATsJnD87\nlzd21/H1RzcCWAnZdqDO56zJ9cr2at7Z30Cjr4eXbj2Hv75Twq7qVi45MZ+399cjAm/Zo5nWlTbR\n2ROk0x90Yj04RCOtjkYTgRrXTi3O4q3vXnDUfZcH4/W4+3QrTelVs7jtsjkDPu/Eiek89PklADz/\ntbP7fYzbJc6XSn9EpM/eDwBXzZ/EVfMn0dzRQ3lTJ3FuK0GcUpjBXZ+c7xSpP31aESneOE6cmObM\nDv/JlSf2ea0lU7NZtnK/071UkO7l3y+exf66dvbXtnPj6cX8+PntzMxP5cvnT3daDWFnzsjh/1Yd\nYGpOMgsnZ/L3tYdo6wowpyCVWfmpfHJRIct31li/znOS+fw5U/F1B5xukofeLeV7l87h8w+u45xZ\nuZTU+/DbM9LDQ2n31bYzMy+FvbXtzmim8qZObjqjmJ5giEffL+PkwnSaOnrITU3AJcLWiha+dfEs\nslMSOGdmLq/uqOHjCwud+oDX42Jfbbsz6mtXdZv997YSzv9cezK/X76X5zdVckJBGjurWslOjqe1\ny+8kqC5/kGc3VRLvdrGruo3H1paxu7oVY+ALD65DgM+cXszf3rVm0x8550XEal0MB00Eatz7MElg\nNMtIiicjKZ62Lj9ej4sl07KdobUASfFxH+gqO9JZM3K489p5FGYmccNf1lCQ7mVSRiJPfflM2nsC\nNLb3EOcSFkzO+MAMdICzpmfzo4/N5fJ5BSwoyuCjf1xNfJyL+29a7NQKbjh9Mst31bKwOJMblhQ7\nz507MY33/nMpoZDho/MK+NSiInJSEvAHQ6w52MDf13Vz5d2rqWrp4qsXTHe6j6blJlNS7+OWs6ey\nqayZR98vozg7ibs+OZ/MZA/763y8vLWKa08tBOCSufm8tqOGq//0Nh6X9fc5fVo2q/bUUdHcSXZy\nPA2+HvJSE5iem0JNWxd5aV5+ec08fnH1STy9oYJvP7GZabnJNPp6OFjv44l1ZXz3qS0AfOW86byy\nvZrbX9pJyECaN44GXw+3Lp3JJXPz+du7pZw7K9eZdDg1J5mD9T4WFWc681miTROBUjEu1evhjf+4\nwJnNfSzcLuFTiycTChkmZSQyK98areRyCWleD2leDxt/dPGAXXBxbhe3nD0VsIb83n/TYoLGOEkA\nrImEn1pUxL8sKuz3NVwuYdkNC/scm5abTE8gxFt765kzIZXL5xXwzIYKJmUmcue1J7O3tp3i7GRS\nEuKYlJHIaVOzne6/Eyemc2WvXemWnpBPnEswWENwAT6zpJi9Ne1UtXTyg4+ewLce38wpRRn89MoT\nnRoBWC2y06dbs9mLs5PJSo7n/YONbDzUTFFmEgXpXq5fMpmclAR+9sIOXAL/+5lTeXNPHbdeOAO3\nS/jRx+Zy2bwJXPLbVWQnx/OZ04u5Z9V+LpiTx9qS3bR0+Add0mUoyFhYB33RokVm3bp1Ix2GUuNa\nS4cfb7y11/VotPFQE5lJ8X265iK1tbyF9u4A1937ntWV8/NLcbmE7kCQeLeLmx9Yy8cXFvZJIL39\n4oUdXDgnj4ykeD75f+/S3h3g/31+iVPzaenwc9rtrzM9N4WXvnFOv6+xbOU+0hM93LBkMsGQYcWu\nWr740Hqe/epZR10GfSAist4Ys+hoj9MWgVIqItH+VfphLZh8/BsezitMxxjjLCkSntgYTnoP3Hza\noM//Ya+9wB+8ZTHrS5s4a8bhda/Skzzcfs08MpMH/hv2Hq4c5xam56UwZ0Iq3f7ggM8ZKtoiUEop\n2+s7amjr9nPNgv67qcYabREopdQxuqif+R7jgS4xoZRS45wmAqWUGuc0ESil1DiniUAppcY5TQRK\nKTXOaSJQSqlxThOBUkqNc5oIlFJqnBsTM4tFpA4oPc6n5wD1QxjOaDQezhHGx3nqOcaG0XKOxcaY\n3KM9aEwkgg9DRNZFMsV6LBsP5wjj4zz1HGPDWDtH7RpSSqlxThOBUkqNc+MhEdwz0gEMg/FwjjA+\nzlPPMTaMqXOM+RqBUkqpwY2HFoFSSqlBaCJQSqlxLqYTgYhcKiK7RWSfiNw20vEMFREpEZGtIrJJ\nRNbZx7JE5DUR2Wv/e/z79o0AEblfRGpFZFuvYwOek4h83/5cd4vIR0Ym6mMzwDn+REQq7M9yk4hc\n3uu+sXiORSKyUkR2iMh2EfmGfTxmPstBznHsfpbGmJi8AG5gPzANiAc2A3NHOq4hOrcSIOeIY/8D\n3GZfvw24c6TjPMZzOhdYCGw72jkBc+3PMwGYan/O7pE+h+M8x58A/9HPY8fqORYAC+3rqcAe+1xi\n5rMc5BzH7GcZyy2C04B9xpgDxpge4DHgqhGOKZquAh60rz8IXD2CsRwzY8wqoPGIwwOd01XAY8aY\nbmPMQWAf1uc9qg1wjgMZq+dYZYzZYF9vA3YCk4ihz3KQcxzIqD/HWE4Ek4CyXrfLGfzDGksM8LqI\nrBeRL9rH8o0xVfb1aiAWNl8d6Jxi7bP9uohssbuOwl0mY/4cRWQKsABYQ4x+lkecI4zRzzKWE0Es\nO9sYMx+4DPiqiJzb+05jtUdjalxwLJ6T7c9Y3ZfzgSrgNyMbztAQkRTgKeCbxpjW3vfFymfZzzmO\n2c8ylhNBBVDU63ahfWzMM8ZU2P/WAs9gNTNrRKQAwP63duQiHDIDnVPMfLbGmBpjTNAYEwLu5XCX\nwZg9RxHxYH1BPmyMedo+HFOfZX/nOJY/y1hOBGuBmSIyVUTigU8Dz49wTB+aiCSLSGr4OnAJsA3r\n3G6yH3YT8NzIRDikBjqn54FPi0iCiEwFZgLvj0B8H1r4y9F2DdZnCWP0HEVEgPuAncaYu3rdFTOf\n5UDnOKY/y5GuVkfzAlyOVdHfD/xgpOMZonOahjUCYTOwPXxeQDawHNgLvA5kjXSsx3hej2I1p/1Y\nfaifH+ycgB/Yn+tu4LKRjv9DnONDwFZgC9YXRsEYP8ezsbp9tgCb7MvlsfRZDnKOY/az1CUmlFJq\nnIvlriGllFIR0ESglFLjnCYCpZQa5zQRKKXUOKeJQCmlxjlNBEopNc5pIlBKqXFOE4FSx0FEFtuL\ni3nt2d7bReSkkY5LqeOhE8qUOk4i8gvACyQC5caY/x7hkJQ6LpoIlDpO9hpWa4Eu4ExjTHCEQ1Lq\nuGjXkFLHLxtIwdqlyjvCsSh13LRFoNRxEpHnsXa+m4q1wNjXRjgkpY5L3EgHoNRYJCKfBfzGmEdE\nxA28IyIXGmNWjHRsSh0rbREopdQ4pzUCpZQa5zQRKKXUOKeJQCmlxjlNBEopNc5pIlBKqXFOE4FS\nSo1zmgiUUmqc+/9pFmYIjkmNOgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1e4cc2f0320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nzHcQJwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1e4c8fb1d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEWCAYAAAB1xKBvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKvkfECH6Wvr/m5EAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1e4cfc99e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "avg_loss = list()\n",
    "avg_acc = list()\n",
    "avg_perp = list()\n",
    "i = 0\n",
    "while(i<len(J)):\n",
    "    avg_loss.append(np.mean(J[i:i+30]))\n",
    "    avg_acc.append(np.mean(A[i:i+30]))\n",
    "    avg_perp.append(np.mean(P[i:i+30]))\n",
    "    i += 30\n",
    "\n",
    "plt.plot(list(range(len(avg_loss))),avg_loss)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"Loss (Avg of 30 batches)\")\n",
    "plt.title(\"Loss Graph\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(list(range(len(avg_perp))),avg_perp)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"Perplexity (Avg of 30 batches)\")\n",
    "plt.title(\"Perplexity Graph\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(list(range(len(avg_acc))),avg_acc)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"Accuracy (Avg of 30 batches)\")\n",
    "plt.title(\"Accuracy Graph\")\n",
    "plt.show()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's make some predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#predict\n",
    "def predict(parameters,embeddings,id_char,vocab_size):\n",
    "    #to store some predicted names\n",
    "    names = []\n",
    "    \n",
    "    #predict 20 names\n",
    "    for i in range(20):\n",
    "        #initial activation_matrix(a0) and cell_matrix(c0)\n",
    "        a0 = np.zeros([1,hidden_units],dtype=np.float32)\n",
    "        c0 = np.zeros([1,hidden_units],dtype=np.float32)\n",
    "\n",
    "        #initalize blank name\n",
    "        name = ''\n",
    "        \n",
    "        #make a batch dataset of single char\n",
    "        batch_dataset = np.zeros([1,vocab_size])\n",
    "        \n",
    "        #get random start character\n",
    "        index = np.random.randint(0,27,1)[0]\n",
    "        \n",
    "        #make that index 1.0\n",
    "        batch_dataset[0,index] = 1.0\n",
    "        \n",
    "        #add first char to name\n",
    "        name += id_char[index]\n",
    "        \n",
    "        #get char from id_char dict\n",
    "        char = id_char[index]\n",
    "        \n",
    "        #loop until algo predicts '.'\n",
    "        while(char!='.'):\n",
    "            #get embeddings\n",
    "            batch_dataset = get_embeddings(batch_dataset,embeddings)\n",
    "\n",
    "            #lstm cell\n",
    "            lstm_activations,ct,at = lstm_cell(batch_dataset,a0,c0,parameters)\n",
    "\n",
    "            #output cell\n",
    "            ot = output_cell(at,parameters)\n",
    "            \n",
    "            #either select random.choice ot np.argmax\n",
    "            pred = np.random.choice(27,1,p=ot[0])[0]\n",
    "            \n",
    "            #get predicted char index\n",
    "            #pred = np.argmax(ot)\n",
    "                \n",
    "            #add char to name\n",
    "            name += id_char[pred]\n",
    "            \n",
    "            char = id_char[pred]\n",
    "            \n",
    "            #change the batch_dataset to this new predicted char\n",
    "            batch_dataset = np.zeros([1,vocab_size])\n",
    "            batch_dataset[0,pred] = 1.0\n",
    "\n",
    "            #update a0 and c0 to new 'at' and 'ct' for next lstm cell\n",
    "            a0 = at\n",
    "            c0 = ct\n",
    "            \n",
    "        #append the predicted name to names list\n",
    "        names.append(name)\n",
    "        \n",
    "    return names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's Predict Names using Argmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['donald.',\n",
       " 'margaret.',\n",
       " 'zena.',\n",
       " 'gustav.',\n",
       " 'gustav.',\n",
       " 'roseanna.',\n",
       " 'queen.',\n",
       " 'zena.',\n",
       " 'gustav.',\n",
       " 'katheryn.',\n",
       " 'william.',\n",
       " 'vincent.',\n",
       " 'harris.',\n",
       " 'gustav.',\n",
       " 'isabella.',\n",
       " 'x.',\n",
       " 'norman.',\n",
       " 'orange.',\n",
       " 'orange.',\n",
       " 'percy.']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(parameters,embeddings,id_char,vocab_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Awesome names predicted like -- Donald, Margaret, Harris, Isabella, William**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lets predict using Random.Choice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['frora.',\n",
       " 'harry.',\n",
       " 'queen.',\n",
       " 'warren.',\n",
       " 'hugbard.',\n",
       " 'joshua.',\n",
       " 'wash.',\n",
       " '.',\n",
       " 'roxy.',\n",
       " 'yem.',\n",
       " 'zina.',\n",
       " 'beulah.',\n",
       " 'ila.',\n",
       " 'x.',\n",
       " 'zoe.',\n",
       " 'vannie.',\n",
       " 'wilton.',\n",
       " 'philomene.',\n",
       " 'rae.',\n",
       " 'thomas.']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predict(parameters,embeddings,id_char,vocab_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Awesome names again -- Warren, Harry Wilton, Zoe, Thomas, Joshua, Queen**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The END"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}