Digit Recognizer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os \n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "from tensorflow.python import keras\n",
    "from tensorflow.python.keras.models import Sequential\n",
    "from tensorflow.python.keras.layers import Dense, Flatten, Conv2D, Dropout\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Vincent\\PycharmProjects\\Kaggle\\DigitRecognizer\n"
     ]
    }
   ],
   "source": [
    "dir=os.getcwd()\n",
    "print(os.getcwd())\n",
    "\n",
    "X_train = pd.read_csv(os.path.join(dir, \"data/train.csv\")) \n",
    "X_test_file = pd.read_csv(os.path.join(dir, \"data/test.csv\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000, 785)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    4684\n",
       "7    4401\n",
       "3    4351\n",
       "9    4188\n",
       "2    4177\n",
       "6    4137\n",
       "0    4132\n",
       "4    4072\n",
       "8    4063\n",
       "5    3795\n",
       "Name: label, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Y_train = X_train[\"label\"]\n",
    "g = sns.countplot(Y_train)\n",
    "\n",
    "Y_train.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count       785\n",
       "unique        1\n",
       "top       False\n",
       "freq        785\n",
       "dtype: object"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.isnull().any().describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count       784\n",
       "unique        1\n",
       "top       False\n",
       "freq        784\n",
       "dtype: object"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test_file.isnull().any().describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_rows,img_cols= 28,28\n",
    "nb_classes=10\n",
    "\n",
    "def data_prep(raw):\n",
    "    out_y=tf.keras.utils.to_categorical(raw.label, nb_classes)\n",
    "    nb_images=raw.shape[0]\n",
    "    x_as_array = raw.values[:,1:]\n",
    "    x_shaped_array = x_as_array.reshape(nb_images, img_rows, img_cols, 1)\n",
    "    out_x = x_shaped_array / 255\n",
    "    return out_x, out_y\n",
    "\n",
    "\n",
    "X,y = data_prep(X_train)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 33600 samples, validate on 8400 samples\n",
      "Epoch 1/10\n",
      "33600/33600 [==============================] - 9s 262us/sample - loss: 0.4220 - accuracy: 0.8640 - val_loss: 0.1057 - val_accuracy: 0.9670\n",
      "Epoch 2/10\n",
      "33600/33600 [==============================] - 9s 254us/sample - loss: 0.1188 - accuracy: 0.9635 - val_loss: 0.0644 - val_accuracy: 0.9799\n",
      "Epoch 3/10\n",
      "33600/33600 [==============================] - 8s 253us/sample - loss: 0.0803 - accuracy: 0.9762 - val_loss: 0.0519 - val_accuracy: 0.9842\n",
      "Epoch 4/10\n",
      "33600/33600 [==============================] - 8s 248us/sample - loss: 0.0641 - accuracy: 0.9802 - val_loss: 0.0440 - val_accuracy: 0.9861\n",
      "Epoch 5/10\n",
      "33600/33600 [==============================] - 8s 251us/sample - loss: 0.0532 - accuracy: 0.9833 - val_loss: 0.0382 - val_accuracy: 0.9879\n",
      "Epoch 6/10\n",
      "33600/33600 [==============================] - 8s 252us/sample - loss: 0.0468 - accuracy: 0.9857 - val_loss: 0.0351 - val_accuracy: 0.9883\n",
      "Epoch 7/10\n",
      "33600/33600 [==============================] - 8s 251us/sample - loss: 0.0377 - accuracy: 0.9888 - val_loss: 0.0338 - val_accuracy: 0.9898\n",
      "Epoch 8/10\n",
      "33600/33600 [==============================] - 9s 256us/sample - loss: 0.0368 - accuracy: 0.9878 - val_loss: 0.0342 - val_accuracy: 0.9904\n",
      "Epoch 9/10\n",
      "33600/33600 [==============================] - 9s 253us/sample - loss: 0.0352 - accuracy: 0.9891 - val_loss: 0.0334 - val_accuracy: 0.9913\n",
      "Epoch 10/10\n",
      "33600/33600 [==============================] - 8s 251us/sample - loss: 0.0310 - accuracy: 0.9900 - val_loss: 0.0394 - val_accuracy: 0.9892\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x16d14a4a308>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model=Sequential()\n",
    "\n",
    "\n",
    "model.add(Conv2D(32, kernel_size=(5, 5), strides=2, activation='relu',input_shape=(img_rows, img_cols, 1)))\n",
    "model.add(Conv2D(32, kernel_size=(5, 5), activation='relu'))\n",
    "model.add(Dropout(0.25))\n",
    "model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))\n",
    "model.add(Dropout(0.25))\n",
    "\n",
    "model.add(Flatten())\n",
    "model.add(Dense(256, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(nb_classes, activation='softmax'))\n",
    "\n",
    "model.compile(loss=keras.losses.categorical_crossentropy,optimizer='adam',metrics=['accuracy'])\n",
    "model.fit(X, y,batch_size=100,epochs=10,validation_split = 0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.python.keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "datagen = ImageDataGenerator(\n",
    "        featurewise_center=False,  # set input mean to 0 over the dataset\n",
    "        samplewise_center=False,  # set each sample mean to 0\n",
    "        featurewise_std_normalization=False,  # divide inputs by std of the dataset\n",
    "        samplewise_std_normalization=False,  # divide each input by its std\n",
    "        zca_whitening=False,  # apply ZCA whitening\n",
    "        rotation_range=10,  # randomly rotate images in the range (degrees, 0 to 180)\n",
    "        zoom_range = 0.1, # Randomly zoom image \n",
    "        width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)\n",
    "        height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)\n",
    "        horizontal_flip=False,  # randomly flip images\n",
    "        vertical_flip=False)  # randomly flip images\n",
    "\n",
    "\n",
    "datagen.fit(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#history = model.fit_generator(datagen.flow(X,y, batch_size=100),\n",
    "#                              epochs = 100, validation_data = (X_val,Y_val),\n",
    "#                              verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size\n",
    "#                              , callbacks=[learning_rate_reduction])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_images=X_test_file.shape[0]\n",
    "X_as_array = X_test_file.values[:,:]\n",
    "X_test = X_as_array.reshape(nb_images, img_rows, img_cols, 1) / 255\n",
    "\n",
    "\n",
    "results = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9.3396096e-11 8.1299741e-12 1.0000000e+00 3.2349573e-10 2.2119950e-13\n",
      " 2.6126420e-14 2.3525016e-13 2.4510418e-11 2.1891518e-11 2.3258858e-15]\n",
      "28000\n"
     ]
    }
   ],
   "source": [
    "print(results[0])\n",
    "print(nb_images)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select the indix with the maximum probability\n",
    "results_modified = np.argmax(results,axis = 1)\n",
    "\n",
    "results_series = pd.Series(results_modified,name=\"Label\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0        2\n",
      "1        0\n",
      "2        9\n",
      "3        0\n",
      "4        3\n",
      "        ..\n",
      "27995    9\n",
      "27996    7\n",
      "27997    3\n",
      "27998    9\n",
      "27999    2\n",
      "Name: Label, Length: 28000, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(results_series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import itertools\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, cm[i, j],\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "\n",
    "# Predict the values from the validation dataset\n",
    "y_pred = model.predict(X)\n",
    "# Convert predictions classes to one hot vectors \n",
    "Y_pred_classes = np.argmax(y_pred,axis = 1) \n",
    "# Convert validation observations to one hot vectors\n",
    "Y_true = np.argmax(y,axis = 1) \n",
    "# compute the confusion matrix\n",
    "confusion_mtx = confusion_matrix(Y_true, Y_pred_classes) \n",
    "# plot the confusion matrix\n",
    "plot_confusion_matrix(confusion_mtx, classes = range(10)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.concat([pd.Series(range(1,28001),name = \"ImageId\"),results_series],axis = 1)\n",
    "\n",
    "submission.to_csv(\"cnn_mnist_datagen.csv\",index=False)"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}