LeNet in Keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Deep CNN(LeNet in Keras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Setting up seed for reproducible results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Importing necessary stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/mohammed/anaconda3/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": [
    "import keras\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten, MaxPooling2D,Conv2D\n",
    "from keras.optimizers import SGD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data():\n",
    "    \"\"\"\n",
    "    This function loads the MNIST digit data using Keras inbuilt function \\\n",
    "    and returns the train and test set\n",
    "    \"\"\"\n",
    "    \n",
    "    (X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
    "    return (X_train, y_train), (X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parameters about the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Unique No of types of output labels we want to classify\n",
    "n_classes = 10\n",
    "\n",
    "#No of data points in training set\n",
    "train_shape = 60000\n",
    "\n",
    "#No of data points in test set\n",
    "test_shape = 10000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Preprocess data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_data(X_train, y_train, X_test, y_test, n_classes, train_shape, test_shape):\n",
    "    \"\"\"\n",
    "    This function takes the input MNist data(train & test), preprocesses it \\\n",
    "    and returns the preprocessed data\n",
    "    \"\"\"\n",
    "    \n",
    "    \n",
    "    #Reshaping the image shapes as 6000 x widht x height x color_dimensions\n",
    "    X_train = X_train.reshape(60000, 28, 28, 1).astype('float32')\n",
    "    X_test = X_test.reshape(10000, 28, 28, 1).astype('float32')\n",
    "    \n",
    "    #Normalizing the pixel values between 0 and 1 for faster convergence\n",
    "    X_train /= 255\n",
    "    X_test /= 255\n",
    "    \n",
    "    #Converting the labels into one-hot vector for easy calculation of cost fuction\n",
    "    y_train = keras.utils.to_categorical(y_train, n_classes)\n",
    "    y_test = keras.utils.to_categorical(y_test, n_classes)\n",
    "    \n",
    "    #returning the processed data for model fitting process\n",
    "    \n",
    "    return (X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LeNetModel():\n",
    "    \"\"\"\n",
    "    This function speecified the architecture of the Deep Neural Network.\n",
    "    We are repliicating an existing model(LeNet) in this function\n",
    "    \"\"\"\n",
    "    \n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(32, kernel_size=(3, 3), activation='relu',input_shape=(28, 28, 1)))\n",
    "    model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2,2)))\n",
    "    model.add(Dropout(0.25))\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(128, activation='relu'))\n",
    "    model.add(Dropout(0.5))\n",
    "    model.add(Dense(n_classes, activation='softmax'))\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compiling Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compile_model(model, loss_func, optimizer, metrics):\n",
    "    \"\"\"\n",
    "    This function compiles the model with parameters mentioned\n",
    "    \"\"\"\n",
    "    \n",
    "    model.compile(loss=loss_func, optimizer=optimizer, metrics=metrics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_model(model, X_train, y_train, X_test, y_test, batch_sz, epoch, show_output=True):\n",
    "    \"\"\"\n",
    "    This functions fits and returns the model scores on both train as well as test set\n",
    "    \"\"\"\n",
    "    return model.fit(X_train, y_train, batch_size=batch_sz, epochs=epoch, verbose=show_output, validation_data=(X_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's run stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X_train, y_train), (X_test, y_test) = load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X_train, y_train, X_test, y_test) = preprocess_data(X_train, y_train, X_test, y_test, n_classes, train_shape, test_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 26, 26, 32)        320       \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 24, 24, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 9216)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               1179776   \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 1,199,882\n",
      "Trainable params: 1,199,882\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = LeNetModel()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "compile_model(model, 'categorical_crossentropy', 'adam', ['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/20\n",
      "60000/60000 [==============================] - 178s 3ms/step - loss: 0.2401 - acc: 0.9275 - val_loss: 0.0507 - val_acc: 0.9841\n",
      "Epoch 2/20\n",
      "60000/60000 [==============================] - 196s 3ms/step - loss: 0.0856 - acc: 0.9744 - val_loss: 0.0434 - val_acc: 0.9860\n",
      "Epoch 3/20\n",
      "60000/60000 [==============================] - 1140s 19ms/step - loss: 0.0635 - acc: 0.9808 - val_loss: 0.0388 - val_acc: 0.9883\n",
      "Epoch 4/20\n",
      "60000/60000 [==============================] - 193s 3ms/step - loss: 0.0534 - acc: 0.9836 - val_loss: 0.0321 - val_acc: 0.9893\n",
      "Epoch 5/20\n",
      "41600/60000 [===================>..........] - ETA: 55s - loss: 0.0442 - acc: 0.9860"
     ]
    }
   ],
   "source": [
    "fit_model(model, X_train, y_train, X_test, y_test, 128, 20, True)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}