From dd4cb52d4c37a436fdd7f240e8a15362d8235a7c Mon Sep 17 00:00:00 2001 From: ADJason Date: Sat, 4 Aug 2018 21:54:57 +0530 Subject: [PATCH] Adding File --- .gitignore | 2 + CNN_LeNet.ipynb | 309 +++++++++++++++++++++++++++++++++++++++++ Digits.ipynb | 73 ++++++++++ Recognize digits.ipynb | 271 ++++++++++++++++++++++++++++++++++++ images/sample_8.jpg | Bin 0 -> 1046 bytes images/sample_9.jpg | Bin 0 -> 1142 bytes images/sample_five.jpg | Bin 0 -> 1187 bytes 7 files changed, 655 insertions(+) create mode 100644 .gitignore create mode 100644 CNN_LeNet.ipynb create mode 100644 Digits.ipynb create mode 100644 Recognize digits.ipynb create mode 100644 images/sample_8.jpg create mode 100644 images/sample_9.jpg create mode 100644 images/sample_five.jpg diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0c45b52 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.ipynb_checkpoints/ +/WEIGHTS diff --git a/CNN_LeNet.ipynb b/CNN_LeNet.ipynb new file mode 100644 index 0000000..2fbb6f5 --- /dev/null +++ b/CNN_LeNet.ipynb @@ -0,0 +1,309 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Seed for reproducibility" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Import Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import keras\n", + "import matplotlib.pyplot as plt\n", + "from keras.datasets import mnist\n", + "from keras.models import Sequential, model_from_json\n", + "from keras.layers import Conv2D, Flatten, Dense, MaxPooling2D, Dropout\n", + "from keras.optimizers import SGD, Adam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, y_train),(X_test, y_test) = mnist.load_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Preprocessing Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X_train = X_train.reshape(60000, 28, 28, 1).astype('float32')\n", + "X_test = X_test.reshape(10000, 28, 28, 1).astype('float32')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X_train /= 255\n", + "X_test /= 255" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "n_classes = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "y_train = keras.utils.to_categorical(y_train, n_classes)\n", + "y_test = keras.utils.to_categorical(y_test, n_classes)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Defining Neural Network Architecture" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "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'))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Compile Model" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model.compile(optimizer='adam',loss='categorical_crossentropy', metrics=['accuracy'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train Model" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 60000 samples, validate on 10000 samples\n", + "Epoch 1/10\n", + "60000/60000 [==============================] - 156s 3ms/step - loss: 0.2395 - acc: 0.9271 - val_loss: 0.0507 - val_acc: 0.9840\n", + "Epoch 2/10\n", + "60000/60000 [==============================] - 161s 3ms/step - loss: 0.0848 - acc: 0.9753 - val_loss: 0.0422 - val_acc: 0.9864\n", + "Epoch 3/10\n", + "60000/60000 [==============================] - 1925s 32ms/step - loss: 0.0638 - acc: 0.9803 - val_loss: 0.0369 - val_acc: 0.9881\n", + "Epoch 4/10\n", + "60000/60000 [==============================] - 160s 3ms/step - loss: 0.0528 - acc: 0.9839 - val_loss: 0.0315 - val_acc: 0.9894\n", + "Epoch 5/10\n", + "60000/60000 [==============================] - 163s 3ms/step - loss: 0.0454 - acc: 0.9855 - val_loss: 0.0287 - val_acc: 0.9912\n", + "Epoch 6/10\n", + "60000/60000 [==============================] - 169s 3ms/step - loss: 0.0397 - acc: 0.9873 - val_loss: 0.0313 - val_acc: 0.9903\n", + "Epoch 7/10\n", + "60000/60000 [==============================] - 163s 3ms/step - loss: 0.0352 - acc: 0.9889 - val_loss: 0.0269 - val_acc: 0.9915\n", + "Epoch 8/10\n", + "60000/60000 [==============================] - 169s 3ms/step - loss: 0.0297 - acc: 0.9905 - val_loss: 0.0250 - val_acc: 0.9929\n", + "Epoch 9/10\n", + "60000/60000 [==============================] - 180s 3ms/step - loss: 0.0299 - acc: 0.9904 - val_loss: 0.0274 - val_acc: 0.9916\n", + "Epoch 10/10\n", + "60000/60000 [==============================] - 178s 3ms/step - loss: 0.0252 - acc: 0.9919 - val_loss: 0.0290 - val_acc: 0.9913\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(X_train, y_train, batch_size=128, epochs=10, verbose=1, validation_data=[X_test, y_test])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Saving Model data" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "model.save_weights('WEIGHTS/Model_LeNet_weights.h5')\n", + "with open('WEIGHTS/MODEL_ARCHITECTURE.json','w') as m:\n", + " m.write(model.to_json())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Loading Model data" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "with open('WEIGHTS/MODEL_ARCHITECTURE.json','r') as m:\n", + " mo = model_from_json(m.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "mo.load_weights('WEIGHTS/Model_LeNet_weights.h5')" + ] + }, + { + "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 +} diff --git a/Digits.ipynb b/Digits.ipynb new file mode 100644 index 0000000..520f038 --- /dev/null +++ b/Digits.ipynb @@ -0,0 +1,73 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from keras.datasets import mnist\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, y_train),(X_test, y_test) = mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def getDigit(no):\n", + " index = np.argmax(y_train == no)\n", + " sample_img = X_train[index]\n", + " plt.imsave(f'images/sample_{no}.jpg',sample_img,cmap='gray')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "getDigit(9)" + ] + }, + { + "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 +} diff --git a/Recognize digits.ipynb b/Recognize digits.ipynb new file mode 100644 index 0000000..89c7117 --- /dev/null +++ b/Recognize digits.ipynb @@ -0,0 +1,271 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Importing libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mohammedsunasra/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": [ + "from scipy.misc import imread\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "from keras.models import model_from_json\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Reading Image" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mohammedsunasra/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: `imread` is deprecated!\n", + "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n", + "Use ``imageio.imread`` instead.\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAEGVJREFUeJzt3W+oXdWZx/HfY0xAoqhBksY0Y2qRMKKgwyUMRIZMJMWOQizaoKBksDSCilPpCzVvKhJBhv6ZvBgNcRIaJbGJtNGIMlP/BGJllEQNjTXOJJSMzRhyK1ZMQDR/nnlxd4ZrvGet41l7n71vnu8Hwr33PHfvve4595dzzn322svcXQDiOavtAQBoB+EHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxDU2cM8mJlxOiHQMHe3fr6vKPxmdp2k1ZKmSPo3d3+0ZH9nKrP0Y5E7xTq3fYncvk+ePFm0/7POGvzFZemxU3LjavLYXTHwI2NmUyT9q6TvSrpc0q1mdnldAwPQrJL3/Ask7Xf3P7r7F5J+JWlpPcMC0LSS8M+R9KdxXx+sbvsSM1thZrvMbFfBsQDUrOQ9/0RvFr/y5tXd10paK/EHP6BLSp75D0qaO+7rb0r6sGw4AIalJPw7JV1mZt8ys2mSbpG0rZ5hAWjawC/73f24md0j6T801upb7+5/qG1kZ5DSqyW1ebWl0jZjSctsypQpRftO3W+5bSO0Am2Yv1i85++eJs8hkMr+42oy/DmTOfz9nuTD6b1AUIQfCIrwA0ERfiAowg8ERfiBoIY6nz+q0im9OV2dNiul23W5n/vEiRNFx07dL7ljd7mVVxee+YGgCD8QFOEHgiL8QFCEHwiK8ANB0eobgqZnTja5/9JZf6XtupTcrL8mjz2ZZ/2dwjM/EBThB4Ii/EBQhB8IivADQRF+ICjCDwTF1Xs7oM2r1Ob6+E2u4tt0r7zkHIU2L5deiqv3Akgi/EBQhB8IivADQRF+ICjCDwRF+IGgivr8ZnZA0hFJJyQdd/eRzPdP3ubpJFU6H7/NfnfpeQCp7SfDfPtB9dvnr+NiHn/v7h/VsB8AQ8TLfiCo0vC7pN+a2VtmtqKOAQEYjtKX/Qvd/UMzmynpJTN73913jP+G6j8F/mMAOqa2iT1m9pCko+7+08T38Ae/IeMPfoNtO5k1PrHHzKab2XmnPpf0HUnvDro/AMNV8rJ/lqSt1TPL2ZI2ufu/1zIqAI1jPv8QlF5fvsl5721e+34yX3e/6WXXSzCfH0AS4QeCIvxAUIQfCIrwA0ERfiAolugegtKzyUrOZBsZSc6y1m233ZasX3vttcn6/Pnzk/VUO+/ee+9Nbjs6OpqsL1y4MFnftGlTz9obb7yR3DZnMl/a+xSe+YGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gqEnV50/1jJtcxjp37NzU09yxS5fJvummm3rWHnvsseS2559/frJ+9tnpX5Ht27cn6zNmzOhZW716dXLb0vMjZs6c2bN2yy23JLft8pTduvDMDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBDb3PX7KKSsmlnKdNm5asf/HFF40dOyd3GencnPx169b1rJ1zzjnJbXfs2JGsP/LII8n666+/nqyn7vctW7Ykt12yZEmynvt92b17d89ahD5+Ds/8QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxBUts9vZusl3SBp1N2vqG6bIWmzpHmSDkha5u5/6eeAqd5sybz2XM8318fPmTp16sDHzp0jsHz58mR9zZo1yXrqWgMvv/xyctubb745WT9y5EiynrNs2bKetcWLFye3zS3h/cEHHyTrTzzxRLJeosll04eln2f+X0q67rTbHpD0irtfJumV6msAk0g2/O6+Q9LHp928VNKG6vMNkm6seVwAGjboe/5Z7n5IkqqPva+XBKCTGj+338xWSFrR9HEAfD2DPvMfNrPZklR97LmioruvdfcRd0/PTgEwVIOGf5ukU3+iXi7puXqGA2BYsuE3s6cl/aek+WZ20Mx+IOlRSUvMbJ+kJdXXACYRG+a8ZTNr7GC5nnCu195k33bVqlXJ+v3335+s58b2+OOP96ytXLkyue2nn36arJfer3v37u1Zmz9/fnLb3H2eWq9Akp5//vmB951br+D48ePJepvcPX3CTIUz/ICgCD8QFOEHgiL8QFCEHwiK8ANBdWqJ7pJ2W2nLMtf6SU3pffDBB5Pb5uqff/55sv7qq68m6/fdd1/P2rFjx5Lb5i5pnptmfcMNNyTrc+fOTdZTHn744WR927ZtyXpq7LmfK9fKK22BdgHP/EBQhB8IivADQRF+ICjCDwRF+IGgCD8Q1KSa0luyvHdOru977rnn9qzt378/ue2MGTOS9RdffDFZX7p0abKekpuaeskllyTrTz31VLK+YMGCZD11v27evDm57Z133pmsl15WPIUpvQDOWIQfCIrwA0ERfiAowg8ERfiBoAg/ENTQ+/ypvm9uLE32+XN93QsvvLBn7fDhw8ltc2O79NJLk/Xc8uKpJb6vv/765LZXXnllsn7BBRck6yXz1m+8Mb2+6wsvvDDwvqX070tu3LnzPoaZm6+LPj+AJMIPBEX4gaAIPxAU4QeCIvxAUIQfCCrb5zez9ZJukDTq7ldUtz0k6YeS/lx920p3T09KV34+f5PLZJfuO9Xvfu+995Lbzpw5M1nv4zEoqqccOnQoWc/1w+fMmZOsj46O9qxdfPHFyW2bVNrH7/J5AHX2+X8p6boJbv+Fu19V/csGH0C3ZMPv7jskfTyEsQAYopL3/PeY2e/NbL2Z9T73FUAnDRr+xyV9W9JVkg5J+lmvbzSzFWa2y8x2DXgsAA0YKPzuftjdT7j7SUlPSOp5FUd3X+vuI+4+MuggAdRvoPCb2exxX35P0rv1DAfAsGSX6DazpyUtknSRmR2U9BNJi8zsKkku6YCk9DWWAXRONvzufusEN68b9IAlc/JLti3tux49erRnLXdd/dy89IsuuihZz60LsHXr1p61DRs2JLf95JNPkvWNGzcm67le/TPPPJOslyjptU+ZMiW5be66/F2ez98vzvADgiL8QFCEHwiK8ANBEX4gKMIPBJVt9dWtqWm5pa2+XNso1fp55513ktvOmjUrWW+ybTR16tRkfWQkfeLlokWLio6/b9++nrVcu63Jy2uXLrHd5PTzYeGZHwiK8ANBEX4gKMIPBEX4gaAIPxAU4QeCGnqfv+Qy06W92ZRcrz3Vk86Nq+RnlvK9+mPHjg1Uk5pdgluSNm/ePPC+c8uml/w+lF56ezL08XN45geCIvxAUIQfCIrwA0ERfiAowg8ERfiBoLJLdNd6sMwS3SVK54aX7L/py4aXKO2V5362XD21hPdHH32U3Lb0MUv18ksfky7P569ziW4AZyDCDwRF+IGgCD8QFOEHgiL8QFCEHwgqO5/fzOZKelLSNySdlLTW3Veb2QxJmyXNk3RA0jJ3/0tzQ00r7Qm3uf/SueUpuT7+kiVLkvXc2HL3S+p6Arltc+du5JQ8Zl3u49eln2f+45J+7O5/LelvJd1tZpdLekDSK+5+maRXqq8BTBLZ8Lv7IXd/u/r8iKS9kuZIWippQ/VtGyTd2NQgAdTva73nN7N5kq6W9KakWe5+SBr7D0LSzLoHB6A5fV/Dz8zOlfRrST9y90/7vS6dma2QtGKw4QFoSl/P/GY2VWPB3+juv6luPmxms6v6bEmjE23r7mvdfcTd0ytCAhiqbPht7Cl+naS97v7zcaVtkpZXny+X9Fz9wwPQlH5e9i+UdLukPWa2u7ptpaRHJW0xsx9I+kDS9/s5YJPTLEuUtHZyLakuT/mdP39+sl56ee3cZcdLjp1761kyDTtXb7I9OyzZ8Lv77yT1+kmvrXc4AIaFM/yAoAg/EBThB4Ii/EBQhB8IivADQQ19ie6S/mfpUtcpJVM0m55OnDsHISV3f2/fvj1Zz53DkNt/6r7J7Tv3eOemKzf5uOQek6Z/J+rAMz8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBHXGLNFdKtdTTvV1S+ed5+ol5yCUzjvft29fsj5v3rxk/ZprrulZ27lzZ3Lb3M9dch2F3M89mS/dzRLdAJIIPxAU4QeCIvxAUIQfCIrwA0ERfiAo+vxDUNozLrmOQe7xze37jjvuSNbXrFmTrL/22ms9a3fddVdy2/fffz9ZzylZI4I+P4AzFuEHgiL8QFCEHwiK8ANBEX4gKMIPBJXt85vZXElPSvqGpJOS1rr7ajN7SNIPJf25+taV7v5iZl8h+/w5pXPuUz3p0n709OnTk/WtW7cm64sXL+5Ze/bZZ5Pb3n777cn6Z599lqyX9PlLrhXQz/6b1G+fv59FO45L+rG7v21m50l6y8xeqmq/cPefDjpIAO3Jht/dD0k6VH1+xMz2SprT9MAANOtrvec3s3mSrpb0ZnXTPWb2ezNbb2YX9thmhZntMrNdRSMFUKu+w29m50r6taQfufunkh6X9G1JV2nslcHPJtrO3de6+4i7j9QwXgA16Sv8ZjZVY8Hf6O6/kSR3P+zuJ9z9pKQnJC1obpgA6pYNv439yXSdpL3u/vNxt88e923fk/Ru/cMD0JR+Wn3XSHpN0h6NtfokaaWkWzX2kt8lHZB0Z/XHwdS+Qrb6SpbYlsradbmWVelS0uedd16yvmrVqp61u+++O7nt1Vdfnazv2bMnWU+ZzFN2c2pr9bn77yRNtLNkTx9At3GGHxAU4QeCIvxAUIQfCIrwA0ERfiAoLt09CTTZq296+fCS6calU51L9l167MkwpZdnfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8Iqp+r99bpI0n/M+7ri6rbuqgzYzutj1/ruGruV39lbCXz4mvulX9pbB3r09f5mF7S7zcO9SSfrxzcbFdXr+3X1bF1dVwSYxtUW2PjZT8QFOEHgmo7/GtbPn5KV8fW1XFJjG1QrYyt1ff8ANrT9jM/gJa0En4zu87M/svM9pvZA22MoRczO2Bme8xsd9tLjFXLoI2a2bvjbpthZi+Z2b7q44TLpLU0tofM7H+r+263mf1DS2Oba2bbzWyvmf3BzP6pur3V+y4xrlbut6G/7DezKZL+W9ISSQcl7ZR0q7u/N9SB9GBmBySNuHvrPX4z+ztJRyU96e5XVLf9s6SP3f3R6j/OC939/o6M7SFJR9teublaUGb2+JWlJd0o6R/V4n2XGNcytXC/tfHMv0DSfnf/o7t/IelXkpa2MI7Oc/cdkj4+7ealkjZUn2/Q2C/P0PUYWye4+yF3f7v6/IikUytLt3rfJcbVijbCP0fSn8Z9fVDdWvLbJf3WzN4ysxVtD2YCs06tjFR9nNnyeE6XXbl5mE5bWboz990gK17XrY3wT3SJoS61HBa6+99I+q6ku6uXt+hPXys3D8sEK0t3wqArXtetjfAflDR33NfflPRhC+OYkLt/WH0clbRV3Vt9+PCpRVKrj6Mtj+f/dWnl5olWllYH7rsurXjdRvh3SrrMzL5lZtMk3SJpWwvj+Aozm179IUZmNl3Sd9S91Ye3SVpefb5c0nMtjuVLurJyc6+VpdXyfde1Fa9bOcmnamX8i6Qpkta7+yNDH8QEzOxSjT3bS2MzHje1OTYze1rSIo3N+jos6SeSnpW0RdJfSfpA0vfdfeh/eOsxtkX6mis3NzS2XitLv6kW77s6V7yuZTyc4QfExBl+QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxAU4QeC+j8jXiF65VoauwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img = imread('images/sample_9.jpg',0)\n", + "plt.imshow(img, cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28, 28, 3)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Converting Image into GrayScale" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gray_image = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n", + "plt.imshow(gray_image,cmap='gray')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(28, 28)\n", + "\n" + ] + } + ], + "source": [ + "print(gray_image.shape)\n", + "print(type(gray_image))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Resize Image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "gray_image.resize((28, 28, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(28, 28, 1)\n" + ] + } + ], + "source": [ + "print(gray_image.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "final_img = np.expand_dims(gray_image, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 28, 28, 1)\n" + ] + } + ], + "source": [ + "print(final_img.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Loading LeNet model" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "with open('WEIGHTS/MODEL_ARCHITECTURE.json','r') as m:\n", + " model = model_from_json(m.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "model.load_weights('WEIGHTS/Model_LeNet_weights.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9\n" + ] + } + ], + "source": [ + "print(np.argmax(model.predict(final_img)))" + ] + }, + { + "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 +} diff --git a/images/sample_8.jpg b/images/sample_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f58886ee65a8281c91d8e321edeae8f66f95017 GIT binary patch literal 1046 zcmex=%kxU@K!VDr=Sy-4^*jU-vz?hwr zgN>b&osEryn}d@J1b{3aZY~}W2V@9DD-$a-Gb`H|qMvW5}awt1(JSZA;@q>zSQc)8pmzcPOq?D?fx`w8fiK&^ng{76V zi>sTvho@I?NN8AiL}XNQN@`kqMrKxVNoiSmMP*fUOKV$uM`zch$y26In?7UatVN5L zEM2yI#mZHiHgDOwZTpU$yAB;ba`f2o6DLnyx_ss8wd*%--g@}x@sp>|p1*kc>f@)+ zU%r0({^RE_kiQrim?7Q*k`Rxf`AZP!FD6hNu!H=?$W#u*%z`YeiiT`Lj)Clng~Cck zjT|CQ6Blkg$f;}`^g%SK=pvVxipfLOk07sseMX$en#l4Q++zrT-D2QjW&}navmk># z!@v61n}4|fwye8QFaJ($%MZ~H#>eE0C*6v8yeppTN7n0rPqOC(>?ca++`V09-1S)d z`{aMTFMfo6-2d&se}*Qr8uuTfzqS9A)Aw~9--?%Tbj z;@P!VhlBUc4xFN5cq@8_|BMi$6VKdwoeUHU&~$HmdLNnB};m^{4aXlgDMQf0_8P|Iz*~ z`v<+Z)O$_l%iM|hqxyH+KFJEV?}zG{{%|fi$a`$-$LOQxRn;cHmcB{l>6eNzc{;a8 z;GN-)dkcjBoLsyoPo?+Nra7yboA}q3+6(`){FD3Rw%Tm-WA#08S|5vFeDh9UV&D14 kxp;-NbZKa4o3QovsS+Upf&~l#h6fh#g>`8x;QxOU095~&CjbBd literal 0 HcmV?d00001 diff --git a/images/sample_9.jpg b/images/sample_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ddd6dc4f0583c19908b2f14a491cb4d6a71a93e5 GIT binary patch literal 1142 zcmex=%kxU@K!VDr=Sy-4^*jU-vz?hwr zgN>b&osEryn}d@J1b{3aZY~}W2V@9DD-$a-Gb`H|qMvW5}awt1(JSZA;@q>zSQc)8pmzcPOq?D?fx`w8fiK&^ng{76V zi>sTvho@I?NN8AiL}XNQN@`kqMrKxVNoiSmMP*fUOKV$uM`zch$y26In?7UatVN5L zEM2yI#mZHiHgDOwZTpU$yAB;ba`f2o6DLnyx_ss8wd*%--g@}x@sp>|p1*kc>f@)+ zU%r0({^RE_kiQrim?7Q*k`Rxf`AZP!FD6hNu!H=?$W#u*%z`YeiiT`Lj)Clng~Cck zjT|CQ6Blkg$f;}`^g%SK=pvVxipfLOk07sseMX$en#l4Q++zrT-D2QjW&}navmk># z!@v61tA2QXFn*kW{Jqe8wi=Ef){oXpXEU15RX=1WxAV%nvgeYY)?U0V`MzuKZ=*l_ zSNCVGzh!Iz&d?O;D-Z z%)kF3Aiq7(^FIU2>i-N)#(yL}`X8L%E*7=_=05$pD{}Tm8MFF(zq<5Ja@#uP(Zeqv z>^xfMq^9J&O_a9T)KJG$IKG~Z5B*^O=Gpm0uj*7j zimmzntG%PfktONcvqzav(#k(=vvHU_t!%~|rp9``6^!4uhns~P-n$uNW9;$F`{|IB1FZ@!$9!*D00|MaXE{{;R-|LFc8{;03<fA)>|?^^h)XK)pPwaCupB6 zR5|m>n1O+1qe>4?RhVv-{@eK9oz-(RGC5_k(ae-vPLe7`s~TG6N*(0?-vj{t>CH3% literal 0 HcmV?d00001 diff --git a/images/sample_five.jpg b/images/sample_five.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b4375553bf02eb90103a4c716a67871fb556a96f GIT binary patch literal 1187 zcmex=%kxU@K!VDr=Sy-4^*jU-vz?hwr zgN>b&osEryn}d@J1b{3aZY~}W2V@9DD-$a-Gb`H|qMvW5}awt1(JSZA;@q>zSQc)8pmzcPOq?D?fx`w8fiK&^ng{76V zi>sTvho@I?NN8AiL}XNQN@`kqMrKxVNoiSmMP*fUOKV$uM`zch$y26In?7UatVN5L zEM2yI#mZHiHgDOwZTpU$yAB;ba`f2o6DLnyx_ss8wd*%--g@}x@sp>|p1*kc>f@)+ zU%r0({^RE_kiQrim?7Q*k`Rxf`AZP!FD6hNu!H=?$W#u*%z`YeiiT`Lj)Clng~Cck zjT|CQ6Blkg$f;}`^g%SK=pvVxipfLOk07sseMX$en#l4Q++zrT-D2QjW&}navmk># z!yl&Y+js2Q(Rb+*`?Sayl|Z+pGjGgcV0bdAI{fB*_Wcj;<^Rw*ew^EF--rG;l8?^X zDN0-9i^oL1aBWa1*wu5v(B43~&&}fm+df10iaVatQ&TO&f}8l)*6sdx(EdYc{cZMt zT=KsaYrOt5G^PA;|GVdFKj)wLkEZ{oud0#z_`PFKz^)weXIIxgo`3jK+_9$Uw3*66 z#}58ysMOjdQ`xhrq2~F==zqL_{;vGbkbe8Tc;@{r@o#m1+gETsKe$h(JM2o%AJ2~t z+_R@mOfB8ibdN)ImiJ_tY_&^`X6MD^b)5dF$G!f~z^d>g`*%T&{@=BKydVB&_@R-N zz4?#7V=mj;HQAplKV@x*jy|55Uo@S$d&U_77qOg44;_;tW_?)2@XkK{Kf}%C-x~g| z`loQaM*Hs^JN}C1W3&EV=~%hEqTaW|Iz;Na>{>()ISy@4NP&A?^Jw;p6iB>q|Yvc>UfVl+)RBDRp;ebkUOa*-DZk zLLNLGEYCLXQ?3d7vG`;A5%#0|#r~YpT`!j<22X*KtixS3Way=7z|byS^q> zO?HsauRmB^|6uifM*9bgjB3<=X#du!QM_Jb|Kan4_V%<3dra5-*!Ri0H#%aw;jP2c dUPo*;u3Eb2@6RWhJgs-MxqfhUX)yo42>_io-YEb8 literal 0 HcmV?d00001