CNN using Keras and TensorFlow2.0_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MNIST Handwritten Numbers detection via CNN using Keras,TensorFlow 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import Modules\n",
    "import tensorflow as tf\n",
    "import cv2 as cv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import copy\n",
    "\n",
    "#Dataset.\n",
    "from tensorflow.keras.datasets import mnist\n",
    "#One-hot encoding.\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "#Feedforward sequential network with no feedback loop.\n",
    "from tensorflow.keras.models import Sequential\n",
    "#Layers.\n",
    "from tensorflow.keras.layers import Dense, Dropout, Flatten\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D\n",
    "#Optimizer.\n",
    "from tensorflow.keras.optimizers import SGD\n",
    "from tensorflow.keras import backend as K\n",
    "#Model loader.\n",
    "from tensorflow.keras.models import load_model\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the MNIST handwritten number dataset.\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "print(x_train.shape)\n",
    "print(x_test.shape)\n",
    "print(x_train[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Display random samples from training set.\n",
    "\n",
    "#pyplot subplot nrows,ncols,index->3,3,1\n",
    "subplot_num=331\n",
    "for index in range(0,5):\n",
    "    random_num=np.random.randint(0,len(x_train))\n",
    "    image=x_train[random_num]\n",
    "    plt.subplot(subplot_num)\n",
    "    plt.imshow(image,cmap='gray')\n",
    "    subplot_num=subplot_num+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Preprocess the data.\n",
    "#Convert the image shape for Keras.\n",
    "#Convert labels to one-hot encoded representation.\n",
    "#Normalize the data.\n",
    "\n",
    "#Convert for Keras.\n",
    "img_rows=x_train[0].shape[0]\n",
    "img_cols=x_train[0].shape[1]\n",
    "input_img_shape=(img_rows,img_cols,1)\n",
    "\n",
    "#Reshape.\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",
    "\n",
    "#One Hot encoding.\n",
    "print('Before one-hot encoding',y_train.shape[0])\n",
    "\n",
    "y_train=to_categorical(y_train)\n",
    "y_test=to_categorical(y_test)\n",
    "\n",
    "print(\"After one-hot encoding\",y_train.shape[0],y_train.shape[1])\n",
    "num_classes=y_train.shape[1]\n",
    "num_pixels=x_train.shape[0]*x_train.shape[1]\n",
    "\n",
    "#Normalize the data.\n",
    "print(x_test.dtype)\n",
    "print(x_train.dtype)\n",
    "x_train=x_train.astype('float32')\n",
    "x_test=x_test.astype('float32')\n",
    "\n",
    "x_train=x_train/255.0\n",
    "x_test=x_test/255.0\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Build the model.\n",
    "\n",
    "model=Sequential()\n",
    "\n",
    "#First layer.\n",
    "#padding=0, stride=1\n",
    "#(nxn)*(f*f) =[((n+2p-f)/s) +1, ((n+2p-f)/s) +1]\n",
    "# (28x28x1)*(3x3x32)= (26x26x32)\n",
    "model.add(Conv2D(32, kernel_size=(3,3), activation='relu',input_shape=input_img_shape))\n",
    "\n",
    "#Second layer.(24x24x64)\n",
    "model.add(Conv2D(64,(3,3),activation='relu'))\n",
    "\n",
    "#Max-Pooling.(12x12x64)\n",
    "model.add(MaxPooling2D(pool_size=(2,2)))\n",
    "\n",
    "#Dropout\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "#Flatten 9216x1\n",
    "model.add(Flatten())\n",
    "\n",
    "#Dense Layer (1x128)\n",
    "model.add(Dense(128,activation='relu'))\n",
    "\n",
    "#Dropout.\n",
    "model.add(Dropout(0.5))\n",
    "\n",
    "#Final layer \n",
    "model.add(Dense(num_classes,activation='softmax'))\n",
    "\n",
    "#Compile the model.(SGD, LR=0.01, loss=CCE)\n",
    "model.compile(loss='categorical_crossentropy', optimizer=SGD(0.01), metrics=['accuracy'])\n",
    "\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Training the model\n",
    "batch=5\n",
    "epochs=10\n",
    "\n",
    "history=model.fit(x_train,y_train,batch_size=batch,epochs=epochs,verbose=1,validation_data=(x_test,y_test))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluate the model\n",
    "score=model.evaluate(x_test,y_test,verbose=1)\n",
    "\n",
    "print('Test accuracy',score[1])\n",
    "print('Test loss',score[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot loss.\n",
    "\n",
    "history_dict=history.history\n",
    "\n",
    "loss_values=history_dict['loss']\n",
    "#validation loss\n",
    "val_loss=history_dict['val_loss']\n",
    "\n",
    "epochs=range(1,len(loss_values)+1)\n",
    "\n",
    "line1=plt.plot(epochs,val_loss,label='Validation loss')\n",
    "line2=plt.plot(epochs,loss_values,label='Training loss')\n",
    "plt.setp(line1,linewidth=2.0,marker='+', markersize=10.0)\n",
    "plt.setp(line2,linewidth=2.0,marker='3',markersize=10.0)\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot accuracy\n",
    "history_dict = history.history\n",
    "\n",
    "acc_values = history_dict['accuracy']\n",
    "val_acc_values = history_dict['val_accuracy']\n",
    "epochs = range(1, len(loss_values) + 1)\n",
    "\n",
    "line1 = plt.plot(epochs, val_acc_values, label='Validation/Test Accuracy')\n",
    "line2 = plt.plot(epochs, acc_values, label='Training Accuracy')\n",
    "plt.setp(line1, linewidth=2.0, marker = '+', markersize=10.0)\n",
    "plt.setp(line2, linewidth=2.0, marker = '4', markersize=10.0)\n",
    "plt.xlabel('Epochs') \n",
    "plt.ylabel('Accuracy')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Save the model.\n",
    "model.save('models/mnist_number_trained_model.h5')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the saved model\n",
    "classifier=load_model('models/mnist_number_trained_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Test on test data.\n",
    "test_image=x_test[3]\n",
    "print(test_image.shape)\n",
    "#Reshape for Keras.\n",
    "test_image=test_image.reshape(1,28,28,1)\n",
    "\n",
    "#res=classifier.predict_classes(test_image,1,verbose=0)\n",
    "#res=str(res[0])\n",
    "#print(res)\n",
    "\n",
    "res=classifier.predict(test_image)\n",
    "print(res)\n",
    "res=np.argmax(res)\n",
    "print(res)\n",
    "\n",
    "test_image=test_image.reshape(28,28)\n",
    "plt.imshow(test_image,cmap='gray')\n",
    "print('Prediction',res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv.VideoCapture(0)\n",
    "\n",
    "while True:\n",
    "\n",
    "    ret, frame = cap.read()\n",
    "    \n",
    "    #define region of interest\n",
    "    roi = frame[100:400, 320:620]\n",
    "    cv.imshow('roi', roi)\n",
    "    roi = cv.cvtColor(roi, cv.COLOR_BGR2GRAY)\n",
    "    roi = cv.resize(roi, (28, 28), interpolation = cv.INTER_AREA)\n",
    "    \n",
    "    cv.imshow('roi sacled and gray', roi)\n",
    "    copy = frame.copy()\n",
    "    cv.rectangle(copy, (320, 100), (620, 400), (255,0,0), 5)\n",
    "    \n",
    "    roi = roi.reshape(1,28,28,1) \n",
    "\n",
    "    result = classifier.predict(roi)\n",
    "    result =np.argmax(result)\n",
    "    #print(result)\n",
    "    result=str(result)[0]\n",
    "    cv.putText(copy, result, (300 , 100), cv.FONT_HERSHEY_COMPLEX, 2, (0, 255, 0), 2)\n",
    "    cv.imshow('frame', copy)    \n",
    "    \n",
    "    if cv.waitKey(1) == 13: #13 is the Enter Key\n",
    "        break\n",
    "        \n",
    "cap.release()\n",
    "cv.destroyAllWindows() "
   ]
  },
  {
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}