20-ml-baseline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A baseline Neural Network\n",
    "\n",
    "This notebook contains a simple convolutional neural network that serves as baseline for other methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/thead/anaconda/envs/toolbox-talk/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.layers import Dense, Flatten, Activation, Dropout, Input\n",
    "from keras.models import Model\n",
    "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
    "\n",
    "import json\n",
    "import numpy as np\n",
    "\n",
    "import utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data loading and augmentation\n",
    "\n",
    "We augment the dataset by adding rotations and flips of the original images to the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = utils.load_data(one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)\n",
    "\n",
    "def augment(X, y):\n",
    "    X_prime = np.concatenate((\n",
    "        X,\n",
    "        np.rot90(X, 1, (1,2)),\n",
    "        np.rot90(X, 2, (1,2)),\n",
    "        np.rot90(X, 3, (1,2)),\n",
    "        np.flip(X, 1),\n",
    "        np.flip(X, 1)\n",
    "        ))\n",
    "    y_prime = np.concatenate((y, y, y, y, y, y))\n",
    "    return X_prime, y_prime\n",
    "\n",
    "X_train, y_train = augment(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((12600, 80, 80, 3), (12600, 2))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network definition and training\n",
    "\n",
    "A three layer convnet with pooling and dropout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = Input(shape=(80, 80, 3))\n",
    "\n",
    "h = Conv2D(32, (3,3), padding='same', activation='relu')(x)\n",
    "h = MaxPooling2D(pool_size=(2,2))(h)\n",
    "h = Dropout(0.25)(h)\n",
    "\n",
    "h = Conv2D(32, (3,3), padding='same', activation='relu')(x)\n",
    "h = MaxPooling2D(pool_size=(2,2))(h)\n",
    "h = Dropout(0.25)(h)\n",
    "\n",
    "h = Conv2D(32, (3,3), padding='same', activation='relu')(x)\n",
    "h = MaxPooling2D(pool_size=(2,2))(h)\n",
    "h = Dropout(0.25)(h)\n",
    "\n",
    "d = Flatten()(h)\n",
    "y = Dense(2, activation='softmax')(d)\n",
    "\n",
    "model = Model(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='sgd',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 10080 samples, validate on 2520 samples\n",
      "Epoch 1/10\n",
      "10080/10080 [==============================] - 59s 6ms/step - loss: 0.3813 - acc: 0.8368 - val_loss: 0.3276 - val_acc: 0.8437\n",
      "Epoch 2/10\n",
      "10080/10080 [==============================] - 67s 7ms/step - loss: 0.2649 - acc: 0.8845 - val_loss: 0.2400 - val_acc: 0.8937\n",
      "Epoch 3/10\n",
      "10080/10080 [==============================] - 58s 6ms/step - loss: 0.2242 - acc: 0.9037 - val_loss: 0.2087 - val_acc: 0.9071\n",
      "Epoch 4/10\n",
      "10080/10080 [==============================] - 56s 6ms/step - loss: 0.2074 - acc: 0.9129 - val_loss: 0.1927 - val_acc: 0.9147\n",
      "Epoch 5/10\n",
      "10080/10080 [==============================] - 55s 5ms/step - loss: 0.1962 - acc: 0.9188 - val_loss: 0.1868 - val_acc: 0.9226\n",
      "Epoch 6/10\n",
      "10080/10080 [==============================] - 55s 5ms/step - loss: 0.1863 - acc: 0.9225 - val_loss: 0.1796 - val_acc: 0.9238\n",
      "Epoch 7/10\n",
      "10080/10080 [==============================] - 54s 5ms/step - loss: 0.1806 - acc: 0.9259 - val_loss: 0.1783 - val_acc: 0.9258\n",
      "Epoch 8/10\n",
      "10080/10080 [==============================] - 54s 5ms/step - loss: 0.1722 - acc: 0.9300 - val_loss: 0.1691 - val_acc: 0.9274\n",
      "Epoch 9/10\n",
      "10080/10080 [==============================] - 55s 6ms/step - loss: 0.1674 - acc: 0.9313 - val_loss: 0.1837 - val_acc: 0.9321\n",
      "Epoch 10/10\n",
      "10080/10080 [==============================] - 61s 6ms/step - loss: 0.1632 - acc: 0.9316 - val_loss: 0.1559 - val_acc: 0.9345\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\n",
    "history = model.fit(X_train,\n",
    "                    y_train,\n",
    "                    epochs=epochs,\n",
    "                    validation_split=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Debugging plots\n",
    "\n",
    "The loss should decrease over time. Want to stop once the validation loss starts increasing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['loss'], label='loss')\n",
    "plt.plot(history.history['val_loss'], label='validation loss')\n",
    "plt.legend(loc='best');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "700/700 [==============================] - 2s 3ms/step\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(x=X_test, y=y_test,\n",
    "                                verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.9414285710879735\n"
     ]
    }
   ],
   "source": [
    "print(\"Test accuracy:\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12600/12600 [==============================] - 19s 2ms/step\n"
     ]
    }
   ],
   "source": [
    "_, train_accuracy = model.evaluate(x=X_train, y=y_train,\n",
    "                                   verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Store model\n",
    "\n",
    "Store the model for later use in production."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"conv-net.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import papermill as pm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/papermill.record+json": {
       "name": "conv-net"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/papermill.record+json": {
       "epochs": 10
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/papermill.record+json": {
       "test_accuracy": 0.9414285710879735
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/papermill.record+json": {
       "train_accuracy": 0.9385714285335843
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pm.record('name', 'conv-net')\n",
    "pm.record('epochs', epochs)\n",
    "pm.record('test_accuracy', accuracy)\n",
    "pm.record('train_accuracy', train_accuracy)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}