dog breed classification 2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "%matplotlib inline\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "DATA_DIR = '/home/ubuntu/Downloads/train/'\n",
    "images_path_list = [file_name for file_name in os.listdir(DATA_DIR) if file_name.endswith('jpg')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "at image 0 out of 10222\n",
      "at image 1000 out of 10222\n",
      "at image 2000 out of 10222\n",
      "at image 3000 out of 10222\n",
      "at image 4000 out of 10222\n",
      "at image 5000 out of 10222\n",
      "at image 6000 out of 10222\n",
      "at image 7000 out of 10222\n",
      "at image 8000 out of 10222\n",
      "at image 9000 out of 10222\n",
      "at image 10000 out of 10222\n"
     ]
    }
   ],
   "source": [
    "im_list = []\n",
    "for im_ind, im_path in enumerate(images_path_list):\n",
    "    if im_ind % 1000 ==0:\n",
    "        print ('at image {} out of {}'.format(im_ind, len(images_path_list)))\n",
    "    im = cv2.imread(os.path.join(DATA_DIR,im_path))\n",
    "    im = cv2.cvtColor(im,cv2.COLOR_BGR2RGB)\n",
    "    im = cv2.resize(im,(64,64))\n",
    "    im_list.append(im)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "labels_df = pd.read_csv('/home/ubuntu/Downloads/labels.csv')\n",
    "labels_list = []\n",
    "for im_path in images_path_list:\n",
    "    labels_list.append( (str(labels_df[labels_df['id'] == (im_path[:-4])]['breed'].values[0])) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "X = np.array(im_list)\n",
    "Y = np.array(labels_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "labels_dict = dict([ [bread_name,k] for k, bread_name in enumerate(set(labels_list))])\n",
    "Y = [labels_dict[y] for y in Y]\n",
    "\n",
    "from keras.utils import np_utils\n",
    "Y = np_utils.to_categorical(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dividing into train and test "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "total_samples_num = len(Y)\n",
    "\n",
    "train_percent = 0.7\n",
    "val_percent = 0.2\n",
    "test_percent = 0.1\n",
    "\n",
    "train_sample_num = int(total_samples_num * train_percent)\n",
    "val_sample_num = int(total_samples_num * val_percent)\n",
    "test_sample_num = int(total_samples_num * test_percent)\n",
    "\n",
    "last_train_index = train_sample_num \n",
    "last_val_index = last_train_index + val_sample_num\n",
    "first_test_index = last_val_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_X = X[:last_train_index]\n",
    "val_X = X[last_train_index:last_val_index]\n",
    "test_X = X[first_test_index :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# from sklearn.preprocessing import StandardScaler\n",
    "# scaler = StandardScaler()\n",
    "# scaler.fit(train_X)\n",
    "# scaler.transform(val_X)\n",
    "# scaler.transform(test_X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train_Y = Y[:last_train_index]\n",
    "val_Y = Y[last_train_index:last_val_index]\n",
    "test_Y = Y[first_test_index :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "train_X = train_X.astype(np.float32)\n",
    "val_X = val_X.astype(np.float32)\n",
    "test_X = test_X.astype(np.float32)\n",
    "\n",
    "train_X = train_X/255.0\n",
    "val_X = val_X/255.0\n",
    "test_X = test_X/255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from keras.models import Sequential, load_model\n",
    "from keras.layers.convolutional import Convolution2D, MaxPooling2D\n",
    "from keras.layers.core import Activation, Flatten, Dense, Dropout\n",
    "from keras.layers import BatchNormalization\n",
    "from keras.callbacks import EarlyStopping , ModelCheckpoint\n",
    "from keras.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "224/224 [==============================] - 333s 1s/step - loss: 6.4802 - acc: 0.0220 - val_loss: 4.9079 - val_acc: 0.0132\n",
      "Epoch 2/100\n",
      "224/224 [==============================] - 329s 1s/step - loss: 5.3649 - acc: 0.0388 - val_loss: 5.0649 - val_acc: 0.0294\n",
      "Epoch 3/100\n",
      "224/224 [==============================] - 320s 1s/step - loss: 5.0856 - acc: 0.0468 - val_loss: 5.1753 - val_acc: 0.0406\n",
      "Epoch 4/100\n",
      "224/224 [==============================] - 315s 1s/step - loss: 4.4664 - acc: 0.0624 - val_loss: 4.5929 - val_acc: 0.0675\n",
      "Epoch 5/100\n",
      "224/224 [==============================] - 317s 1s/step - loss: 4.1316 - acc: 0.0908 - val_loss: 4.3819 - val_acc: 0.0641\n",
      "Epoch 6/100\n",
      "224/224 [==============================] - 310s 1s/step - loss: 3.9810 - acc: 0.1067 - val_loss: 4.3596 - val_acc: 0.0758\n",
      "Epoch 7/100\n",
      "224/224 [==============================] - 339s 2s/step - loss: 3.8589 - acc: 0.1238 - val_loss: 4.6080 - val_acc: 0.0719\n",
      "Epoch 8/100\n",
      "224/224 [==============================] - 304s 1s/step - loss: 3.7726 - acc: 0.1421 - val_loss: 4.2850 - val_acc: 0.0837\n",
      "Epoch 9/100\n",
      "224/224 [==============================] - 305s 1s/step - loss: 3.6881 - acc: 0.1540 - val_loss: 4.5082 - val_acc: 0.0797\n",
      "Epoch 10/100\n",
      "224/224 [==============================] - 307s 1s/step - loss: 3.5907 - acc: 0.1717 - val_loss: 4.4801 - val_acc: 0.0753\n",
      "Epoch 11/100\n",
      "224/224 [==============================] - 307s 1s/step - loss: 3.4877 - acc: 0.1776 - val_loss: 4.4844 - val_acc: 0.0793\n",
      "Epoch 12/100\n",
      "224/224 [==============================] - 310s 1s/step - loss: 3.3998 - acc: 0.2002 - val_loss: 4.5038 - val_acc: 0.0807\n",
      "Epoch 00012: early stopping\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f0ac1faf438>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_gen = ImageDataGenerator(horizontal_flip=True, height_shift_range=0.05, width_shift_range=0.05) \n",
    "early_stop = EarlyStopping(monitor='val_loss', patience=4,verbose=1)\n",
    "\n",
    "fBestModel = 'dogs_best_model.h5' \n",
    "best_model = ModelCheckpoint(fBestModel, verbose=0, save_best_only=True)\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Convolution2D(filters=96, kernel_size=3,padding='valid',\n",
    "                        input_shape=(64, 64,3)))\n",
    "model.add(BatchNormalization())\n",
    "model.add(Activation('relu'))\n",
    "model.add(MaxPooling2D(pool_size=2,strides=2))\n",
    "\n",
    "model.add(Convolution2D(filters=96, kernel_size=3,padding='valid'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling2D(pool_size=2,strides=2))\n",
    "\n",
    "model.add(Convolution2D(filters=96, kernel_size=3,padding='valid'))\n",
    "model.add(Activation('relu'))\n",
    "model.add(BatchNormalization())\n",
    "model.add(MaxPooling2D(pool_size=2,strides=2))\n",
    "model.add(Flatten())\n",
    "model.add(Activation('relu'))\n",
    "\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(120))\n",
    "model.add(Activation('softmax'))\n",
    "\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam',metrics=[\"accuracy\"])\n",
    "\n",
    "model.fit_generator(data_gen.flow( train_X, train_Y ), validation_data=(val_X, val_Y),\n",
    "                    epochs=100, callbacks=[early_stop,best_model])\n",
    "# model.fit( train_X, train_Y , validation_data=(val_X, val_Y), callbacks=[early_stop], epochs=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "best_model = load_model('dogs_best_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2044/2044 [==============================] - 38s 18ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4.2850019087296873, 0.083659491237478942]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_model.evaluate(val_X,val_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1023/1023 [==============================] - 19s 18ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4.3888850580329191, 0.070381231613289699]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_model.evaluate(test_X,test_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}