tl_inception.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transfer learning with Inception v3\n",
    "Rupert Thomas - Nov 2017\n",
    "\n",
    "This demo covers retraining a pre-trained Inception v3 network in Keras/TensorFlow. Originally trained using the ImageNet dataset, we use the Kaggle Cats and Dogs dataset to adapt the network for a new purpose.\n",
    "\n",
    "Based on code from: https://deeplearningsandbox.com/how-to-use-transfer-learning-and-fine-tuning-in-keras-and-tensorflow-to-build-an-image-recognition-94b0b02444f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "import numpy as np\n",
    "import datetime\n",
    "import urllib\n",
    "import zipfile\n",
    "import glob\n",
    "import shutil\n",
    "#from sklearn.model_selection import train_test_split\n",
    "from random import shuffle\n",
    "\n",
    "from keras import __version__\n",
    "from keras.applications.inception_v3 import InceptionV3, preprocess_input\n",
    "from keras.models import Model\n",
    "from keras.layers import Dense, GlobalAveragePooling2D, Dropout\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.optimizers import SGD\n",
    "from keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "IM_WIDTH, IM_HEIGHT = 299, 299  # fixed size for InceptionV3\n",
    "NUM_COLOUR_CHANNELS = 3  # must be 3 for pre-trained weights\n",
    "NB_EPOCHS = 3\n",
    "BATCH_SIZE = 32\n",
    "FC_SIZE = 1024\n",
    "NB_IV3_LAYERS_TO_FREEZE = 172  # layers to freeze during fine-tuning\n",
    "\n",
    "MULTILABEL = False  # if multilabel, classes are not mutually exclusive\n",
    "\n",
    "output_model_file_suffix = 'inception_V3_retrained.h5'\n",
    "\n",
    "MODEL_PATH = 'output'\n",
    "\n",
    "if not os.path.exists(MODEL_PATH):\n",
    "    os.mkdir(MODEL_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download dataset\n",
    "# N.B. these are sitting in my Dropbox, so may disappear at some point/be a little slow. \n",
    "# You can manually download the training file here, with a Kaggle account:\n",
    "# https://www.kaggle.com/c/dogs-vs-cats/data\n",
    "\n",
    "if not os.path.exists('data'):\n",
    "    os.mkdir('data')\n",
    "\n",
    "if not os.path.exists('data/train.zip'):\n",
    "    urllib.request.urlretrieve(\"https://www.dropbox.com/s/qhghnv5l1eoxkxc/train.zip?raw=1\", \"data/train.zip\")\n",
    "\n",
    "    with zipfile.ZipFile('data/train.zip', \"r\") as z:\n",
    "        z.extractall('data/')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split up the dataset, and move images into class-specific subdirectories (Keras likes this setup)\n",
    "\n",
    "train_path = 'data/train'\n",
    "if not os.path.exists(train_path):\n",
    "    os.mkdir(train_path)\n",
    "if not os.path.exists(os.path.join(train_path, 'cat')):\n",
    "    os.mkdir(os.path.join(train_path, 'cat'))\n",
    "if not os.path.exists(os.path.join(train_path, 'dog')):\n",
    "    os.mkdir(os.path.join(train_path, 'dog'))\n",
    "    \n",
    "test_path = 'data/test'\n",
    "if not os.path.exists(test_path):\n",
    "    os.mkdir(test_path)\n",
    "if not os.path.exists(os.path.join(test_path, 'cat')):\n",
    "    os.mkdir(os.path.join(test_path, 'cat'))\n",
    "if not os.path.exists(os.path.join(test_path, 'dog')):\n",
    "    os.mkdir(os.path.join(test_path, 'dog'))\n",
    "\n",
    "train_files = glob.glob(os.path.join(train_path, '*.jpg'))\n",
    "\n",
    "# Split into training and test subsets\n",
    "#train_files, test_files = train_test_split(train_files, test_size=0.1)\n",
    "shuffle(train_files)\n",
    "cut_off = len(train_files) // 10\n",
    "train_files, test_files = train_files[cut_off:], train_files[:cut_off]\n",
    "\n",
    "# Move training files into their class subdirectories\n",
    "for file_path in train_files:\n",
    "    if 'cat' in file_path:\n",
    "        shutil.move(file_path, os.path.join(train_path, 'cat', os.path.basename(file_path)))\n",
    "    if 'dog' in file_path:\n",
    "        shutil.move(file_path, os.path.join(train_path, 'dog', os.path.basename(file_path)))\n",
    "\n",
    "# Move test files\n",
    "for file_path in test_files:\n",
    "    if 'cat' in file_path:\n",
    "        shutil.move(file_path, os.path.join(test_path, 'cat', os.path.basename(file_path)))\n",
    "    if 'dog' in file_path:\n",
    "        shutil.move(file_path, os.path.join(test_path, 'dog', os.path.basename(file_path)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Some support functions\n",
    "\n",
    "def get_nb_files(directory):\n",
    "    \"\"\"Get number of files by searching directory recursively\"\"\"\n",
    "    if not os.path.exists(directory):\n",
    "        return 0\n",
    "    cnt = 0\n",
    "    for r, dirs, files in os.walk(directory):\n",
    "        for dr in dirs:\n",
    "            cnt += len(glob.glob(os.path.join(r, dr + \"/*\")))\n",
    "    return cnt\n",
    "\n",
    "\n",
    "def plot_training(history):\n",
    "    fig,ax_arr = plt.subplots(nrows=2, figsize=(10,10))\n",
    "    acc = history.history['acc']\n",
    "    val_acc = history.history['val_acc']\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    epochs = range(len(acc))\n",
    "\n",
    "    ax_arr[0].plot(epochs, acc, 'r.')\n",
    "    ax_arr[0].plot(epochs, val_acc, 'r')\n",
    "    ax_arr[0].set_title('Training and validation accuracy')\n",
    "    ax_arr[0].yaxis.set_major_formatter(FuncFormatter('{0:.1%}'.format))\n",
    "    \n",
    "    ax_arr[1].plot(epochs, loss, 'r.')\n",
    "    ax_arr[1].plot(epochs, val_loss, 'r-')\n",
    "    ax_arr[1].set_title('Training and validation loss')\n",
    "    ax_arr[1].set_xlabel('Epochs')\n",
    "    \n",
    "    for ax in ax_arr:\n",
    "        \n",
    "        for item in [ax.title, ax.xaxis.label, ax.yaxis.label]:\n",
    "            item.set_fontsize(16)\n",
    "        for item in ([] + ax.get_xticklabels() + ax.get_yticklabels()):          \n",
    "            item.set_fontsize(14)\n",
    "    \n",
    "    plt.legend(labels=['Training', 'Validation'])\n",
    "    plt.show()\n",
    "    \n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 22500 images belonging to 2 classes.\n",
      "Found 2500 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "# Setup an input pipeline, to feed training data in\n",
    "\n",
    "nb_train_samples = get_nb_files(train_path)\n",
    "nb_classes = len(glob.glob(train_path + \"/*\"))\n",
    "nb_test_samples = get_nb_files(test_path)\n",
    "\n",
    "# data prep\n",
    "train_datagen = ImageDataGenerator(\n",
    "    preprocessing_function=preprocess_input,\n",
    "    rotation_range=30,\n",
    "    width_shift_range=0.2,\n",
    "    height_shift_range=0.2,\n",
    "    shear_range=0.2,\n",
    "    zoom_range=0.2,\n",
    "    horizontal_flip=True\n",
    ")\n",
    "\n",
    "test_datagen = ImageDataGenerator(\n",
    "    preprocessing_function=preprocess_input\n",
    ")\n",
    "\n",
    "train_generator = train_datagen.flow_from_directory(train_path, target_size=(IM_WIDTH, IM_HEIGHT),\n",
    "    batch_size=BATCH_SIZE, class_mode='categorical', shuffle=True)\n",
    "\n",
    "test_generator = test_datagen.flow_from_directory(test_path, target_size=(IM_WIDTH, IM_HEIGHT),\n",
    "    batch_size=BATCH_SIZE, class_mode='categorical', shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create base model\n",
    "#base_model = InceptionV3(input_shape=(IM_WIDTH, IM_HEIGHT, NUM_COLOUR_CHANNELS), weights=None, include_top=False)  # do not use pre-trained weights (e.g. if different input shape)\n",
    "base_model = InceptionV3(input_shape=(IM_WIDTH, IM_HEIGHT, NUM_COLOUR_CHANNELS), weights='imagenet', include_top=False)  # include_top=False excludes final FC layer #weights='imagenet',\n",
    "\n",
    "# Top Model Block\n",
    "x = base_model.output\n",
    "x = GlobalAveragePooling2D()(x)\n",
    "x = Dropout(0.25)(x)\n",
    "x = Dense(FC_SIZE, activation='relu')(x)  # new FC layer, random init\n",
    "if MULTILABEL:\n",
    "    predictions = Dense(nb_classes, activation='sigmoid')(x)  # new sigmoid layer, so that each class probability is independent\n",
    "else:\n",
    "    predictions = Dense(nb_classes, activation='softmax')(x)  # new softmax layer: class probabilities sum to 1\n",
    "\n",
    "# add your top layer block to your base model\n",
    "model = Model(base_model.input, predictions)\n",
    "\n",
    "loss_func = 'categorical_crossentropy'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transfer learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "703/703 [==============================] - 125s 177ms/step - loss: 0.1931 - acc: 0.9320 - val_loss: 0.0561 - val_acc: 0.9796\n"
     ]
    }
   ],
   "source": [
    "# Transfer Learning: train only the top layers (which were randomly initialized)\n",
    "# i.e. freeze all layers of the based model that is already pre-trained.\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "    \n",
    "model.compile(optimizer='nadam', loss=loss_func, metrics=['accuracy'])\n",
    "    \n",
    "NB_EPOCHS = 3\n",
    "workers_per_gpu = 6\n",
    "model_desc = 'cats_and_dogs'\n",
    "desc = 'TL_%s_epochs_%s'%(NB_EPOCHS,model_desc)\n",
    "timestamp = datetime.datetime.today().strftime('%Y%m%d%H%M%S')\n",
    "\n",
    "# Create call-backs: save checkpoint each epoch if better, and stop early if not improving\n",
    "# N.B. ModelCheckpoint not currently working with multi-gpu\n",
    "#top_weights_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_top_model_weights.h5')\n",
    "callbacks_list = [\n",
    "    #ModelCheckpoint(top_weights_path, monitor='val_acc', verbose=1, save_best_only=True),\n",
    "    EarlyStopping(monitor='val_acc', patience=5, verbose=0)\n",
    "]\n",
    "\n",
    "history = model.fit_generator(train_generator, epochs=NB_EPOCHS, steps_per_epoch=nb_train_samples // BATCH_SIZE,\n",
    "                          validation_data=test_generator, validation_steps=nb_test_samples // BATCH_SIZE,\n",
    "                          class_weight='auto', verbose=1, workers=workers_per_gpu, callbacks=callbacks_list)\n",
    "\n",
    "#save_model_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+output_model_file_suffix)\n",
    "#model.load_weights(top_weights_path) # load the best weights from the training\n",
    "#model.save(save_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAJnCAYAAAD899WDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2864cd7dd68>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot training history\n",
    "fig = plot_training(history)\n",
    "#fig.savefig(os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+'training_history.jpg'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fine tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the classifier and the top two Inception blocks, but not the whole stack\n",
    "for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]:\n",
    "    layer.trainable = False\n",
    "for layer in model.layers[NB_IV3_LAYERS_TO_FREEZE:]:\n",
    "    layer.trainable = True\n",
    "    \n",
    "model.compile(optimizer='nadam', loss=loss_func, metrics=['accuracy'])\n",
    "    \n",
    "NB_EPOCHS = 3\n",
    "workers_per_gpu = 6\n",
    "desc = desc+'_then_fine_tune'\n",
    "timestamp = datetime.datetime.today().strftime('%Y%m%d%H%M%S')\n",
    "\n",
    "# Create call-backs: save checkpoint each epoch if better, and stop early if not improving\n",
    "# N.B. ModelCheckpoint not currently working with multi-gpu\n",
    "#top_weights_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_top_model_weights.h5')\n",
    "callbacks_list = [\n",
    "    ModelCheckpoint(top_weights_path, monitor='val_acc', verbose=1, save_best_only=True),\n",
    "    #EarlyStopping(monitor='val_acc', patience=5, verbose=0)\n",
    "]\n",
    "\n",
    "history = model.fit_generator(train_generator, epochs=NB_EPOCHS, steps_per_epoch=nb_train_samples // BATCH_SIZE,\n",
    "                          validation_data=test_generator, validation_steps=nb_test_samples // BATCH_SIZE,\n",
    "                          class_weight='auto', verbose=1, workers=workers_per_gpu, callbacks=callbacks_list)\n",
    "\n",
    "save_model_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+output_model_file_suffix)\n",
    "#model.load_weights(top_weights_path) # load the best weights from the training\n",
    "#model.save(save_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot training history\n",
    "fig = plot_training(history)\n",
    "#fig.savefig(os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+'training_history.jpg'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Full training"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I've included full training here for completeness, but with this size dataset it will probably over-fit very quickly. Look out for divergence between the accuracy on the training set and the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train all layers\n",
    "for layer in model.layers:\n",
    "    layer.trainable = True\n",
    "    \n",
    "model.compile(optimizer='nadam', loss=loss_func, metrics=['accuracy'])\n",
    "    \n",
    "NB_EPOCHS = 3\n",
    "workers_per_gpu = 6\n",
    "\n",
    "# # if starting from scratch\n",
    "# model_desc = 'cats_and_dogs'\n",
    "# desc = 'full_train_%s_epochs_%s'%(NB_EPOCHS,model_desc)\n",
    "\n",
    "# if previously done TL or FT \n",
    "desc = desc+'_full_train'\n",
    "timestamp = datetime.datetime.today().strftime('%Y%m%d%H%M%S')\n",
    "\n",
    "# Create call-backs: save checkpoint each epoch if better, and stop early if not improving\n",
    "# N.B. ModelCheckpoint not currently working with multi-gpu\n",
    "#top_weights_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_top_model_weights.h5')\n",
    "callbacks_list = [\n",
    "    ModelCheckpoint(top_weights_path, monitor='val_acc', verbose=1, save_best_only=True),\n",
    "    #EarlyStopping(monitor='val_acc', patience=5, verbose=0)\n",
    "]\n",
    "\n",
    "history = model.fit_generator(train_generator, epochs=NB_EPOCHS, steps_per_epoch=nb_train_samples // BATCH_SIZE,\n",
    "                          validation_data=test_generator, validation_steps=nb_test_samples // BATCH_SIZE,\n",
    "                          class_weight='auto', verbose=1, workers=workers_per_gpu, callbacks=callbacks_list)\n",
    "\n",
    "#save_model_path = os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+output_model_file_suffix)\n",
    "#model.load_weights(top_weights_path) # load the best weights from the training\n",
    "#model.save(save_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot training history\n",
    "fig = plot_training(history)\n",
    "#fig.savefig(os.path.join(MODEL_PATH, timestamp+'_'+desc+'_'+'training_history.jpg'))\n",
    "#plt.close('all')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.980\n"
     ]
    }
   ],
   "source": [
    "# Evaluate on test data\n",
    "test_generator.reset()\n",
    "y_test = test_generator.classes  # get true values for the test dataset. Do not shuffle the test dataset!\n",
    "y_hat = model.predict_generator(test_generator, workers=6)\n",
    "pred = np.argmax(y_hat, axis=1)\n",
    "\n",
    "print('Test accuracy: %0.3f' % (np.sum(pred == y_test) / len(pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Support functions for plotting a confusion matrix\n",
    "\n",
    "# Normally I would just import the confusion_matrix code straight from scikit-learn,\n",
    "# but I've copied it here, and jerry-rigged it to work without the library,\n",
    "# as it appears to not be installed on the AWS build.\n",
    "\n",
    "from scipy.sparse import coo_matrix\n",
    "#from sklearn.metrics import confusion_matrix\n",
    "import itertools\n",
    "\n",
    "def confusion_matrix(y_true, y_pred, labels=None, sample_weight=None):\n",
    "    \"\"\"Compute confusion matrix to evaluate the accuracy of a classification\n",
    "    By definition a confusion matrix :math:`C` is such that :math:`C_{i, j}`\n",
    "    is equal to the number of observations known to be in group :math:`i` but\n",
    "    predicted to be in group :math:`j`.\n",
    "    Thus in binary classification, the count of true negatives is\n",
    "    :math:`C_{0,0}`, false negatives is :math:`C_{1,0}`, true positives is\n",
    "    :math:`C_{1,1}` and false positives is :math:`C_{0,1}`.\n",
    "    Read more in the :ref:`User Guide <confusion_matrix>`.\n",
    "    Parameters\n",
    "    ----------\n",
    "    y_true : array, shape = [n_samples]\n",
    "        Ground truth (correct) target values.\n",
    "    y_pred : array, shape = [n_samples]\n",
    "        Estimated targets as returned by a classifier.\n",
    "    labels : array, shape = [n_classes], optional\n",
    "        List of labels to index the matrix. This may be used to reorder\n",
    "        or select a subset of labels.\n",
    "        If none is given, those that appear at least once\n",
    "        in ``y_true`` or ``y_pred`` are used in sorted order.\n",
    "    sample_weight : array-like of shape = [n_samples], optional\n",
    "        Sample weights.\n",
    "    Returns\n",
    "    -------\n",
    "    C : array, shape = [n_classes, n_classes]\n",
    "        Confusion matrix\n",
    "    \"\"\"\n",
    "#     y_type, y_true, y_pred = _check_targets(y_true, y_pred)\n",
    "#     if y_type not in (\"binary\", \"multiclass\"):\n",
    "#         raise ValueError(\"%s is not supported\" % y_type)\n",
    "\n",
    "    if labels is None:\n",
    "        labels = unique_labels(y_true, y_pred)\n",
    "    else:\n",
    "        labels = np.asarray(labels)\n",
    "        if np.all([l not in y_true for l in labels]):\n",
    "            raise ValueError(\"At least one label specified must be in y_true\")\n",
    "\n",
    "    if sample_weight is None:\n",
    "        sample_weight = np.ones(y_true.shape[0], dtype=np.int64)\n",
    "    else:\n",
    "        sample_weight = np.asarray(sample_weight)\n",
    "\n",
    "#     check_consistent_length(sample_weight, y_true, y_pred)\n",
    "\n",
    "    n_labels = labels.size\n",
    "    label_to_ind = dict((y, x) for x, y in enumerate(labels))\n",
    "    # convert yt, yp into index\n",
    "    y_pred = np.array([label_to_ind.get(x, n_labels + 1) for x in y_pred])\n",
    "    y_true = np.array([label_to_ind.get(x, n_labels + 1) for x in y_true])\n",
    "\n",
    "    # intersect y_pred, y_true with labels, eliminate items not in labels\n",
    "    ind = np.logical_and(y_pred < n_labels, y_true < n_labels)\n",
    "    y_pred = y_pred[ind]\n",
    "    y_true = y_true[ind]\n",
    "    # also eliminate weights of eliminated items\n",
    "    sample_weight = sample_weight[ind]\n",
    "\n",
    "    # Choose the accumulator dtype to always have high precision\n",
    "    if sample_weight.dtype.kind in {'i', 'u', 'b'}:\n",
    "        dtype = np.int64\n",
    "    else:\n",
    "        dtype = np.float64\n",
    "\n",
    "    CM = coo_matrix((sample_weight, (y_true, y_pred)),\n",
    "                    shape=(n_labels, n_labels), dtype=dtype,\n",
    "                    ).toarray()\n",
    "\n",
    "    return CM\n",
    "\n",
    "#**************************************************************#\n",
    "# Plot confusion matrix                                        #\n",
    "# Shows accuracy of neural network inference                   #\n",
    "#**************************************************************#\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "\n",
    "    # fig,ax_arr = plt.subplots(nrows=1, ncols=2)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "        num_formatter = '%.1f%%'\n",
    "        multiplier = 100\n",
    "    else:\n",
    "        print('Confusion matrix')\n",
    "        num_formatter = '%d'\n",
    "        multiplier = 1\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.grid(False)\n",
    "    # plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, num_formatter % (multiplier * cm[i, j]),\n",
    "                 horizontalalignment=\"center\", fontsize=10,\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    #plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix\n",
      "[[1215   35]\n",
      " [  16 1234]]\n",
      "Normalized confusion matrix\n",
      "[[ 1.  0.]\n",
      " [ 0.  1.]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs4AAAFsCAYAAADc0D9UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x281c0db0240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Print \n",
    " \n",
    "fig = plt.figure(figsize=(12, 6))\n",
    "cnf_matrix = confusion_matrix(y_test, pred, labels=[0, 1])\n",
    "class_names = ['Cat', 'Dog']\n",
    "np.set_printoptions(precision=1)\n",
    "ax = plt.subplot(121)\n",
    "plot_confusion_matrix(cnf_matrix, classes=class_names,\n",
    "                      title='Confusion matrix', normalize=False)\n",
    "\n",
    "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
    "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "    item.set_fontsize(10)\n",
    "\n",
    "ax = plt.subplot(122)\n",
    "plot_confusion_matrix(cnf_matrix, classes=class_names,\n",
    "                      title='Confusion matrix', normalize=True)\n",
    "\n",
    "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
    "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
    "    item.set_fontsize(10)\n",
    "    \n",
    "fig.subplots_adjust(bottom=0.2)\n",
    "\n",
    "#plt.tight_layout()\n",
    "plt.show()\n",
    "#fig.savefig(os.path.join(MODEL_PATH, desc+'_validation_confusion_matrix.png'), facecolor='w', transparent=False)"
   ]
  },
  {
   "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
}