ResNet50.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from keras import layers\n",
    "from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D, Dropout\n",
    "from keras.models import Model, load_model\n",
    "from keras.preprocessing import image\n",
    "from keras.utils import layer_utils\n",
    "from keras.utils.data_utils import get_file\n",
    "from keras.applications.imagenet_utils import preprocess_input\n",
    "import pydot\n",
    "from IPython.display import SVG\n",
    "from keras.utils.vis_utils import model_to_dot\n",
    "from keras.utils import plot_model\n",
    "from keras.initializers import glorot_uniform\n",
    "import scipy.misc\n",
    "from matplotlib.pyplot import imshow\n",
    "%matplotlib inline\n",
    "\n",
    "import keras.backend as K\n",
    "K.set_image_data_format('channels_last')\n",
    "K.set_learning_phase(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import h5py\n",
    "import math\n",
    "\n",
    "def load_dataset():\n",
    "    train_dataset = h5py.File(r'C:\\Users\\harla\\Desktop\\Jupyter Notebooks\\ResNet\\Dataset\\signs\\train_signs.h5', \"r\")\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "    test_dataset = h5py.File(r'C:\\Users\\harla\\Desktop\\Jupyter Notebooks\\ResNet\\Dataset\\signs\\test_signs.h5', \"r\")\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "    \n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identity block \n",
    "\n",
    "In this block, input activation (say $a^{[l]}$) has the same dimension as the output activation (say $a^{[l+2]}$). Here is a diagram illustrating how this works:\n",
    "\n",
    "<img src=\"files\\images\\idblock2_kiank.png\" style=\"width:650px;height:150px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 1** </u><font color='purple'>  : **Identity block.** Skip connection \"skips over\" 2 layers. </center></caption>\n",
    "\n",
    "The upper path is the shortcut path through which the activation in the previous layers \"skips\" through and is added and is added to the output of the main path before the non-linearity computation. \n",
    "\n",
    "Here, I have performed skipping over 3 hidden layers rather than just 2 which is described in the figure below. \n",
    "<img src=\"files\\images\\idblock3_kiank.png\" style=\"width:650px;height:150px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 2** </u><font color='purple'>  : **Identity block.** Skip connection \"skips over\" 3 layers. </center></caption>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implementation of Identity Block\n",
    "\n",
    "def identity_block(X, f, filters, stage, block):\n",
    "    \"\"\"\n",
    "    Implementation of the identity block as defined in Figure 3\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the identity block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value. You'll need this later to add back to the main path. \n",
    "    X_shortcut = X\n",
    "    \n",
    "    # First component of main path\n",
    "    X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "        \n",
    "    # Second component of main path \n",
    "    X = Conv2D(filters = F2, kernel_size = (f,f), strides = (1,1), padding = 'same', name = conv_name_base + '2b',kernel_initializer = glorot_uniform())(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    # Third component of main path \n",
    "    X = Conv2D(filters = F3, kernel_size = (1,1), strides = (1,1) ,padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = Add()([X,X_shortcut])\n",
    "    X = Activation('relu')(X)\n",
    "   \n",
    "    \n",
    "    return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolution Block\n",
    "\n",
    "This block is different from the identity block in the sense that in shotcut step, convolution is used. This is to map the inout of the block to have same dimension as the output of the block, so that the two can be added, before applying the non-linearity step. The figure below explains how this block works. \n",
    "\n",
    "<img src=\"files\\images\\convblock_kiank.png\" style=\"width:650px;height:150px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 3** </u><font color='purple'>  : **Convolutional block** </center></caption>\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convolutional_block(X, f, filters, stage, block, s = 2):\n",
    "    \"\"\"\n",
    "    Implementation of the convolutional block as defined in Figure 4\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    s -- Integer, specifying the stride to be used\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value\n",
    "    X_shortcut = X\n",
    "\n",
    "    ##### MAIN PATH #####\n",
    "    # First component of main path \n",
    "    X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a', kernel_initializer = glorot_uniform())(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    # Second component of main path \n",
    "    X = Conv2D(F2, (f, f), strides = (1,1), name = conv_name_base + '2b', kernel_initializer = glorot_uniform(), padding=\"same\")(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    # Third component of main path \n",
    "    X = Conv2D(F3, (1, 1), strides = (1,1), name = conv_name_base + '2c', kernel_initializer = glorot_uniform())(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "\n",
    "    ##### SHORTCUT PATH #### \n",
    "    X_shortcut = Conv2D(F3, (1, 1), strides = (s,s), name = conv_name_base + '1', kernel_initializer = glorot_uniform())(X_shortcut)\n",
    "    X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = Add()([X, X_shortcut])\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    return X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ResNet 50\n",
    "\n",
    "In this part, multiple identity and convolutional blocks have been implemented to map the architecture of ResNet50. The figure below shows how this assembly has been carried out. \n",
    "\n",
    "<img src=\"files\\images\\resnet_kiank.png\" style=\"width:850px;height:150px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 4** </u><font color='purple'>  : **ResNet-50 model** </center></caption>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ResNet50(input_shape = (64, 64, 3), classes = 6):\n",
    "    \"\"\"\n",
    "    Implementation of the popular ResNet50 the following architecture:\n",
    "    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3\n",
    "    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER\n",
    "\n",
    "    Arguments:\n",
    "    input_shape -- shape of the images of the dataset\n",
    "    classes -- integer, number of classes\n",
    "\n",
    "    Returns:\n",
    "    model -- a Model() instance in Keras\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define the input as a tensor with shape input_shape\n",
    "    X_input = Input(input_shape)\n",
    "\n",
    "    \n",
    "    # Zero-Padding\n",
    "    X = ZeroPadding2D((3, 3))(X_input)\n",
    "    \n",
    "    # Stage 1\n",
    "    X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = 'bn_conv1')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    X = MaxPooling2D((3, 3), strides=(2, 2))(X)\n",
    "\n",
    "    # Stage 2\n",
    "    X = convolutional_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s = 1)\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')\n",
    "\n",
    "\n",
    "    # Stage 3 \n",
    "    X = convolutional_block(X,f=3, filters = [128, 128, 512], stage = 3, block = 'a', s =2)\n",
    "    X = identity_block(X,3,[128, 128, 512], stage = 3, block = 'b')\n",
    "    X = identity_block(X,3,[128,128,512], stage = 3, block = 'c')\n",
    "    X = identity_block(X,3,[128,128,512], stage = 3, block = 'd')\n",
    "\n",
    "    # Stage 4 \n",
    "    X = convolutional_block(X,f=3, filters = [256, 256, 1024], stage = 4, block = 'a', s =2)\n",
    "    X = identity_block(X,3,[256, 256, 1024], stage = 4, block = 'b')\n",
    "    X = identity_block(X,3,[256, 256, 1024], stage = 4, block = 'c')\n",
    "    X = identity_block(X,3,[256, 256, 1024], stage = 4, block = 'd')\n",
    "    X = identity_block(X,3,[256, 256, 1024], stage = 4, block = 'e')\n",
    "    X = identity_block(X,3,[256, 256, 1024], stage = 4, block = 'f')\n",
    "\n",
    "    # Stage 5 \n",
    "    X = convolutional_block(X,f=3, filters = [512, 512, 2048], stage = 5, block = 'a', s =2) \n",
    "    X = identity_block(X,3,[512, 512, 2048], stage = 5, block = 'b')\n",
    "    X = identity_block(X,3,[512, 512, 2048], stage = 5, block = 'c')\n",
    "\n",
    "    # AVGPOOL \n",
    "    X = AveragePooling2D((2,2))(X)\n",
    "    \n",
    "    \n",
    "    # Output layer\n",
    "    X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    \n",
    "    \n",
    "    # Create model\n",
    "    model = Model(inputs = X_input, outputs = X, name='ResNet50')\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\harla\\Anaconda3\\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"
     ]
    }
   ],
   "source": [
    "model = ResNet50(input_shape = (64,64, 3), classes = 6)   # This dimension depends on input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train, y_train, x_test, y_test, classes = load_dataset()\n",
    "y_train = y_train.T\n",
    "y_test = y_test.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of training set : (1080, 64, 64, 3)\n",
      "shape of test set : (120, 64, 64, 3)\n",
      "shape of training_labels: (1080, 1)\n",
      "shape of test labels: (120, 1)\n",
      "Number of training samples =  1080\n",
      "Number of test samples =  120\n"
     ]
    }
   ],
   "source": [
    "# Print shape of training and test datasets\n",
    "print('Shape of training set :' ,x_train.shape)\n",
    "print('shape of test set :', x_test.shape )\n",
    "print('shape of training_labels:', y_train.shape)\n",
    "print('shape of test labels:', y_test.shape)\n",
    "print('Number of training samples = ', x_train.shape[0])\n",
    "print('Number of test samples = ', x_test.shape[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This image is of class:  [2]\n"
     ]
    },
    {
     "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": [
    "# Visualize  training set \n",
    "training_sample = 4;                # Change this to any value between 0 to 49999 and see how different training images look like\n",
    "myImage = x_train[training_sample,:,:,:];\n",
    "imshow(myImage)\n",
    "print('This image is of class: ' , y_train[training_sample])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Normalizing the train and test set\n",
    "x_train = x_train/255;\n",
    "x_test = (x_test)/255;\n",
    "# Subtracting pixel mean\n",
    "#subtract_pixel_mean = True\n",
    "\n",
    "#if subtract_pixel_mean:\n",
    " #   x_train_mean = np.mean(x_train, axis=0)\n",
    "  #  x_train -= x_train_mean\n",
    "   # x_test -= x_train_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\harla\\Anaconda3\\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 864 samples, validate on 216 samples\n",
      "Epoch 1/20\n",
      "864/864 [==============================] - 123s 143ms/step - loss: 2.6543 - acc: 0.3530 - val_loss: 1.0845 - val_acc: 0.5787\n",
      "Epoch 2/20\n",
      "864/864 [==============================] - 109s 126ms/step - loss: 0.8272 - acc: 0.6921 - val_loss: 0.7353 - val_acc: 0.7685\n",
      "Epoch 3/20\n",
      "864/864 [==============================] - 115s 133ms/step - loss: 0.5125 - acc: 0.8264 - val_loss: 0.9048 - val_acc: 0.7685\n",
      "Epoch 4/20\n",
      "864/864 [==============================] - 110s 128ms/step - loss: 0.4077 - acc: 0.8715 - val_loss: 0.4725 - val_acc: 0.8796\n",
      "Epoch 5/20\n",
      "864/864 [==============================] - 107s 124ms/step - loss: 0.1733 - acc: 0.9421 - val_loss: 0.7643 - val_acc: 0.8102\n",
      "Epoch 6/20\n",
      "864/864 [==============================] - 110s 127ms/step - loss: 0.2156 - acc: 0.9410 - val_loss: 0.7101 - val_acc: 0.8611\n",
      "Epoch 7/20\n",
      "864/864 [==============================] - 108s 125ms/step - loss: 0.3576 - acc: 0.9028 - val_loss: 0.4730 - val_acc: 0.8657\n",
      "Epoch 8/20\n",
      "864/864 [==============================] - 110s 127ms/step - loss: 0.2197 - acc: 0.9329 - val_loss: 1.2116 - val_acc: 0.7685\n",
      "Epoch 9/20\n",
      "864/864 [==============================] - 109s 126ms/step - loss: 0.1440 - acc: 0.9560 - val_loss: 0.5775 - val_acc: 0.8796\n",
      "Epoch 10/20\n",
      "864/864 [==============================] - 109s 126ms/step - loss: 0.0825 - acc: 0.9711 - val_loss: 0.6186 - val_acc: 0.8565\n",
      "Epoch 11/20\n",
      "864/864 [==============================] - 110s 127ms/step - loss: 0.1095 - acc: 0.9676 - val_loss: 0.3167 - val_acc: 0.9120\n",
      "Epoch 12/20\n",
      "864/864 [==============================] - 109s 127ms/step - loss: 0.0390 - acc: 0.9850 - val_loss: 0.2942 - val_acc: 0.9444\n",
      "Epoch 13/20\n",
      "864/864 [==============================] - 109s 126ms/step - loss: 0.0442 - acc: 0.9850 - val_loss: 0.3787 - val_acc: 0.9398\n",
      "Epoch 14/20\n",
      "864/864 [==============================] - 110s 128ms/step - loss: 0.1332 - acc: 0.9664 - val_loss: 0.9644 - val_acc: 0.8380\n",
      "Epoch 15/20\n",
      "864/864 [==============================] - 110s 127ms/step - loss: 0.1020 - acc: 0.9699 - val_loss: 0.4138 - val_acc: 0.9028\n",
      "Epoch 16/20\n",
      "864/864 [==============================] - 109s 126ms/step - loss: 0.1228 - acc: 0.9595 - val_loss: 0.5701 - val_acc: 0.9120\n",
      "Epoch 17/20\n",
      "864/864 [==============================] - 110s 127ms/step - loss: 0.2003 - acc: 0.9456 - val_loss: 0.4905 - val_acc: 0.9074\n",
      "Epoch 18/20\n",
      "864/864 [==============================] - 108s 125ms/step - loss: 0.0824 - acc: 0.9722 - val_loss: 0.3162 - val_acc: 0.9306\n",
      "Epoch 19/20\n",
      "864/864 [==============================] - 110s 128ms/step - loss: 0.0325 - acc: 0.9873 - val_loss: 0.4598 - val_acc: 0.9074\n",
      "Epoch 20/20\n",
      "864/864 [==============================] - 113s 131ms/step - loss: 0.0572 - acc: 0.9884 - val_loss: 0.4124 - val_acc: 0.9028\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x2631b2a9a58>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(x = x_train, y = y_train, verbose = 1, validation_split = 0.2, epochs = 20, batch_size = 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120/120 [==============================] - 2s 20ms/step\n"
     ]
    }
   ],
   "source": [
    "scores = model.evaluate(x_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss on test set is:  0.2492149790128072\n",
      "Accuracy on test set is:  0.949999996026357\n"
     ]
    }
   ],
   "source": [
    "print('Loss on test set is: ', scores[0])\n",
    "print('Accuracy on test set is: ', scores[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.00470322 0.73543936 0.1079357  0.03907827 0.10078382 0.01205959]]\n",
      "predicted sign is: 1\n",
      "actual sign is:  [1]\n"
     ]
    },
    {
     "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": [
    "test_sample = 9\n",
    "x = x_test[test_sample,:,:,:]\n",
    "imshow(x)\n",
    "x = np.expand_dims(x,axis = 0)\n",
    "print(model.predict(x))\n",
    "print('predicted sign is:', np.argmax(model.predict(x)))\n",
    "print('actual sign is: ', y_test[test_sample])"
   ]
  }
 ],
 "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
}