Gesture Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gesture Recognition\n",
    "In this group project, you are going to build a 3D Conv model that will be able to predict the 5 gestures correctly. Please import the following libraries to get started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "from skimage.io import imread\n",
    "from skimage.transform import resize\n",
    "import datetime\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We set the random seed so that the results don't vary drastically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(30)\n",
    "import random as rn\n",
    "rn.seed(30)\n",
    "from keras import backend as K\n",
    "import tensorflow as tf\n",
    "tf.set_random_seed(30)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this block, you read the folder names for training and validation. You also set the `batch_size` here. Note that you set the batch size in such a way that you are able to use the GPU in full capacity. You keep increasing the batch size until the machine throws an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#reading csv files\n",
    "\n",
    "train_doc = np.random.permutation(open('./Project_data/train.csv').readlines())\n",
    "val_doc = np.random.permutation(open('./Project_data/val.csv').readlines())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator\n",
    "This is one of the most important part of the code. The overall structure of the generator has been given. In the generator, you are going to preprocess the images as you have images of 2 different dimensions as well as create a batch of video frames. You have to experiment with `img_idx`, `y`,`z` and normalization such that you get high accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(source_path, folder_list, batch_size):\n",
    "    print( 'Source path = ', source_path, '; batch size =', batch_size)\n",
    "    #create a list of image numbers you want to use for a particular video\n",
    "    img_idx = np.arange(0,30,2)\n",
    "    \n",
    "    #To ensure continuos flow of data across epochs\n",
    "    while True:        \n",
    "        #Shuffling the .csv files so that we get a random order of data and so the network wont be biased.\n",
    "        t = np.random.permutation(folder_list)\n",
    "        num_batches = len(t)//batch_size # calculate the number of batches\n",
    "        #considering the left out sequences\n",
    "        if(len(t)%batch_size != 0):\n",
    "            num_batches = num_batches+1\n",
    "        for batch in range(num_batches): # we iterate over the number of batches\n",
    "            batch_data = np.zeros((batch_size,len(img_idx),100,100,3)) # x is the number of images you use for each video, (y,z) is the final size of the input images and 3 is the number of channels RGB\n",
    "            batch_labels = np.zeros((batch_size,5)) # batch_labels is the one hot representation of the output\n",
    "            \n",
    "            for folder in range(batch_size): # iterate over the batch_size\n",
    "                if (folder + (batch*batch_size)) > len(t)-1:\n",
    "                    continue\n",
    "                imgs = os.listdir(source_path+'/'+ t[folder + (batch*batch_size)].split(';')[0]) # read all the images in the folder\n",
    "                for idx,item in enumerate(img_idx): #  Iterate iver the frames/images of a folder to read them in\n",
    "                    image = imread(source_path+'/'+ t[folder + (batch*batch_size)].strip().split(';')[0]+'/'+imgs[item]).astype(np.float32)\n",
    "                    \n",
    "                    #crop the images and resize them. Note that the images are of 2 different shape \n",
    "                    #and the conv3D will throw error if the inputs in a batch have different shapes\n",
    "                    image=resize(image,(100,100))\n",
    "                    image=image/255\n",
    "                    batch_data[folder,idx,:,:,0] =image[:,:,0] #normalise and feed in the image\n",
    "                    batch_data[folder,idx,:,:,1] =image[:,:,1] #normalise and feed in the image\n",
    "                    batch_data[folder,idx,:,:,2] =image[:,:,2] #normalise and feed in the image\n",
    "                    \n",
    "                batch_labels[folder, int(t[folder + (batch*batch_size)].strip().split(';')[2])] = 1\n",
    "            yield batch_data, batch_labels #you yield the batch_data and the batch_labels, remember what does yield do\n",
    "\n",
    "               "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note here that a video is represented above in the generator as (number of images, height, width, number of channels). Take this into consideration while creating the model architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# training sequences = 663\n",
      "# validation sequences = 100\n",
      "# epochs = 40\n",
      "# batch size = 64\n"
     ]
    }
   ],
   "source": [
    "#Calculating training sequences and defining batch size and epochs\n",
    "\n",
    "curr_dt_time = datetime.datetime.now()\n",
    "train_path = './Project_data/train'\n",
    "val_path = './Project_data/val'\n",
    "num_train_sequences = len(train_doc)\n",
    "print('# training sequences =', num_train_sequences)\n",
    "num_val_sequences = len(val_doc)\n",
    "print('# validation sequences =', num_val_sequences)\n",
    "num_epochs =40 # choose the number of epochs\n",
    "print ('# epochs =', num_epochs)\n",
    "batch_size=64 # choose the batch size\n",
    "print ('# batch size =', batch_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model\n",
    "Here you make the model using different functionalities that Keras provides. Remember to use `Conv3D` and `MaxPooling3D` and not `Conv2D` and `Maxpooling2D` for a 3D convolution model. You would want to use `TimeDistributed` while building a Conv2D + RNN model. Also remember that the last layer is the softmax. Design the network in such a way that the model is able to give good accuracy on the least number of parameters so that it can fit in the memory of the webcam."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conv3D Model \n",
    "* Batch Size=64\n",
    "*  No of Epochs=40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Dense, GRU, Flatten, TimeDistributed, Flatten, BatchNormalization, Activation,Dropout\n",
    "from keras.layers.convolutional import Conv3D, MaxPooling3D\n",
    "from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau\n",
    "from keras import optimizers\n",
    "from keras.regularizers import l2\n",
    "\n",
    "#write your model here\n",
    "model = Sequential()\n",
    "        \n",
    "model.add(Conv3D(16, (3,3,3), padding='same',input_shape = (15,100,100,3)))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "\n",
    "model.add(Conv3D(32, (3,3,3), padding='same'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling3D(pool_size=(2, 2, 2)))\n",
    "\n",
    "model.add(Conv3D(64, (3,3,3), padding='same'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling3D(pool_size=(2, 2, 2)))\n",
    "\n",
    "model.add(Conv3D(128, (3,3,3), padding='same'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling3D(pool_size=(2, 2, 2)))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dropout(0.5))\n",
    "\n",
    "model.add(Dense(64,activation='relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Dropout(0.5))\n",
    "\n",
    "model.add(Dense(5,activation='softmax'))\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have written the model, the next step is to `compile` the model. When you print the `summary` of the model, you'll see the total number of parameters you have to train."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv3d_37 (Conv3D)           (None, 15, 100, 100, 16)  1312      \n",
      "_________________________________________________________________\n",
      "activation_37 (Activation)   (None, 15, 100, 100, 16)  0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_53 (Batc (None, 15, 100, 100, 16)  64        \n",
      "_________________________________________________________________\n",
      "conv3d_38 (Conv3D)           (None, 15, 100, 100, 32)  13856     \n",
      "_________________________________________________________________\n",
      "activation_38 (Activation)   (None, 15, 100, 100, 32)  0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_54 (Batc (None, 15, 100, 100, 32)  128       \n",
      "_________________________________________________________________\n",
      "max_pooling3d_34 (MaxPooling (None, 7, 50, 50, 32)     0         \n",
      "_________________________________________________________________\n",
      "conv3d_39 (Conv3D)           (None, 7, 50, 50, 64)     55360     \n",
      "_________________________________________________________________\n",
      "activation_39 (Activation)   (None, 7, 50, 50, 64)     0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_55 (Batc (None, 7, 50, 50, 64)     256       \n",
      "_________________________________________________________________\n",
      "max_pooling3d_35 (MaxPooling (None, 3, 25, 25, 64)     0         \n",
      "_________________________________________________________________\n",
      "conv3d_40 (Conv3D)           (None, 3, 25, 25, 128)    221312    \n",
      "_________________________________________________________________\n",
      "activation_40 (Activation)   (None, 3, 25, 25, 128)    0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_56 (Batc (None, 3, 25, 25, 128)    512       \n",
      "_________________________________________________________________\n",
      "max_pooling3d_36 (MaxPooling (None, 1, 12, 12, 128)    0         \n",
      "_________________________________________________________________\n",
      "flatten_9 (Flatten)          (None, 18432)             0         \n",
      "_________________________________________________________________\n",
      "dense_25 (Dense)             (None, 128)               2359424   \n",
      "_________________________________________________________________\n",
      "batch_normalization_57 (Batc (None, 128)               512       \n",
      "_________________________________________________________________\n",
      "dropout_17 (Dropout)         (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_26 (Dense)             (None, 64)                8256      \n",
      "_________________________________________________________________\n",
      "batch_normalization_58 (Batc (None, 64)                256       \n",
      "_________________________________________________________________\n",
      "dropout_18 (Dropout)         (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_27 (Dense)             (None, 5)                 325       \n",
      "=================================================================\n",
      "Total params: 2,661,573\n",
      "Trainable params: 2,660,709\n",
      "Non-trainable params: 864\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#Definibg optimiser and compiling the model and printing model summary\n",
    "\n",
    "optimiser = optimizers.Adam()#write your optimizer\n",
    "model.compile(optimizer=optimiser, loss='categorical_crossentropy', metrics=['categorical_accuracy'])\n",
    "print (model.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us create the `train_generator` and the `val_generator` which will be used in `.fit_generator`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calling generator functions\n",
    "train_generator = generator(train_path, train_doc, batch_size)\n",
    "val_generator = generator(val_path, val_doc, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Processing steps\n",
    "\n",
    "model_name = 'model_init' + '_' + str(curr_dt_time).replace(' ','').replace(':','_') + '/'\n",
    "    \n",
    "if not os.path.exists(model_name):\n",
    "    os.mkdir(model_name)\n",
    "        \n",
    "filepath = model_name + 'model-{epoch:05d}-{loss:.5f}-{categorical_accuracy:.5f}-{val_loss:.5f}-{val_categorical_accuracy:.5f}.h5'\n",
    "\n",
    "checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)\n",
    "\n",
    "LR = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2, cooldown=1, verbose=1)# write the REducelronplateau code here\n",
    "callbacks_list = [checkpoint, LR]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `steps_per_epoch` and `validation_steps` are used by `fit_generator` to decide the number of next() calls it need to make."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculating stpes per epoch\n",
    "\n",
    "if (num_train_sequences%batch_size) == 0:\n",
    "    steps_per_epoch = int(num_train_sequences/batch_size)\n",
    "else:\n",
    "    steps_per_epoch = (num_train_sequences//batch_size) + 1\n",
    "\n",
    "if (num_val_sequences%batch_size) == 0:\n",
    "    validation_steps = int(num_val_sequences/batch_size)\n",
    "else:\n",
    "    validation_steps = (num_val_sequences//batch_size) + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now fit the model. This will start training the model and with the help of the checkpoints, you'll be able to save the model at the end of each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Source path =  ./Project_data/val ; batch size = 64\n",
      "Source path =  ./Project_data/train ; batch size = 64\n",
      "Epoch 1/40\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/disks/user/anaconda3/lib/python3.6/site-packages/skimage/transform/_warps.py:105: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.\n",
      "  warn(\"The default mode, 'constant', will be changed to 'reflect' in \"\n",
      "/mnt/disks/user/anaconda3/lib/python3.6/site-packages/skimage/transform/_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.\n",
      "  warn(\"Anti-aliasing will be enabled by default in skimage 0.15 to \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11/11 [==============================] - 84s 8s/step - loss: 1.8409 - categorical_accuracy: 0.2969 - val_loss: 2.0043 - val_categorical_accuracy: 0.2266\n",
      "\n",
      "Epoch 00001: val_loss improved from inf to 2.00426, saving model to model_init_2020-02-0810_06_23.995411/model-00001-1.84090-0.29688-2.00426-0.22656.h5\n",
      "Epoch 2/40\n",
      "11/11 [==============================] - 53s 5s/step - loss: 1.3722 - categorical_accuracy: 0.4361 - val_loss: 2.0252 - val_categorical_accuracy: 0.2500\n",
      "\n",
      "Epoch 00002: val_loss did not improve from 2.00426\n",
      "Epoch 3/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 1.1384 - categorical_accuracy: 0.5185 - val_loss: 1.8369 - val_categorical_accuracy: 0.2578\n",
      "\n",
      "Epoch 00003: val_loss improved from 2.00426 to 1.83686, saving model to model_init_2020-02-0810_06_23.995411/model-00003-1.13839-0.51847-1.83686-0.25781.h5\n",
      "Epoch 4/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 0.9936 - categorical_accuracy: 0.5852 - val_loss: 0.9656 - val_categorical_accuracy: 0.4219\n",
      "\n",
      "Epoch 00004: val_loss improved from 1.83686 to 0.96556, saving model to model_init_2020-02-0810_06_23.995411/model-00004-0.99365-0.58523-0.96556-0.42188.h5\n",
      "Epoch 5/40\n",
      "11/11 [==============================] - 62s 6s/step - loss: 0.8902 - categorical_accuracy: 0.6151 - val_loss: 0.7507 - val_categorical_accuracy: 0.4844\n",
      "\n",
      "Epoch 00005: val_loss improved from 0.96556 to 0.75073, saving model to model_init_2020-02-0810_06_23.995411/model-00005-0.89023-0.61506-0.75073-0.48438.h5\n",
      "Epoch 6/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.7690 - categorical_accuracy: 0.6491 - val_loss: 1.2073 - val_categorical_accuracy: 0.3203\n",
      "\n",
      "Epoch 00006: val_loss did not improve from 0.75073\n",
      "Epoch 7/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.6285 - categorical_accuracy: 0.7230 - val_loss: 0.7060 - val_categorical_accuracy: 0.7500\n",
      "\n",
      "Epoch 00007: val_loss improved from 0.75073 to 0.70596, saving model to model_init_2020-02-0810_06_23.995411/model-00007-0.62850-0.72301-0.70596-0.75000.h5\n",
      "Epoch 8/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.5407 - categorical_accuracy: 0.7543 - val_loss: 0.6214 - val_categorical_accuracy: 0.5312\n",
      "\n",
      "Epoch 00008: val_loss improved from 0.70596 to 0.62136, saving model to model_init_2020-02-0810_06_23.995411/model-00008-0.54069-0.75426-0.62136-0.53125.h5\n",
      "Epoch 9/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.3673 - categorical_accuracy: 0.8310 - val_loss: 0.7521 - val_categorical_accuracy: 0.5547\n",
      "\n",
      "Epoch 00011: val_loss did not improve from 0.62136\n",
      "Epoch 12/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 0.3400 - categorical_accuracy: 0.8352 - val_loss: 0.7416 - val_categorical_accuracy: 0.7812\n",
      "\n",
      "Epoch 00012: val_loss did not improve from 0.62136\n",
      "\n",
      "Epoch 00012: ReduceLROnPlateau reducing learning rate to 0.0002500000118743628.\n",
      "Epoch 13/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.2947 - categorical_accuracy: 0.8608 - val_loss: 0.7157 - val_categorical_accuracy: 0.7734\n",
      "\n",
      "Epoch 00013: val_loss did not improve from 0.62136\n",
      "Epoch 14/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.2552 - categorical_accuracy: 0.8778 - val_loss: 0.6610 - val_categorical_accuracy: 0.5703\n",
      "\n",
      "Epoch 00014: val_loss did not improve from 0.62136\n",
      "\n",
      "Epoch 00014: ReduceLROnPlateau reducing learning rate to 0.0001250000059371814.\n",
      "Epoch 15/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.2553 - categorical_accuracy: 0.8835 - val_loss: 0.5103 - val_categorical_accuracy: 0.8438\n",
      "\n",
      "Epoch 00016: val_loss improved from 0.57595 to 0.51033, saving model to model_init_2020-02-0810_06_23.995411/model-00016-0.25533-0.88352-0.51033-0.84375.h5\n",
      "Epoch 17/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.2251 - categorical_accuracy: 0.8878 - val_loss: 0.4966 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00017: val_loss improved from 0.51033 to 0.49662, saving model to model_init_2020-02-0810_06_23.995411/model-00017-0.22514-0.88778-0.49662-0.85156.h5\n",
      "Epoch 18/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.2098 - categorical_accuracy: 0.8963 - val_loss: 0.4728 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00018: val_loss improved from 0.49662 to 0.47283, saving model to model_init_2020-02-0810_06_23.995411/model-00018-0.20985-0.89631-0.47283-0.85156.h5\n",
      "Epoch 19/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.2132 - categorical_accuracy: 0.8935 - val_loss: 0.4769 - val_categorical_accuracy: 0.8438\n",
      "\n",
      "Epoch 00019: val_loss did not improve from 0.47283\n",
      "Epoch 20/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1772 - categorical_accuracy: 0.9034 - val_loss: 0.4461 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00020: val_loss improved from 0.47283 to 0.44606, saving model to model_init_2020-02-0810_06_23.995411/model-00020-0.17719-0.90341-0.44606-0.85156.h5\n",
      "Epoch 21/40\n",
      "11/11 [==============================] - 57s 5s/step - loss: 0.1906 - categorical_accuracy: 0.9062 - val_loss: 0.4560 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00021: val_loss did not improve from 0.44606\n",
      "Epoch 22/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1603 - categorical_accuracy: 0.9077 - val_loss: 0.4544 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00022: val_loss did not improve from 0.44606\n",
      "\n",
      "Epoch 00022: ReduceLROnPlateau reducing learning rate to 6.25000029685907e-05.\n",
      "Epoch 23/40\n",
      "11/11 [==============================] - 57s 5s/step - loss: 0.1839 - categorical_accuracy: 0.9119 - val_loss: 0.4414 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00023: val_loss improved from 0.44606 to 0.44140, saving model to model_init_2020-02-0810_06_23.995411/model-00023-0.18390-0.91193-0.44140-0.85156.h5\n",
      "Epoch 24/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.1562 - categorical_accuracy: 0.9332 - val_loss: 0.4426 - val_categorical_accuracy: 0.8594\n",
      "\n",
      "Epoch 00024: val_loss did not improve from 0.44140\n",
      "Epoch 25/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1649 - categorical_accuracy: 0.9205 - val_loss: 0.4570 - val_categorical_accuracy: 0.8438\n",
      "\n",
      "Epoch 00025: val_loss did not improve from 0.44140\n",
      "\n",
      "Epoch 00025: ReduceLROnPlateau reducing learning rate to 3.125000148429535e-05.\n",
      "Epoch 26/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.1575 - categorical_accuracy: 0.9134 - val_loss: 0.4461 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00026: val_loss did not improve from 0.44140\n",
      "Epoch 27/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 0.1412 - categorical_accuracy: 0.9347 - val_loss: 0.4373 - val_categorical_accuracy: 0.8516\n",
      "\n",
      "Epoch 00027: val_loss improved from 0.44140 to 0.43730, saving model to model_init_2020-02-0810_06_23.995411/model-00027-0.14117-0.93466-0.43730-0.85156.h5\n",
      "Epoch 28/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.1328 - categorical_accuracy: 0.9318 - val_loss: 0.4234 - val_categorical_accuracy: 0.8594\n",
      "\n",
      "Epoch 00028: val_loss improved from 0.43730 to 0.42338, saving model to model_init_2020-02-0810_06_23.995411/model-00028-0.13284-0.93182-0.42338-0.85938.h5\n",
      "Epoch 29/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1699 - categorical_accuracy: 0.9148 - val_loss: 0.4201 - val_categorical_accuracy: 0.8672\n",
      "\n",
      "Epoch 00029: val_loss improved from 0.42338 to 0.42008, saving model to model_init_2020-02-0810_06_23.995411/model-00029-0.16989-0.91477-0.42008-0.86719.h5\n",
      "Epoch 30/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1316 - categorical_accuracy: 0.9347 - val_loss: 0.4154 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00030: val_loss improved from 0.42008 to 0.41538, saving model to model_init_2020-02-0810_06_23.995411/model-00030-0.13159-0.93466-0.41538-0.87500.h5\n",
      "Epoch 31/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1553 - categorical_accuracy: 0.9176 - val_loss: 0.4072 - val_categorical_accuracy: 0.8672\n",
      "\n",
      "Epoch 00031: val_loss improved from 0.41538 to 0.40716, saving model to model_init_2020-02-0810_06_23.995411/model-00031-0.15534-0.91761-0.40716-0.86719.h5\n",
      "Epoch 32/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 0.1424 - categorical_accuracy: 0.9276 - val_loss: 0.3992 - val_categorical_accuracy: 0.8750\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 00032: val_loss improved from 0.40716 to 0.39919, saving model to model_init_2020-02-0810_06_23.995411/model-00032-0.14237-0.92756-0.39919-0.87500.h5\n",
      "Epoch 33/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.1233 - categorical_accuracy: 0.9290 - val_loss: 0.3933 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00033: val_loss improved from 0.39919 to 0.39329, saving model to model_init_2020-02-0810_06_23.995411/model-00033-0.12334-0.92898-0.39329-0.87500.h5\n",
      "Epoch 34/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.1512 - categorical_accuracy: 0.9276 - val_loss: 0.3885 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00034: val_loss improved from 0.39329 to 0.38849, saving model to model_init_2020-02-0810_06_23.995411/model-00034-0.15116-0.92756-0.38849-0.87500.h5\n",
      "Epoch 35/40\n",
      "11/11 [==============================] - 59s 5s/step - loss: 0.1380 - categorical_accuracy: 0.9361 - val_loss: 0.3818 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00035: val_loss improved from 0.38849 to 0.38183, saving model to model_init_2020-02-0810_06_23.995411/model-00035-0.13804-0.93608-0.38183-0.87500.h5\n",
      "Epoch 36/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1446 - categorical_accuracy: 0.9318 - val_loss: 0.3750 - val_categorical_accuracy: 0.8672\n",
      "\n",
      "Epoch 00036: val_loss improved from 0.38183 to 0.37495, saving model to model_init_2020-02-0810_06_23.995411/model-00036-0.14464-0.93182-0.37495-0.86719.h5\n",
      "Epoch 37/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1105 - categorical_accuracy: 0.9418 - val_loss: 0.3710 - val_categorical_accuracy: 0.8672\n",
      "\n",
      "Epoch 00037: val_loss improved from 0.37495 to 0.37101, saving model to model_init_2020-02-0810_06_23.995411/model-00037-0.11050-0.94176-0.37101-0.86719.h5\n",
      "Epoch 38/40\n",
      "11/11 [==============================] - 61s 6s/step - loss: 0.1495 - categorical_accuracy: 0.9176 - val_loss: 0.3619 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00038: val_loss improved from 0.37101 to 0.36195, saving model to model_init_2020-02-0810_06_23.995411/model-00038-0.14949-0.91761-0.36195-0.87500.h5\n",
      "Epoch 39/40\n",
      "11/11 [==============================] - 58s 5s/step - loss: 0.1317 - categorical_accuracy: 0.9446 - val_loss: 0.3609 - val_categorical_accuracy: 0.8750\n",
      "\n",
      "Epoch 00039: val_loss improved from 0.36195 to 0.36092, saving model to model_init_2020-02-0810_06_23.995411/model-00039-0.13167-0.94460-0.36092-0.87500.h5\n",
      "Epoch 40/40\n",
      "11/11 [==============================] - 60s 5s/step - loss: 0.1301 - categorical_accuracy: 0.9304 - val_loss: 0.3480 - val_categorical_accuracy: 0.8906\n",
      "\n",
      "Epoch 00040: val_loss improved from 0.36092 to 0.34796, saving model to model_init_2020-02-0810_06_23.995411/model-00040-0.13015-0.93040-0.34796-0.89062.h5\n"
     ]
    }
   ],
   "source": [
    "#Fitting the model and saving \n",
    "\n",
    "history=model.fit_generator(train_generator, steps_per_epoch=steps_per_epoch, epochs=num_epochs, verbose=1, \n",
    "                    callbacks=callbacks_list, validation_data=val_generator, \n",
    "                    validation_steps=validation_steps, class_weight=None, workers=1, initial_epoch=0)"
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}