4_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Recurrent Neural Nets : Name Origin Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import glob  #helpful in finding pathnames following specific pattern\n",
    "import unicodedata\n",
    "import string\n",
    "import os\n",
    "import random\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_letters = string.ascii_letters + \" .,;'\"\n",
    "n_letters = len(all_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing data and making its tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findTxtFiles(path_pattern):\n",
    "    return glob.glob(path_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_pattern = \"./rnn_data/names/*.txt\"\n",
    "files = findTxtFiles(path_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['./rnn_data/names/Czech.txt',\n",
       " './rnn_data/names/Dutch.txt',\n",
       " './rnn_data/names/Korean.txt',\n",
       " './rnn_data/names/Russian.txt',\n",
       " './rnn_data/names/Scottish.txt',\n",
       " './rnn_data/names/Spanish.txt',\n",
       " './rnn_data/names/Greek.txt',\n",
       " './rnn_data/names/Vietnamese.txt',\n",
       " './rnn_data/names/Irish.txt',\n",
       " './rnn_data/names/German.txt',\n",
       " './rnn_data/names/Polish.txt',\n",
       " './rnn_data/names/French.txt',\n",
       " './rnn_data/names/Portuguese.txt',\n",
       " './rnn_data/names/Chinese.txt',\n",
       " './rnn_data/names/Italian.txt',\n",
       " './rnn_data/names/Arabic.txt',\n",
       " './rnn_data/names/English.txt',\n",
       " './rnn_data/names/Japanese.txt']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_list = []\n",
    "word_class_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unicodeToAscii(s):\n",
    "    return ''.join(\n",
    "        c for c in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(c) != 'Mn'\n",
    "        and c in all_letters)\n",
    "def readTxt(file):\n",
    "    lines = open(file, encoding='utf-8').read().strip().split('\\n')\n",
    "    return [unicodeToAscii(line) for line in lines]\n",
    "\n",
    "for file in files:\n",
    "    class_name = os.path.splitext(os.path.basename(file))[0]\n",
    "    class_list.append(class_name)\n",
    "    lines = readTxt(file)\n",
    "    word_class_dict[class_name] = lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Abel', 'Abraham', 'Adam', 'Albert', 'Allard']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_class_dict['French'][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_class = len(class_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "#preparing character-wise tensor\n",
    "print(all_letters.index('g'))\n",
    "\n",
    "\n",
    "def letter2index(letter):\n",
    "    return all_letters.index(letter)\n",
    "def letter2tensor(letter):\n",
    "    idx = letter2index(letter)\n",
    "    x = torch.zeros(1,n_letters)\n",
    "    x[0][idx]=1\n",
    "    return x\n",
    "def name2tensor(name):\n",
    "    n_name = len(name)\n",
    "    x = torch.zeros(n_name,1,n_letters)\n",
    "    for i,letter in enumerate(name):\n",
    "        x[i][0][letter2index(letter)]=1\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]],\n",
       "\n",
       "        [[0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "          0., 0., 0., 0., 0., 0.]]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2tensor('ashish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Auxillary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predictClass(output):\n",
    "    max_val,max_idx = output.topk(1)\n",
    "    class_idx = max_idx[0].item()\n",
    "    return class_list[class_idx],class_idx\n",
    "\n",
    "# give random choice index in a list\n",
    "def makeRandomChoice(l):\n",
    "    return random.randint(0,len(l)-1)\n",
    "\n",
    "\n",
    "\n",
    "def makeRandomExampleTensor():\n",
    "    choose_class = class_list[makeRandomChoice(class_list)]\n",
    "    choose_word = word_class_dict[choose_class][makeRandomChoice(word_class_dict[choose_class])]\n",
    "    y = torch.tensor([class_list.index(choose_class)],dtype=torch.long)\n",
    "    X = name2tensor(choose_word)\n",
    "    return choose_class,choose_word,X,y\n",
    "\n",
    "\n",
    "            \n",
    "def initCuda(force_cpu=True):\n",
    "    ## Do check for cuda device\n",
    "    if torch.cuda.is_available() and force_cpu==False:\n",
    "        device = torch.device(\"cuda:0\")\n",
    "        print(\"GPU Process\")\n",
    "    elif force_cpu:\n",
    "        device = torch.device(\"cpu\")\n",
    "        print(\"CPU Process\")\n",
    "    else:\n",
    "        device = torch.device(\"cpu\")\n",
    "        print(\"CPU Process\")\n",
    "    return device\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RNN Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(self,input_size,hidden_size,output_size):\n",
    "        super(RNN,self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.input_size = hidden_size + input_size\n",
    "        \n",
    "        #Layers\n",
    "        self.input_hidden = nn.Linear(self.input_size,self.hidden_size)\n",
    "        self.hidden_hidden = nn.Linear(self.hidden_size,self.hidden_size)\n",
    "        self.hidden_output = nn.Linear(self.hidden_size,output_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "    #forward gives us recursion by prev_hidden arguement!\n",
    "    def forward(self,data, prev_hidden):\n",
    "        combined = torch.cat((data,prev_hidden),1)\n",
    "        hidden = self.input_hidden(combined)\n",
    "        hidden = F.relu(hidden)\n",
    "        hidden = self.hidden_hidden(hidden)\n",
    "        hidden = F.relu(hidden)\n",
    "        output = self.hidden_output(hidden)\n",
    "        output = self.softmax(output)\n",
    "        return output,hidden\n",
    "    def init_hidden(self):\n",
    "        return torch.zeros(1,self.hidden_size)\n",
    "    \n",
    "\n",
    "    \n",
    "###Training Function\n",
    "\n",
    "def train(model,n_iters):\n",
    "    loss_tracker = []\n",
    "    for i in range(n_iters):\n",
    "        hidden = model.init_hidden()\n",
    "        _,_,X,y = makeRandomExampleTensor()\n",
    "        X=X.to(device)\n",
    "        y=y.to(device)\n",
    "        model.zero_grad()\n",
    "        for j in range(X.size()[0]):\n",
    "            output,hidden = model(X[j],hidden)\n",
    "            output.to(device)\n",
    "            hidden.to(device)\n",
    "            #print(output)\n",
    "            #print(y)\n",
    "        loss = criterion(output,y)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if i%5000==0:\n",
    "            loss_tracker.append(loss)    \n",
    "    return loss_tracker\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What's happening?\n",
    "Sequence will be passed letter by letter and output will pe predicted at each time step, loss is calculated at each time step.\n",
    "<img src=\"./images/rnn.png\" height=\"600\" width=\"600\">\n",
    "\n",
    "\n",
    "We sum up the error gradient at each time step  de/dw = <img src=\"./images/sum_error_grad.png\">\n",
    "\n",
    "and similarly for U and V\n",
    "\n",
    "* Gradient wrt W will not only depend on current time step but also on prev time steps hence it is backproogation through time otherwise there is no difference between this and normal backprop used in feedforward nn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU Process\n"
     ]
    }
   ],
   "source": [
    "device = initCuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RNN(\n",
      "  (input_hidden): Linear(in_features=185, out_features=128, bias=True)\n",
      "  (hidden_hidden): Linear(in_features=128, out_features=128, bias=True)\n",
      "  (hidden_output): Linear(in_features=128, out_features=18, bias=True)\n",
      "  (softmax): LogSoftmax()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "hidden_size = 128\n",
    "rnn = RNN(n_letters,hidden_size,n_class).to(device)\n",
    "print(rnn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "optimizer = optim.Adam(rnn.parameters(),lr=0.00025)\n",
    "criterion = nn.NLLLoss()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_plot = train(rnn,50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deVzU173/8deHfRtABQYB2RTGLRqVuJvUJG2zGE0b02ZpEpNYm+7pbW/uTX79JTfpvffXNr3tbW96b5rFJUuzXE0bk5ql2eMu7itKBBQRARdAZJ/z+4PBKAEZZIbvLJ/n4zGPDjOH7/fjFN75cs75niPGGJRSSvm/EKsLUEop5Rka6EopFSA00JVSKkBooCulVIDQQFdKqQARZtWJk5KSTHZ2tlWnV0opv7R58+YaY0xyd+9ZFujZ2dkUFhZadXqllPJLIlLW03va5aKUUgFCA10ppQKEBrpSSgUIDXSllAoQGuhKKRUgNNCVUipAaKArpVSA0ED3czvKT7H+4HGry1BK+QANdD/W7jR878Ut/POKHVaXopTyAW4HuoiEishWEXmzm/ciReQVESkWkQ0iku3JIlX33tt7jPKTjZSdOENjS7vV5SilLNaXK/QfA3t7eO9e4KQxZgTwO+BX/S1M9W7x6hIAjIHiqtMWV6OUsppbgS4iGcD1wDM9NJkHLHM9Xw5cJSLS//JUT3ZX1LKh5AS3Th4GQNGxeosrUkpZzd0r9P8EHgCcPbyfDhwGMMa0AbXAkH5Xp3q0ZE0pMRGhPPDVkUSEhbBfA12poNdroIvIHKDKGLP5Qs26ee0Lu0+LyCIRKRSRwurq6j6Uqc5VXd/Mym0VzJ+UwaDYCEYkx2mgK6XcukKfAcwVkVLgZeBKEXmhS5tyYBiAiIQBCcCJrgcyxjxljCkwxhQkJ3e7nK9yw4sbymhpd7JgejYAjlQb+ys10JUKdr0GujHmQWNMhjEmG7gF+MAY860uzVYCd7mez3e1+cIVuuq/5rZ2Xlh/iNmOZHKT4wDIs8dRUdtEXVOrxdUppax00fPQReQxEZnr+vJZYIiIFAP/APyzJ4pTX/Tm9qPUnG7mnpk5Z19z2G0AHNBuF6WCWp92LDLGfAR85Hr+8DmvNwE3e7Iw9UXGGBavKSEvJY6ZI5LOvp7vCvSiytNMyhpsVXlKKYvpnaJ+ZFPpSXZX1HH3jBzOnRWanhhNbESoDowqFeQ00P3I4tUlJMaE87UJ6ee9HhIi5NltGuhKBTkNdD9x+MQZ3t1TyW2TM4mOCP3C+/l2nbqoVLDTQPcTy9aWEiLCHdOyun0/326j5nQLNaebB7gypZSv0ED3A6eb23il8DDXXjKUoQnR3bZxpHYMjOpVulLBSwPdD6zYXE59Uxv3zMjusc3nUxd1kS6lgpUGuo9zOg1L15YyITORCZmDemyXbIskITpcF+lSKohpoPu4j/ZXUVLTwN0zci7YTkRw2HUJAKWCmQa6j1u8upTU+CiuHZvaa9v81DiKjtWjqy4oFZw00H1YUWU9q4truHN6FuGhvf9f5bDbqG9qo7KuaQCqU0r5Gg10H7Z0bQlR4SHcelmmW+07lwDYrwOjSgUlDXQfdaKhhde2HOFrEzrWPHfH2UDXfnSlgpIGuo96aeMhmtucF5yq2NWg2AiSbZE600WpIKWB7oNa2508t66UWXlJ5Lmuut3l0DVdlApaGug+aNXOoxyra+aeXqYqdiffbuPAsdM4nTrTRalgo4HugxavKSU3KZYr8vu+TZ8jNY7G1nbKTzZ6oTKllC9zZ5PoKBHZKCLbRWS3iDzaTZsFIlItIttcj4XeKTfwbTl0ku2HT3H3jGxCQrrbe/vCOrtotB9dqeDjzhV6M3ClMWY8cClwjYhM7abdK8aYS12PZzxaZRBZvLoEW1QYX5+YcVHfn5fSsc+o9qMrFXzc2STaGGM6JzaHux7aQesFFacaeWtXJbdOziQ2sk+7A55liwonPTGaIp26qFTQcasPXURCRWQbUAX83RizoZtmN4nIDhFZLiLDejjOIhEpFJHC6urqfpQdmJ5bV4Yxhjt7WPPcXY5UnemiVDByK9CNMe3GmEuBDGCyiIzt0uQNINsYMw54D1jWw3GeMsYUGGMKkpP7PuAXyBpb2nlp4yG+OiaVjEEx/TpWvt3GweoGWtudHqpOKeUP+jTLxRhzCvgIuKbL68eNMZ1b5TwNTPJIdUHkta3l1Da2cs/Mvk9V7CrfHkdLu5Oy4w0eqEwp5S/cmeWSLCKJrufRwNXAvi5thp7z5VxgryeLDHTGGJasKeWS9AQKsnpe89xdnUsAFFXqmi5KBRN3rtCHAh+KyA5gEx196G+KyGMiMtfV5keuKY3bgR8BC7xTbmD69EANxVWnuXtGNiJ9n6rY1YiUOEJEpy4qFWx6nUphjNkBTOjm9YfPef4g8KBnSwsei9eUkGyL5PpxQ3tv7Iao8FCyh8TqIl1KBRm9U9RixVWn+aiomjumZhEZFuqx4+bbbeyv0kBXKphooFts2dpSIsJCuG2Ke2ueuyvfHkdpTQNNre0ePa5SyndpoFuo9kwryzeXM298GklxkR49dn6qDaeBz6p1YFSpYKGBbqGXNx2isbW91w2gL4bj7O5F2u2iVLDQQLdIW7uT59aVMS13CKPT4j1+/OykWMJDRacuKhVENNAt8u6eYxw51cjdfdiRqC/CQ0MYnhzHAb1CVypoaKBbZPHqEjIHx3DVKLvXzpFnt+lcdKWCiAa6BXaUn6Kw7CQLpmcTehFrnrvLYY+j/GQjp5vbvHYOpZTv0EC3wJI1pcRFhnFzwcWtee6uziUAtNtFqeCggT7AjtU18eaOCm4uyMAWFe7VczlSdaaLUsFEA32AvbC+jDanYcH0bK+fa9igGKLCQ9h/TGe6KBUMNNAHUFNrOy9uOMRVI+1kDYn1+vlCQoS8FN3sQqlgoYE+gFZuq+BEQwv3zMwesHPm2226HZ1SQUIDfYAYY1i8poSRqTam5Q4ZsPM6UuOoqm/mZEPLgJ1TKWUNDfQBsu7gcfZV1nPPzByPrHnurnxdAkCpoOHOjkVRIrJRRLa7NrF4tJs2kSLyiogUi8gGEcn2RrH+bPHqUobERjB3fNqAnvfsTJcqHRhVKtC5c4XeDFxpjBkPXApcIyJTu7S5FzhpjBkB/A74lWfL9G9lxxt4f98xbp+SSVS459Y8d0dqfBS2yDDd7EKpINBroJsOnZd34a6H6dJsHrDM9Xw5cJUMZL+Cj1u6tpSwEOFbU7MG/NwiQn6qLgGgVDBwqw9dREJFZBtQRceeohu6NEkHDgMYY9qAWuALI38iskhECkWksLq6un+V+4n6plb+t7CcOePSSImPsqSGfHvH1EVjuv53WCkVSNwKdGNMuzHmUiADmCwiY7s06e5q/AvpYYx5yhhTYIwpSE5O7nu1fujVwnJON7dxjxfWPHeXwx7HqTOtVNc3W1aDUsr7+jTLxRhzCvgIuKbLW+XAMAARCQMSgBMeqM+vtTsNy9aWcln2IC7JSLCsjvyzSwDowKhSgcydWS7JIpLoeh4NXA3s69JsJXCX6/l84AOjf9/z/t5jHDpxxis7EvVF59RF7UdXKrCFudFmKLBMRELp+A/Aq8aYN0XkMaDQGLMSeBZ4XkSK6bgyv8VrFfuRxWtKSE+M5iujvbfmuTuS4iIZEhuhM12UCnC9BroxZgcwoZvXHz7neRNws2dL8297KupYf/AED103krBQ6+/fytfNLpQKeNYnTR8dOdXIP7y6jdKaBqtLuaAla0qIDg/lmwWZVpcCdNxgdEBnuigV0Pwu0HeWn2LVzqNc9duPefC1HVScarS6pC+oOd3M69sqmD8pg4QY76557q58u42GlnaO+ODnpZTyDL8L9GvGDuWTf5zNt6ZksnxzOV/6zUc89sYeak77zpS8P284REu7kwVe2gD6YuTb4wBd00WpQOZ3gQ6QEh/Fo/PG8sFPv8S88WksXVvC5b/+kMff2UftmVZLa2tua+f59WXMdiQzPDnO0lrOldc506VSpy4qFaj8MtA7DRscw+M3j+fv/3AFV45M4Y8ffsasX3/AEx8coMGijZH/tuMo1fXNlk9V7CohOpyhCVF6ha5UAPPrQO80PDmOJ26byKofzWJyzmB+8+5+Lv/1hzy7uoSm1vYBq6NzzfMRKXHMyksasPO6Sze7UCqwBUSgdxqdFs8zd13Ga9+bjiPVxi/e3MPs33zEnzccorXd6fXzF5adZNeROu6ZMbBrnrvLkWqjuPo07U6d6aJUIAqoQO80MXMQf/72VP68cAqpCVE89JedXP3bj/nr1iNeDbPFq0tIjAnnaxPSvXaO/shLiaOlzUnZcd+e8qmUujgBGeidpo9I4rXvTufZuwqIiQjj/le2ce3vP+HtXZUen499+MQZ3tldya2TM4mOGNg1z911drML7UdXKiAFdKBDx3rgV42y87cfzuSJ2ybQ5jTc98Jm5v1xDR/vr/ZYsD+/vgwR4c5pA7/mubtGpMQhojNdlApUAR/onUJChDnj0nj3/sv59fxxHD/dwl2LN/LNp9azqbR/C0M2NLfx0sZDXDs2laEJ0R6q2PNiIsLIHByjV+hKBaigCfROYaEhfKNgGB/87AoemzeGkpoGbn5yHXct3sjO8tqLOuaKLeXUN7Vxz0zfmqrYnbwUmwa6UgEq6AK9U2RYKHdOy+aTf5zNg9eOZHv5KW54YjX3Pb+5T4HndBqWrinl0mGJTMwc5MWKPcORGkdJTQPNbQM3nVMpNTCCNtA7RUeE8p0rhvPJA7P58VV5rC6u4av/+Qk/eWWbW7NBPt5fzcGaBu72odv8LyTfbqPNaSjx8cXNlFJ9F/SB3ik+KpyffDmfTx6YzaJZuR0LgP3Hxzz0l50cre15QavFa0qwx0dy3SVDB7Dai9c500VvMFIq8GigdzE4NoIHrxvFJw/M5tbJmfxv4WGuePwjfvHmHo53WQBs/7F6Pj1Qw53Tsgn3gTXP3ZGbFEdYiGg/ulIByJ0t6IaJyIcisldEdovIj7tp8yURqRWRba7Hw90dy5/Y46P4xY0dC4DNHZ/GkjUlzPr1h/zHu0XUNnYsALZkTSmRYSHcNtk31jx3R0RYCNlJsbq/qFIByJ0t6NqAnxpjtoiIDdgsIn83xuzp0u5TY8wcz5dorWGDY/jNzeO574rh/O7v+/mvD4pZtraUe2bm8NqWcr4+MZ1BsRFWl9knDruNXRUXN6NHKeW7er1CN8YcNcZscT2vB/YCvnlvuxeNSInjj7dP5M0fzqQgezD/+d4BmtucPreqojvy7TYOnTjDmRZrVqRUSnmHO1foZ4lINh37i27o5u1pIrIdqAB+ZozZ3c33LwIWAWRm+k83xbnGpieweMFlbC47ydHaRvJd64z7E0dqHMZAcdVpxmUkWl2OUspD3B7JE5E4YAVwvzGmrsvbW4AsY8x44L+Av3Z3DGPMU8aYAmNMQXJy8sXW7BMmZQ1izrg0q8u4KPl2nemiVCByK9BFJJyOMH/RGPNa1/eNMXXGmNOu56uAcBHxvQXBFQBZQ2KJCAvhQJUOjCoVSNyZ5SLAs8BeY8xve2iT6mqHiEx2Hfe4JwtVnhMaIoxIjtMrdKUCjDt96DOAO4CdIrLN9dpDQCaAMeZJYD7wXRFpAxqBW4yn16dVHuVItbH+oP43V6lA0mugG2NWAxfcfscY8wTwhKeKUt6Xb7fxl61HqG1sJSE63OpylFIe4B+3NyqPc6TGAXBA7xhVKmBooAepvJTO3Yt0YFSpQKGBHqTSE6OJjQjVNV2UCiAa6EEqJETIs9t0potSAUQDPYg57Lp7kVKBRAM9iOWn2jje0EJNl2WBlVL+SQM9iOXbO2a66FW6UoFBAz2IOVxruuzXfnSlAoIGehBLtkWSGBNOkU5dVCogaKAHMREhXwdGlQoYGuhBzmG3sb+yHl16Ryn/p4Ee5PLtcdQ3t1FZ12R1KUqpftJAD3K62YVSgUMDPch1Brr2oyvl/zTQg9yg2AhSbJEUVepMF6X8nTs7Fg0TkQ9FZK+I7BaRH3fTRkTkDyJSLCI7RGSid8pV3uBI1ZkuSgUCd67Q24CfGmNGAVOB74vI6C5trgXyXI9FwP94tErlVXkpNg5U1eN06kwXpfxZr4FujDlqjNniel4P7AXSuzSbBzxnOqwHEkVkqMerVV7hSI2jqdXJ4ZNnrC5FKdUPfepDF5FsYAKwoctb6cDhc74u54uhj4gsEpFCESmsrq7uW6XKa3Smi1KBwe1AF5E4YAVwvzGmruvb3XzLF/5+N8Y8ZYwpMMYUJCcn961S5TV5OtNFqYDgVqCLSDgdYf6iMea1bpqUA8PO+ToDqOh/eWogxEWGkTEoWtd0UcrPuTPLRYBngb3GmN/20GwlcKdrtstUoNYYc9SDdSovy7fbdMNopfxcmBttZgB3ADtFZJvrtYeATABjzJPAKuA6oBg4A9zt+VKVN+XbbXx6oJrWdifhoXp7gvIsYwwd14bKm3oNdGPMarrvIz+3jQG+76mi1MBzpMbR2m4orWk426euVH81tbZz/8vbqKht5C/fm0FoiIa6N+mlmALOmemi3S7KQ+qaWrnz2Y28vbuSHeW1vLu70uqSAp4GugJgeHIcIaK7FynPqK5v5pY/rWfr4ZP8/pZLyRwcw58+OajLNHuZBroCICo8lOwhsezXmS6qnw6fOMM3/rSOkpoGnrnrMuZdms7CWTlsO3yKzWUnrS4voGmgq7N09yLVXweO1XPzk+s4frqZFxZO5or8jvtN5k/KICE6nKc/PWhxhYFNA12dlZ9qo/R4A02t7VaXovzQtsOnuPlP62g3hle+M41JWYPPvhcTEcYdU7N4d88xSmoaLKwysGmgq7McdhtOA8VV2u2i+mb1gRpue3o98VHhrLhvOqOGxn+hzZ3TswgPCeHZ1XqV7i0a6OosR2ocoEsAqL55e9dR7lm6iczBMSy/bxqZQ2K6bZdii+LGCWks31zOiYaWAa4yOGigq7OyhsQSHio6MKrc9sqmQ3zvxS2MTY/nlUXTSImPumD7hbNyaWp18sL6sgGqMLhooKuzwkNDGJ4cp1foyi1/+vgz/mnFTmbmJfPCwikkxIT3+j35dhuzHck8t65Ux2q8QANdnSffbtNldNUFGWP45Vv7+H9v7WPOuKE8c2cBMRHurCLS4duX51JzuoW/bj3ixSqDkwa6Oo8j1caRU43UN7VaXYryQe1Ow0N/2cmTH3/G7VMy+f0tE4gI61uMTMsdwpi0eJ7+9KDukuVhGujqPJ1LABzQmS6qi+a2dn740hZe2niYH8wewb/eOPai1mYRERZdnstn1Q18WFTlhUqDlwa6Ok++vWOmiy6lq87V0NzGwmWFrNpZyc+vH8XPvuro1+qJ110ylLSEKJ76RKcwepIGujrPsEExRIWHUFSpV+iqw6kzLdz+zAbWfnacx+ePY+Gs3H4fMzw0hLtn5LCh5AQ7yk95oEoFGuiqi5AQ0SUA1FmVtU1840/r2HO0jv+5fSI3Fwzr/ZvcdMvkYdgiw3j60xKPHTPYubNj0WIRqRKRXT28/yURqRWRba7Hw54vUw2kfLtNl9FVlNY0MP/JtRw52cjSuy/jK2NSPXp8W1Q4t07JZNXOo5SfPOPRYwcrd67QlwLX9NLmU2PMpa7HY/0vS1kp3x5HdX0zJ/VuvqC1p6KO+U+u40xLOy8tmsr04UleOc+C6dkIsGRNqVeOH2x6DXRjzCfAiQGoRfmIzpku2u1ycRpb2ln7WQ2nm9usLuWibCo9wTefWkd4qPDqd6YxLiPRa+dKS4xmzrihvLzxELWNOlW2vzzVhz5NRLaLyFsiMqanRiKySEQKRaSwurraQ6dWnuZI1UC/GBWnGvnlW/uY9sv3ue3pDVz2r+/xk1e2saa4xm/mW3+4r4o7nt1Asi2S5d+dzoiUOK+fc+GsXBpa2nlp4yGvnyvQuX97V8+2AFnGmNMich3wVyCvu4bGmKeApwAKCgr84yc8CKXGR2GLCtN+dDcYYygsO8nSNaW8vbsSYwxfHm3nhvFprP3sOG9sr+AvW4+QlhDF1ydmcNOkDHKSYq0uu1uvbzvCT1/dzsihNpbdPZkhcZEDct6x6QnMGDGEJWtKuGdGTp9vVFKf63egG2Pqznm+SkT+W0SSjDE1/T22soaI4LDb2K9TF3vU3NbOm9uPsmRtCbuO1BEfFca9M3O4Y2oWwwZ3rDY4Z1waD88Zzd/3HGP55nL++6NinviwmElZg7hpYgbXjxtKQnTv658MhOfWlfLIyt1Mzh7MM3cVYIsa2LoWzsrl7iWbeHNHBV+fmDGg5w4k/Q50EUkFjhljjIhMpqMb53i/K1OWyrPbWLXzKMaYft1AEmiq6pp4YcMh/ryhjJrTLYxIieNfbxzL1yemd7ueSVR4KDeMT+OG8Wkcq2viL1uPsGJzOQ/9ZSePvrGbr4xJ5aaJ6czKS76ouy77yxjDH94v5nfv7efqUXaeuG0CUeGhA17Hl/KTyUuJ46lPDvK1Cen6M3eReg10EXkJ+BKQJCLlwCNAOIAx5klgPvBdEWkDGoFbjO4E6/cc9jhe2thKdX1zr0uiBoPth0+xZE0Jf9t5lNZ2w5UjU7h7RjYzRyS5HT72+Cjuu2I437k8l51Halm+uZyV2yt4Y3sF9vhIbpyQzvyJGeS5BqW9zek0PPbmHpauLeWmiRn86qZLCAu1prtDRPj25bk8sHwHq4trmJWXbEkd/k6syt6CggJTWFhoyblV79Z+VsNtT2/g+XsnB+0vV2u7k7d2VbJ0TQlbDp0iLjKM+ZMyuGt6tsf6wZvb2vlgbxUrtpTzYVE17U7D+IwEbpqUwdzxaSTGRHjkPF21tjv5p+U7eG3rEe6ZkcPPrx9FiAV/IZyrua2dmb/6kFFD43nunsmW1uLLRGSzMaagu/c8MSiqApDDdZVYVFkfdIF+/HQzL286zPPryqisayJrSAwPzxnNzQUZHu9bjgwL5dpLhnLtJUOprm/m9W1HWL65nIdf382/vrmXq0alMH9SBpfnJxPuoavnptZ2fvDnLby3t4qffSWf788e4RNdHJFhoSyYns3j7xSx92hdt9vYqQvTQFfdGhIXSVJcRFBNXdxTUcfStSX8dVsFLW1OZuUl8W9fG8tsR8qAXL0m2yJZOCuXhbNy2V1Ry4rNR3h92xHe2lVJUlwEN16azk2TMvoVdHVNrSxcVsim0hP84sax3DE1y4P/gv67fUomT3xQzDOflvAf3xhvdTl+RwNd9SgvxUZRgG9H1+40/H3PMZasKWFDyQmiwkOYPymDu6dnD1hfdnfGpCUwJi2BB68byUdF1azYXM6ydaU8s7qEMWnx3DQxg3mXpvVpamHN6WbuWryRosp6fn/LBOaOT/PeP+AiJcZE8M3LhvHihjIeuMaBXcdv+kQDXfXIkWrjfwsP43Qay/tXPa32TCuvFB5i2doyjpxqJD0xmgevHck3LxvmtX7rixEeGsKXR9v58mg7JxpaeGN7Bcs3l/PYm3v491V7mT0yhZsmZnDlyJQLzt8uP3mGO5/dSEVtI0/fVcBsR8oA/iv65p4ZOTy3rpSla0v5p2tGWl2OX9FAVz3Kt9toaGnnyKnGs3Or/V1xVT1L1pTy2pYjNLa2MzlnMP93ziiuHmW3bIaHuwbHRnDX9Gzump7N/mP1rNhczmtbj/D3PccYFBPOvEvTmT8pgzFp8ef1iRdX1XPHsxtpaG7jhXunUJA92MJ/Re8yh8RwzdhUXlxfxvdnjyAuUmPKXfpJqR45Ujtu+95/rN6vA93pNHy0v4ola0r59EANEWEhzBufxoIZ2YxJS7C6vIuSb7fx4HWj+MevOvi0uIblm8v588ZDLF1bisNu46ZJ6dw4IZ2jp5pYsGQjoSEhvPKdaX4z0PjtWbms2lnJq5sOc8/MHKvL8Rsa6KpHnX3IRcfquWqU3eJq+u50cxvLCw+zbF0ZJTUN2OMj+dlX8rl1cuaA3dbubWGhIcx2pDDbkULtmVbe2FHBii3l/Puqffzq7SLCQoSU+EheuHcKWUN8c8mB7kzIHMRl2YNYvKaEO6dl+fxfT75CA131KD4qnKEJUeyv9K+ZLmXHG1i6tpT/LSzndHMbEzIT+f0tl3LdJUM9NvXPFyXEhPOtqVl8a2oWn1WfZsXmcoqrTvOLG8f65eDiwlm5fOf5zby9u5I543xvANcXaaCrC+rYvcg/Zrq0tDn5yavbWLXzKGEhwvWXDGXBjBwuHea95V991fDkOB7w8wHFq0fZyUmK5elPDnL9JUN9Yq68r9NAVxfkSLWx7uBx2tqdPv9n75I1Jfxtx1G+c0Uu987I0SUL/FxoiHDvzBx+/tddbCo9yeQc3x7M9QW+/RuqLJdvt9HS5qTshG9vEVZZ28Qf3j/A1aNSePDaURrmAeKmiRkMignnqU8OWl2KX9BAVxfUuQSAr/ej/7+39tLqNDw8p8f9VZQfio4I5Y5p2by39xifVftH15+VNNDVBY1IiUMEn97sYv3B47y+rYL7rhhO5hD/nV6punfntCwiwkJ45tMSq0vxeRro6oKiI0LJHBzDAR8dGG1rd/LI67tJT4zmu1cMt7oc5QVJcZHcNDGD17aUU3O62epyfJoGuupVvt3ms1foz68vo+hYPf93zmiiIwZ+YwY1MO6dmUNzm5Pn15VZXYpP00BXvXLYbZTUNNDc1m51Keeprm/mt+/uZ1ZeEl8d4383Pin3jUiJ4+pRKTy/voymVt/6OfQlvQa6iCwWkSoR2dXD+yIifxCRYhHZISITPV+mslJ+qo12p+FgdYPVpZznV2/vo6mtnX+ZO0bnKAeBb8/K5URDCyu2lFtdis9y5wp9KXDNBd6/FshzPRYB/9P/spQvybd/vqaLr9hcdpLlm8u5d2Yuw5PjrC5HDYDJOYMZl5HAM5+W4HTqLpfd6TXQjTGfACcu0GQe8JzpsB5IFJGhnipQWS83KY6wEPGZQG93Gh5ZuQt7fCQ/vHKE1eWoASIifHtWLiU1Dby395jV5fgkT/ShpwOHz/m63PXaF4jIIhEpFJHC6upqD5xaDYSIsBBykmIpqvSNmS4vb6Al178AAA4+SURBVDrEriN1/J/rRxOrS6sGlWvHppKeGK1TGHvgiUDvrvOy27+HjDFPGWMKjDEFycnBtU+lv8tPtfnEFfrJhhYef6eIqbmDuWGc/iEYbMJCQ7h3Zg4bS0+w9dBJq8vxOZ4I9HJg2DlfZwAVHjiu8iEOu41DJ85wpqXN0joef7eI+qY2Hp07VgdCg9Q3LhuGLSpMr9K74YlAXwnc6ZrtMhWoNcYc9cBxlQ/pHBgtrrKu22VneS0vbTzEXdOycaRat9+nslZcZBi3T8nirV1HOezjawwNNHemLb4ErAMcIlIuIveKyH0icp+rySrgIFAMPA18z2vVKsvkd252YdGaLk6n4eGVuxgSG8H9X86zpAblOxZMzyY0RHh2tV6ln6vXESVjzK29vG+A73usIuWTsobEEhEWYlk/+oot5Ww9dIrf3Dye+KhwS2pQviM1IYobxqfxauFh7r86z6c29raS3imq3BIaIuSlxFFkwZoutY2t/PKtfUzKGsTXJ3Q7gUoFoW/PyuVMSzsvbjhkdSk+QwNduc1ht1myjO7v/r6fE2daeHTuGEJCdCBUdRg1NJ5ZeUksW1vqc8tSWEUDXbktz26jsq6J2sbWATvn3qN1PLeulNunZDI2PWHAzqv8w6LLc6mqb2blNp1YBxroqg8cqR0zXQ4MUD+6MYZHVu4mITqcn33FMSDnVP5l5ogkRqbaePrTg3QM5wU3DXTltrMzXQYo0Fdur2BjyQkeuGakDnqpbnUuB7D/2Gk+3q93n2ugK7elJ0YTGxE6IP3op5vb+PdVexmXkcA3Cob1/g0qaN0wPg17fKTeaIQGuuoDESE/dWA2u/iv9w9wrK6ZR+eOIVQHQtUFRISFsGB6DquLa9hdUWt1OZbSQFd9kp9i8/p2dMVVp3l2dQnfKMhgQuYgr55LBYbbpmQSGxEa9FfpGuiqT/JTbRxvaPHa3o7GGP5l5W5iIkJ54JqRXjmHCjwJ0eF887JM3thewdHaRqvLsYwGuuoTh2tg1Fv96O/srmR1cQ0//YqDpLhIr5xDBaa7Z2RjgKVrSq0uxTIa6KpP8l1TF73Rj97Y0s4v3tzLyFQbt0/J9PjxVWAbNjiGa8em8ucNh6hvGrh7JXyJBrrqk+S4SAbFhHtlTZf//qiYI6caeWzeWMJC9UdT9d2iy3Opb27jlU2He28cgPS3RvWJiJBnt7HfwwOjpTUN/Onjg9x4aRqTcwZ79NgqeIzLSGRKzmCWrCmltd1pdTkDTgNd9Vnnmi6evDPvF2/uITxUeOi6UR47pgpO356Vy5FTjazaGXzbMmigqz7LT7VR39zG0domjxzv/b3HeH9fFfdfnU9KfJRHjqmC15UjU8hNjg3K5QDcCnQRuUZEikSkWET+uZv3F4hItYhscz0Wer5U5SscHlwCoKm1nUff2MOIlDgWzMju9/GUCgnpWA5g15E61h88YXU5A8qdHYtCgT8C1wKjgVtFZHQ3TV8xxlzqejzj4TqVD+ncjs4TUxef/uQgh06c4V9uGEO4DoQqD/nahHSS4iJ4+tODVpcyoNz5DZoMFBtjDhpjWoCXgXneLUv5ssSYCFJskf0eGC0/eYY/flTMdZekMjMvyUPVKQVR4aHcMTWbD/ZVUVxlzS5bVnAn0NOBc+cAlbte6+omEdkhIstFpNvVlERkkYgUikhhdbWujObPHKm2fk9d/Le/7UUQ/s/13f3Bp1T/3DEti8iwkKBaDsCdQO9uZaSuIw1vANnGmHHAe8Cy7g5kjHnKGFNgjClITk7uW6XKp+TbbRyoqqfdeXGDTp8eqOatXZX84MoRpCdGe7g6pWBwbAQ3F2Tw2pYjVNV7ZgDf17kT6OXAuVfcGcB524MYY44bYzoX93gamOSZ8pSvcthtNLU6OXziTJ+/t6XNySMrd5M9JIaFs3K8UJ1SHe6dmUur08nz68qsLmVAuBPom4A8EckRkQjgFmDluQ1EZOg5X84F9nquROWL8uwXvwTAkjUlHKxu4JEbxhAZFurp0pQ6Kycpli+PsvP8+jIaWwJ/39FeA90Y0wb8AHiHjqB+1RizW0QeE5G5rmY/EpHdIrId+BGwwFsFK9+Q55q62Nft6Cprm/jD+we4epSd2SNTvFGaUudZdHkup860snxz4C8HEOZOI2PMKmBVl9cePuf5g8CDni1N+bK4yDAyBkVT1MeZLv++ai+tTsPDc3QgVA2MSVmDmJCZyDOrS7htSlZAb5iiE3/VRetcAsBd6w8eZ+X2Cu67YjiZQ2K8WJlSn+vcd7Ts+Ble33YE50UO5PsDt67QlepOfqqNj/dX09LmJCLswtcGbe1OHnl9N+mJ0Xz3iuEDVKFSHb46JpXsITH8w6vb+flfd5FvtzEytePhSI1nZKqNQbH+vxG5Brq6aPn2ONqchtLjDeS7+tR78vz6MoqO1fPktyYRHaEDoWpghYYIr35nGh8WVbH3aD1FlfW8s7uSl89ZZtceH8lIV7iPHGrDYY9neEqsXw3ca6Cri9YZ4vuP1V8w0Kvrm/ntu/u5PD+Zr46xD1R5Sp0nJT6Kb172+cYpxhiq65vZV1nPvsq6jv89Ws+6z47T4lp6NyxEyE2OPXsV3xH28aQlRCHie33xGujqog1PjiNEXGu6jOu53a/e3kdTWzuP3DDaJ38JVHASEVLio0iJj+Ly/M9vdGxtd1Ja03A26Isq69lSdpI3tn9++40tKszVXWM7e1Wfn2ojPircin/KWRro6qJFhYeSnRR7wbnom8tOsnxzOfddMZzhyXEDWJ1SFyc8NIQ8u408u40bxqedfb2uqZX9lfXsq+zostlXWcfr2yp4oenQ2TbpidGfd9mkxjMq1UZOUuyA7cClga76xWG3sa+HmS7tTsMjK3eRGh/FD68cMcCVKeVZ8VHhFGQPpiD78x21jDFU1DZRVFl3tm9+X2UdH++vps01myYiNIQRKXGfX9EPjWdMWrxXNkHXQFf9kme38fbuSppa24kKP3/w6OVNh9h1pI7/unUCsZH6o6YCj4iQnhhNemI0V478fHyoua2dz6oaKDpWx76jHVf1az87zmtbjwCwcGYOP/fCvRj6W6b6xWG3YQwUV51mbHrC2ddPNrTw+DtFTM0dzJxxQy9wBKUCT2RYKKPT4hmdFg8TPn/91JkW9lXWkxTnnSmSemOR6hdHqmuziy796I+/W0R9UxuPzh2rA6FKuSTGRDA1dwgjUi48zfdiaaCrfskaEktEaMh5A6M7y2t5aeMh7pqWjSPVOz+4Sqkv0kBX/RIeGkJucuzZJQCcTsPDK3cxJDaS+7+cZ3F1SgUXDXTVb/l229nt6FZsKWfroVM8eO1Iy+fkKhVsNNBVvzlSbRw51UjFqUZ++dY+JmUN4msTutulUCnlTTrLRfVb523/P3xpKyfOtLBs7mRCAniJUqV8lVtX6CJyjYgUiUixiPxzN+9Hisgrrvc3iEi2pwtVvsvhCvTNZSe5fUrmedMXlVIDp9dAF5FQ4I/AtcBo4FYR6Toj/l7gpDFmBPA74FeeLlT5roxB0USHhzIoJpyffcVhdTlKBS13ulwmA8XGmIMAIvIyMA/Yc06becC/uJ4vB54QETHGBO5K8uqskBDhwetGkjk4hsQY/19TWil/5U6gpwPnbsZXDkzpqY0xpk1EaoEhQI0nilS+785p2VaXoFTQc6cPvbvRra5X3u60QUQWiUihiBRWV1e7U59SSik3uRPo5cCwc77OACp6aiMiYUACcKLrgYwxTxljCowxBcnJyV3fVkop1Q/uBPomIE9EckQkArgFWNmlzUrgLtfz+cAH2n+ulFIDq9c+dFef+A+Ad4BQYLExZreIPAYUGmNWAs8Cz4tIMR1X5rd4s2illFJf5NaNRcaYVcCqLq89fM7zJuBmz5amlFKqL/TWf6WUChAa6EopFSA00JVSKkCIVZNRRKQaKLvIb09Cb1o6l34e59PP43P6WZwvED6PLGNMt/O+LQv0/hCRQmNMgdV1+Ar9PM6nn8fn9LM4X6B/HtrlopRSAUIDXSmlAoS/BvpTVhfgY/TzOJ9+Hp/Tz+J8Af15+GUfulJKqS/y1yt0pZRSXWigK6VUgPC7QO9tf9NgIiLDRORDEdkrIrtF5MdW12Q1EQkVka0i8qbVtVhNRBJFZLmI7HP9jEyzuiariMhPXL8ju0TkJRGJsromb/CrQHdzf9Ng0gb81BgzCpgKfD/IPw+AHwN7rS7CR/weeNsYMxIYT5B+LiKSDvwIKDDGjKVj1diAXBHWrwKdc/Y3Nca0AJ37mwYlY8xRY8wW1/N6On5h062tyjoikgFcDzxjdS1WE5F44HI6lrbGGNNijDllbVWWCgOiXRvwxPDFTXoCgr8Fenf7mwZtgJ1LRLKBCcAGayux1H8CDwBOqwvxAblANbDE1QX1jIjEWl2UFYwxR4DfAIeAo0CtMeZda6vyDn8LdLf2Lg02IhIHrADuN8bUWV2PFURkDlBljNlsdS0+IgyYCPyPMWYC0AAE5ZiTiAyi4y/5HCANiBWRb1lblXf4W6C7s79pUBGRcDrC/EVjzGtW12OhGcBcESmloyvuShF5wdqSLFUOlBtjOv9iW05HwAejq4ESY0y1MaYVeA2YbnFNXuFvge7O/qZBQ0SEjj7SvcaY31pdj5WMMQ8aYzKMMdl0/Fx8YIwJyKswdxhjKoHDIuJwvXQVsMfCkqx0CJgqIjGu35mrCNABYre2oPMVPe1vanFZVpoB3AHsFJFtrtcecm0ZqNQPgRddFz8HgbstrscSxpgNIrIc2ELHzLCtBOgSAHrrv1JKBQh/63JRSinVAw10pZQKEBroSikVIDTQlVIqQGigK6VUgNBAV0qpAKGBrpRSAeL/A1hqVjS3Ia81AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "plt.plot(loss_plot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluation : Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Copied as it is from 60 min blitz\n",
    "confusion = torch.zeros(n_class, n_class)\n",
    "n_confusion = 10000\n",
    "all_categories=class_list\n",
    "n_categories = n_class\n",
    "# Just return an output given a line\n",
    "def evaluate(line_tensor):\n",
    "    with torch.no_grad():\n",
    "        hidden = rnn.init_hidden().to(device)\n",
    "\n",
    "        for i in range(line_tensor.size()[0]):\n",
    "            output, hidden = rnn(line_tensor[i], hidden)\n",
    "\n",
    "    return output\n",
    "\n",
    "# Go through a bunch of examples and record which are correctly guessed\n",
    "for i in range(n_confusion):\n",
    "    category, line, line_tensor,category_tensor = makeRandomExampleTensor()\n",
    "    #print(line_tensor)\n",
    "    output = evaluate(line_tensor.to(device))\n",
    "    guess, guess_i = predictClass(output)\n",
    "    category_i = all_categories.index(category)\n",
    "    confusion[category_i][guess_i] += 1\n",
    "\n",
    "# Normalize by dividing every row by its sum\n",
    "for i in range(n_categories):\n",
    "    confusion[i] = confusion[i] / confusion[i].sum()\n",
    "\n",
    "# Set up plot\n",
    "fig = plt.figure(figsize=(15,15))\n",
    "ax = fig.add_subplot(111)\n",
    "cax = ax.matshow(confusion.numpy())\n",
    "fig.colorbar(cax)\n",
    "\n",
    "# Set up axes\n",
    "ax.set_xticklabels([''] + all_categories, rotation=90)\n",
    "ax.set_yticklabels([''] + all_categories)\n",
    "\n",
    "# Force label at every tick\n",
    "ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "\n",
    "# sphinx_gallery_thumbnail_number = 2\n",
    "plt.show()"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}