pyimagesearch-22-minutes-to-2nd-place.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Title:** 22 minutes to 2nd place in a Kaggle competition with deep learning and the Microsoft Azure cloud\n",
    "**Author:** Adrian Rosebrock, [PyImageSearch.com](https://www.pyimagesearch.com/)\n",
    "\n",
    "The code in this tutorial was executed on a [Microsoft Data Science Virtual Machine](https://azure.microsoft.com/en-us/services/virtual-machines/data-science-virtual-machines/). Results were gathered for Microsoft's blog.\n",
    "\n",
    "For an in-depth treatment of deep learning and Convolutional Neural Networks, please refer to [*Deep Learning for Computer Vision with Python*](https://www.pyimagesearch.com/deep-learning-computer-vision-python-book/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# import the necessary packages\n",
    "from keras.applications import ResNet50\n",
    "from keras.applications import imagenet_utils\n",
    "from keras.preprocessing.image import img_to_array\n",
    "from keras.preprocessing.image import load_img\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import accuracy_score\n",
    "from imutils import paths\n",
    "import numpy as np\n",
    "import progressbar\n",
    "import random\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# since we are not using command line arguments (like we typically\n",
    "# would inside Deep Learning for Computer Vision with Python, let's\n",
    "# \"pretend\" we are by using an `args` dictionary -- this will enable\n",
    "# us to easily reuse and swap out code depending if we are using the\n",
    "# command line or Jupyter Notebook\n",
    "args = {\n",
    "    \"dataset\": \"../datasets/kaggle_dogs_vs_cats/train\",\n",
    "    \"batch_size\": 32,\n",
    "}\n",
    "\n",
    "# store the batch size in a convenience variable\n",
    "bs = args[\"batch_size\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000\n"
     ]
    }
   ],
   "source": [
    "# grab the list of images in the Kaggle Dogs vs. Cats download and\n",
    "# shuffle them to allow for easy training and testing splits via\n",
    "# array slicing during training time\n",
    "imagePaths = list(paths.list_images(args[\"dataset\"]))\n",
    "random.shuffle(imagePaths)\n",
    "print(len(imagePaths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# extract the class labels from the image paths then encode the\n",
    "# labels\n",
    "labels = [p.split(os.path.sep)[-1].split(\".\")[0] for p in imagePaths]\n",
    "le = LabelEncoder()\n",
    "labels = le.fit_transform(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# load the ResNet50 network (i.e., the network we'll be using for\n",
    "# feature extraction)\n",
    "model = ResNet50(weights=\"imagenet\", include_top=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Extracting Features:   0% |                                    | ETA:  --:--:--\r"
     ]
    }
   ],
   "source": [
    "# initialize the progress bar\n",
    "widgets = [\"Extracting Features: \", progressbar.Percentage(), \" \",\n",
    "    progressbar.Bar(), \" \", progressbar.ETA()]\n",
    "pbar = progressbar.ProgressBar(maxval=len(imagePaths),\n",
    "    widgets=widgets).start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Extracting Features:  99% |#################################### | ETA:  0:00:02\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6min 24s, sys: 1min 4s, total: 7min 29s\n",
      "Wall time: 22min 48s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Extracting Features: 100% |#####################################| Time: 0:22:48\r\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# initialize our data matrix (where we will store our extracted\n",
    "# features)\n",
    "data = None\n",
    "\n",
    "# loop over the images in batches\n",
    "for i in np.arange(0, len(imagePaths), bs):\n",
    "    # extract the batch of images and labels, then initialize the\n",
    "    # list of actual images that will be passed through the network\n",
    "    # for feature extraction\n",
    "    batchPaths = imagePaths[i:i + bs]\n",
    "    batchLabels = labels[i:i + bs]\n",
    "    batchImages = []\n",
    "    \n",
    "    # loop over the images and labels in the current batch\n",
    "    for (j, imagePath) in enumerate(batchPaths):\n",
    "        # load the input image using the Keras helper utility\n",
    "        # while ensuring the image is resized to 224x224 pixels\n",
    "        image = load_img(imagePath, target_size=(224, 224))\n",
    "        image = img_to_array(image)\n",
    "\n",
    "        # preprocess the image by (1) expanding the dimensions and\n",
    "        # (2) subtracting the mean RGB pixel intensity from the\n",
    "        # ImageNet dataset\n",
    "        image = np.expand_dims(image, axis=0)\n",
    "        image = imagenet_utils.preprocess_input(image)\n",
    "\n",
    "        # add the image to the batch\n",
    "        batchImages.append(image)\n",
    "\n",
    "    # pass the images through the network and use the outputs as\n",
    "    # our actual features\n",
    "    batchImages = np.vstack(batchImages)\n",
    "    features = model.predict(batchImages, batch_size=bs)\n",
    "\n",
    "    # reshape the features so that each image is represented by\n",
    "    # a flattened feature vector of the `MaxPooling2D` outputs\n",
    "    features = features.reshape((features.shape[0], 2048))\n",
    "    \n",
    "    # if our data matrix is None, initialize it\n",
    "    if data is None:\n",
    "        data = features\n",
    "    \n",
    "    # otherwise, stack the data and features together\n",
    "    else:\n",
    "        data = np.vstack([data, features])\n",
    "    \n",
    "    # update the progress bar\n",
    "    pbar.update(i)\n",
    "\n",
    "# finish up the progress bar\n",
    "pbar.finish()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25000, 2048)\n",
      "204800000\n"
     ]
    }
   ],
   "source": [
    "# show the data matrix shape and amount of memory it consumes\n",
    "print(data.shape)\n",
    "print(data.nbytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] tuning hyperparameters...\n",
      "[INFO] best hyperparameters: {'C': 0.01}\n",
      "CPU times: user 13.5 s, sys: 808 ms, total: 14.3 s\n",
      "Wall time: 36.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# determine the index of the training and testing split (75% for\n",
    "# training and 25% for testing)\n",
    "i = int(data.shape[0] * 0.75)\n",
    "\n",
    "# define the set of parameters that we want to tune then start a\n",
    "# grid search where we evaluate our model for each value of C\n",
    "print(\"[INFO] tuning hyperparameters...\")\n",
    "params = {\"C\": [0.0001, 0.001, 0.01, 0.1, 1.0]}\n",
    "clf = GridSearchCV(LogisticRegression(), params, cv=3, n_jobs=-1)\n",
    "clf.fit(data[:i], labels[:i])\n",
    "print(\"[INFO] best hyperparameters: {}\".format(clf.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] evaluating...\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "        cat       0.99      0.99      0.99      3180\n",
      "        dog       0.99      0.99      0.99      3070\n",
      "\n",
      "avg / total       0.99      0.99      0.99      6250\n",
      "\n",
      "[INFO] score: 0.98896\n"
     ]
    }
   ],
   "source": [
    "# generate a classification report for the model\n",
    "print(\"[INFO] evaluating...\")\n",
    "preds = clf.predict(data[i:])\n",
    "print(classification_report(labels[i:], preds, target_names=le.classes_))\n",
    "\n",
    "# compute the raw accuracy with extra precision\n",
    "acc = accuracy_score(labels[i:], preds)\n",
    "print(\"[INFO] score: {}\".format(acc))"
   ]
  },
  {
   "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": 2
}