3 - Final Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import warnings\n",
    "import cv2\n",
    "import keras\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.style as style\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from PIL import Image\n",
    "from keras import models, layers, optimizers\n",
    "from keras.applications import VGG16\n",
    "from keras.callbacks import EarlyStopping, ModelCheckpoint\n",
    "from keras.layers import Dense, Dropout, Flatten\n",
    "from keras.models import Model\n",
    "from keras.preprocessing import image as image_utils\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.utils import to_categorical\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "% matplotlib inline\n",
    "style.use('seaborn-whitegrid')\n",
    "warnings.filterwarnings(action='once')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "gestures = {'L_': 'L',\n",
    "           'fi': 'Fist',\n",
    "           'C_': 'C',\n",
    "           'ok': 'Okay',\n",
    "           'pe': 'Peace',\n",
    "           'pa': 'Palm'\n",
    "            }\n",
    "\n",
    "gestures_map = {'Fist' : 0,\n",
    "                'L': 1,\n",
    "                'Okay': 2,\n",
    "                'Palm': 3,\n",
    "                'Peace': 4\n",
    "                }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(path):\n",
    "    img = Image.open(path)\n",
    "    img = img.resize((224, 224))\n",
    "    img = np.array(img)\n",
    "    return img\n",
    "\n",
    "def process_data(X_data, y_data):\n",
    "    X_data = np.array(X_data, dtype = 'float32')\n",
    "    if rgb:\n",
    "        pass\n",
    "    else:\n",
    "        X_data = np.stack((X_data,)*3, axis=-1)\n",
    "    X_data /= 255\n",
    "    y_data = np.array(y_data)\n",
    "    y_data = to_categorical(y_data)\n",
    "    return X_data, y_data\n",
    "\n",
    "def walk_file_tree(relative_path):\n",
    "    X_data = []\n",
    "    y_data = [] \n",
    "    for directory, subdirectories, files in os.walk(relative_path):\n",
    "        for file in files:\n",
    "            if not file.startswith('.') and (not file.startswith('C_')):\n",
    "                path = os.path.join(directory, file)\n",
    "                gesture_name = gestures[file[0:2]]\n",
    "                y_data.append(gestures_map[gesture_name])\n",
    "                X_data.append(process_image(path))   \n",
    "\n",
    "            else:\n",
    "                continue\n",
    "\n",
    "    X_data, y_data = process_data(X_data, y_data)\n",
    "    return X_data, y_data\n",
    "\n",
    "class Data(object):\n",
    "    def __init__(self):\n",
    "        self.X_data = []\n",
    "        self.y_data = []\n",
    "\n",
    "    def get_data(self):\n",
    "        return self.X_data, self.y_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get 'silhouette' data (this is the data we used for the final model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "relative_path = './frames/silhouettes/'\n",
    "rgb = False\n",
    "\n",
    "# # This method processes the data\n",
    "X_data, y_data = walk_file_tree(relative_path)\n",
    "\n",
    "# Can also optionally use a class to get this data, in order to keep it separate from Drawing data\n",
    "silhouette = Data()\n",
    "silhouette.X_data, silhouette.y_data = walk_file_tree(relative_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_data shape: (2748, 224, 224, 3)\n",
      "y_data shape: (2748, 5)\n"
     ]
    }
   ],
   "source": [
    "print(f'X_data shape: {X_data.shape}')\n",
    "print(f'y_data shape: {y_data.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a30f7f198>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X_data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get 'drawing' data (this was not used for final model, but I built and tested several models with it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "relative_path = './frames/drawings/'\n",
    "rgb = True\n",
    "\n",
    "# This method processes the data\n",
    "X_data, y_data = walk_file_tree(relative_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_data shape: (2565, 224, 224, 3)\n",
      "y_data shape: (2565, 5)\n"
     ]
    }
   ],
   "source": [
    "print(f'X_data shape: {X_data.shape}')\n",
    "print(f'y_data shape: {y_data.shape}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a30eedd68>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X_data[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Send the dictionaries to a dataframe to be saved for future use\n",
    "# d = {'image_path':image_path, 'gesture':gesture, 'image_rgb': image_rgb, 'image_bw_x': X_data, 'image_bw_y': y_data}\n",
    "d = {'image_path':image_path, 'gesture':gesture}\n",
    "df = pd.DataFrame(d)\n",
    "# df['gesture_num'] = df['gesture'].apply(lambda x: x[1:2])\n",
    "# df['gesture_name'] = df['gesture'].apply(lambda x: x[3:])\n",
    "\n",
    "# df.to_csv('silhouette_df.csv')\n",
    "# df = pd.read_csv('silhouette_df.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bring in Kaggle data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gestures_map = {3: 0,\n",
    "                2: 1,\n",
    "                7: 2,\n",
    "                1: 3,\n",
    "                'Peace': 4\n",
    "                }\n",
    "X_data = []\n",
    "y_data = []\n",
    "\n",
    "root_dir = os.fsencode('./data/gestures_data/')\n",
    "\n",
    "for directory, subdirectories, files in os.walk(root_dir):\n",
    "    for file in files:\n",
    "        if not file.startswith(b'.'):\n",
    "            gesture_name = int(file.decode('utf8')[10:11])\n",
    "            if gesture_name in [1, 2, 3, 7]:\n",
    "                path = os.path.join(directory, file).decode('utf8')\n",
    "                y_data.append(gestures_map[gesture_name])\n",
    "\n",
    "                img = cv2.imread(path, cv2.IMREAD_COLOR)\n",
    "                img = cv2.flip(img, 1)\n",
    "                gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "                blur = cv2.GaussianBlur(gray, (41, 41), 0)  #tuple indicates blur value\n",
    "                ret, thresh = cv2.threshold(blur, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n",
    "                thresh = cv2.resize(thresh, (224, 224))\n",
    "                thresh = np.array(thresh)\n",
    "                X_data.append(thresh)\n",
    "\n",
    "            else:\n",
    "                continue\n",
    "\n",
    "process_data(X_data, y_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Have to add a column of zeroes for the 'Peace' sign, since the Kaggle data does not have photos of \n",
    "# 'Peace' signs.\n",
    "z = np.zeros((len(y_data),1))\n",
    "y_data = np.append(y_data, z, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8000, 5)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Notice that the Kaggle images are now thresholded and binarized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a30eb6400>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(.5 - X_data[250])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a33ec8dd8>"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(.5 - X_data[100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1a3415f208>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(.5 - X_data[1200])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train-test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_train_rgb, X_test_rgb, y_train_rgb, y_test_rgb = train_test_split(image_rgb, y_data, test_size = 0.2, random_state=12, stratify=y_data)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size = 0.2, random_state=12, stratify=y_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build the VGG Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_path = './models/saved_model.hdf5'\n",
    "model_checkpoint = ModelCheckpoint(filepath=file_path, save_best_only=True)\n",
    "\n",
    "early_stopping = EarlyStopping(monitor='val_acc',\n",
    "                               min_delta=0,\n",
    "                               patience=10,\n",
    "                               verbose=1,\n",
    "                               mode='auto',\n",
    "                               restore_best_weights=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vgg_base = VGG16(weights='imagenet', include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "optimizer1 = optimizers.Adam()\n",
    "\n",
    "base_model = vgg_base  # Topless\n",
    "# Add top layer\n",
    "x = base_model.output\n",
    "x = Flatten()(x)\n",
    "x = Dense(128, activation='relu', name='fc1')(x)\n",
    "x = Dense(128, activation='relu', name='fc2')(x)\n",
    "x = Dense(128, activation='relu', name='fc3')(x)\n",
    "x = Dropout(0.5)(x)\n",
    "x = Dense(64, activation='relu', name='fc4')(x)\n",
    "predictions = Dense(5, activation='softmax')(x)\n",
    "\n",
    "model = Model(inputs=base_model.input, outputs=predictions)\n",
    "\n",
    "# Train top layers only\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "\n",
    "callbacks_list = [keras.callbacks.EarlyStopping(monitor='val_acc', patience=3, verbose=1)]\n",
    "\n",
    "model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "model.fit(X_train, y_train, epochs=50, batch_size=64, validation_data=(X_train, y_train), verbose=1,\n",
    "          callbacks=[early_stopping, model_checkpoint])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load VGG16\n",
    "# Get back the convolutional part of a VGG network trained on ImageNet\n",
    "\n",
    "imageSize = 224\n",
    "model1 = VGG16(weights='imagenet', include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "optimizer1 = optimizers.Adam()\n",
    "\n",
    "base_model = model1  # Topless\n",
    "# Add top layer\n",
    "x = base_model.output\n",
    "x = Flatten()(x)\n",
    "x = Dense(128, activation='relu', name='fc1')(x)\n",
    "x = Dense(128, activation='relu', name='fc2')(x)\n",
    "x = Dense(128, activation='relu', name='fc3')(x)\n",
    "x = Dropout(0.5)(x)\n",
    "x = Dense(64, activation='relu', name='fc4')(x)\n",
    "\n",
    "predictions = Dense(5, activation='softmax')(x)\n",
    "model = Model(inputs=base_model.input, outputs=predictions)\n",
    "\n",
    "# Train top layer\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "\n",
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer=optimizers.Adam(),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "callbacks_list = [keras.callbacks.EarlyStopping(monitor='val_acc', patience=3, verbose=1)]\n",
    "\n",
    "model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "model.fit(X_train, y_train, epochs=200, batch_size=64, validation_data=(X_train, y_train), verbose=1,\n",
    "          callbacks=[early_stopping, model_checkpoint])\n",
    "\n",
    "'''\n",
    "# Uncomment the section below and use in lieu of model.fit() above\n",
    "# if using image augmentation. Our final model did not.\n",
    "\n",
    "datagen = ImageDataGenerator(\n",
    "    featurewise_center=True,\n",
    "    featurewise_std_normalization=True,\n",
    "    rotation_range=45.,\n",
    "    width_shift_range=0.3,\n",
    "    height_shift_range=0.3,\n",
    "    horizontal_flip=True)\n",
    "\n",
    "datagen.fit(X_train)\n",
    "\n",
    "fits the model on batches with real-time data augmentation:\n",
    "model.fit_generator(datagen.flow(X_train, y_train, batch_size=32),\n",
    "                    steps_per_epoch=len(X_train)/32, epochs=150, validation_data=(X_test, y_test))\n",
    "'''\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Save and import model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.save('models/VGG_reversed.h5')\n",
    "\n",
    "from keras.models import load_model\n",
    "model = load_model('/home/ubuntu/project_kojak/models/VGG_reversed.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get classification metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_classification_metrics(X_test, y_test):\n",
    "    pred = model.predict(X_test)\n",
    "    pred = np.argmax(pred, axis=1)\n",
    "    y_true = np.argmax(y_test, axis=1)\n",
    "    print(confusion_matrix(y_true, pred))\n",
    "    print('\\n')\n",
    "    print(classification_report(y_true, pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**VGG_cross_validated model**\n",
    "\n",
    "Note that there are no predictions for class \\#5 since 'Peace' sign did not exist in cross_val images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[200   0   0   0   0]\n",
      " [  0 199   0   1   0]\n",
      " [  0   0 200   0   0]\n",
      " [ 11   0   0 187   2]\n",
      " [  0   0   0   0   0]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.95      1.00      0.97       200\n",
      "           1       1.00      0.99      1.00       200\n",
      "           2       1.00      1.00      1.00       200\n",
      "           3       0.99      0.94      0.96       200\n",
      "           4       0.00      0.00      0.00         0\n",
      "\n",
      "   micro avg       0.98      0.98      0.98       800\n",
      "   macro avg       0.79      0.79      0.79       800\n",
      "weighted avg       0.99      0.98      0.98       800\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# get_classification_metrics(X_data, y_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Predict gesture on a single image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "gesture_names = {0: 'C',\n",
    "                 1: 'Fist',\n",
    "                 2: 'L',\n",
    "                 3: 'Okay',\n",
    "                 4: 'Palm',\n",
    "                 5: 'Peace'}\n",
    "\n",
    "def predict_rgb_image(path):\n",
    "    img2rgb = image_utils.load_img(path=path, target_size=(224, 224))\n",
    "    img2rgb = image_utils.img_to_array(img2rgb)\n",
    "    img2rgb = img2rgb.reshape(1, 224, 224, 3)\n",
    "    return gesture_names[np.argmax(model.predict(img2rgb))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict_rgb_image('images_to_predict/test - palm.jpg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Image Augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datagen = ImageDataGenerator(\n",
    "    featurewise_center=True,\n",
    "    featurewise_std_normalization=True,\n",
    "    rotation_range=45.,\n",
    "    width_shift_range=0.2,\n",
    "    height_shift_range=0.2,\n",
    "    horizontal_flip=True)\n",
    "\n",
    "# compute quantities required for featurewise normalization\n",
    "# (std, mean, and principal components if ZCA whitening is applied)\n",
    "datagen.fit(X_train_rgb)\n",
    "\n",
    "# fits the model on batches with real-time data augmentation:\n",
    "model.fit_generator(datagen.flow(X_train_rgb, y_train_rgb, batch_size=32),\n",
    "                    steps_per_epoch=len(X_train_rgb) / 128, epochs=10, validation_data=(X_test_rgb, y_test_rgb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(model.predict(X_test_rgb[0].reshape(1, 224, 224, 3)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build own model\n",
    "Note that we ended up using the model on top of VGG, not this one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = models.Sequential()\n",
    "model.add(layers.Conv2D(32, (5, 5), strides=(2, 2), activation='relu', input_shape=(224, 224, 3)))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(layers.MaxPooling2D((2, 2)))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(128, activation='relu'))\n",
    "model.add(layers.Dense(128, activation='relu'))\n",
    "model.add(layers.Dense(128, activation='relu'))\n",
    "model.add(Dropout(0.25, seed=21))\n",
    "model.add(layers.Dense(5, activation='softmax'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X_train[:500], y_train[:500], epochs=4, batch_size=64, validation_data=(X_test[:500], y_test[:500]), verbose=1, callbacks = [MetricsCheckpoint('logs')])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1020 samples, validate on 256 samples\n",
      "Epoch 1/200\n",
      "1020/1020 [==============================] - 2s 2ms/step - loss: 1.4084 - acc: 0.4069 - val_loss: 1.1192 - val_acc: 0.5703\n",
      "Epoch 2/200\n",
      "1020/1020 [==============================] - 1s 746us/step - loss: 0.6555 - acc: 0.7657 - val_loss: 0.6208 - val_acc: 0.7930\n",
      "Epoch 3/200\n",
      "1020/1020 [==============================] - 1s 637us/step - loss: 0.2596 - acc: 0.9039 - val_loss: 0.4631 - val_acc: 0.8438\n",
      "Epoch 4/200\n",
      "1020/1020 [==============================] - 1s 708us/step - loss: 0.1080 - acc: 0.9627 - val_loss: 0.6910 - val_acc: 0.8359\n",
      "Epoch 5/200\n",
      "1020/1020 [==============================] - 1s 664us/step - loss: 0.0659 - acc: 0.9775 - val_loss: 0.6188 - val_acc: 0.8242\n",
      "Epoch 6/200\n",
      "1020/1020 [==============================] - 1s 703us/step - loss: 0.0566 - acc: 0.9794 - val_loss: 0.5668 - val_acc: 0.8633\n",
      "Epoch 7/200\n",
      "1020/1020 [==============================] - 1s 661us/step - loss: 0.0515 - acc: 0.9833 - val_loss: 0.5964 - val_acc: 0.8711\n",
      "Epoch 8/200\n",
      "1020/1020 [==============================] - 1s 726us/step - loss: 0.0353 - acc: 0.9873 - val_loss: 0.8839 - val_acc: 0.8281\n",
      "Epoch 9/200\n",
      "1020/1020 [==============================] - 1s 643us/step - loss: 0.0369 - acc: 0.9912 - val_loss: 0.5798 - val_acc: 0.8711\n",
      "Epoch 10/200\n",
      "1020/1020 [==============================] - 1s 760us/step - loss: 0.0267 - acc: 0.9931 - val_loss: 0.5418 - val_acc: 0.8867\n",
      "Epoch 11/200\n",
      "1020/1020 [==============================] - 1s 645us/step - loss: 0.0117 - acc: 0.9971 - val_loss: 0.6868 - val_acc: 0.8516\n",
      "Epoch 12/200\n",
      "1020/1020 [==============================] - 1s 765us/step - loss: 0.0402 - acc: 0.9941 - val_loss: 0.4497 - val_acc: 0.8945\n",
      "Epoch 13/200\n",
      "1020/1020 [==============================] - 1s 669us/step - loss: 0.0120 - acc: 0.9951 - val_loss: 0.8285 - val_acc: 0.8164\n",
      "Epoch 14/200\n",
      "1020/1020 [==============================] - 1s 744us/step - loss: 0.0136 - acc: 0.9971 - val_loss: 0.5083 - val_acc: 0.8984\n",
      "Epoch 15/200\n",
      "1020/1020 [==============================] - 1s 634us/step - loss: 4.4614e-04 - acc: 1.0000 - val_loss: 0.4932 - val_acc: 0.8945\n",
      "Epoch 16/200\n",
      "1020/1020 [==============================] - 1s 750us/step - loss: 1.8427e-04 - acc: 1.0000 - val_loss: 0.4931 - val_acc: 0.8906\n",
      "Epoch 17/200\n",
      "1020/1020 [==============================] - 1s 635us/step - loss: 1.4111e-04 - acc: 1.0000 - val_loss: 0.4997 - val_acc: 0.8945\n",
      "Epoch 18/200\n",
      "1020/1020 [==============================] - 1s 754us/step - loss: 9.8069e-05 - acc: 1.0000 - val_loss: 0.5031 - val_acc: 0.8945\n",
      "Epoch 19/200\n",
      "1020/1020 [==============================] - 1s 630us/step - loss: 7.8075e-05 - acc: 1.0000 - val_loss: 0.5078 - val_acc: 0.8906\n",
      "Epoch 20/200\n",
      "1020/1020 [==============================] - 1s 748us/step - loss: 6.4122e-05 - acc: 1.0000 - val_loss: 0.5116 - val_acc: 0.8906\n",
      "Epoch 21/200\n",
      "1020/1020 [==============================] - 1s 622us/step - loss: 5.3658e-05 - acc: 1.0000 - val_loss: 0.5147 - val_acc: 0.8906\n",
      "Epoch 22/200\n",
      "1020/1020 [==============================] - 1s 801us/step - loss: 4.5645e-05 - acc: 1.0000 - val_loss: 0.5179 - val_acc: 0.8906\n",
      "Epoch 23/200\n",
      "1020/1020 [==============================] - 1s 675us/step - loss: 3.9416e-05 - acc: 1.0000 - val_loss: 0.5214 - val_acc: 0.8906\n",
      "Epoch 24/200\n",
      "1020/1020 [==============================] - 1s 833us/step - loss: 3.4119e-05 - acc: 1.0000 - val_loss: 0.5247 - val_acc: 0.8906\n",
      "Restoring model weights from the end of the best epoch\n",
      "Epoch 00024: early stopping\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f95d8250dd8>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train_rgb, y_train_rgb, epochs=200, batch_size=16, validation_data=(X_test_rgb, y_test_rgb), verbose=1, callbacks =[early_stopping, model_checkpoint])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_classification_reports(y_pred, y_true):\n",
    "    y_pred_classes = np.array(np.argmax(y_pred))  # reconverts back from one hot encoded \n",
    "    y_true = np.array(np.argmax(y_true))  # reconverts back from one hot encoded\n",
    "    print(confusion_matrix(y_true, y_pred_classes))\n",
    "    print(classification_report(y_true, y_pred_classes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classification metrics for an earlier version of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.91      0.89      0.90        44\n",
      "          1       0.86      0.95      0.90        39\n",
      "          2       0.90      0.81      0.85        53\n",
      "          3       0.85      0.91      0.88        44\n",
      "          4       0.95      0.93      0.94        76\n",
      "\n",
      "avg / total       0.90      0.90      0.90       256\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(y_pred_classes, y_true))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[39  2  0  2  1]\n",
      " [ 0 37  1  1  0]\n",
      " [ 3  3 43  3  1]\n",
      " [ 1  0  1 40  2]\n",
      " [ 0  1  3  1 71]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(y_pred_classes, y_true))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  },
  "varInspector": {
   "cols": {
    "lenName": 16.0,
    "lenType": 16.0,
    "lenVar": 40.0
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}