Road_Signs_Detection_Model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    },
    "colab": {
      "name": "Road_Signs_Detection_Model.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7PRdbSAx4yFr"
      },
      "source": [
        "# Road Sign detection model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JtHLQ8sS4yFt",
        "outputId": "25fdb7bb-8ba7-4851-c3e3-98149997d927"
      },
      "source": [
        "# useful libraries\n",
        "import pickle\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras import models, layers\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "\n",
        "print('Tensorflow version :', tf.__version__)\n",
        "print(\"Num GPUs Available: \", len(tf.config.experimental.list_physical_devices('GPU')))\n",
        "\n",
        "%matplotlib inline"
      ],
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Tensorflow version : 2.4.0\n",
            "Num GPUs Available:  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ShVFn7TM4yFv"
      },
      "source": [
        "### Load the data and check shapes (summary of the data set)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C0gOe0GI4yFw"
      },
      "source": [
        "# load data\n",
        "with open(\"train.p\", mode='rb') as training_data:\n",
        "    train = pickle.load(training_data)\n",
        "with open(\"valid.p\", mode='rb') as validation_data:\n",
        "    valid = pickle.load(validation_data)\n",
        "with open(\"test.p\", mode='rb') as testing_data:\n",
        "    test = pickle.load(testing_data)\n",
        "  \n",
        "# label and features\n",
        "x_train, y_train = train['features'], train['labels']\n",
        "x_validation, y_validation = valid['features'], valid['labels']\n",
        "x_test, y_test = test['features'], test['labels']"
      ],
      "execution_count": 150,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-f8I_S1w4yFx",
        "outputId": "395d5f34-6aab-4230-a585-bde13b086159"
      },
      "source": [
        "# check the shape of the data\n",
        "x_shape = x_train.shape\n",
        "y_shape = y_train.shape\n",
        "x_val_shape = x_validation.shape\n",
        "y_val_shape = y_validation.shape\n",
        "\n",
        "print(\"Features shape :\", x_shape)\n",
        "print(\"Validation features shape :\", x_val_shape)\n",
        "print(\"Labels shape :\", y_shape)\n",
        "print(\"Validation labels shape :\", y_val_shape)"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Features shape : (34799, 32, 32, 3)\n",
            "Validation features shape : (4410, 32, 32, 3)\n",
            "Labels shape : (34799,)\n",
            "Validation labels shape : (4410,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SrljNg0Ws4jV",
        "outputId": "85af9f07-5709-4128-c6d6-cac088d0069b"
      },
      "source": [
        "# Number of training examples\r\n",
        "num_train = x_train.shape[0]\r\n",
        "\r\n",
        "# Number of validation examples\r\n",
        "num_validation = x_validation.shape[0]\r\n",
        "\r\n",
        "# Number of testing examples.\r\n",
        "num_test = x_test.shape[0]\r\n",
        "\r\n",
        "# What's the shape of an traffic sign image?\r\n",
        "image_shape = x_train.shape[1:]\r\n",
        "\r\n",
        "# How many unique classes/labels there are in the dataset.\r\n",
        "n_classes = len(set(y_train))\r\n",
        "\r\n",
        "print(\"Number of training examples =\", num_train)\r\n",
        "print(\"Number of validation examples =\", num_validation)\r\n",
        "print(\"Number of testing examples =\", num_test)\r\n",
        "print(\"Image data shape =\", image_shape)\r\n",
        "print(\"Number of classes =\", n_classes)"
      ],
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of training examples = 34799\n",
            "Number of validation examples = 4410\n",
            "Number of testing examples = 12630\n",
            "Image data shape = (32, 32, 3)\n",
            "Number of classes = 43\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XqUYebxYtLzo"
      },
      "source": [
        "### Group the image by class labels.\r\n",
        "\r\n",
        "We will group the images by label."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4vTfv48X4yFy"
      },
      "source": [
        "from sklearn.utils import shuffle\n",
        "x_train, y_train = shuffle(x_train, y_train)\n",
        "x_validation, y_validation = shuffle(x_validation, y_validation)\n",
        "x_test, y_test = shuffle(x_test, y_test)"
      ],
      "execution_count": 153,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XpejvBoO4yFy"
      },
      "source": [
        "### Convert to grayscale and normalization of the data\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "uKAHzwJe4yFz"
      },
      "source": [
        "# convert color images to grayscale using averaging method (np.sum)\n",
        "x_train_gray = np.sum(x_train, axis=3, keepdims=True)/3\n",
        "x_test_gray  = np.sum(x_test, axis=3, keepdims=True)/3\n",
        "x_validation_gray  = np.sum(x_validation, axis=3, keepdims=True)/3\n",
        "\n",
        "# normalization of the data\n",
        "x_train_gray -= np.mean(x_train_gray, axis=0)\n",
        "x_test_gray -= np.mean(x_test_gray, axis=0)\n",
        "x_validation_gray -= np.mean(x_train_gray, axis=0)\n",
        "\n",
        "x_train_gray /= (np.std(x_train_gray, axis=0) + np.finfo('float32').eps)\n",
        "x_test_gray /= (np.std(x_test_gray, axis=0) + np.finfo('float32').eps)\n",
        "x_validation_gray /= (np.std(x_validation_gray, axis=0) + np.finfo('float32').eps)\n",
        "\n",
        "# one-hot encoding classes\n",
        "#y_train = to_categorical(y_train)\n",
        "#y_test = to_categorical(y_test)\n",
        "#y_validation = to_categorical(y_validation)"
      ],
      "execution_count": 154,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8WoIZ1ar2To4"
      },
      "source": [
        "### Display the images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 533
        },
        "id": "HAqhcCyD2XyL",
        "outputId": "4af2d736-31e2-4e29-a313-e9b0c976910e"
      },
      "source": [
        "i = 610\r\n",
        "plt.imshow(x_train_gray[i].squeeze(), cmap='gray')\r\n",
        "plt.figure()\r\n",
        "plt.imshow(x_train[i])"
      ],
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fc796478860>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 155
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcyA5AS34yF0"
      },
      "source": [
        "### Model architecture\n",
        "\n",
        "After normalization of the data, we've one-hot encoded the 43 different classes of road signs. Now we'll define a model architecture to train our network and to prevent overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EUe2zJCz4yF1"
      },
      "source": [
        "from tensorflow.keras import regularizers\n",
        "\n",
        "# Model architecture\n",
        "def cnn_model_architecture(kernel_size, input_shape):\n",
        "            \n",
        "    cnn_model = tf.keras.Sequential()\n",
        "           \n",
        "    cnn_model.add(layers.Conv2D(32, kernel_size, activation = 'relu', input_shape=input_shape)) \n",
        "    cnn_model.add(layers.Conv2D(64, kernel_size, activation='relu', kernel_regularizer=regularizers.l2(0.001), input_shape=input_shape))      \n",
        "    cnn_model.add(layers.MaxPooling2D(pool_size=(2,2))) \n",
        "    cnn_model.add(layers.Dropout(0.25))\n",
        "    cnn_model.add(layers.Conv2D(128, kernel_size, activation='relu', kernel_regularizer=regularizers.l2(0.001), input_shape=input_shape)) \n",
        "    cnn_model.add(layers.MaxPooling2D(pool_size=(2,2)))        \n",
        "    cnn_model.add(layers.Dropout(0.5))\n",
        "\n",
        "    cnn_model.add(layers.Flatten())   \n",
        "    cnn_model.add(layers.Dropout(0.25)) \n",
        "    cnn_model.add(layers.Dense(256, activation='relu', kernel_regularizer=regularizers.l2(0.001))) \n",
        "    cnn_model.add(layers.Dropout(0.5))   \n",
        "    cnn_model.add(layers.Dense(n_classes, activation='softmax'))\n",
        "    \n",
        "    return cnn_model   "
      ],
      "execution_count": 156,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8QE9k7lD4yF2"
      },
      "source": [
        "# Compiling the model \n",
        "def compile_model():\n",
        "    cnn_model_architecture(kernel_size, input_shape)    \n",
        "    cnn_model.compile(optimizer='adam', \n",
        "                      loss='sparse_categorical_crossentropy', \n",
        "                      metrics=['acc'])\n",
        "    return cnn_model"
      ],
      "execution_count": 157,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K7iiFNhQGzU-"
      },
      "source": [
        "# using callbacks\r\n",
        "class myCallback(tf.keras.callbacks.Callback):\r\n",
        "  def on_epoch_end(self, epoch, logs={}):\r\n",
        "    if(logs.get('val_loss')<0.45):\r\n",
        "      print(\"\\nReached 0.45 validation loss so cancelling training!\")\r\n",
        "      self.model.stop_training = True\r\n",
        "\r\n",
        "callbacks = myCallback()"
      ],
      "execution_count": 158,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKdITn5_4yF4"
      },
      "source": [
        "### Compile the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ph3V8F_4yF4"
      },
      "source": [
        "kernel_size = (3,3)\n",
        "input_shape = x_train_gray[1].shape\n",
        "batch_size = 348\n",
        "epochs = 70\n",
        "\n",
        "cnn_model = cnn_model_architecture(kernel_size, input_shape)\n",
        "cnn_model = compile_model()"
      ],
      "execution_count": 159,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TzGGI2jF4yF4"
      },
      "source": [
        "### Train and evaluate the model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JlnCsB4x4yF4"
      },
      "source": [
        "def train_model(model, x_train, y_train, x_validation, y_validation, batch_size, epochs, callbacks):   \n",
        "\n",
        "    # train the model    \n",
        "    model_history = model.fit(x_train,\n",
        "                        y_train,\n",
        "                        batch_size= batch_size,\n",
        "                        epochs = epochs, \n",
        "                        steps_per_epoch = len(x_train) / batch_size,\n",
        "                        verbose=1, \n",
        "                        validation_data= (x_validation, y_validation),\n",
        "                        callbacks=[callbacks])\n",
        "    \n",
        "    return model_history\n"
      ],
      "execution_count": 160,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zQu9FkbL4yF4",
        "outputId": "e1ec777b-4782-4c8a-fa8e-dfd3b8398d1e"
      },
      "source": [
        "# train and evaluate the model\n",
        "history = train_model(cnn_model,\n",
        "                      x_train_gray, \n",
        "                      y_train, \n",
        "                      x_validation_gray, \n",
        "                      y_validation,\n",
        "                      batch_size,\n",
        "                      epochs,\n",
        "                      callbacks)    "
      ],
      "execution_count": 161,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/70\n",
            " 5/99 [>.............................] - ETA: 3s - loss: 4.3045 - acc: 0.0442WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0117s vs `on_train_batch_end` time: 0.0222s). Check your callbacks.\n",
            "99/99 [==============================] - 3s 28ms/step - loss: 3.5790 - acc: 0.1961 - val_loss: 1.5367 - val_acc: 0.7639\n",
            "Epoch 2/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 1.1437 - acc: 0.7848 - val_loss: 1.0153 - val_acc: 0.8841\n",
            "Epoch 3/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.7832 - acc: 0.8972 - val_loss: 0.8329 - val_acc: 0.9166\n",
            "Epoch 4/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.6745 - acc: 0.9252 - val_loss: 0.7837 - val_acc: 0.9234\n",
            "Epoch 5/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.5885 - acc: 0.9445 - val_loss: 0.7076 - val_acc: 0.9317\n",
            "Epoch 6/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.5568 - acc: 0.9470 - val_loss: 0.6967 - val_acc: 0.9293\n",
            "Epoch 7/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.5157 - acc: 0.9544 - val_loss: 0.6794 - val_acc: 0.9286\n",
            "Epoch 8/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4861 - acc: 0.9585 - val_loss: 0.6168 - val_acc: 0.9431\n",
            "Epoch 9/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4712 - acc: 0.9584 - val_loss: 0.5806 - val_acc: 0.9431\n",
            "Epoch 10/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4549 - acc: 0.9615 - val_loss: 0.5883 - val_acc: 0.9429\n",
            "Epoch 11/70\n",
            "99/99 [==============================] - 3s 27ms/step - loss: 0.4411 - acc: 0.9627 - val_loss: 0.5631 - val_acc: 0.9379\n",
            "Epoch 12/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4379 - acc: 0.9623 - val_loss: 0.5436 - val_acc: 0.9458\n",
            "Epoch 13/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4255 - acc: 0.9648 - val_loss: 0.5586 - val_acc: 0.9397\n",
            "Epoch 14/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4180 - acc: 0.9653 - val_loss: 0.5376 - val_acc: 0.9415\n",
            "Epoch 15/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4067 - acc: 0.9670 - val_loss: 0.5163 - val_acc: 0.9435\n",
            "Epoch 16/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.4045 - acc: 0.9663 - val_loss: 0.4984 - val_acc: 0.9512\n",
            "Epoch 17/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3999 - acc: 0.9673 - val_loss: 0.4919 - val_acc: 0.9535\n",
            "Epoch 18/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3929 - acc: 0.9679 - val_loss: 0.5010 - val_acc: 0.9449\n",
            "Epoch 19/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3910 - acc: 0.9686 - val_loss: 0.4869 - val_acc: 0.9599\n",
            "Epoch 20/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3763 - acc: 0.9726 - val_loss: 0.4896 - val_acc: 0.9501\n",
            "Epoch 21/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3834 - acc: 0.9695 - val_loss: 0.4869 - val_acc: 0.9449\n",
            "Epoch 22/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3777 - acc: 0.9713 - val_loss: 0.4810 - val_acc: 0.9435\n",
            "Epoch 23/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3710 - acc: 0.9721 - val_loss: 0.4945 - val_acc: 0.9463\n",
            "Epoch 24/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3703 - acc: 0.9712 - val_loss: 0.4697 - val_acc: 0.9494\n",
            "Epoch 25/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3613 - acc: 0.9741 - val_loss: 0.4572 - val_acc: 0.9506\n",
            "Epoch 26/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3721 - acc: 0.9698 - val_loss: 0.4866 - val_acc: 0.9399\n",
            "Epoch 27/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3652 - acc: 0.9722 - val_loss: 0.4512 - val_acc: 0.9567\n",
            "Epoch 28/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3576 - acc: 0.9741 - val_loss: 0.4578 - val_acc: 0.9497\n",
            "Epoch 29/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3644 - acc: 0.9724 - val_loss: 0.4613 - val_acc: 0.9424\n",
            "Epoch 30/70\n",
            "99/99 [==============================] - 3s 26ms/step - loss: 0.3553 - acc: 0.9732 - val_loss: 0.4491 - val_acc: 0.9465\n",
            "\n",
            "Reached 0.45 validation loss so cancelling training!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PnbvNazBelW8",
        "outputId": "e4c1b615-b761-411e-97e3-1e46749e7dcf"
      },
      "source": [
        "# evaluate the model\r\n",
        "score = cnn_model.evaluate(x_test_gray, y_test, verbose=0)\r\n",
        "print('\\nTest loss : {:.4f}'.format(score[0]))\r\n",
        "print('Test Accuracy : {:.4f}'.format(score[1]))"
      ],
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Test loss : 0.3919\n",
            "Test Accuracy : 0.9652\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "dRFIo88s4yF5",
        "outputId": "22f1d496-1417-4290-f031-c1ad321a8d0e"
      },
      "source": [
        "# plot loss _values\n",
        "history_dict = history.history\n",
        "\n",
        "loss_values = history_dict['loss']\n",
        "val_loss_values = history_dict['val_loss']\n",
        "epochs = range(1, len(loss_values)+ 1)\n",
        "line1 = plt.plot(epochs, val_loss_values, label = 'Validation Loss')\n",
        "line2 = plt.plot(epochs, loss_values, label= 'Training Loss')\n",
        "plt.setp(line1, linewidth=2.0, marker = '+', markersize=10.0)\n",
        "plt.setp(line2, linewidth=2.0, marker= '4', markersize=10.0)\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "6lvWP5KO4yF5",
        "outputId": "dadfae36-29bd-4939-d794-50720935e024"
      },
      "source": [
        "# plot accuracy \n",
        "\n",
        "acc_values = history_dict['acc']\n",
        "val_acc_values = history_dict['val_acc']\n",
        "epochs = range(1, len(loss_values)+ 1)\n",
        "line1 = plt.plot(epochs, val_acc_values, label = 'Validation Accuracy')\n",
        "line2 = plt.plot(epochs, acc_values, label= 'Training Accuracy')\n",
        "plt.setp(line1, linewidth=2.0, marker = '+', markersize=10.0)\n",
        "plt.setp(line2, linewidth=2.0, marker= '4', markersize=10.0)\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEJCAYAAACZjSCSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3yV1f3A8c83exJGICB7BESUlQgIiKBVcYEiVtFaqQPlVyvQJbZ11NHaOii2SgW1iFVRaxlWKgISURkmzLJngLBJgCRk557fH8+TcLNvxs24z/f9et3Xfca5557DJef7POc8z3nEGINSSinn8mvoAiillGpYGgiUUsrhNBAopZTDaSBQSimH00CglFIOp4FAKaUczmuBQETeEZGTIrK1gv0iIq+JyF4R2SIiA71VFqWUUhXz5hnBXGB0JftvAGLt1yRglhfLopRSqgIB3srYGLNKRLpUkmQsMM9Yd7StFZHmItLOGHOssnyjo6NNly4lsz1//jzh4eG1LHHj4Wv1Ad+rk6/VB3yvTr5WH6hdndavX3/aGNO6vH1eCwQeaA8cdltPsbeVCQQiMgnrrIGYmBhefvnlEvszMzOJiIjwXknrma/VB3yvTr5WH/C9OvlafaB2dRo1atTBivY1ZCDwmDFmNjAbID4+3owcObLE/oSEBEpva8p8rT7ge3XytfqA79XJ1+oD3qtTQ141dATo6Lbewd6mlFKqHjVkIFgM/Ni+emgIcK6q8QGllFJ1z2tdQyLyITASiBaRFOBpIBDAGPN3YAlwI7AXyAJ+4q2yKKWUqpjXzgiMMROMMe2MMYHGmA7GmLeNMX+3gwDG8lNjTHdjzGXGmCRvlUUp5SDfzoCMEw2Xp6dpvZFnDemdxUo5XUM2XN7IM/MkfDez4fL0NK038qwhDQRKVUdTaQyrk2dDNlzeyHPYFNj8AUG5Z+o8T4/+TT1NW4M8PapTDTSJy0eVqpFvZ0C/uyEypu7SFjUcIddVnWdR2tF/qJt03spz2BR4YwhB/S/3KB3DplT97+Rp2qGPwawrYOjPoFm76udpDOScg8wT1ivjBGQeh+ad6bvlGQjeDeHREN4aItpY7+HRENwMRMrm6XJBdhpkHLPyyjgGGcet95DmMGcUtOoBfgHg5w/ib727L4s/RMTAvDHQIb7yOhWla9cfXAVgCq13l6vUeiEEhNBn6x/h+tsqz7MGpKk9qjI+Pt4kJZUcTvC164V9rT7gQZ280Wh/8QQgnjWGnqbNOA5vDGF1/xkMreoP0k7L/62rvKyepHO5wJUP6Udg9ii4/0urQcOAcVkNonFZL4zVKL53G/NjX+auIT0gLxNyM0q+3LcdWkt2dhahnQbaeRrrHS4sGwOnd1vLLbpCYb7dSOVDYUHZ5ewzVnkCQ613V6FdxsIL67i1PwEhVtrAMPtlLwe5rR//HxTkWg165nEr4BXkVP47lMc/+EJQyEqFwjzwD7J+C1d+9fNrSFdNh1FPVJlMRNYbY8qNTBoIGqFGX58aNNoJ63dUXicvNtpVNsQl0q6FoHCrgck8aR9pnoTzbstH1pOfk0Vgq85W4xEQbL0XvQKCrIbGPwiObrAa0HZ9rQasMM9quAryoDDX2laQax1xmkIIDLcbVLdXYT4lGkxVVkgLiLnEOuoPbQXbF3I84hLa9hoE50+VfGWegvzzVefZvAt0Hmr93wltBeveIDHyGi6/elypI/bCC++uQsjPgoQXoccPoNPgivMvyIVVL1vpugwvdWZhn3H4BYD4WcF1yS/Y3/Iqut33eo3+iSoLBNo1pC6obvdIdboyqupKqaorwRi7UcyDuInw9nVw8c3W6X1WaqlX2oVlVyHM7AfBEYBY6cFt2V4XsfKe0cf6nioEApzcXnX9i5za4Vm6vIoaKAH/QKthAKuxKVOocAiJshoOEauhOX+ybLp2/aHbVRAcCUGRVsBa9RKHmw2k45V3U+Lfxv3fqzAX/jsd+twKsdfZ5Qm0Gqzi5QDwD7CC1wd3wuCH4bI7rDIVNXLFy36Qnw1zrrZ+90vHQV6WVbf8bKuxzs+21vOyIPssrHweet8Cl463Gv2IGPu3dbNgMvS8np3Nf0jbig4+8s7D+dNw9jAsmAT9JsDAe638AkPLpl8wGbqN4o61N5D80NUV/EZuaXtcA7dW0WB7mq4obdcRHGp+B92qTl1tGgh8XXWO3j1t4CtqtF2uC0e5hXnW+yVj4f07aBnbHHbnWn/MOecgx37PPnthWfzgb/FW/21hnv3Kt7sb8sqWY+4Nnv87FGR7nra0dv2h1w1WwxMSBcufYX+LEXS7frJV38J8u875bvXPh9x0WPUSW0Mv59JhN1tnCgEh1tlC8XKQ1U3yr/t57sQwnnziqQuNqV/RKxD87Os68s5bXUPDp0L/uysuc955XG+O5FdnxvHyCy8ixQ16ORZMhu6jePnUrcy8uJKAvWCyFUCuf6Hqf7MFk6HTECsQVGbJr6x+9AH3WOuBoUCrivPs8QNmBD3MtM49y0+z8X3rLOyhr1jw7ndUeBIaFG69El6EbiPhmicrLqNbnqxNqLw+bmlnLNvNtGurLmeV3NOuTqw6fQ1oIPB1njbu+dl2oz0e2lxiHQnmpkNOuv1+znoVbTMueK2/1S1S1M1RyZF0360vQLlPpihHbnr52/0C7O6XQOsMobx0XUfCZeMhrJXVr/yfqVZj1Gcc5fZ5WxusBvbDu+CKRyH+frcj4VIWTIYuV1pHZm0vrbwedsN189qbSO5/U+XpOg/l7WM38mRVAfvzX1oNZyVB4GxWHkfnPsSe1Iv41DWCja98zbWXxHBdnxgGdGyBn59b3dwamUVPJVDh9TM1bbg8TFdpo1kq7cynEipOe/4U3DEXgsJZtC+/4vpUp5x2ngX+5ZwpVPL9M1fs8aic1clzwZ68ioNbLWggaKo8PdIvOnrvdYPdF30U0t1eGcesAchst8vSFv/U83KU7qIQfwiKuNBPHhBk9W+eO1T2s91GQZ/bILS5lfa/v7Ya4Utvv9Dg+wday+UcFS/tNI3r7/l5xWWzG1iGTK66HgsmQ6cr4PIHKk7j6dFmqbSVHkXa6XJ/sgzWflN5GatoOJ//z3be+vYA4/2/ZpL/JqbnPQfA/tPneXPVft5ctR+ASy9qxs+v68nQ7tGEeNoguaWrstH2NK2njWaptJUaPrXy/TXIs+CKx/j3hiPMeHslAFf++SviOrVgYOcWDOzUgovbRhLg71e9769OOd3SVhncakgDQWNS1Lh7oqIjfWPgzAFIWQ9HkiAl0TqSf/fmyvPzC4DIdtZR9OldZff3HA1974SQZlajvfhn/P7EMJ7+7bPWWUFAsD2wVepI2m60f5H3CK/84U8Vf/+CydaAmSd/IPZR8cNre5FcUZoaHsF62nBV+Qd5/hSZY95iQ7IVKOes2s/Z7DzOZOVzLiufM1l5nM3K56b0NSzNf5Atz1pB4I6/r+bK2NaM6Nmay9pH4e9+9F5Bw3k4LYs3V+3j46QUAFqRzj8ueoa5143kztlrmT9pCF9uO8GX24+TciabrUfTuX9uEmFB/ozsdSXXhkdydUQVV8q4/S5VNtqepq1hY1gZYwy5BS5y813VyrO8333Gsl3MXLG3zMcOp2VzOC2bhZuOAhDgJ8R3aUGcHRgGdmpBi/Agj8pb0XfXNw0EjUl1rlEvOtKPmwjpKZCSZL2OJFmDpJ7oczsM+xk0aw9h0VY/uqeNdueh/OPYjTwdXkF/bhG70f40ZQSvVJSmhl0ElR5p1/AItjYN19msPL4/kMa6A2msOxDH9s8P4TLWmdALS8ofLN5OyXGOxOQzJCaf4dVluwGIbRPBg1d25crY1lxU6vv3nMhgVsI+Fm0+SqHL6uYa3actN416kb4dmhenG9KtFUO6teLJm3uz83hGcVDYdjSdJf87zpL/HS8OOD/7cCOxbSLoGRNBbEwknVuGXTjarSculyH1fB4n0nM4mZHDifRcTqRb76cycgG47Y3vyMl3kZNf6PZykVNQiPuFkA/MTeTmfu34Qe8YIkMCK/zO0r/7uv2pfLPndPF6x5ah/PK6XkyZv4klj13JhkNn2HDwDBsOnSE5NYu1+9NYuz+tOH23aOss46PEQ8R1bkn31uEVjtNUGVjrgQaCxsT9xp6CPPtyN/fLGE+4XdZ40roi5vVybgIKi7b6kdvHQ8ylsOx3cOUvKh9chGo32tUZOPO00a7qj6Iw8yS7h7/G6u+tq2F2Hc+ge+vwso1VDY9gq+N0Zq7V8O9PZd2BNHYez/D4s7cNaM8Dw7vSPCyQ5mFBhAf50/WJJbx5bxzf7DnFqt2nOZSWxZ6TmTz+6f8A6N46nBE9WzOgUwsArp2xCgB/P2HcwPZMvqo7sTGRFX6niNC7XTN6t2uGyxi2Hb0wxlIUSD7bfLTEZ/wEesZE0qNNBD1jIoltY12hk3z6PGFB/oQFBxAa6F/yzKUcLpchPSef05m5nM7MIzUzj9TzRctW4z729e84mZ7DqYxcClyVXy678dDZSvcXWbHzJCt2Xrhy6oZL2/LKD/sRFlR+07fjWDovLd3FV/ZnWoUH8bOre3D34M4EBfgxZf4mLrmoGZdc1IwfDekMWP8Pfr94G59tuTB58v7T1tVfRb9dkWHdWzHt2p5c2j6KkED/Cst9Ljufw2lZ1utMFofSsjicVosLHqqggaAxyUqD8NbEr3kI1tTippbLH4BRv7GWF0yGjoOrDgIb3yf/cBKzYucAR3hyYfkju8NPbGV3y99ycskBAJ5etBURQQT8RPCz30WEwce2c+CipzmTYHVZrN2fSo82EbQKDyp5dFRJQ1zoMmw7eo41+1JZsz+VxAO9OZ93GrCO1q7/yyqCA/zo3a4Zl7ZvxqUXRXFp+yhiYyIIDqj4D600YwzZ+YWAFVzOZeeTnp3POfuVnuO2nG0Nisc/v7xEHkEBfgzo2JzB3VoxuGtLBnZqQWiQP12mf07yi5UMFru5vk9bru/TFoCDqedZtfsUq/acZs2+VPadOs++U+f5x3fJxd/3w/gOPDyiOx1bhnlcV4Bp1/YsERzP5xbQ5+mlvDS+L3tOZrL7RAZ7TmRy5Gw2O49n2EHuQkM38uWEEvkFB/hZgSEogNAgf8KC/IsbukEvLCftfF6VjfvmwyUb91bhQfRpH0VMZDAxzUKIaRZM68gQHvnnej6dfAUhgf4XXgF+xctFQanL9M95dmwf/rP5GIkH0zAG/rv1OAm7TnF17zbc0rcdI3u1KS7ntI82sXDTEYyB8CB/HhrRjQev7EZEcOXNZHREMH+9eyB/tf/E8gtdbD+aztjXv+PGy9qSlHyGk/aZzHf7Uvlu3xqC/P24rEMU8Z2toP6HJTs4nFbU4GeRnlPxhRddpn9eYn3KNbG1PqPQQNAYHFoH374Ku78AoNzexZjLrGuOI2KsyxiDm8F/f8WXLe/hunt/XX6+HnS5zFi2m5kr9vCw/zd85XqQPUetZwO9t7b8p9q9x3B7ydr/7poKn37H3xmKdaWO1c961+y1Jfb3adeMWwe0p0ebCHq0iaB9c+uqjKKGf619pJ1RyR8FQG6Bi02Hz7LJrSEJ9Bd6xkRy6UVRAPz5i51k5BSQmVtARk4+6TkFZORYy0Xbi46Kr//Lqkq/ryIPXdmVX11/cY0+W57OrcK594pwTmfmsWx72flo8gpc/HPtIf651up+Kq9BmHJNrEffFW43dnfEdyyx/U9f7GRWwr4qP59b4CK3wMWZrLIHMEWNYJF2USH07RBFdEQwrSKCiY4I4qlF2/h08hW0iQyhdWRwpUfLAHGdW1ZZJoAfX9GFH1/RhePncvj8f8f4z5ajbDx0ls+3HOPzLceICA4gzm6MF2w8QqC/cM/gzjx6dQ+iI4I9+o7SAv396NfR6pp74544jDGknMkm6WAaSclnSEo+w+6TGaw/eIb1B62LNGbbA/lFQgP96dgylE4tw+jQIoyOLcPo1DKMh+YleXxQUR0aCOpDeVf4GAN7V1gB4OB31jb/YAgM5Y8Zo3niuTesm24qsmAydB7GpLV9Kh4wraTLxRjDmn2pbLQbzzcLb8HfT7i1XzsWbjrKs2P7VFmtpxZt45lbLsFlwGV3zLqMKV43xvqe/ELDzBV76NexOftOZpKZazXs246ls+3Yhe6J4ACre+em174t8T2dWoZxRbdWDOnekiu6RdM2KgSg+Ej7XFY+246eY+vRc2w9ks7Wo+c4cPo8246mF3d/vOFBY1aRfh2iuKpna5qFBtIsNJCo0EAefm89u5+/gaAA7/eflz56Bzw+y6jtkeLjoy/m8dElg1vp73a5DDkFhWTlFZKdZ71n5RWQnV/I3XPWseaJq2kZHlTpGdpTi7Z53LjXRNuoEB4Y3pUHhnfl959tKz6ryswt4Ovdp4rT5Rca5q5OZu7q5FoFVnciQseWVmOefDqLXSeq7kKcNKIr067tVe3vqikNBPXBHgSe4T+Radd0h+2LrOBwfIu1PzgKBj0IaQcgMJQ3197EE5UFAU/73svpcil0Gb7Yepw3V+1jS8o5wDr6uGtQRx4Y3pUOLcJYuOkoP76iS5XVemrRNiYO61plOrD66Rf9dBjGGE5m5LL3ZCZzVu0nwe2PMLeg/Cs9bhvQvtIGLSoskKE9ohnaI5oZy3azuFQ/d3nGDWzP/cO6EhkSQGRIIBHBAQQF+FWrG6eug0BNGpnGwM9PCAsKqLDfvV2UB9ff16Onb+nD07dYBzrJp8+z7kAqj3/6v3oJrLUJ6t6kgaA+2IPA59PPwI61kGafBoa3gSt+CvH3k75xAWxayIsd3gBSefDdRFqEBdEy3Hq1CA+iZVgQLSOC6HLqCIG3vEVEYPX6hd9fd5A5q/aTnGpd0tgyPIiJQ7tw75DO1brcrTZExO7vDWFYj+gS+85l59Pv919y4I83Vn4nbCUa4x+apw18Q185MrZ7xVfVNCae/nt6Up8u0eF0iQ4vM6hbF5pSYNdAUEseXQN8JhkK8/ld4AeQBjTvTN6Qn7G22WhmrDzExv98w8P+a/jK9TB7TlmXfi7fUc4cMcX6wFeHCPA7DMDA55YR4CcE+vsR6G+9B/j7EVS8bDWqv11gDQB3bBnKpCu7MT6uI6FBng+oeltUqPWHW9Mg0Fg1dAPvqdti6+dgoDzVaTQ9/fdsyPqAd353bwVrDQS1VOmlicZA4lvwxfSS0y+cPUjQF79kBL9kQ8E4NjKeuTKWQT1ackdsNH9YspM3743jzPk8Us/nceZ8HmlZeaw/eIaDqRfu5C26CiPtfDnz8FTicFo2Ty7axunMvHLL7ukfZXX+eL3xH7ghj7ga+ui5Ietene9uKmdDTYW3gpsGAi9JPXOWvEVTaJe8EICzJoIX8u/mE9dIwLoB97L2UQzvEc0HPaIZ2LlF8ZUSf1iys/gSwsrk5Bdy8ZNfkPS7H1BQaMgvdNmvC8sFLkN+gYu731rncZeLp3+U1fnj9cZ/YG80Hp42XL54tOmN724qDXxTCazeooGgDuQVuNh+LJ1Nh86w8fBZjh/cxZPn/8ilfslkmWD+5+rKIdOmOAiAdbKwJeUco3q1YWipvnJPFQUOTy9zawpdLt74o/BGt4PyLU0lsHqLBoJaKLq2+9JnlpJnX/Fypd8W/h74N1r4ZXLcvx272t3CwPSv6PLjufDy2ga/OqCx88YfRWP4Q1OqMdNAUA1FN18BPOK/mE8LRwDN7SBg+D//xfwy4GP8xOCKvY624+bQdv1c6PlPIqOrmJPHTUP3PyulnKV+Z5Nq4qZd25PkF2/i7fviifE7x8MBnwGwefoVJPf/kF8HfoSfGLhqOn4TPrKmVx4+Fdr0rtb3VKf/2RsDu0opZ9EzgmpatfsUk/+5gajCm/k6/Am+KIwn6p/PWA/1Do6CcbOh1+h6K483BnaVUs7i1TMCERktIrtEZK+ITC9nf2cRWSEiW0QkQUQ6eLM8tbV2fyqT3ksir9DFDVf0JzT2Kj4I+oMVBFr3hkkrKw0CelSulGqMvBYIRMQfeB24AbgEmCAil5RK9jIwzxjTF3gW+KO3ylNb6w+mcf/cRHLyXdx1eUeeufkS5Oh6gsSasZJTO+CvA+GZKFhZfjX0qFwp1Rh5s2toELDXGLMfQETmA2OB7W5pLgGKnjW4EljoxfLU2JaUs0x8J5GsvEJuG9CeF267DL/9KyH9KDn+EYT85qD1sHGllGqCxJjK5wivccYi44HRxpgH7fV7gcHGmEfd0nwArDPGzBSRccCnQLQxJrVUXpOASQAxMTFx8+fPL/FdmZmZRERE1Gn5F+zJ47bYIA6lF/KnxBzO58Plbf15pG8w/n7C4LUPE5pznIOdxnOg2711+t3eqE9D87U6+Vp9wPfq5Gv1gdrVadSoUeuNMfHl7jTGeOUFjAfeclu/F/hbqTQXAf8GNgIzgRSgeWX5xsXFmdJWrlxZZlttdX78P2b38XQz8NkvTefH/2MemJto8goKrZ3r5hjzdJQxTzczJnVfnX+3N+rT0HytTr5WH2N8r06+Vh9jalcnIMlU0K56sz/jCOD+lIsO9jb3IHQUGAcgIhHA7cYYz55BVw/ueWsdqefzGNGzNa/fM4DAosch7l8JGOhyJbTs1qBlVEqp2vLmVUOJQKyIdBWRIOAuYLF7AhGJFpGiMjwBvOPF8njscJo1sdvJjFyu6NaKN38UV/KhGun2fPcDf9wApVNKqbrltUBgjCkAHgWWAjuAj40x20TkWREZYycbCewSkd1ADPCCt8rjqczcAu55ax0A8Z1b8NZ98SWnaj6+1XooTHAU9L6lgUqplFJ1x6uXuhhjlgBLSm17ym35X8C/vFkGT7hPHeEu6eAZ+jy9tHh9yjWxTCt4z1rpewcENq4nLymlVE3oNY+UfKrVE//ewoffWw98KTNBXEEuvPKRtTygbq8UUkqphqJzDZXy3d7Uinfu/A9kn4G2feGi/vVXKKWU8iINBG4Op2VxKC2LyJAKTpQ2zLPedZBYKeVDNBC4WbPPOhsY0q2cKaPPHIT9CeAfDJeNr9+CKaWUF+kYgZvv9p0GYGj3VlzSrlnJnZvet94vGQuhLeq5ZEop5T0aCGzGGFbbZwTDekTTMybywk5XIWz8p7U8UAeJlVK+RbuGbHtPZnIqI5fWkcHEtik1l8e+lZB+BFp0gc7DG6R8SinlLRoIbN/tvdAtVOYh7xvtQeIB94Kf/pMppXyLtmq274q6hbpHl9xx/jTsXALiB/3vboCSKaWUd2kgAAoKXazdbwWCK7qXumJo83xw5UOPa6HZRQ1QOqWU8i4NBMDWo+lk5BTQqWUYHVuGXdhhDGy0p5TQeweUUj5KAwGw2r5sdFiPUmcDKUlwaieEt4Ge1zdAyZRSyvs0EACr7WklhpYeH9jwrvXe7y7wD6znUimlVP1wfCDIyS8kMTkNKDU+kJsJ2xZYyzrBnFLKhzk+EGw4dIbcAhcXt40kOiL4wo5tCyAvEzpdAa17NlwBlVLKyxwfCIrmFyruFvp2BmScuDDBnJ4NKKV8nOMDQdGNZMUDxZknYfnTkPI9BEVCn1sbsHRKKeV9jg4EGTn5bE45h7+fMKhrS2vjsCmw7d/W8mW3Q1B4wxVQKaXqgaMDwfcH0ih0Gfp1iCIyxL4qKLQlYE8xMUDvHVBK+T5Hzz76XXmXjR7fAgU51vJbV5f8wFXTYdQT9VQ6pZSqH44OBEU3kg11v5HsXIr13qYP/N/qBiiVUkrVL8d2DZ3OzGXn8QyCA/wY2MntQTNrZ1nvMX0apmBKKVXPHBsIii4bvbxLS0IC/a2NG9+HtP3WcljLBiqZUkrVL8cGgnK7hc6fgotvtpb1cZRKKYfwaiAQkdEisktE9orI9HL2dxKRlSKyUUS2iMiN3iyPu9WlbyQDGD71woNnNBAopRzCa4FARPyB14EbgEuACSJySalkvwM+NsYMAO4C3vBWedylnMniYGoWkSEBXNY+quTO7DPWuwYCpZRDePOMYBCw1xiz3xiTB8wHxpZKY4Bm9nIUcNSL5SlWNNvokG6t8Pcr9VjK4kCgYwRKKWcQY4x3MhYZD4w2xjxor98LDDbGPOqWph3wJdACCAd+YIxZX05ek4BJADExMXHz588vsT8zM5OIiIjSH6vQ3zfnsPZYIff0DuLaziWnlx64/hc0y9jL+oEvkdGsYSabq259mgJfq5Ov1Qd8r06+Vh+oXZ1GjRq13hgTX96+hr6PYAIw1xjziohcAbwnIpcaY1zuiYwxs4HZAPHx8WbkyJElMklISKD0tooYY/jVdyuAQiaOHkJsTGTJBJsLAIgbdg206l6DKtVederTVPhanXytPuB7dfK1+oD36uTNrqEjQEe39Q72NncPAB8DGGPWACFAqafD1K29JzM5lZFL68hgerQpJ7Jm6RiBUspZvBkIEoFYEekqIkFYg8GLS6U5BFwDICK9sQLBKS+WqXi20aHdWyFSanygsAByzwECIVFlP6yUUj7Ia4HAGFMAPAosBXZgXR20TUSeFZExdrJfAA+JyGbgQ2Ci8daghe07+7LRYaUfSwmQc856D20Ofv7eLIZSSjUaXh0jMMYsAZaU2vaU2/J2YJg3y+CuoNDF2v32/QOlH1QPeumoUsqRHHVn8baj6WTkFNC5VRgdWoSVTZBtPbtYA4FSykkcFQj+9MVOwBofKJeeESilHMhRgaDcaSXcaSBQSjmQYwJBTn5h8XLVZwR6V7FSyjkcEwg2HjoLwMVtI2kVEVx+Ij0jUEo5kGMCQdG008N6VHK/WpYOFiulnKehp5jwmhnLdjNzxZ4y29/+9gBvf3ugeH3KNbFMu9aeU0jPCJRSDuSzgWDatT0vNPDAlpSzjPnbd/zvmeuIDAks/0NFgUCfTqaUchDHdA317dAcoOIgAHpGoJRyJMcEAo9oIFBKOZAGAnd6Z7FSyoEcFQimXBNb8U5XoT3pnM48qpRyFkcFAvfB4zKKZh4NidKZR5VSjuKoQFApHR9QSjmUBoIiGgiUUg5VZSAQkVtExPcDht5VrJRyKE8a+DuBPSLyZxG52NsFajB6RqCUcqgqA4Ex5kfAAGAfMFdE1ojIJBGJ9Hrp6pPeVayUciiPunyMMenAv98qffwAAB3sSURBVID5QDvgNmCDiPzMi2WrX3pGoJRyKE/GCMaIyAIgAQgEBhljbgD6YT183jdoIFBKOZQnk87dDswwxqxy32iMyRKRB7xTrAagdxUrpRzKk0DwDHCsaEVEQoEYY0yyMWaFtwpW7/TpZEoph/JkjOATwOW2Xmhv8y3aNaSUcihPAkGAMSavaMVeDvJekRqIBgKllEN5EghOiciYohURGQuc9l6RGogGAqWUQ3kSCB4BfiMih0TkMPA48LAnmYvIaBHZJSJ7RWR6OftniMgm+7VbRM5Wr/h1xFUI2fZX68yjSimHqXKw2BizDxgiIhH2eqYnGYuIP/A6cC2QAiSKyGJjzHa3vKe5pf8Z1o1r9S/nHGCsIODvs0/vVEqpcnnU6onITUAfIEREADDGPFvFxwYBe40x++085gNjge0VpJ8APO1JeeqcdgsppRysykAgIn8HwoBRwFvAeOB7D/JuDxx2W08BBlfwHZ2BrsBXFeyfBEwCiImJISEhocT+zMzMMtuqIzJ9N3FAekEAG2qRT12pbX0aI1+rk6/VB3yvTr5WH/BinYwxlb6ALaXeI4BvPPjceOAtt/V7gb9VkPZx4K9V5WmMIS4uzpS2cuXKMtuqZfeXxjzdzJh5t9YunzpS6/o0Qr5WJ1+rjzG+Vydfq48xtasTkGQqaFc9GSzOsd+zROQiIB9rvqGqHAE6uq13sLeV5y7gQw/y9A7tGlJKOZgngeAzEWkOvARsAJKBDzz4XCIQKyJdRSQIq7FfXDqRPbV1C2CNp4Wuc3pXsVLKwSodI7AfSLPCGHMW+FRE/gOEGGPOVZWxMaZARB4FlgL+wDvGmG0i8izWKUpRULgLmG+fujQMPSNQSjlYpYHAGOMSkdexL+s0xuQCuZ5mboxZAiwpte2pUuvPeJqf12ggUEo5mCddQytE5HYpum7UF+ljKpVSDuZJIHgYa5K5XBFJF5EMEUn3crnql54RKKUczJM7i33rkZTl0cdUKqUczJMbykaUt92UelBNk6ZnBEopB/NkiolfuS2HYE0dsR642islaggaCJRSDuZJ19At7usi0hH4i9dKVN9cLsgpmnm0ecOWRSmlGoAng8WlpQC967ogDSb3HBgXBOvMo0opZ/JkjOCvQNHNXn5Af6w7jH1DcbeQng0opZzJk0PgJLflAuBDY8x3XipP/dPxAaWUw3kSCP4F5BhjCsF64IyIhBljsrxbtHqigUAp5XAe3VkMhLqthwLLvVOcBpClgUAp5WyeBIIQ4/Z4Sns5zHtFqmd6M5lSyuE8CQTnRWRg0YqIxAHZ3itSPdOuIaWUw3kyRjAV+EREjgICtAXu9Gqp6pMGAqWUw3lyQ1mi/fCYXvamXcaYfO8Wqx5pIFBKOVyVXUMi8lMg3Biz1RizFYgQkf/zftHqSbZOQa2UcjZPxggesp9QBoAx5gzwkPeKVM/0MZVKKYfzJBD4uz+URkT8gSDvFameadeQUsrhPBks/gL4SETetNcfBv7rvSLVMw0ESimH8yQQPA5MAh6x17dgXTnU9LlcOteQUsrxquwaMsa4gHVAMtazCK4Gdni3WPUkN92eebQZ+Ac2dGmUUqpBVHhGICI9gQn26zTwEYAxZlT9FK0e6NmAUkpV2jW0E/gGuNkYsxdARKbVS6nqi44PKKVUpV1D44BjwEoRmSMi12DdWew7NBAopVTFgcAYs9AYcxdwMbASa6qJNiIyS0Su8yRzERktIrtEZK+ITK8gzQ9FZLuIbBORD2pSiRrTQKCUUh4NFp83xnxgP7u4A7AR60qiStn3G7wO3ABcAkwQkUtKpYkFngCGGWP6YAWb+qM3kymlVPWeWWyMOWOMmW2MucaD5IOAvcaY/caYPGA+MLZUmoeA1+27lTHGnKxOeWpNzwiUUsqj+whqqj1w2G09BRhcKk1PABH5DvAHnjHGfFE6IxGZhHUvAzExMSQkJJTYn5mZWWabJ7rv3UJHYO/RNFJq8HlvqWl9GjNfq5Ov1Qd8r06+Vh/wXp28GQg8/f5YYCRWt9MqEbnMfW4jAGPMbGA2QHx8vBk5cmSJTBISEii9zSNn5kMK9Lg0nh4DavB5L6lxfRoxX6uTr9UHfK9OvlYf8F6dqtU1VE1HgI5u6x3sbe5SgMXGmHxjzAFgN1ZgqB9ZOvOoUkp5MxAkArEi0lVEgoC7gMWl0izEOhtARKKxuor2e7FMJeljKpVSynuBwBhTADwKLMWakuJjY8w2EXlWRMbYyZYCqSKyHesS1V8ZY1K9VaYydLBYKaW8O0ZgjFkCLCm17Sm3ZQP83H7VPw0ESinl1a6hxs2YC4EgROcaUko5l3MDQW46mEIIioQA33nOjlJKVZdzA4F2CymlFKCBQKegVko5ngYCPSNQSjmcBgINBEoph3NuICi6q1hvJlNKOZxzA0G2PZ2RnhEopRzOwYFAu4aUUgo0EGggUEo5noMDgc48qpRS4OhAoI+pVEop0ECgZwRKKcfTQKCBQCnlcM4MBO4zj+oUE0oph3NmIMjNAFcBBIZDQHBDl0YppRqUMwOBPqJSKaWKOTsQaLeQUko5PRDoQLFSSmkgUEoph3NoICi6q1jHCJRSyqGBQM8IlFKqiEMDgU5BrZRSRRwaCPSMQCmlimggUEoph/NqIBCR0SKyS0T2isj0cvZPFJFTIrLJfj3ozfIU08dUKqVUsQBvZSwi/sDrwLVACpAoIouNMdtLJf3IGPOot8pRLj0jUEqpYt48IxgE7DXG7DfG5AHzgbFe/D7PaSBQSqliYozxTsYi44HRxpgH7fV7gcHuR/8iMhH4I3AK2A1MM8YcLievScAkgJiYmLj58+eX2J+ZmUlERIRnBTOGEavG42cKWHXlJ7j8g2pQO++qVn2aCF+rk6/VB3yvTr5WH6hdnUaNGrXeGBNf7k5jjFdewHjgLbf1e4G/lUrTCgi2lx8Gvqoq37i4OFPaypUry2yrUE6GMU83M+b5tp5/pp5Vqz5NhK/VydfqY4zv1cnX6mNM7eoEJJkK2lVvdg0dATq6rXewt7kHoVRjTK69+hYQ58XyWPSuYqWUKsGbgSARiBWRriISBNwFLHZPICLt3FbHADu8WB6Ljg8opVQJXrtqyBhTICKPAksBf+AdY8w2EXkW6xRlMfCYiIwBCoA0YKK3ylNMp6BWSqkSvBYIAIwxS4AlpbY95bb8BPCEN8tQhp4RKKVUCc67s1ifTqaUUiU4LxAU3VWsZwRKKQU4MRBo15BSSpXgwECgU1ArpZQ7BwYCPSNQSil3Xr1qqFHSG8qUj8jPzyclJYWcnJw6yS8qKoodO7x/K0998bX6gGd1CgkJoUOHDgQGBnqcrwMDgZ4RKN+QkpJCZGQkXbp0QURqnV9GRgaRkZF1ULLGwdfqA1XXyRhDamoqKSkpdO3a1eN8tWtIqSYqJyeHVq1a1UkQUL5BRGjVqlW1zxKdFQiM0TuLlU+pSRCYsWy3F0qiGoua/J9wViDIz4LCPAgIhcDQhi6NUg1i5oo9DV0E1cg4KxDoIyqVqjOjRo1i6dKlJbb95S9/YfLkyRV+ZuTIkSQlJQFw4403cvbs2TJpnnnmGV5++eVKv3vhwoVs337hYYdPPfUUy5cvr07xKzV16lTat2+Py+WqszwbM2cFAh0fUKrOTJgwgdIPiZo/fz4TJkzw6PNLliyhefOaddGWDgTPPvssP/jBD2qUV2kul4sFCxbQsWNHvv766zrJszwFBQVey7u6nHXVkAYC5aO6TP/cK+mTX7ypwn3jx4/nd7/7HXl5eQQFBZGcnMzRo0e58sormTx5MomJiWRnZzN+/Hh+//vfly1Dly4kJSURHR3NCy+8wLvvvkubNm3o2LEjcXHWo0nmzJnD7NmzycvLo0ePHrz33nts2rSJxYsX8/XXX/P888/z6aef8txzz3HzzTczfvx4VqxYwS9/+Uvy8vIYPHgws2bNIjg4mC5dunDffffx2WefkZ+fzyeffMLFF19cplwJCQn06dOHO++8kw8//JBRo0YBcOLECR555BH2798PwKxZsxg6dCjz5s3j5ZdfRkTo27cv7733HhMnTiwuD0BERASZmZkkJCTw5JNP0qJFC3bu3Mnu3bu59dZbOXz4MDk5OUyZMoVJkyYB8MUXX/Cb3/yGwsJCoqOjWbZsGf3792ft2rW0bt0al8tFz549WbNmDa1bt/bo96yIQ88IdKBYqdpq2bIlgwYN4r///S9gnQ388Ic/RER44YUXSEpKYsuWLXz99dds2bKlwnzWr1/P/Pnz2bRpE0uWLCExMbF437hx40hMTGTz5s307t2bt99+m6FDhzJmzBheeuklNm3aRPfu3YvT5+TkMHHiRD766CPWrl1LQUEBs2bNKt4fHR3Nhg0bmDx5coXdTx9++CETJkzgtttu4/PPPyc/Px+Axx57jKuuuorNmzezYcMG+vTpw7Zt23j++ef56quv2Lx5MzNnzqzy323Dhg3MnDmT3butQft33nmH9evXk5SUxGuvvUZqaiqnTp3ioYce4tNPP2Xz5s188skn+Pn5ceedd/L+++8DsHz5cvr161frIACOPSPQMQLlWyo7ci+ty/TPy01fk+vui7qHxo4dy/z583n77bcB+Pjjj5k9ezYFBQUcO3aM7du307dv33Lz+Oabb7jtttsICwsDYMyYMcX7tm7dyu9+9zvOnj1LZmYm119/faXl2bVrF127dqVnz55kZGRw33338frrrzN16lTACiwAcXFx/Pvf/y7z+by8PJYsWcKrr75KZGQkgwcPZunSpdx888189dVXzJs3DwB/f3+ioqKYN28ed9xxB9HR0YAVHKsyaNCgEtf4v/baayxYsACAw4cPs2fPHk6dOsWIESOK0xXle++993LPPfcwdepU3nnnHX7yk59U+X2ecFgg0JlHlapLY8eOZdq0aWzYsIGsrCzi4uI4cOAAL7/8MomJibRo0YKJEyfW+O7niRMnsnDhQvr168fcuXNJSEioVXmDg4MBqyEvr49+6dKlnD17lssuuwyArKwsQkNDufnmm6v1PQEBAcUDzS6Xi7y8vOJ94eHhxcsJCQksX76cNWvWEBYWxsiRIyv9t+rQoQMxMTF89dVXfP/998VnB7Xl0K4hDQRK1YWIiAhGjRrF/fffXzxInJ6eTnh4OFFRUZw4caK466giI0aMYOHChWRnZ5ORkcFnn31WvC8jI4N27dqRn59fotGLjIwkIyOjTF69evUiOTmZvXv3AvDee+9x1VVXeVyfDz/8kLfeeovk5GSSk5M5cOAAy5YtIysri2uuuaa4m6mwsJBz585x9dVX88knn5CamgpAWpp1sNmlSxfWr18PwOLFi4u7l0o7d+4cLVq0ICwsjJ07d7J27VoAhgwZwqpVqzhw4ECJfAEefPBBfvSjH3HHHXfg7+/vcd0qo4FAKVUrEyZMYPPmzcWBoF+/fgwYMICLL76Yu+++m2HDhlX6+YEDB3LnnXfSr18/brjhBi6//PLifc899xyDBw9m2LBhJQZ277rrLl566SUGDBjAvn37ireHhITwj3/8gzvuuIMhQ4bg5+fHI4884lE9srKy+OKLL7jppgvdZuHh4QwfPpzPPvuMmTNnsnLlSi677DLi4uLYvn07ffr04be//S1XXXUV/fr14+c//zkADz30EF9//TX9+vVjzZo1Jc4C3I0ePZqCggJ69+7N9OnTGTJkCACtW7dm9uzZjBs3jn79+nHnnXcWf2bMmDFkZmbWWbcQYM1N0ZRecXFxprSVK1eW2VauD+825ulmxmxb5Fn6BuJxfZoQX6tTY6jP9u3ba/S5V7/cVe729PT02hSn0fG1+hhj1SkxMdEMHz680nTl/d/AelZ8ue2qw8YI9DGVSk27tmdDF0HV0Kuvvso777xTZ2MDRZzVNaSPqVRKNWE///nPOXjwIMOHD6/TfJ0VCHSMQCmlynBOICgx86gGAqWUKuKcQJCfDYW5EBCiM48qpZQbrwYCERktIrtEZK+ITK8k3e0iYkQk3muF0buKldN9OwMyTjR0KVQj5LVAICL+wOvADcAlwAQRuaScdJHAFGCdt8oC6F3FSmWehO+qngvHU6mpqfTv35/+/fvTtm1b2rdvX7zufidteZKSknjssceq/I6hQ4fWVXEB500v7SlvnhEMAvYaY/YbY/KA+cDYctI9B/wJqJsncFdExweU0w2bAps/qLOzglatWrFp0yY2bdrEI488wrRp04rXg4KCKp1mOT4+ntdee63K71i9enWdlBWcOb20p7x5H0F74LDbegow2D2BiAwEOhpjPheRX1WUkYhMAiYBxMTElJlvpGh618pEn1rNpcCp8wVsq+V8Jd7mSX2aGl+rU2OoT1RUVPE0C5GvdPD8g6+Ufx9BedPNZfwixaMsc3NzCQwM5J577iEkJITNmzczZMgQbr/9dh5//HFyc3MJCQlh1qxZxMbG8s033/Daa6/xySef8Ic//IGUlBSSk5NJSUlh8uTJxQ+3adeuHceOHeObb77hj3/8I61atWL79u3079+ft956CxFh6dKl/OY3vyE8PJzBgweTnJzMJ598QmFhYYlpKL7++mt69erFuHHjmDdvHvHxVk/0yZMnmTp1KsnJyQDMmDGDwYMH88EHH/DXv/4VEaFPnz7MmTOHRx55hNGjR3PrrbeWKd/zzz9P8+bN2b17Nxs3bmTChAkcOXKEnJwcJk+eXHwn8LJly3j22WcpLCykVatWLFq0iIEDB7J8+XKio6NxuVwMGDCAFStWFE9mV6R0nSqSk5NTrf+fDXZDmYj4Aa8CE6tKa4yZDcwGiI+PNyNHjiyxPyEhgdLbylifDNugdaeeVadtYB7Vp4nxtTo1hvrs2LGj2rOFVpen+QcHBxMcHExgYCAnTpxg3bp1+Pv7k56ezurVqwkICGD58uW88MILfPrpp4SFhREQEEBkZCTBwcHs27ePlStXkpGRQa9evZg2bRqBgYHFZQgLC2PLli1s27aNiy66iGHDhrFlyxbi4+OZNm0aq1atomvXrkyYMKE439KzqS5atIh7772XsWPH8txzzxESEkJgYCAPPvgg11xzDVOnTqWwsJDMzEwOHTrEK6+8wurVq4mOjiYtLY3IyEgCAwMJDQ0tkW9R+TZv3szWrVuLZwydN28eLVu2JDs7m8svv5x77rkHl8vFlClTisublpZGVFQUP/7xj1m0aBFTp07lyy+/ZMCAASVmKC3i6QyxISEhDBgwwKPfDrwbCI4AHd3WO9jbikQClwIJ9sOW2wKLRWSMMSapTkvy7QzIsaOodg0pX/TMuarT5J2H2aNg+FTof3eZ3TWZhro87pOhnTt3jvvuu489e/YgIhVOvnbTTTcVB5M2bdpw4sQJOnQoeZYzaNCg4m39+/cnOTmZiIgIunXrVtxoTpgwgdmzZ5fJv7FPL33//fczduzYOp9e2lPeDASJQKyIdMUKAHcBxf/7jDHngOLzHhFJAH5Z50EArEGyg3ZfowYC5VSf/xI6xJcbBOqS+wRrTz75JKNGjWLBggUkJydXeBZVND00VDxFtCdpKtLYp5fu2LGjV6aX9pTXBouNMQXAo8BSYAfwsTFmm4g8KyJjKv90HRs2BU7azzfVQKCcaOP7cHQD3PhSvX7tuXPnaN++PQBz586t8/x79erF/v37i/v3P/roo3LTOXV6aU959T4CY8wSY0xPY0x3Y8wL9ranjDGLy0k70itnAwCRbaGZ9Z9RA4FypPOn4I65EFT+dMje8utf/5onnniCAQMGeOVqmtDQUN544w1Gjx5NXFwckZGRREVFlUjj6OmlPSTW7KRNR3x8vElKKhkvPBq4m3szJH9TdvtV02HUE3VXwDrQGAYi65qv1akx1GfHjh307t27zvKrqzGC+paZmUlERATGGH76058SGxvLtGnTmlx9kpKSmDZtGt98U047ZfO0TuX93xCR9caYcm/adcY01HnnrXGCW2d5vX9UKVW/5syZw7vvvkteXh4DBgzg4YcfbugiVduLL77IrFmz6n1soIgzAkE9DZIpperftGnTmDZtWkMXo1amT5/O9OkVzsLjdb4fCIoGyR76qqFLolSdM8ZgX36tFGD9n6gu3599tIEGyZTytpCQEFJTU2v0h698kzGG1NRUQkJCqvU53z8jGD61oUuglFd06NCBlJQUTp06VSf55eTkVLsBacx8rT7gWZ1CQkLK3IxXFd8PBEr5qMDAwHKnIaiphISEak1L0Nj5Wn3Ae3Xy/a4hpZRSldJAoJRSDqeBQCmlHK7J3VksIqeAg6U2RwOnG6A43uJr9QHfq5Ov1Qd8r06+Vh+oXZ06G2Nal7ejyQWC8ohIUkW3TjdFvlYf8L06+Vp9wPfq5Gv1Ae/VSbuGlFLK4TQQKKWUw/lKICj7SKKmzdfqA75XJ1+rD/henXytPuClOvnEGIFSSqma85UzAqWUUjWkgUAppRyuSQcCERktIrtEZK+INNxk3nVIRJJF5H8isklEvPPoTi8TkXdE5KSIbHXb1lJElonIHvu9yTwztIL6PCMiR+zfaZOI3NiQZawOEekoIitFZLuIbBORKfb2pvwbVVSnJvk7iUiIiHwvIpvt+vze3t5VRNbZbd5HIhJUJ9/XVMcIRMQf2A1cC6QAicAEY8z2Bi1YLYlIMhBvjGmyN8KIyAggE5hnjLnU3vZnIM0Y86IdtFsYYx5vyHJ6qoL6PANkGmNebsiy1YSItAPaGWM2iEgksB64FZhI0/2NKqrTD2mCv5NYD5kIN8Zkikgg8C0wBfg58G9jzHwR+Tuw2Rgzq7bf15TPCAYBe40x+40xecB8YGwDl0kBxphVQFqpzWOBd+3ld7H+SJuECurTZBljjhljNtjLGcAOoD1N+zeqqE5NkrFk2quB9ssAVwP/srfX2W/UlANBe+Cw23oKTfiHd2OAL0VkvYhMaujC1KEYY8wxe/k4ENOQhakjj4rIFrvrqMl0o7gTkS7AAGAdPvIblaoTNNHfSUT8RWQTcBJYBuwDzhpjCuwkddbmNeVA4KuGG2MGAjcAP7W7JXyKsfojm2af5AWzgO5Af+AY8ErDFqf6RCQC+BSYaoxJd9/XVH+jcurUZH8nY0yhMaY/0AGrB+Rib31XUw4ER4CObusd7G1NmjHmiP1+EliA9R/AF5yw+3GL+nNPNnB5asUYc8L+Q3UBc2hiv5Pd7/wp8L4x5t/25ib9G5VXp6b+OwEYY84CK4ErgOYiUvRAsTpr85pyIEgEYu1R9CDgLmBxA5epVkQk3B7oQkTCgeuArZV/qslYDNxnL98HLGrAstRaUYNpu40m9DvZA5FvAzuMMa+67Wqyv1FFdWqqv5OItBaR5vZyKNZFMTuwAsJ4O1md/UZN9qohAPtSsL8A/sA7xpgXGrhItSIi3bDOAsB6jOgHTbFOIvIhMBJrytwTwNPAQuBjoBPWNOI/NMY0iQHYCuozEqu7wQDJwMNu/euNmogMB74B/ge47M2/wepTb6q/UUV1mkAT/J1EpC/WYLA/1gH7x8aYZ+02Yj7QEtgI/MgYk1vr72vKgUAppVTtNeWuIaWUUnVAA4FSSjmcBgKllHI4DQRKKeVwGgiUUsrhNBAoZRORQrdZKjfV5Yy2ItLFffZSpRqTgKqTKOUY2fYt/Uo5ip4RKFUF+xkRf7afE/G9iPSwt3cRka/sCc1WiEgne3uMiCyw55LfLCJD7az8RWSOPb/8l/Ydo4jIY/Y8+ltEZH4DVVM5mAYCpS4ILdU1dKfbvnPGmMuAv2HdzQ7wV+BdY0xf4H3gNXv7a8DXxph+wEBgm709FnjdGNMHOAvcbm+fDgyw83nEW5VTqiJ6Z7FSNhHJNMZElLM9GbjaGLPfntjsuDGmlYicxnoYSr69/ZgxJlpETgEd3G/9t6dGXmaMibXXHwcCjTHPi8gXWA++WQgsdJuHXql6oWcESnnGVLBcHe5zwhRyYYzuJuB1rLOHRLfZJZWqFxoIlPLMnW7va+zl1Viz3gLcgzXpGcAKYDIUP1wkqqJMRcQP6GiMWQk8DkQBZc5KlPImPfJQ6oJQ+4lQRb4wxhRdQtpCRLZgHdVPsLf9DPiHiPwKOAX8xN4+BZgtIg9gHflPxnooSnn8gX/awUKA1+z555WqNzpGoFQV7DGCeGPM6YYui1LeoF1DSinlcHpGoJRSDqdnBEop5XAaCJRSyuE0ECillMNpIFBKKYfTQKCUUg73/6hrmYewJ0iOAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DyjBu0nZ-1I6",
        "outputId": "f2fac5e8-10fc-49b4-ea5d-fcbec21b9e03"
      },
      "source": [
        "#Printing the classification report\r\n",
        "from sklearn.metrics import classification_report\r\n",
        "predictions = cnn_model.predict_classes(x_test_gray)\r\n",
        "print(classification_report(y_test,predictions))"
      ],
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/sequential.py:450: UserWarning: `model.predict_classes()` is deprecated and will be removed after 2021-01-01. Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype(\"int32\")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).\n",
            "  warnings.warn('`model.predict_classes()` is deprecated and '\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       1.00      0.98      0.99        60\n",
            "           1       0.98      0.98      0.98       720\n",
            "           2       0.96      0.99      0.98       750\n",
            "           3       0.97      0.94      0.95       450\n",
            "           4       0.99      0.98      0.99       660\n",
            "           5       0.93      0.95      0.94       630\n",
            "           6       1.00      0.83      0.91       150\n",
            "           7       0.96      0.92      0.94       450\n",
            "           8       0.92      0.98      0.95       450\n",
            "           9       0.96      1.00      0.98       480\n",
            "          10       0.99      1.00      0.99       660\n",
            "          11       0.93      1.00      0.96       420\n",
            "          12       0.94      0.98      0.96       690\n",
            "          13       0.99      1.00      0.99       720\n",
            "          14       1.00      0.99      1.00       270\n",
            "          15       0.98      1.00      0.99       210\n",
            "          16       1.00      0.99      0.99       150\n",
            "          17       0.99      0.97      0.98       360\n",
            "          18       0.95      0.90      0.93       390\n",
            "          19       1.00      0.95      0.97        60\n",
            "          20       0.86      0.98      0.92        90\n",
            "          21       0.98      0.69      0.81        90\n",
            "          22       0.90      0.97      0.94       120\n",
            "          23       0.85      0.94      0.90       150\n",
            "          24       0.99      0.86      0.92        90\n",
            "          25       0.99      0.96      0.97       480\n",
            "          26       0.95      0.87      0.91       180\n",
            "          27       0.72      0.97      0.83        60\n",
            "          28       1.00      0.99      1.00       150\n",
            "          29       0.99      0.99      0.99        90\n",
            "          30       1.00      0.75      0.86       150\n",
            "          31       0.94      0.99      0.97       270\n",
            "          32       0.97      1.00      0.98        60\n",
            "          33       1.00      0.99      0.99       210\n",
            "          34       1.00      0.99      1.00       120\n",
            "          35       1.00      0.99      0.99       390\n",
            "          36       0.97      0.95      0.96       120\n",
            "          37       0.98      1.00      0.99        60\n",
            "          38       0.97      0.99      0.98       690\n",
            "          39       0.96      0.94      0.95        90\n",
            "          40       0.94      0.81      0.87        90\n",
            "          41       1.00      0.68      0.81        60\n",
            "          42       1.00      0.99      0.99        90\n",
            "\n",
            "    accuracy                           0.97     12630\n",
            "   macro avg       0.96      0.94      0.95     12630\n",
            "weighted avg       0.97      0.97      0.96     12630\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kHKTkLl14yF6"
      },
      "source": [
        "# save model\n",
        "cnn_model.save(\"./road_sign_model_31_12_7.h5\")"
      ],
      "execution_count": 166,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ax-v3enB4yF7"
      },
      "source": [
        ""
      ],
      "execution_count": 166,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "zTS3ICPi4yF7",
        "outputId": "8807ddad-c62f-4ed1-ef27-8a97f905ec4d"
      },
      "source": [
        "%%javascript\n",
        "<!-- Save the notebook -->\n",
        "IPython.notebook.save_checkpoint();"
      ],
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "<!-- Save the notebook -->\n",
              "IPython.notebook.save_checkpoint();"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FauIw0N84yF8"
      },
      "source": [
        ""
      ],
      "execution_count": 167,
      "outputs": []
    }
  ]
}