Keras Image Classifiers.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Conv2D\n",
    "from keras.layers import MaxPooling2D\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Dropout\n",
    "from keras.models import model_from_json\n",
    "from keras import metrics\n",
    "from keras.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reimplement the precision & recall metrics, as they were removed from the later versions of keras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras.backend as K\n",
    "def precision(y_true, y_pred):\n",
    "    \"\"\"Precision metric.\n",
    "\n",
    "    Only computes a batch-wise average of precision.\n",
    "\n",
    "    Computes the precision, a metric for multi-label classification of\n",
    "    how many selected items are relevant.\n",
    "    \"\"\"\n",
    "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
    "    precision = true_positives / (predicted_positives + K.epsilon())\n",
    "    return precision\n",
    "\n",
    "\n",
    "def recall(y_true, y_pred):\n",
    "    \"\"\"Recall metric.\n",
    "\n",
    "    Only computes a batch-wise average of recall.\n",
    "\n",
    "    Computes the recall, a metric for multi-label classification of\n",
    "    how many relevant items are selected.\n",
    "    \"\"\"\n",
    "    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
    "    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
    "    recall = true_positives / (possible_positives + K.epsilon())\n",
    "    return recall"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Real vs Spam Image Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining the model and it's architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = Sequential()\n",
    "classifier.add(Conv2D(32, (3, 3), input_shape = (128, 128, 3), activation = 'relu'))\n",
    "classifier.add(MaxPooling2D(pool_size = (10, 10)))\n",
    "classifier.add(Flatten())\n",
    "classifier.add(Dense(units = 128, activation = 'relu'))\n",
    "classifier.add(Dropout(0.3))\n",
    "classifier.add(Dense(units = 1, activation = 'sigmoid'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compling the model.\n",
    "##### Selecing the optimizer, the loss function, and the metrics we want to measure the performance against."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.compile(optimizer = 'adamax', loss = 'binary_crossentropy', metrics = ['accuracy', metrics.binary_accuracy, precision , recall])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the training and testing datasets and performing transformations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 643 images belonging to 2 classes.\n",
      "Found 36 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "train_datagen = ImageDataGenerator(rescale = 1./255,\n",
    "shear_range = 0.2,\n",
    "zoom_range = 0.2,\n",
    "horizontal_flip = True)\n",
    "test_datagen = ImageDataGenerator(rescale = 1./255)\n",
    "\n",
    "training_set = train_datagen.flow_from_directory('Keras/train_irma',\n",
    "target_size = (128, 128),\n",
    "batch_size = 15,\n",
    "class_mode = 'binary')\n",
    "\n",
    "test_set = test_datagen.flow_from_directory('Keras/test_irma',\n",
    "target_size = (128, 128),\n",
    "batch_size = 32,\n",
    "class_mode = 'binary')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "43/43 [==============================] - 7s 154ms/step - loss: 0.6102 - acc: 0.7807 - binary_accuracy: 0.7807 - precision: 0.1527 - recall: 0.1442 - val_loss: 1.0768 - val_acc: 0.4722 - val_binary_accuracy: 0.4722 - val_precision: 0.0000e+00 - val_recall: 0.0000e+00\n",
      "Epoch 2/25\n",
      "43/43 [==============================] - 6s 135ms/step - loss: 0.4864 - acc: 0.8106 - binary_accuracy: 0.8106 - precision: 0.3360 - recall: 0.1864 - val_loss: 0.8058 - val_acc: 0.5833 - val_binary_accuracy: 0.5833 - val_precision: 0.8222 - val_recall: 0.2647\n",
      "Epoch 3/25\n",
      "43/43 [==============================] - 6s 138ms/step - loss: 0.4138 - acc: 0.8481 - binary_accuracy: 0.8481 - precision: 0.4631 - recall: 0.3007 - val_loss: 0.4906 - val_acc: 0.7500 - val_binary_accuracy: 0.7500 - val_precision: 0.6667 - val_recall: 0.7407\n",
      "Epoch 4/25\n",
      "43/43 [==============================] - 6s 136ms/step - loss: 0.3849 - acc: 0.8494 - binary_accuracy: 0.8494 - precision: 0.3886 - recall: 0.3705 - val_loss: 0.6510 - val_acc: 0.6389 - val_binary_accuracy: 0.6389 - val_precision: 0.7778 - val_recall: 0.3457\n",
      "Epoch 5/25\n",
      "43/43 [==============================] - 6s 144ms/step - loss: 0.3393 - acc: 0.8788 - binary_accuracy: 0.8788 - precision: 0.6497 - recall: 0.5274 - val_loss: 0.4453 - val_acc: 0.8333 - val_binary_accuracy: 0.8333 - val_precision: 0.8296 - val_recall: 0.6914\n",
      "Epoch 6/25\n",
      "43/43 [==============================] - 6s 142ms/step - loss: 0.2958 - acc: 0.8884 - binary_accuracy: 0.8884 - precision: 0.6852 - recall: 0.5010 - val_loss: 0.2999 - val_acc: 0.8611 - val_binary_accuracy: 0.8611 - val_precision: 0.7556 - val_recall: 0.8395\n",
      "Epoch 7/25\n",
      "43/43 [==============================] - 6s 145ms/step - loss: 0.2835 - acc: 0.9021 - binary_accuracy: 0.9021 - precision: 0.7163 - recall: 0.5655 - val_loss: 0.2831 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.7953 - val_recall: 0.8395\n",
      "Epoch 8/25\n",
      "43/43 [==============================] - 6s 145ms/step - loss: 0.2475 - acc: 0.9145 - binary_accuracy: 0.9145 - precision: 0.8046 - recall: 0.6715 - val_loss: 0.3497 - val_acc: 0.8056 - val_binary_accuracy: 0.8056 - val_precision: 0.8254 - val_recall: 0.6420\n",
      "Epoch 9/25\n",
      "43/43 [==============================] - 7s 163ms/step - loss: 0.2270 - acc: 0.9127 - binary_accuracy: 0.9127 - precision: 0.8120 - recall: 0.6519 - val_loss: 0.2590 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 10/25\n",
      "43/43 [==============================] - 8s 192ms/step - loss: 0.2088 - acc: 0.9140 - binary_accuracy: 0.9140 - precision: 0.7644 - recall: 0.6345 - val_loss: 0.2014 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 11/25\n",
      "43/43 [==============================] - 12s 285ms/step - loss: 0.1877 - acc: 0.9302 - binary_accuracy: 0.9302 - precision: 0.8159 - recall: 0.6648 - val_loss: 0.1736 - val_acc: 0.9444 - val_binary_accuracy: 0.9444 - val_precision: 0.9111 - val_recall: 1.0000\n",
      "Epoch 12/25\n",
      "43/43 [==============================] - 11s 245ms/step - loss: 0.1962 - acc: 0.9280 - binary_accuracy: 0.9280 - precision: 0.8152 - recall: 0.7422 - val_loss: 0.2769 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 13/25\n",
      "43/43 [==============================] - 11s 265ms/step - loss: 0.1787 - acc: 0.9426 - binary_accuracy: 0.9426 - precision: 0.8492 - recall: 0.7527 - val_loss: 0.2507 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 14/25\n",
      "43/43 [==============================] - 10s 242ms/step - loss: 0.1477 - acc: 0.9517 - binary_accuracy: 0.9517 - precision: 0.8847 - recall: 0.7787 - val_loss: 0.1648 - val_acc: 0.9444 - val_binary_accuracy: 0.9444 - val_precision: 0.9111 - val_recall: 1.0000\n",
      "Epoch 15/25\n",
      "43/43 [==============================] - 10s 241ms/step - loss: 0.1604 - acc: 0.9426 - binary_accuracy: 0.9426 - precision: 0.8713 - recall: 0.7449 - val_loss: 0.1876 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 16/25\n",
      "43/43 [==============================] - 18s 417ms/step - loss: 0.1558 - acc: 0.9422 - binary_accuracy: 0.9422 - precision: 0.8794 - recall: 0.7834 - val_loss: 0.1691 - val_acc: 0.9167 - val_binary_accuracy: 0.9167 - val_precision: 0.8730 - val_recall: 1.0000\n",
      "Epoch 17/25\n",
      "43/43 [==============================] - 17s 403ms/step - loss: 0.1492 - acc: 0.9424 - binary_accuracy: 0.9424 - precision: 0.8934 - recall: 0.8213 - val_loss: 0.1926 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 18/25\n",
      "43/43 [==============================] - 17s 398ms/step - loss: 0.1430 - acc: 0.9470 - binary_accuracy: 0.9470 - precision: 0.8655 - recall: 0.7775 - val_loss: 0.2152 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 19/25\n",
      "43/43 [==============================] - 17s 399ms/step - loss: 0.1385 - acc: 0.9566 - binary_accuracy: 0.9566 - precision: 0.8431 - recall: 0.7975 - val_loss: 0.1509 - val_acc: 0.9722 - val_binary_accuracy: 0.9722 - val_precision: 0.9532 - val_recall: 1.0000\n",
      "Epoch 20/25\n",
      "43/43 [==============================] - 18s 407ms/step - loss: 0.1463 - acc: 0.9466 - binary_accuracy: 0.9466 - precision: 0.8895 - recall: 0.8056 - val_loss: 0.2459 - val_acc: 0.8889 - val_binary_accuracy: 0.8889 - val_precision: 0.8384 - val_recall: 1.0000\n",
      "Epoch 21/25\n",
      "43/43 [==============================] - 18s 422ms/step - loss: 0.1769 - acc: 0.9238 - binary_accuracy: 0.9238 - precision: 0.7915 - recall: 0.7463 - val_loss: 0.1502 - val_acc: 0.9444 - val_binary_accuracy: 0.9444 - val_precision: 0.9506 - val_recall: 0.9506\n",
      "Epoch 22/25\n",
      "43/43 [==============================] - 17s 402ms/step - loss: 0.1334 - acc: 0.9535 - binary_accuracy: 0.9535 - precision: 0.9046 - recall: 0.8568 - val_loss: 0.2100 - val_acc: 0.9167 - val_binary_accuracy: 0.9167 - val_precision: 0.8735 - val_recall: 1.0000\n",
      "Epoch 23/25\n",
      "43/43 [==============================] - 18s 414ms/step - loss: 0.1151 - acc: 0.9643 - binary_accuracy: 0.9643 - precision: 0.8794 - recall: 0.8318 - val_loss: 0.1717 - val_acc: 0.9167 - val_binary_accuracy: 0.9167 - val_precision: 0.8735 - val_recall: 1.0000\n",
      "Epoch 24/25\n",
      "43/43 [==============================] - 18s 414ms/step - loss: 0.1252 - acc: 0.9566 - binary_accuracy: 0.9566 - precision: 0.8178 - recall: 0.7318 - val_loss: 0.2396 - val_acc: 0.9167 - val_binary_accuracy: 0.9167 - val_precision: 0.8596 - val_recall: 1.0000\n",
      "Epoch 25/25\n",
      "43/43 [==============================] - 18s 411ms/step - loss: 0.1168 - acc: 0.9535 - binary_accuracy: 0.9535 - precision: 0.8779 - recall: 0.8205 - val_loss: 0.2007 - val_acc: 0.9167 - val_binary_accuracy: 0.9167 - val_precision: 0.8596 - val_recall: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f2f2f07fe50>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.fit_generator(training_set,\n",
    "epochs = 25,\n",
    "validation_data = test_set, workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating model's accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = classifier.evaluate_generator(training_set,\n",
    "                             workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 9.99%\n",
      "acc: 96.73%\n",
      "binary_accuracy: 96.73%\n",
      "precision: 91.21%\n",
      "recall: 85.76%\n"
     ]
    }
   ],
   "source": [
    "print(\"%s: %.2f%%\" % (classifier.metrics_names[0], score[0]*100))\n",
    "print(\"%s: %.2f%%\" % (classifier.metrics_names[1], score[1]*100))\n",
    "print(\"%s: %.2f%%\" % (classifier.metrics_names[2], score[2]*100))\n",
    "print(\"%s: %.2f%%\" % (classifier.metrics_names[3], score[3]*100))\n",
    "print(\"%s: %.2f%%\" % (classifier.metrics_names[4], score[4]*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving the model to secondary storage.\n",
    "##### We are doing this to avoid retraining the model again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved model to disk\n"
     ]
    }
   ],
   "source": [
    "# serialize model to JSON\n",
    "model_json = classifier.to_json()\n",
    "with open(\"model.json\", \"w\") as json_file:\n",
    "    json_file.write(model_json)\n",
    "# serialize weights to HDF5\n",
    "classifier.save_weights(\"model.h5\")\n",
    "print(\"Saved model to disk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the model when needed.\n",
    "##### We need to recompile the model after loading the weights."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded model from disk\n"
     ]
    }
   ],
   "source": [
    "# load json and create model\n",
    "json_file = open('model.json', 'r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "loaded_model = model_from_json(loaded_model_json)\n",
    "# load weights into new model\n",
    "loaded_model.load_weights(\"model.h5\")\n",
    "print(\"Loaded model from disk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "loaded_model.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy', metrics = ['accuracy', metrics.binary_accuracy, precision , recall])\n",
    "score = loaded_model.evaluate_generator(training_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 8.78%\n",
      "acc: 96.58%\n",
      "binary_accuracy: 96.58%\n",
      "precision: 90.67%\n",
      "recall: 81.88%\n"
     ]
    }
   ],
   "source": [
    "print(\"%s: %.2f%%\" % (loaded_model.metrics_names[0], score[0]*100))\n",
    "print(\"%s: %.2f%%\" % (loaded_model.metrics_names[1], score[1]*100))\n",
    "print(\"%s: %.2f%%\" % (loaded_model.metrics_names[2], score[2]*100))\n",
    "print(\"%s: %.2f%%\" % (loaded_model.metrics_names[3], score[3]*100))\n",
    "print(\"%s: %.2f%%\" % (loaded_model.metrics_names[4], score[4]*100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flooding vs Wind vs Destruction Image Classifier.\n",
    "##### Only \"Real\" images go through this classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining the model and it's architecture.\n",
    "##### NOT DONE, YET!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier2 = Sequential()\n",
    "# Layers should be added here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the training and testing datasets and performing transformations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datagen = ImageDataGenerator(rescale = 1./255,\n",
    "shear_range = 0.2,\n",
    "zoom_range = 0.2,\n",
    "horizontal_flip = True)\n",
    "test_datagen = ImageDataGenerator(rescale = 1./255)\n",
    "\n",
    "training_set = train_datagen.flow_from_directory('Keras2/train',\n",
    "target_size = (128, 128),\n",
    "batch_size = 15,\n",
    "class_mode='categorical')\n",
    "\n",
    "test_set = test_datagen.flow_from_directory('Keras2/test',\n",
    "target_size = (128, 128),\n",
    "batch_size = 3,\n",
    "class_mode = 'categorical')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier2.fit_generator(training_set,\n",
    "epochs = 25,\n",
    "validation_data = test_set, workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing the model against an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from keras.preprocessing import image\n",
    "img_path = '/home/saed/Desktop/Research/Twitter/Images Classification/images/2bO4EEqOGPwAFFrC.jpg'\n",
    "test_image = image.load_img(img_path, target_size = (128, 128))\n",
    "test_image = image.img_to_array(test_image)\n",
    "test_image = np.expand_dims(test_image/255.0, axis = 0)\n",
    "result = classifier.predict_classes(test_image)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}