train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import tensorflow as tf\n",
    "from PIL import Image\n",
    "import os\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.utils import to_categorical\n",
    "from keras.models import Sequential, load_model\n",
    "from keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "labels = []\n",
    "classes = 43\n",
    "cur_path = os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Retrieving the images and their labels \n",
    "for i in range(classes):\n",
    "    path = os.path.join(cur_path,'data\\\\train',str(i))\n",
    "    images = os.listdir(path)\n",
    "    for a in images:\n",
    "        try:\n",
    "            image = Image.open(path + '\\\\'+ a)\n",
    "            image = image.resize((30,30))\n",
    "            image = np.array(image)\n",
    "            #sim = Image.fromarray(image)\n",
    "            data.append(image)\n",
    "            labels.append(i)\n",
    "        except:\n",
    "            print(\"Error loading image\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting lists into numpy arrays\n",
    "data = np.array(data)\n",
    "labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(39209, 30, 30, 3) (39209,)\n"
     ]
    }
   ],
   "source": [
    "print(data.shape, labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(31367, 30, 30, 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7842, 30, 30, 3)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(31367,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting the labels into one hot encoding\n",
    "y_train = to_categorical(y_train, 43)\n",
    "y_test = to_categorical(y_test, 43)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    }
   ],
   "source": [
    "#Building the model\n",
    "model = Sequential()\n",
    "model.add(Conv2D(filters=32, kernel_size=(5,5), activation='relu', input_shape=X_train.shape[1:]))\n",
    "model.add(Conv2D(filters=32, kernel_size=(5,5), activation='relu'))\n",
    "model.add(MaxPool2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(rate=0.25))\n",
    "model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(Conv2D(filters=64, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(MaxPool2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(rate=0.25))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(256, activation='relu'))\n",
    "model.add(Dropout(rate=0.5))\n",
    "model.add(Dense(43, activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Compilation of the model\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Train on 31367 samples, validate on 7842 samples\n",
      "Epoch 1/15\n",
      "31367/31367 [==============================] - 254s 8ms/step - loss: 2.7454 - acc: 0.4175 - val_loss: 0.7551 - val_acc: 0.7988\n",
      "Epoch 2/15\n",
      "31367/31367 [==============================] - 276s 9ms/step - loss: 1.0087 - acc: 0.6934 - val_loss: 0.4204 - val_acc: 0.8799\n",
      "Epoch 3/15\n",
      "31367/31367 [==============================] - 281s 9ms/step - loss: 0.6479 - acc: 0.7970 - val_loss: 0.2635 - val_acc: 0.9166\n",
      "Epoch 4/15\n",
      "31367/31367 [==============================] - 278s 9ms/step - loss: 0.4788 - acc: 0.8520 - val_loss: 0.2034 - val_acc: 0.9359\n",
      "Epoch 5/15\n",
      "31367/31367 [==============================] - 260s 8ms/step - loss: 0.3898 - acc: 0.8805 - val_loss: 0.1726 - val_acc: 0.9449\n",
      "Epoch 6/15\n",
      "31367/31367 [==============================] - 256s 8ms/step - loss: 0.3453 - acc: 0.8920 - val_loss: 0.1370 - val_acc: 0.9578\n",
      "Epoch 7/15\n",
      "31367/31367 [==============================] - 251s 8ms/step - loss: 0.3228 - acc: 0.9016 - val_loss: 0.1367 - val_acc: 0.9593\n",
      "Epoch 8/15\n",
      "31367/31367 [==============================] - 252s 8ms/step - loss: 0.3023 - acc: 0.9102 - val_loss: 0.1107 - val_acc: 0.9661\n",
      "Epoch 9/15\n",
      "31367/31367 [==============================] - 253s 8ms/step - loss: 0.2668 - acc: 0.9207 - val_loss: 0.1790 - val_acc: 0.9440\n",
      "Epoch 10/15\n",
      "31367/31367 [==============================] - 259s 8ms/step - loss: 0.2785 - acc: 0.9176 - val_loss: 0.0891 - val_acc: 0.9727\n",
      "Epoch 11/15\n",
      "31367/31367 [==============================] - 263s 8ms/step - loss: 0.2598 - acc: 0.9256 - val_loss: 0.0894 - val_acc: 0.9737\n",
      "Epoch 12/15\n",
      "31367/31367 [==============================] - 244s 8ms/step - loss: 0.2496 - acc: 0.9274 - val_loss: 0.0708 - val_acc: 0.9801\n",
      "Epoch 13/15\n",
      "31367/31367 [==============================] - 241s 8ms/step - loss: 0.2451 - acc: 0.9305 - val_loss: 0.0747 - val_acc: 0.9787\n",
      "Epoch 14/15\n",
      "31367/31367 [==============================] - 238s 8ms/step - loss: 0.2485 - acc: 0.9290 - val_loss: 0.0783 - val_acc: 0.9781\n",
      "Epoch 15/15\n",
      "31367/31367 [==============================] - 253s 8ms/step - loss: 0.2678 - acc: 0.9249 - val_loss: 0.1658 - val_acc: 0.9503\n"
     ]
    }
   ],
   "source": [
    "epochs = 15\n",
    "history = model.fit(X_train, y_train, batch_size=32, epochs=epochs, validation_data=(X_test, y_test))\n",
    "model.save(\"my_model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xd8VfX9+PHXO3sQIIOdQFDZyoyIddRdtQpucRVwta5qvx2OX+vssC3dWltqRdyiOGhVQKyjVlSSAMreCWEGsndy7/v3x7m5XEISbkJu7k3u+/l43Me9Z9xz3zfjvM/5TFFVjDHGGICIYAdgjDEmdFhSMMYY42VJwRhjjJclBWOMMV6WFIwxxnhZUjDGGONlScEYY4yXJQUTNkTkIxEpFpHYYMdiTKiypGDCgohkAqcBCkztxM+N6qzPMqYjWFIw4eI7wOfAs8CMxpUiEi8ivxORPBEpFZFPRSTes+1UEflMREpEZIeIzPSs/0hEbvY5xkwR+dRnWUXkDhHZBGzyrPuT5xhlIpIjIqf57B8pIg+IyBYRKfdszxCRJ0Xkd75fQkT+JSL3BOIHZAxYUjDh4zvAi57Ht0Skn2f9bGAS8A0gBfgJ4BaRwcB7wF+APsB4YGUbPu8S4CRgtGd5uecYKcBLwGsiEufZ9n/ANcCFQE/gRqAKmAdcIyIRACKSBpwNvNyWL25MW1hSMN2eiJwKDAHmq2oOsAW41nOyvRG4W1V3qqpLVT9T1VrgOmCpqr6sqvWqekBV25IUfqWqRapaDaCqL3iO0aCqvwNigRGefW8GfqqqG9SxyrPvl0ApTiIAmA58pKp7j/JHYkyLLCmYcDADWKKq+z3LL3nWpQFxOEmiqYwW1vtrh++CiPxQRNZ5iqhKgF6ezz/SZ80Drve8vh54/ihiMuaIrBLMdGue+oGrgEgR2eNZHQv0BgYANcCxwKomb90BTG7hsJVAgs9y/2b28Q4/7Kk/uBfnin+NqrpFpBgQn886FljdzHFeAFaLyDhgFPBWCzEZ0yHsTsF0d5cALpyy/fGexyjgvzj1DM8AvxeRgZ4K35M9TVZfBM4RkatEJEpEUkVkvOeYK4HLRCRBRI4DbjpCDElAA1AIRInIgzh1B42eBh4TkWHiGCsiqQCqWoBTH/E8sKCxOMqYQLGkYLq7GcBcVc1X1T2ND+AJnHqD+4CvcU68RcCvgQhVzcep+P2hZ/1KYJznmH8A6oC9OMU7Lx4hhsU4ldYbgTycuxPf4qXfA/OBJUAZ8E8g3mf7POAErOjIdAKxSXaMCW0icjpOMVKmqrqDHY/p3uxOwZgQJiLRwN3A05YQTGewpGBMiBKRUUAJToX4H4McjgkTVnxkjDHGy+4UjDHGeAWsn4KIPANcBOxT1eOb2S7An3BaeFQBM1U190jHTUtL08zMzA6O1hhjurecnJz9qtrnSPsFsvPaszjN/p5rYfsFwDDP4yTgKc9zqzIzM8nOzu6gEI0xJjyISJ4/+wWs+EhVP8Fp392SacBznrFePgd6i8iAQMVjjDHmyIJZpzCIQzvwFHjWHUZEbhWRbBHJLiws7JTgjDEmHAUzKUgz65ptCqWqc1Q1S1Wz+vQ5YpGYMcaYdgpmUijAGR2yUTqwK0ixGGOMIbhJYSHwHc8AYFOAUlXdHcR4jDEm7AWySerLwBlAmogUAA8B0QCq+jfgXZzmqJtxmqTOClQsxhhj/BOwpKCq1xxhuwJ3BOrzjTHGtJ1NsmOMCS2uBqjYC+V7oHyX81y5HyKiIDIKImM8j+iDryNaWB8Z7bPcZH2EZ5tEgDTX7iU8WVIwxnQOVagqgvLdBx9lja99EkDFPlpoiBhAAhGRIJFOkojwPB/yuqVtvuvFWR44AabcDn2Gd/L3OHqWFIwxB6mC2wXuenA3eB4ucDVZbrrd3eDs46qDqgNNTvg+J35X3eGfmZAKSQOcR/+xznPPAQfXJQ2AxDRQ98HP8D7XeT67rsn6+kP3aXztbrq+wTmuupxnt8vz2vNzaNzm+9q7zfc97oOvXXWw6mXImQvDvgXfuBMyT+sydyOWFIwJJ243bHgHlj0J+zceftJXV8d9VnTiwZN7xhSfE31/SBroee4PUbF+HjDSKe45ZHrsEFW5H5b/E76cA/MuhgHj4OQ7Ycylnu8Qurrc0NlZWVlqYx8Z00YNtfDVq/C/P8OBTdB7CBx39sHy+MMenhOw73JElFMO77sc2WQ5IgoS0pwEEJsU7G8dfPU1zs992ZOwfwP0HAQnfRcmzYS4Xp0aiojkqGrWEfezpGBMO9RVQtkuKNt58LmmzDnRZp7mnCRDQU0pZM+Fz5+Cij1O8cwpd8PoS5xKW9M53G7YvBSW/QW2fQIxPWDid+Ck70HykE4JwZKCMe2hCrVlTU74zbyuKT38vRFRThFM0gA4/nIYe5VzEg5GWXL5HicRZD/jfJ+h34RT74FjzuwyZdvd1u5Vzp3D6gVOPcToaXDyXZA+KaAfa0nBhC/VgxWJDXU+lYqN62qcMt+WTvp1FYcfM7Ev9Bzo3P73HNjM64HOfhveg69fg03vO5WaaSNg7JVwwpWQnBn4775/M3z2J1j1ipOgRk9z7gwGTgj8Z5u2Kd0JX/4dsp+F2lIYfLJT7zDigoDcaVpSMF2T2wX7N8HOHNi1wmm14qoHV+3BViMNta2s87Qw8ZdEQI/+LZzoPa+TBkBUTNu+R1URrH0LvpoP+cucdRlTnAQx5jJISGnb8Y6kIBv+90dY92+nnmDCdc4JJvXYjv0c0/Fqy2HFC/D5X6EkH1KOcZqzjr8OYjquUt2Sggl9qs4/wa5c2Ol57F558Eo9Jgl6ZzgnuahYnw5IsYd2RIqK8emU5NM56bD3+KxP7OOc8BP7Br5svTgPVr/uJIjC9U4x03HnOgli+AXt/8dXdcqpP/0j5H3qVFyeeItTkdmjb8d+BxN4rgZY/y/47AnYmQ3xyZB1E0y+FZL6HfXhLSmY0FNReDABND5X7Xe2RcZA/xNg4EQYNAkGTYTUYRDRjaYRV4U9X8PX8+HrBU5nrZgeMOpip/5h6Df9KzZw1cPqN+B/f4J9a5w7mpPvcCourcVP16cKO76Az/4C699xLmROuMr5Hfcb3e7DWlIwwVVbDrtWeoqBcmHnCijNd7ZJBPQZ6UkAE5wk0HdM24toujK3C/L+5zRXXLvQqQzu0e9gBfWA8YdXCNdVQu7zsOwJKN3h/AxPuRuOvyK8fnbh5MAWp1hpxYvQUA0X/BZOurVdh7KkYDpPXSXsW+9TDJTjdIxqHKqg95CDV/8DJzodeWJ7BDXkkFJfA5sWO8VLm5Y49SKpw5zkcMKVENvTqZD8cg5UFzt1E6fe4/SW7U53UqZlVUVOS7Ixl7a7nsiSgulYDbVQtA2KtsCBzc4VzIEtznK5zzQYiX0PnvwHTXJavSSmBi/urqa6GNa+DV+95tQTgFO05qqDERc6dwaDpwQ3RtMl+ZsUrPeKOcjVACV5ULTV58S/2TnxlxY4baobJaQ5VyzHnuW0lkgb7iSDnoOsHfzRiE92ertOmgklO5wK6vK9znLfkUEOzoQDSwrhxu122uR7r/i3HjzxF2932rY3iu3pnPjTJ8O4a53XqcdCyrEQ3ztoXyFs9M6AU38Q7ChMmLGkEA6qimDjIqclw5YPob7y4LaoeOdE33c0jJrqOfEf55z4E9Psqt+YMGNJobsq3g7r33USQf5nTtFP0kAYd7XT9DPFc/JPGmCVlSbsqCq1DW5qG9zEREYQHSlERghiF0GWFLoNVWdMlQ2eRLB3tbO+72g47Ycw8tvNN3M0pgtQVarqXFTWNVBZ66KytsF51DVQ4btc27iP86iodVFV1/i6gao6l/fZ5T60kY0IREdGeJNEdGSEsxx16PKhryOIiWqyHCnEx0TRKz76sEfvhGh6xkeTFBtFRERo/i9aUujKXPWQ95mTBDa867RdlwinyeJ5v4CRFzqVwMYEkKpSXFXPjqIqdpZUU1HbQJ3nKtx5dh1h+eB633XOa886lxt/G0rGRUfQIzaKhJgoEmOj6BEbSe+EGNKTE0iMjSQhJsrZHhtJTGQEDW6lvsFNvctNnUupd7m9j7qGJssuZ9+6BjeVtQ3UuZQG73alznVwW4O75YBFoGfc4UmjZzOJxPfRJymW+JjAjsBrSaGrqa2ALR84iWDjIme0zqg4pxXQGffB8POdugBjOlBVXQM7iqrZUVTFjuIq53VxFTuKqigodhJBa6IjhZjICGKjIz3PEd7n2ChnXXJiTKv7JMZEek7yUSTERNIj1jnpJ8ZGep6jSIiOJCoy+MWhjXc2pdX1hz3KmllXWl3PrtJq77Z6V/MJ5bFpY7jh5MyAxm5JoSuo2OcpFnoXtn7kDAQXnwIjvu0UCx17JsQkBjtK00Fq6l1s3lfBhj3lbNxbTmF5LfGHnASjSPI5ITau9z1Jxka17Wqy3uVmV0m192SfX1TlSQDVFBRVcaDy0Gk046MjyUiJJyM5gSnHpJKeHM/glATSkxNIiosiNso5kTee2EO1qCRQRMT7uxrYO75N71VVqut9EkrVwcQxYXBygCI+yJJCqCraBusWOncEO74EFHoPhhNvchJBxhSbJKWLq2tws21/JRv3Oif/xiSQV1TlLSqJiYygT1Is1fUub7GMP6IjPSelmMZkEXlI4ugRG0VFbYP3Sn93aTW+pR1REcKgZOekf96YfqQnJ5CRkkBGcjwZKQmkJsZYpWyAiAgJMU7x14BebUsoHcHOKqGmugQ+etwZ0kBdzpAQZ9zvJIJ+Y6yiuAtyuZX8oirvSb/xsbWw0lvuHBkhZKYmMHpgTy6ZMIgR/ZIY1i+JzNSEQ4pD6hrcVNU5laYVPpWplT7Lvuu86+saKKtpYHdpjbOupoGE2EgykhOYPDSFjOR40lMSyEhOICMlngG94okMs6t747CkECrcblj1Eix92JkAJmuW03Gp9+BgR2b8pKrsLKlm094KNuwtZ+OecjbsLWfzvgpqfa7wM1LiGdEviXNG9WNE/ySG90vimD6JfhX5xERFEBMVQ+8EGwDPBIYlhVCwMxfe/bEzhnr6ZLjudRg4PthRmWa43Mqeshry9leSV1RF3oEq8osq2b6/irwDlVTWubz79u8Zx/D+SZx8TCrD+ycxol8Sx/XtQWKs/duZ0BXQv04ROR/4ExAJPK2qjzfZPgR4BugDFAHXq2pBIGMKKZUH4D+PQs48p8XQJU/B2OnWmSzIahtc7CiqJr+okrwDVZ6HkwQKiqqpcx286o+OFNKTExiSmsCJmckM65fkXP33TaJXQnQQv4Ux7ROwpCAikcCTwLlAAbBcRBaq6lqf3WYDz6nqPBE5C/gVcEOgYgoZbhfkPAv/eQxqymDKbU5z0rhewY4sbJTX1Huu8qvYfqCS/ANV3uVdpdWHtIlPjIlkcGoiw/smce6ofgxJTWRIagKDUxIY2NvK3k33Esg7hcnAZlXdCiAirwDTAN+kMBpoHPHrQ+CtAMYTGvK/gHd/BHu+gszT4ILfHNVsSqZlLreyq6SazYUVbNlXwZbCSrYUVrC1sIL9FYc2sUxNjGFwqlPpOjjFufJ3HonW0saElUAmhUHADp/lAuCkJvusAi7HKWK6FEgSkVRVPeC7k4jcCtwKMHhwF614Ld8LSx+CVS87YxBdMdeZMMNONketqq6BrZ4TfuOJf8u+Crbtrzykgjc5IZrj+vbg7JH9yExL9J74B6ckkBRnRT3GQGCTQnNnu6bd9H4EPCEiM4FPgJ3AYV0jVXUOMAecSXY6NswAc9U7zUs//BU01MCp/+eMRWQzj7WJqlJYUcuWfY0n/wo276tga2ElO0uqvftFCGSkJHBsnx6cNiyNY/v04Ni+PTi2Tw9SEq3FjjFHEsikUABk+CynA7t8d1DVXcBlACLSA7hcVUsDGFPn2vaJ06qocD0cdw6c/2tIOy7YUYW8wvJa1u0uY93uMjburfAmgfKag9cL8dGRHNs3kazMZKb3yfCe+IekJhAXHdixYYzpzgKZFJYDw0RkKM4dwHTgWt8dRCQNKFJVN3A/Tkukrq+0AJb8FNa86cxPPP1lGHGBFRU14XIr2/ZXsHZ3OWt3OUlg7e4yCstrvfv0TYrluL49uGT8II7tk+g9+ffvGRd2QycY0xkClhRUtUFE7gQW4zRJfUZV14jIo0C2qi4EzgB+JSKKU3x0R6Di6RQNtbDsCfhktjN/wRkPwCnfh+jO76oeaspr6lm/p9w58XsSwPo95d4y/+hI4bi+SZw+rA+jBiQxekBPRg3oSbIV+RjTqUT9HY82RGRlZWl2dnawwzjcpqXw3k+caS1HXgTf+iUkDwl2VJ1OVdlVWnPwyn+Xc/WfX1Tl3ad3QrT3pN/4fFzfHsREWf8MYwJFRHJUNetI+1nXyqNVkg/v3Qcb3nFmMrt+gVN/EEaytxfxzte7vUmgzFP2LwKZqYkcP6gnV2WlO0lgYE/694yzJp7GhChLCkejqgjmfhuqDsA5j8CU2yEqPIo73G7l/XV7+fvHW8jNLyEuOoKR/Xty0biB3juAkf2TbEgHY7oY+49tL7cb3vwelO+GGxdD+qRgR9QpaupdvLViJ3P+u5WthZVkpMTz6LQxXDkpI+AzQhljAs+SQnv974+waTFc8NuwSAil1fW8+EUec/+3ncLyWsYM7MlfrpnABcf3D4mZrowxHcOSQnts+68zbtGYS2HyLcGOJqB2l1bzzKfbeOmLfCrrXJw2LI0/Xj2ebxybavUCxnRDlhTaqnwvvH4jpBwLU//SbfsebNhTzpxPtvL2yp0ocNHYAdx6+jGMGWiD9hnTnVlSaAtXAyy4CWrL4TtvQ2xSsCPqUKrKF9uK+PvHW/hwQyHx0ZFcP2UIN506lIyUhGCHZ4zpBJYU2uLDX8D2/zrzHnSjkU1dbmXJmj387ZOtrNpRQkpiDP937nBumDLEOo8ZE2YsKfhr42L49Pcw8Tsw/toj798F1NS7WJBbwD8+2cr2A1UMSU3gsUuO58pJ6TZ+kDFhypKCP0ry4Y1bof8JzvwHXVxJVR0vfJ7Hs59tZ39FHWPTe/HX6ybyrTH9bcIYY8KcJYUjaaiF12Y6YxldOa9Lj2NUWdvA79/fyMtf5lNV5+KMEX347unHMuWYFGtJZIwBLCkc2ZKfws4cuOp5SD022NG0W2F5LTc+u5w1u0q5ZPwgbjn9GEYN6BnssIwxIcaSQmtWL3AmyJlyB4yeGuxo2m1rYQUz5n7J/vI6np6RxVkj+wU7JGNMiLKk0JL9m2Dh9yF9Mpz7SLCjabfc/GJuenY5ESK8fOsUxmf0DnZIxpgQZkmhOXVVMP87EBULV86FyK45f+/7a/dy18u59OsZx7xZk8lMSwx2SMaYEGdJoSlVeOeHsG+dMwx2r/RgR9QuL3yex4Nvr+aEQb3458wTSesRG+yQjDFdgCWFplY8D6tegm/eC8edHexo2kxV+d2SjTzx4WbOGtmXJ66dQEKM/ZqNMf6xs4Wv3V/BOz+CY85wkkIXU+9yc9+Cr1mQW8A1kzN4bNrxNoKpMaZNLCk0qil16hESUuCypyGia/Xoraht4LYXcvjvpv384JzhfP/s46zvgTGmzSwpgFOP8PYdTs/lme9Ajz7BjqhN9pXVMOvZ5azfU85vLh/LVSdmBDskY0wXZUkB4POnYN2/4Lyfw5CTgx1Nm2zeV8GMZ76kqNLpg3DmiL7BDskY04VZUsj/At7/GYy8CE6+M9jRtElOXhE3zcsmKkJ49btTGJtufRCMMUcnvJNC5QF4fZbT7HTak11qwpxFq/dw9ysrGNg7nnmzJjM41eY7MMYcvfBNCm4XvHEzVO6Hm5ZAfNe5yn5u2XYeWriGcem9+eeMLFKtD4IxpoOEb1L4ZDZs+Q9c9EcYOD7Y0fjF7VZ+s3gDf/t4C+eM6stfrplIfEzXaiVljAlt4ZkUtnwIH/0Kxl4Nk2YGOxq/1DW4uXfBV7y5YifXnjSYR6eOsT4IxpgOF9CzioicLyIbRGSziNzXzPbBIvKhiKwQka9E5MJAxgNA2S5YcDP0GQkX/aFL1COU19Rz47PLeXPFTn503nB+cYl1SjPGBEbA7hREJBJ4EjgXKACWi8hCVV3rs9tPgfmq+pSIjAbeBTIDFROuenhtFtRXw1XzICb0B4jbW1bDzLnL2bS3nN9eMZYrs6wPgjEmcAJZfDQZ2KyqWwFE5BVgGuCbFBRonOmlF7ArgPHAB4/Ajs/h8n9CnxEB/aiOsHlfOTOeWU5xVR3/nHki3xzetTrVGWO6nkAmhUHADp/lAuCkJvs8DCwRkbuAROCcgEWz/h347C9w4s1wwhUB+5iOsnx7ETfPyyY6MoL53z2Z4wf1CnZIxpgwEMiC6eYK67XJ8jXAs6qaDlwIPC8ih8UkIreKSLaIZBcWFrYvmogoOOZM+NYv2/f+TrSrpJoZz3xJamIMb97+DUsIxphOE8ikUAD4FoCnc3jx0E3AfABVXQbEAWlND6Sqc1Q1S1Wz+vRpZxHK8G/BDW86E+eEuF+8sw6XW5l342QyUqxTmjGm8wQyKSwHhonIUBGJAaYDC5vskw+cDSAio3CSQjtvBfzQBVoafbppP+98vZvbzzjOEoIxptMFLCmoagNwJ7AYWIfTymiNiDwqIlM9u/0QuEVEVgEvAzNVtWkRU9ioa3Dz0MLVDE5J4LvfPCbY4RhjwlBAO6+p6rs4zUx91z3o83otcEogY+hKnv1sG1sKK/nnjCzioq2nsjGm81kPqBCxt6yGPy3dxNkj+3L2qH7BDscYE6YsKYSIX7yzjnq38uDFo4MdijEmjFlSCAHLthxg4apdfO/0YxiSGvq9rI0x3ZclhSCrd7l5eOEaBvWO57Yzjgt2OMaYMGdJIcieW5bHhr3lPHjxaBsG2xgTdJYUgmhfeQ1/fH8j3xzeh/NGW+WyMSb4LCkE0ePvrqe2wc3DU8cgXaBjnTGm+7OkECTLtxfxxoqd3HL6UIamWeWyMSY0WFIIggaXm5+9tZqBveK440yrXDbGhA5LCkHw4hf5rN9Tzk8vGk1CTHjOiGqMCU1+JQURWSAi325uWGvTNvsrapm9ZAOnHpfGBcf3D3Y4xhhzCH9P8k8B1wKbRORxERkZwJi6tV+/t56aepdVLhtjQpJfSUFVl6rqdcBEYDvwvoh8JiKzRCQ6kAF2Jzl5xbyWU8CNpw7luL49gh2OMcYcxu/iIBFJBWYCNwMrgD/hJIn3AxJZN+NyKw8tXE2/nrF8/6xhwQ7HGGOa5Vctp4i8AYwEngcuVtXdnk2vikh2oILrTl76Mp/VO8v48zUTSIy1ymVjTGjy9+z0hKr+p7kNqprVgfF0S0WVdcxevIGTj0nl4rEDgh2OMca0yN/io1Ei0rtxQUSSReT2AMXU7fx28Xoqaxt4ZJpVLhtjQpu/SeEWVS1pXFDVYuCWwITUvazaUcIry3cw8xuZDO+XFOxwjDGmVf4mhQjxucQVkUggJjAhdR9ut/Lg26tJ6xHL3edY5bIxJvT5W6ewGJgvIn8DFPgesChgUXUTr2bvYFVBKX+8ejxJcdZy1xgT+vxNCvcC3wVuAwRYAjwdqKC6g5KqOn6zaD2TM1OYNn5gsMMxxhi/+JUUVNWN06v5qcCG033MXrKBshqrXDbGdC3+9lMYBvwKGA3ENa5X1WMCFFeXtnpnKS9+kc+MkzMZNaBnsMMxxhi/+VvRPBfnLqEBOBN4Dqcjm2nC7VZ+9vZqUhNj+MG5w4MdjjHGtIm/SSFeVT8ARFXzVPVh4KzAhdV1vZ5bwIr8Eu67YBS94q1y2RjTtfhb0VzjGTZ7k4jcCewE+gYurK6ptKqeX7+3nklDkrlswqBgh2OMMW3m753CPUAC8H1gEnA9MCNQQXVVf1i6keKqOh6ZOoaICKtcNsZ0PUdMCp6OalepaoWqFqjqLFW9XFU/9+O954vIBhHZLCL3NbP9DyKy0vPYKCIlzR2nK1i7q4znlm3nupOGcPygXsEOxxhj2uWIxUeq6hKRSSIiqqr+HtiTTJ4EzgUKgOUislBV1/oc+wc++98FTGhT9CFC1RkWu3dCDD86b0SwwzHGmHbzt05hBfC2iLwGVDauVNU3WnnPZGCzqm4FEJFXgGnA2hb2vwZ4yM94QsqbK3ayfHsxv778BHolWOWyMabr8jcppAAHOLTFkQKtJYVBwA6f5QLgpOZ2FJEhwFCg2eG5ReRW4FaAwYMH+xly5yirqeeX765nfEZvrpyUEexwjDHmqPjbo3lWO47dXE1rS8VP04HXVdXVwufPAeYAZGVl+V2E1Rme/M9mDlTW8szMLKtcNsZ0ef72aJ5LMyd0Vb2xlbcVAL6XzunArhb2nQ7c4U8soWbxmj2cNaIvY9N7H3lnY4wJcf4WH/3b53UccCktn+AbLQeGichQnH4N04Frm+4kIiOAZGCZn7GEjAMVtWw/UMX0yaFVpGWMMe3lb/HRAt9lEXkZWHqE9zR4OrotBiKBZ1R1jYg8CmSr6kLPrtcAr7SlZVOoyM13WtBOGpIc5EiMMaZjtHcG+WHAES+PVfVd4N0m6x5ssvxwO2MIutz8YqIihBOsX4Ixppvwt06hnEPrFPbgzLEQ1nLyihkzqBdx0ZHBDsUYYzqEv8VHNrlwE/UuN18VlHCN1ScYY7oRv8Y+EpFLRaSXz3JvEbkkcGGFvvW7y6mpdzNxsNUnGGO6D38HxHtIVUsbF1S1hC7a+7ij5OQVAVbJbIzpXvxNCs3t195K6m4hN7+E/j3jGNg7PtihGGNMh/E3KWSLyO9F5FgROUZE/gDkBDKwUJeTV2x3CcaYbsffpHAXUAe8CswHqumiPZA7wt6yGnaWVDNhsPViNsZ0L/62PqoEDpsPIVzl5hUDMNHuFIwx3Yy/rY/eF5HePsvJIrI4cGGFttz8YmKiIhgzsGewQzHGmA7lb/FRmqfFEQCqWkwYz9Gcm1/CCYN6ERtlndaMMd2Lv0nBLSLeXloikknLw2B3a7UNLr4uKLVKZmNMt+Rvs9L/B3wqIh97lk/HM+lNuFmzq4w6l5uJVslsjOmG/K1oXiQiWTiJYCXwNk4LpLDjrWS2nszGmG7I3wHxbgbuxpkrxUA5AAAX+ElEQVQoZyUwBWf+g7Nae193lJtfTHpyPH17xgU7FGOM6XD+1incDZwI5KnqmcAEoDBgUYUoVSUnr9juEowx3Za/SaFGVWsARCRWVdcDIwIXVmjaVVrD3rJaq2Q2xnRb/lY0F3j6KbwFvC8ixRx5Os5ux+oTjDHdnb8VzZd6Xj4sIh8CvYBFAYsqROXkFRMfHcnIATa9hDGme2rzSKeq+vGR9+qeVuQXMza9F9GR/pa6GWNM12JnNz/V1LtYs6vMxjsyxnRrlhT89FVBKQ1uZZLVJxhjujFLCn7KzXcqmW24bGNMd2ZJwU85ecUMTUsktUdssEMxxpiAsaTgB1VlRX6x3SUYY7o9Swp+2FFUzf6KOuu0Zozp9iwp+CEnvwiwTmvGmO4voElBRM4XkQ0isllEmp3OU0SuEpG1IrJGRF4KZDztlZtXQo/YKIb3s05rxpjurc2d1/wlIpHAk8C5QAGwXEQWqupan32GAfcDp6hqsYiE5GxuOXnFjM/oTWSEBDsUY4wJqEDeKUwGNqvqVlWtA14BpjXZ5xbgSc/0nqjqvgDG0y6VtQ2s31Nmk+oYY8JCIJPCIGCHz3KBZ52v4cBwEfmfiHwuIuc3dyARuVVEskUku7Cwc0fsXrWjBLdiPZmNMWEhkEmhubKWpvM6RwHDgDOAa4CnPaOxHvom1TmqmqWqWX369OnwQFvj7bSWYUnBGNP9BTIpFAAZPsvpHD7cdgHwtqrWq+o2YANOkggZufklHNe3B70SooMdijHGBFwgk8JyYJiIDBWRGGA6sLDJPm8BZwKISBpOcdLWAMbUJqpKbn6xjXdkjAkbAUsKqtoA3AksBtYB81V1jYg8KiJTPbstBg6IyFrgQ+DHqnogUDG11db9lZRU1TNxiFUyG2PCQ8CapAKo6rvAu03WPejzWoH/8zxCTo5npjXryWyMCRfWo7kVK/KL6RkXxTFpPYIdijHGdApLCq3IzSth4pBkIqzTmjEmTFhSaEFZTT0b95XbeEfGmLBiSaEFK/NLULVB8Iwx4cWSQgty8oqJEBiX0SvYoRhjTKexpNCC3PxihvdLIinOOq0ZY8KHJYVmuN3KyvwSa4pqjAk7lhSasWlfBeW1DVafYIwJO5YUmtE4CJ6NjGqMCTeWFJqRk1dMSmIMmakJwQ7FGGM6lSWFZuTmFzNxcG9ErNOaMSa8WFJooriyjq2FlVZ0ZIwJS5YUmlixw1OfYJXMxpgwZEmhidy8EiIjhHHpNly2MSb8WFJoIievmNEDehIfExnsUIwxptNZUvDR4HKzqqCEiYPtLsEYE54sKfhYv6ecqjqXVTIbY8KWJQUfK/KtktkYE94sKfjIzS+hb1Is6cnxwQ7FGGOCwpKCj5y8YiYOTrZOa8aYsGVJwaOwvJb8oiomDrFKZmNM+LKk4NE4CJ4Nl22MCWeWFDxy84uJjhTGDLSZ1owx4cuSgseKvBKOH9SLuGjrtGaMCV+WFIC6hsZOa1Z0ZIwJb5YUgHW7y6htcFt9gjEm7AU0KYjI+SKyQUQ2i8h9zWyfKSKFIrLS87g5kPG0JCfPOq0ZYwxAVKAOLCKRwJPAuUABsFxEFqrq2ia7vqqqdwYqDn/k5hczsFcc/XvFBTMMY4wJukDeKUwGNqvqVlWtA14BpgXw89ptRX6JjXdkjDEENikMAnb4LBd41jV1uYh8JSKvi0hGcwcSkVtFJFtEsgsLCzs0yD2lNewsqbaiI2OMIYDFR0BzY0Vok+V/AS+raq2IfA+YB5x12JtU5wBzALKyspoe46hYpzUTLurr6ykoKKCmpibYoZgAiouLIz09nejo6Ha9P5BJoQDwvfJPB3b57qCqB3wW/wH8OoDxNCsnr5jYqAhGDejZ2R9tTKcqKCggKSmJzMxMG9+rm1JVDhw4QEFBAUOHDm3XMQJZfLQcGCYiQ0UkBpgOLPTdQUQG+CxOBdYFMJ5m5eYXMza9FzFR1jrXdG81NTWkpqZaQujGRITU1NSjuhsM2JlQVRuAO4HFOCf7+aq6RkQeFZGpnt2+LyJrRGQV8H1gZqDiaU5NvYs1O8usktmEDUsI3d/R/o4DWXyEqr4LvNtk3YM+r+8H7g9kDK1Zs6uUOpfbKpmNMcYjrMtMcvNKAOu0ZkxnKCkp4a9//Wu73nvhhRdSUlLS6j4PPvggS5cubdfxzUFhnRRy8ooZnJJAn6TYYIdiTLfXWlJwuVytvvfdd9+ld+/W5zp59NFHOeecc9odXzA0NDQEO4TDBLT4KJSpKjn5xZx6XFqwQzGm0z3yrzWs3VXWocccPbAnD108psXt9913H1u2bGH8+PGce+65fPvb3+aRRx5hwIABrFy5krVr13LJJZewY8cOampquPvuu7n11lsByMzMJDs7m4qKCi644AJOPfVUPvvsMwYNGsTbb79NfHw8M2fO5KKLLuKKK64gMzOTGTNm8K9//Yv6+npee+01Ro4cSWFhIddeey0HDhzgxBNPZNGiReTk5JCWduh54LbbbmP58uVUV1dzxRVX8MgjjwCwfPly7r77biorK4mNjeWDDz4gISGBe++9l8WLFyMi3HLLLdx1113emNPS0sjOzuZHP/oRH330EQ8//DC7du1i+/btpKWl8ctf/pIbbriByspKAJ544gm+8Y1vAPCb3/yG559/noiICC644AJuueUWrrzySnJzcwHYtGkT06dPJycnp8N+j2GbFAqKqyksr2XiYJtpzZjO8Pjjj7N69WpWrlwJwEcffcSXX37J6tWrvc0nn3nmGVJSUqiurubEE0/k8ssvJzU19ZDjbNq0iZdffpl//OMfXHXVVSxYsIDrr7/+sM9LS0sjNzeXv/71r8yePZunn36aRx55hLPOOov777+fRYsWMWfOnGZj/cUvfkFKSgoul4uzzz6br776ipEjR3L11Vfz6quvcuKJJ1JWVkZ8fDxz5sxh27ZtrFixgqioKIqKio74s8jJyeHTTz8lPj6eqqoq3n//feLi4ti0aRPXXHMN2dnZvPfee7z11lt88cUXJCQkUFRUREpKCr169WLlypWMHz+euXPnMnPmzDb+JloXtkmhsdPaBKtPMGGotSv6zjR58uRD2tP/+c9/5s033wRgx44dbNq06bCkMHToUMaPHw/ApEmT2L59e7PHvuyyy7z7vPHGGwB8+umn3uOff/75JCc3//8/f/585syZQ0NDA7t372bt2rWICAMGDODEE08EoGdPp2/T0qVL+d73vkdUlHM6TUlJOeL3njp1KvHx8YDTqfDOO+9k5cqVREZGsnHjRu9xZ82aRUJCwiHHvfnmm5k7dy6///3vefXVV/nyyy+P+HltEbZJYUV+CQkxkYzsnxTsUIwJW4mJid7XH330EUuXLmXZsmUkJCRwxhlnNNvePjb2YB1gZGQk1dXVzR67cb/IyEhv2b3qkQdE2LZtG7Nnz2b58uUkJyczc+ZMampqUNVmm3u2tD4qKgq32w1w2Pfw/d5/+MMf6NevH6tWrcLtdhMXF9fqcS+//HLvHc+kSZMOS5pHK2wrmnPyihmX3puoyLD9ERjTqZKSkigvL29xe2lpKcnJySQkJLB+/Xo+//zzDo/h1FNPZf78+QAsWbKE4uLiw/YpKysjMTGRXr16sXfvXt577z0ARo4cya5du1i+fDkA5eXlNDQ0cN555/G3v/3Nm3gai48yMzO9Zf0LFixoMabS0lIGDBhAREQEzz//vLfS/bzzzuOZZ56hqqrqkOPGxcXxrW99i9tuu41Zs2Yd9c+kqbA8I1bVNbB2d5mNd2RMJ0pNTeWUU07h+OOP58c//vFh288//3waGhoYO3YsP/vZz5gyZUqHx/DQQw+xZMkSJk6cyHvvvceAAQNISjq0tGDcuHFMmDCBMWPGcOONN3LKKacAEBMTw6uvvspdd93FuHHjOPfcc6mpqeHmm29m8ODBjB07lnHjxvHSSy95P+vuu+/mtNNOIzKy5Wl+b7/9dubNm8eUKVPYuHGj9y7i/PPPZ+rUqWRlZTF+/Hhmz57tfc91112HiHDeeed19I8I8ed2KpRkZWVpdnb2UR3j860HmD7nc56ZmcVZI/t1UGTGhLZ169YxatSoYIcRVLW1tURGRhIVFcWyZcu47bbbvBXfXcns2bMpLS3lsccea3Z7c79rEclR1awjHTss6xS8lcwZdqdgTDjJz8/nqquuwu12ExMTwz/+8Y9gh9Rml156KVu2bOE///lPQI4fnkkhr4Rj+iSSnBgT7FCMMZ1o2LBhrFixIthhHJXG1lOBEnZ1CqpKbn6xDW1hjDHNCLukkHegiqLKOqtkNsaYZoRdUsjJc+oT7E7BGGMOF3ZJITe/mKTYKIb17RHsUIwxJuSEYVIoYfzg3kRE2GQjxoS6Hj3s4q2zhVVSqKhtYMOeMis6Msb4JRSHtg60sGqSumpHCW7FKpmNee8+2PN1xx6z/wlwweMtbr733nsZMmQIt99+OwAPP/wwSUlJfPe732XatGkUFxdTX1/Pz3/+c6ZNm9bqR7U0xPaiRYt44IEHcLlcpKWl8cEHH1BRUcFdd91FdnY2IsJDDz3E5ZdfTo8ePaioqADg9ddf59///jfPPvssM2fOJCUlhRUrVjBx4kSuvvpq7rnnHqqrq4mPj2fu3LmMGDECl8t12JDZo0eP5oknnvA2G33//fd56qmnvAPydQVhlRRy8ooRgfE2XLYxnW769Oncc8893qQwf/58Fi1aRFxcHG+++SY9e/Zk//79TJkyhalTp7Y613BzQ2y73W5uueUWPvnkE4YOHeodK+ixxx6jV69efP21kwSbG++oqY0bN7J06VIiIyMpKyvjk08+ISoqiqVLl/LAAw+wYMGCZofMTk5O5o477qCwsJA+ffowd+7cgIxPFEhhlRRy84sZ3jeJnnHRwQ7FmOBq5Yo+UCZMmMC+ffvYtWsXhYWFJCcnM3jwYOrr63nggQf45JNPiIiIYOfOnezdu5f+/fu3eKzmhtguLCzk9NNP9w7F3TjU9NKlS3nllVe8721puGxfV155pXe8otLSUmbMmMGmTZsQEerr673HbW7I7BtuuIEXXniBWbNmsWzZMp577rm2/qiCKmySgtutrMgv4cITWv5DM8YE1hVXXMHrr7/Onj17mD59OgAvvvgihYWF5OTkEB0dTWZmZrNDZjdqaYjttg5t7buutaGtf/azn3HmmWfy5ptvsn37ds4444xWjztr1iwuvvhi4uLiuPLKK71Jo6sIm4rmrfsrKK2ut0l1jAmi6dOn88orr/D6669zxRVXAM6VeN++fYmOjubDDz8kLy+v1WO0NMT2ySefzMcff8y2bduAg0NNn3feeTzxxBPe9zcWH/Xr149169bhdrtbHTqitLSUQYMGAfDss89617c0ZPbAgQMZOHAgP//5zzt8VrTOEDZJITevBLBKZmOCacyYMZSXlzNo0CAGDBgAOMNAZ2dnk5WVxYsvvsjIkSNbPUZLQ2z36dOHOXPmcNlllzFu3DiuvvpqAH76059SXFzM8ccfz7hx4/jwww8BZ3rQiy66iLPOOssbS3N+8pOfcP/993PKKad45zoAWhwyu/E7ZWRkMHr06Pb9oIIobIbOXrJmD6/lFDDnhkmtVmAZ013Z0Nmd584772TChAncdNNNQfl8GzrbD+eN6c95Y6w+wRgTWJMmTSIxMZHf/e53wQ6lXcImKRhjTGdonIKzqwponYKInC8iG0Rks4jc18p+V4iIisgRb22MMe3X1YqLTdsd7e84YElBRCKBJ4ELgNHANSJyWK2LiCQB3we+CFQsxhhnwvcDBw5YYujGVJUDBw4QFxfX7mMEsvhoMrBZVbcCiMgrwDRgbZP9HgN+A/wogLEYE/bS09MpKCigsLAw2KGYAIqLiyM9Pb3d7w9kUhgE7PBZLgBO8t1BRCYAGar6bxFpMSmIyK3ArQCDBw8OQKjGdH/R0dHe3r7GtCSQdQrNtfv03reKSATwB+CHRzqQqs5R1SxVzerTp08HhmiMMcZXIJNCAZDhs5wO7PJZTgKOBz4Ske3AFGChVTYbY0zwBDIpLAeGichQEYkBpgMLGzeqaqmqpqlqpqpmAp8DU1W17T3TjDHGdIiA1SmoaoOI3AksBiKBZ1R1jYg8CmSr6sLWj9C8nJyc/SLS+uAoLUsD9rfzvcHQleLtSrFC14q3K8UKXSverhQrHF28Q/zZqcsNc3E0RCTbn27eoaIrxduVYoWuFW9XihW6VrxdKVbonHjDZkA8Y4wxR2ZJwRhjjFe4JYU5wQ6gjbpSvF0pVuha8XalWKFrxduVYoVOiDes6hSMMca0LtzuFIwxxrTCkoIxxhivsEkK/g7jHWwikiEiH4rIOhFZIyJ3Bzsmf4hIpIisEJF/BzuW1ohIbxF5XUTWe37GJwc7ptaIyA88fwerReRlEWn/8JcBICLPiMg+EVntsy5FRN4XkU2e55CYA7eFWH/r+Vv4SkTeFJHewYyxUXOx+mz7kWeqgbRAfHZYJAV/h/EOEQ3AD1V1FM7QH3eEcKy+7gbWBTsIP/wJWKSqI4FxhHDMIjIIZ1j5LFU9HqcT6PTgRnWYZ4Hzm6y7D/hAVYcBH3iWQ8GzHB7r+8DxqjoW2Ajc39lBteBZDo8VEckAzgXyA/XBYZEU8BnGW1XrgMZhvEOOqu5W1VzP63Kck9ag4EbVOhFJB74NPB3sWFojIj2B04F/AqhqnaqWBDeqI4oC4kUkCkjg0PHDgk5VPwGKmqyeBszzvJ4HXNKpQbWguVhVdYmqNngWP8cZoy3oWvi5gjOI6E/wGVy0o4VLUmhuGO+QPtECiEgmMIHQn4Dojzh/qO5gB3IExwCFwFxPUdfTIpIY7KBaoqo7gdk4V4W7gVJVXRLcqPzST1V3g3ORA/QNcjz+uhF4L9hBtEREpgI7VXVVID8nXJJCq8N4hyIR6QEsAO5R1bJgx9MSEbkI2KeqXWFi2ihgIvCUqk4AKgmdoo3DeMripwFDgYFAoohcH9youicR+X84RbcvBjuW5ohIAvD/gAcD/VnhkhSONIx3SBGRaJyE8KKqvhHseI7gFGCqZ/jzV4CzROSF4IbUogKgQFUb77xex0kSoeocYJuqFqpqPfAG8I0gx+SPvSIyAMDzvC/I8bRKRGYAFwHXaeh23DoW5+Jgled/LR3IFZH+Hf1B4ZIUWh3GO5SIiOCUea9T1d8HO54jUdX7VTXdM/z5dOA/qhqSV7OqugfYISIjPKvO5vDpYUNJPjBFRBI8fxdnE8IV4z4WAjM8r2cAbwcxllaJyPnAvTjD9lcFO56WqOrXqtrXZ6qBAmCi52+6Q4VFUvBUJDUO470OmK+qa4IbVYtOAW7AueJe6XlcGOygupG7gBdF5CtgPPDLIMfTIs8dzetALvA1zv9rSA3LICIvA8uAESJSICI3AY8D54rIJpyWMo8HM8ZGLcT6BM6EX+97/tf+FtQgPVqItXM+O3TvlowxxnS2sLhTMMYY4x9LCsYYY7wsKRhjjPGypGCMMcbLkoIxxhgvSwrGBJiInBHqo8ca08iSgjHGGC9LCsZ4iMj1IvKlpxPT3z1zRFSIyO9EJFdEPhCRPp59x4vI5z7j8Cd71h8nIktFZJXnPcd6Dt/DZx6HFz09lBGRx0Vkrec4s4P01Y3xsqRgDCAio4CrgVNUdTzgAq4DEoFcVZ0IfAw85HnLc8C9nnH4v/ZZ/yLwpKqOwxmnaLdn/QTgHpz5PI4BThGRFOBSYIznOD8P7Lc05sgsKRjjOBuYBCwXkZWe5WNwhgN/1bPPC8CpItIL6K2qH3vWzwNOF5EkYJCqvgmgqjU+4+l8qaoFquoGVgKZQBlQAzwtIpcBITv2jgkflhSMcQgwT1XHex4jVPXhZvZrbVyY5oZob1Tr89oFRHnG5JqMMyLuJcCiNsZsTIezpGCM4wPgChHpC955hofg/I9c4dnnWuBTVS0FikXkNM/6G4CPPfNeFIjIJZ5jxHrGwW+WZ86MXqr6Lk7R0vhAfDFj2iIq2AEYEwpUda2I/BRYIiIRQD1wB85EPGNEJAcoxal3AGdI6L95TvpbgVme9TcAfxeRRz3HuLKVj00C3haROJy7jB908Ncyps1slFRjWiEiFaraI9hxGNNZrPjIGGOMl90pGGOM8bI7BWOMMV6WFIwxxnhZUjDGGONlScEYY4yXJQVjjDFe/x8NT6vrGVYsxwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting graphs for accuracy \n",
    "plt.figure(0)\n",
    "plt.plot(history.history['acc'], label='training accuracy')\n",
    "plt.plot(history.history['val_acc'], label='val accuracy')\n",
    "plt.title('Accuracy')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(1)\n",
    "plt.plot(history.history['loss'], label='training loss')\n",
    "plt.plot(history.history['val_loss'], label='val loss')\n",
    "plt.title('Loss')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#testing accuracy on test dataset\n",
    "from sklearn.metrics import accuracy_score\n",
    "y_test = pd.read_csv('data\\\\Test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = y_test[\"ClassId\"].values\n",
    "imgs = y_test[\"Path\"].values\n",
    "data=[]\n",
    "for img in imgs:\n",
    "    image = Image.open(\"data\\\\\"+img)\n",
    "    image = image.resize((30,30))\n",
    "    data.append(np.array(image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test=np.array(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = model.predict_classes(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8983372921615201\n"
     ]
    }
   ],
   "source": [
    "#Accuracy with the test data\n",
    "from sklearn.metrics import accuracy_score\n",
    "print(accuracy_score(labels, pred))\n",
    "model.save('traffic_classifier.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From c:\\users\\chirag saini\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "model = load_model(\"traffic_classifier.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dictionary to label all traffic signs class.\n",
    "classes = { 1:'Speed limit (20km/h)',\n",
    "            2:'Speed limit (30km/h)', \n",
    "            3:'Speed limit (50km/h)', \n",
    "            4:'Speed limit (60km/h)', \n",
    "            5:'Speed limit (70km/h)', \n",
    "            6:'Speed limit (80km/h)', \n",
    "            7:'End of speed limit (80km/h)', \n",
    "            8:'Speed limit (100km/h)', \n",
    "            9:'Speed limit (120km/h)', \n",
    "            10:'No passing', \n",
    "            11:'No passing veh over 3.5 tons', \n",
    "            12:'Right-of-way at intersection', \n",
    "            13:'Priority road', \n",
    "            14:'Yield', \n",
    "            15:'Stop', \n",
    "            16:'No vehicles', \n",
    "            17:'Veh > 3.5 tons prohibited', \n",
    "            18:'No entry', \n",
    "            19:'General caution', \n",
    "            20:'Dangerous curve left', \n",
    "            21:'Dangerous curve right', \n",
    "            22:'Double curve', \n",
    "            23:'Bumpy road', \n",
    "            24:'Slippery road', \n",
    "            25:'Road narrows on the right', \n",
    "            26:'Road work', \n",
    "            27:'Traffic signals', \n",
    "            28:'Pedestrians', \n",
    "            29:'Children crossing', \n",
    "            30:'Bicycles crossing', \n",
    "            31:'Beware of ice/snow',\n",
    "            32:'Wild animals crossing', \n",
    "            33:'End speed + passing limits', \n",
    "            34:'Turn right ahead', \n",
    "            35:'Turn left ahead', \n",
    "            36:'Ahead only', \n",
    "            37:'Go straight or right', \n",
    "            38:'Go straight or left', \n",
    "            39:'Keep right', \n",
    "            40:'Keep left', \n",
    "            41:'Roundabout mandatory', \n",
    "            42:'End of no passing', \n",
    "            43:'End no passing veh > 3.5 tons' }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 26, 26, 32)        2432      \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 22, 22, 32)        25632     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 11, 11, 32)        0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 11, 11, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 9, 9, 64)          18496     \n",
      "_________________________________________________________________\n",
      "conv2d_4 (Conv2D)            (None, 7, 7, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 3, 3, 64)          0         \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 3, 3, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 576)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 256)               147712    \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 43)                11051     \n",
      "=================================================================\n",
      "Total params: 242,251\n",
      "Trainable params: 242,251\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slippery road\n"
     ]
    }
   ],
   "source": [
    "image = Image.open('data/Test/00012.png')\n",
    "image = image.resize((30,30))\n",
    "image = np.expand_dims(image, axis=0)\n",
    "image = np.array(image)\n",
    "pred = model.predict_classes([image])[0]\n",
    "sign = classes[pred+1]\n",
    "print(sign)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred"
   ]
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}