{"cells":[{"metadata":{},"cell_type":"markdown","source":"<p style='text-align:center;font-size:20px'> <b>Kaggle Competition<b/> </p>"},{"metadata":{},"cell_type":"markdown","source":"<p style='text-align:center;font-size:32px'> <b>Digit Recognizer<b/> </p>"},{"metadata":{},"cell_type":"markdown","source":"### Data Loading & Preprocessing"},{"metadata":{"trusted":true},"cell_type":"code","source":"# importing libraries\nfrom __future__ import print_function\nimport pandas as pd\nimport numpy as np\nimport keras\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D\nfrom keras.layers.normalization import BatchNormalization\nfrom keras import backend as K\nimport matplotlib.pyplot as plt\n\nimport warnings\nwarnings.filterwarnings(\"ignore\")","execution_count":16,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# importing train dataset\ntrain = pd.read_csv('../input/train.csv')\nprint('The dimensions of Train dataset are - ', train.shape)","execution_count":17,"outputs":[{"output_type":"stream","text":"The dimensions of Train dataset are -  (42000, 785)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# importing test dataset\ntest = pd.read_csv('../input/test.csv')\nprint('The dimensions of Test dataset are - ', test.shape)","execution_count":18,"outputs":[{"output_type":"stream","text":"The dimensions of Test dataset are -  (28000, 784)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# setting the model parameters\nbatch_size = 128\nnum_classes = 10\nepochs = 10\nimg_rows, img_cols = 28, 28","execution_count":19,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# dropping the label column from train dataset\nX_train = train.drop(['label'], axis=1)\nX_test = test\n\ny_train = train['label']\n# converting each value of y_train to binary vector of size=10\n# for y=2 => [0,0,1,0,0,0,0,0,0,0]\ny_train = keras.utils.to_categorical(y_train, num_classes)","execution_count":20,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# converting the pandas dataframe to numpy array\nX_train = np.array(X_train)\nX_test = np.array(X_test)","execution_count":21,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# resizing the train & test datasets\nif 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    input_shape = (1, img_rows, img_cols)\nelse:\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    input_shape = (img_rows, img_cols, 1)","execution_count":22,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('The dimensions of the resized Train dataset is', X_train.shape)\nprint('The dimensions of the resized Test dataset is', X_train.shape)","execution_count":23,"outputs":[{"output_type":"stream","text":"The dimensions of the resized Train dataset is (42000, 28, 28, 1)\nThe dimensions of the resized Test dataset is (42000, 28, 28, 1)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# this function is used to update the plots for each epoch and error\ndef plt_dynamic(x, ty, ax, colors=['b']):\n    ax.plot(x, ty, 'r', label=\"Train Loss\")\n    plt.legend()\n    plt.grid()\n    fig.canvas.draw()","execution_count":24,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Applying CNN model"},{"metadata":{},"cell_type":"markdown","source":"**3 Convolution Layers + Kernel size=5 + Padding + Batch Norm. with Max Pooling**"},{"metadata":{"trusted":true},"cell_type":"code","source":"model = Sequential()\n# layer 1\nmodel.add(Conv2D(128, kernel_size=(5, 5),\n                 kernel_initializer='he_normal',\n                 activation='relu',\n                 padding='same',\n                 input_shape=input_shape))\nmodel.add(BatchNormalization())\n\n#layer 2\nmodel.add(Conv2D(64, kernel_size=(5, 5),\n                 kernel_initializer='he_normal',\n                 padding='same',\n                 activation='relu'\n                 ))\nmodel.add(BatchNormalization())\n\n#layer 3\nmodel.add(Conv2D(32, kernel_size=(5, 5),\n                 kernel_initializer='he_normal',\n                 padding='same',\n                 activation='relu'))\nmodel.add(BatchNormalization())\n\nmodel.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))\n\nmodel.add(Flatten())\n\nmodel.add(Dense(128, activation='relu'))\nmodel.add(BatchNormalization())\nmodel.add(Dropout(rate=0.5))\n\nmodel.add(Dense(num_classes, activation='softmax'))\n\nmodel.compile(loss=keras.losses.categorical_crossentropy,\n              optimizer=keras.optimizers.Adadelta(),\n              metrics=['accuracy'])\n\nhistory = model.fit(X_train, y_train,\n          batch_size=batch_size,\n          epochs=epochs,\n          verbose=1)","execution_count":25,"outputs":[{"output_type":"stream","text":"Epoch 1/10\n42000/42000 [==============================] - 8s 193us/step - loss: 0.1582 - acc: 0.9526\nEpoch 2/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0541 - acc: 0.9841\nEpoch 3/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0363 - acc: 0.9886\nEpoch 4/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0266 - acc: 0.9918\nEpoch 5/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0205 - acc: 0.9936\nEpoch 6/10\n42000/42000 [==============================] - 7s 167us/step - loss: 0.0159 - acc: 0.9954\nEpoch 7/10\n42000/42000 [==============================] - 7s 164us/step - loss: 0.0118 - acc: 0.9964\nEpoch 8/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0100 - acc: 0.9968\nEpoch 9/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0077 - acc: 0.9975\nEpoch 10/10\n42000/42000 [==============================] - 7s 165us/step - loss: 0.0068 - acc: 0.9982\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# epoch vs loss plot\nfig,ax = plt.subplots(1,1)\nax.set_xlabel('Epoch') \nax.set_ylabel('Categorical Crossentropy Loss')\n\n# list of epoch numbers\nx = list(range(1,epochs+1))\n\nty = history.history['loss']\nplt_dynamic(x, ty, ax)","execution_count":26,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# predicting the class labels\ny_pred = model.predict(X_test)\n\n# converting the probabilities to class labels\ny_classes = y_pred.argmax(axis=-1)","execution_count":27,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# constructing the ID column for submission\nId = [x for x in range(1,28001)]","execution_count":28,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"output=pd.DataFrame({'ImageId':Id,'Label':y_classes})\noutput.to_csv('submission.csv', index=False)","execution_count":29,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"1. **Result** - The model scored an accuracy of **99.27%** on Test dataset. "},{"metadata":{},"cell_type":"markdown","source":"## Conclusion"},{"metadata":{},"cell_type":"markdown","source":"- In this case study, I trained a 3-layered Convolutional Neural Network that achieved 99.27% accuracy on Test data.\n- The size of the kernel used was 5x5 along with Padding.\n- The activation function used was Adam. \n- Techniques such as Batch Normalization, MaxPooling & Dropouts were used."}],"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.7.1"}},"nbformat":4,"nbformat_minor":1}