CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using Theano backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import keras  \n",
    "from keras.datasets import mnist \n",
    "from keras.models import Model \n",
    "from keras.layers import Dense, Input\n",
    "from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten \n",
    "from keras import backend as k \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the train data and test data\n",
    "Test data: Used for testing the model that how are model has been trained.\n",
    "Train data: Used to train our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = mnist.load_data() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While proceeding further, img_rows and img_cols are used as the image dimensions. In mnist dataset, it is 28 and 28. We also need to check the data format i.e. ‘channels_first’ or ‘channels_last’. In CNN, we can normalize data before hands such that large terms of the calculations can be reduced to smaller terms. Like, we can normalize the x_train and x_test data by dividing it with 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Checking data format\n",
    "\n",
    "img_rows, img_cols=28, 28\n",
    "  \n",
    "if k.image_data_format() == 'channels_first': \n",
    "   x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) \n",
    "   x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) \n",
    "   inpx = (1, img_rows, img_cols) \n",
    "  \n",
    "else: \n",
    "   x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) \n",
    "   x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) \n",
    "   inpx = (img_rows, img_cols, 1) \n",
    "  \n",
    "x_train = x_train.astype('float32') \n",
    "x_test = x_test.astype('float32') \n",
    "x_train /= 255\n",
    "x_test /= 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Description of the output classes:\n",
    "Since output of the model can comprise of any of the digits between 0 to 9.so, we need 10 classes in output. To make output for 10 classes, use keras.utils.to_categorical function, which will provide with the 10 columns. Out of these 10 columns only one value will be one and rest 9 will be zero and this one value of the output will denote the class of the digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = keras.utils.to_categorical(y_train) \n",
    "y_test = keras.utils.to_categorical(y_test) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Now, dataset is ready so let’s move towards the cnn model :\n",
    "\n",
    "inpx = Input(shape=inpx) \n",
    "layer1 = Conv2D(32, kernel_size=(3, 3), activation='relu')(inpx) \n",
    "layer2 = Conv2D(64, (3, 3), activation='relu')(layer1) \n",
    "layer3 = MaxPooling2D(pool_size=(3, 3))(layer2) \n",
    "layer4 = Dropout(0.5)(layer3) \n",
    "layer5 = Flatten()(layer4) \n",
    "layer6 = Dense(250, activation='sigmoid')(layer5) \n",
    "layer7 = Dense(10, activation='softmax')(layer6) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explanation of the working of each layer in CNN model:\n",
    "layer1 is Conv2d layer which convolves the image using 32 filters each of size (3*3).\n",
    "layer2 is again a Conv2D layer which is also used to convolve the image and is using 64 filters each of size (3*3).\n",
    "layer3 is MaxPooling2D layer which picks the max value out of a matrix of size (3*3).\n",
    "layer4 is showing Dropout at a rate of 0.5.\n",
    "layer5 is flattening the output obtained from layer4 and this flatten output is passed to layer6.\n",
    "layer6 is a hidden layer of neural network containng 250 neurons.\n",
    "layer7 is the output layer having 10 neurons for 10 classes of output that is using the softmax function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/12\n",
      "60000/60000 [==============================] - 136s 2ms/step - loss: 0.7354 - acc: 0.7739\n",
      "Epoch 2/12\n",
      "60000/60000 [==============================] - 140s 2ms/step - loss: 0.2278 - acc: 0.9356\n",
      "Epoch 3/12\n",
      "60000/60000 [==============================] - 139s 2ms/step - loss: 0.1367 - acc: 0.9612\n",
      "Epoch 4/12\n",
      "60000/60000 [==============================] - 217s 4ms/step - loss: 0.0984 - acc: 0.9715\n",
      "Epoch 5/12\n",
      "60000/60000 [==============================] - 231s 4ms/step - loss: 0.0804 - acc: 0.9762\n",
      "Epoch 6/12\n",
      "60000/60000 [==============================] - 229s 4ms/step - loss: 0.0679 - acc: 0.9799\n",
      "Epoch 7/12\n",
      "60000/60000 [==============================] - 222s 4ms/step - loss: 0.0597 - acc: 0.9824\n",
      "Epoch 8/12\n",
      "60000/60000 [==============================] - 140s 2ms/step - loss: 0.0527 - acc: 0.9837\n",
      "Epoch 9/12\n",
      "60000/60000 [==============================] - 144s 2ms/step - loss: 0.0478 - acc: 0.9859\n",
      "Epoch 10/12\n",
      "60000/60000 [==============================] - 152s 3ms/step - loss: 0.0435 - acc: 0.9869\n",
      "Epoch 11/12\n",
      "60000/60000 [==============================] - 150s 2ms/step - loss: 0.0406 - acc: 0.9885\n",
      "Epoch 12/12\n",
      "60000/60000 [==============================] - 149s 2ms/step - loss: 0.0372 - acc: 0.9888\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x25f8fd88828>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Compile and fit function\n",
    "\n",
    "model = Model([inpx], layer7) \n",
    "model.compile(optimizer=keras.optimizers.Adadelta(), \n",
    "              loss=keras.losses.categorical_crossentropy, \n",
    "              metrics=['accuracy']) \n",
    "  \n",
    "model.fit(x_train, y_train, epochs=12, batch_size=500) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Firstly, we made an object of the model as shown in the above given lines, where [inpx] is the input in the model and layer7 is the output of the model. We compiled the model using required optimizer, loss function and printed the accuracy and at the last model.fit was called along with parameters like x_train(means image vectors), y_train(means the label), number of epochs and the batch size. Using fit function x_train, y_train dataset is fed to model in a particular batch size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate function:\n",
    "model.evaluate provides the score for the test data i.e. provided the test data to the model. Now, model will predict class of the data and predicted class will be matched with y_test label to give us the accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss= 0.02920876793176867\n",
      "accuracy= 0.99\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(x_test, y_test, verbose=0) \n",
    "print('loss=', score[0]) \n",
    "print('accuracy=', score[1]) "
   ]
  },
  {
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}