Detecting Pneumonia through X-ray Images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detecting Pneumonia through X-ray Images with Convolutional Neural Networks in Keras and Back-end Tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Written by: Udbhav Prasad <br>\n",
    "Linkedin: https://www.linkedin.com/in/udbhav-prasad-1506b7192/ <br>\n",
    "HackerRank: https://www.hackerrank.com/uprasad1 <br>\n",
    "Github: https://github.com/UdbhavPrasad072300 <br>\n",
    "Computer Science Co-op - Ryerson University <br> <hr>\n",
    "Making a Convolutional Neural Network with Keras and back-end Tensorflow to detect whether someone has pneumonia based on an X-ray scan of their chest <br>\n",
    "An accuracy of <b>96%</b> was achieved for Training Set & <br>\n",
    "An accuracy of <b>90%</b> was achieved for Validation Set "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "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.preprocessing.image import ImageDataGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking if GPU is being used by Tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "My CPU: Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz, 3696 Mhz, 6 Core(s), 12 Logical Processor(s) <br>\n",
    "My GPU: NVIDIA GeForce GTX 1080 8GB Dedicated Memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[name: \"/device:CPU:0\"\n",
      "device_type: \"CPU\"\n",
      "memory_limit: 268435456\n",
      "locality {\n",
      "}\n",
      "incarnation: 15043386031989147291\n",
      ", name: \"/device:GPU:0\"\n",
      "device_type: \"GPU\"\n",
      "memory_limit: 6657650197\n",
      "locality {\n",
      "  bus_id: 1\n",
      "  links {\n",
      "  }\n",
      "}\n",
      "incarnation: 5262185982309028731\n",
      "physical_device_desc: \"device: 0, name: GeForce GTX 1080, pci bus id: 0000:01:00.0, compute capability: 6.1\"\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "print(device_lib.list_local_devices())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialising the Convolutional Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#strategy = tf.distribute.MirroredStrategy(devices=None, cross_device_ops=None)\n",
    "\n",
    "#with strategy.scope():\n",
    "classifier = Sequential()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Layers to Neural Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First Convolutional Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu')) # Step 1 - Convolution\n",
    "classifier.add(MaxPooling2D(pool_size = (2, 2))) # Step 2 - Pooling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second Convolutional Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.add(Conv2D(32, (3, 3), activation = 'relu')) # Step 1 - Convolution\n",
    "classifier.add(MaxPooling2D(pool_size = (2, 2))) # Step 2 - Pooling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Flattening Layer <br>\n",
    "Turns into 1 dimension for input layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.add(Flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arificial Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.add(Dense(units = 128, activation = 'relu'))\n",
    "classifier.add(Dense(units = 1, activation = 'sigmoid'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compiling Convolutional Neural Network "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting Images to Convolutional Neural Network "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datagen = ImageDataGenerator(rescale = 1./255,\n",
    "                                   shear_range = 0.2,\n",
    "                                   zoom_range = 0.2,\n",
    "                                   horizontal_flip = True)\n",
    "\n",
    "test_datagen = ImageDataGenerator(rescale = 1./255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 5216 images belonging to 2 classes.\n",
      "Found 624 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "training_set = train_datagen.flow_from_directory('train',\n",
    "                                                 target_size = (64, 64),\n",
    "                                                 batch_size = 32,\n",
    "                                                 class_mode = 'binary')\n",
    "\n",
    "test_set = test_datagen.flow_from_directory('test',\n",
    "                                            target_size = (64, 64),\n",
    "                                            batch_size = 32,\n",
    "                                            class_mode = 'binary')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary of the Layers and Characteristics of the Convolutional Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 62, 62, 32)        896       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 31, 31, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 29, 29, 32)        9248      \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 14, 14, 32)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 6272)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               802944    \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 129       \n",
      "=================================================================\n",
      "Total params: 813,217\n",
      "Trainable params: 813,217\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "classifier.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the Network with Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Steps per epoch: 250 <br>\n",
    "Num. of epochs: 15 <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "250/250 [==============================] - 149s 598ms/step - loss: 0.3224 - accuracy: 0.8602 - val_loss: 0.7070 - val_accuracy: 0.8349\n",
      "Epoch 2/15\n",
      "250/250 [==============================] - 147s 586ms/step - loss: 0.2066 - accuracy: 0.9151 - val_loss: 0.8791 - val_accuracy: 0.8878\n",
      "Epoch 3/15\n",
      "250/250 [==============================] - 147s 590ms/step - loss: 0.1885 - accuracy: 0.9236 - val_loss: 0.4848 - val_accuracy: 0.9054\n",
      "Epoch 4/15\n",
      "250/250 [==============================] - 148s 591ms/step - loss: 0.1668 - accuracy: 0.9375 - val_loss: 0.2572 - val_accuracy: 0.9006\n",
      "Epoch 5/15\n",
      "250/250 [==============================] - 147s 589ms/step - loss: 0.1498 - accuracy: 0.9436 - val_loss: 0.0839 - val_accuracy: 0.9103\n",
      "Epoch 6/15\n",
      "250/250 [==============================] - 147s 589ms/step - loss: 0.1422 - accuracy: 0.9446 - val_loss: 0.1573 - val_accuracy: 0.8990\n",
      "Epoch 7/15\n",
      "250/250 [==============================] - 148s 593ms/step - loss: 0.1347 - accuracy: 0.9504 - val_loss: 0.3816 - val_accuracy: 0.8686\n",
      "Epoch 8/15\n",
      "250/250 [==============================] - 148s 591ms/step - loss: 0.1262 - accuracy: 0.9525 - val_loss: 0.3847 - val_accuracy: 0.8958\n",
      "Epoch 9/15\n",
      "250/250 [==============================] - 146s 584ms/step - loss: 0.1251 - accuracy: 0.9536 - val_loss: 0.1533 - val_accuracy: 0.8750\n",
      "Epoch 10/15\n",
      "250/250 [==============================] - 146s 585ms/step - loss: 0.1198 - accuracy: 0.9564 - val_loss: 0.3077 - val_accuracy: 0.9022\n",
      "Epoch 11/15\n",
      "250/250 [==============================] - 146s 582ms/step - loss: 0.1140 - accuracy: 0.9579 - val_loss: 0.2485 - val_accuracy: 0.9151\n",
      "Epoch 12/15\n",
      "250/250 [==============================] - 147s 587ms/step - loss: 0.1105 - accuracy: 0.9588 - val_loss: 0.1223 - val_accuracy: 0.9103\n",
      "Epoch 13/15\n",
      "250/250 [==============================] - 146s 583ms/step - loss: 0.1140 - accuracy: 0.9585 - val_loss: 0.2996 - val_accuracy: 0.8942\n",
      "Epoch 14/15\n",
      "250/250 [==============================] - 147s 587ms/step - loss: 0.0981 - accuracy: 0.9621 - val_loss: 0.2505 - val_accuracy: 0.9135\n",
      "Epoch 15/15\n",
      "250/250 [==============================] - 147s 588ms/step - loss: 0.1013 - accuracy: 0.9614 - val_loss: 0.0827 - val_accuracy: 0.8926\n"
     ]
    }
   ],
   "source": [
    "history = classifier.fit_generator(training_set,\n",
    "                         steps_per_epoch = 250,\n",
    "                         epochs = 15,\n",
    "                         validation_data = test_set,\n",
    "                         validation_steps = 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just checking the GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/device:GPU:0'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.test.gpu_device_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns a dictionary of the Configuration of the Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'sequential_1',\n",
       " 'layers': [{'class_name': 'Conv2D',\n",
       "   'config': {'name': 'conv2d_1',\n",
       "    'trainable': True,\n",
       "    'batch_input_shape': (None, 64, 64, 3),\n",
       "    'dtype': 'float32',\n",
       "    'filters': 32,\n",
       "    'kernel_size': (3, 3),\n",
       "    'strides': (1, 1),\n",
       "    'padding': 'valid',\n",
       "    'data_format': 'channels_last',\n",
       "    'dilation_rate': (1, 1),\n",
       "    'activation': 'relu',\n",
       "    'use_bias': True,\n",
       "    'kernel_initializer': {'class_name': 'VarianceScaling',\n",
       "     'config': {'scale': 1.0,\n",
       "      'mode': 'fan_avg',\n",
       "      'distribution': 'uniform',\n",
       "      'seed': None}},\n",
       "    'bias_initializer': {'class_name': 'Zeros', 'config': {}},\n",
       "    'kernel_regularizer': None,\n",
       "    'bias_regularizer': None,\n",
       "    'activity_regularizer': None,\n",
       "    'kernel_constraint': None,\n",
       "    'bias_constraint': None}},\n",
       "  {'class_name': 'MaxPooling2D',\n",
       "   'config': {'name': 'max_pooling2d_1',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'pool_size': (2, 2),\n",
       "    'padding': 'valid',\n",
       "    'strides': (2, 2),\n",
       "    'data_format': 'channels_last'}},\n",
       "  {'class_name': 'Conv2D',\n",
       "   'config': {'name': 'conv2d_2',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'filters': 32,\n",
       "    'kernel_size': (3, 3),\n",
       "    'strides': (1, 1),\n",
       "    'padding': 'valid',\n",
       "    'data_format': 'channels_last',\n",
       "    'dilation_rate': (1, 1),\n",
       "    'activation': 'relu',\n",
       "    'use_bias': True,\n",
       "    'kernel_initializer': {'class_name': 'VarianceScaling',\n",
       "     'config': {'scale': 1.0,\n",
       "      'mode': 'fan_avg',\n",
       "      'distribution': 'uniform',\n",
       "      'seed': None}},\n",
       "    'bias_initializer': {'class_name': 'Zeros', 'config': {}},\n",
       "    'kernel_regularizer': None,\n",
       "    'bias_regularizer': None,\n",
       "    'activity_regularizer': None,\n",
       "    'kernel_constraint': None,\n",
       "    'bias_constraint': None}},\n",
       "  {'class_name': 'MaxPooling2D',\n",
       "   'config': {'name': 'max_pooling2d_2',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'pool_size': (2, 2),\n",
       "    'padding': 'valid',\n",
       "    'strides': (2, 2),\n",
       "    'data_format': 'channels_last'}},\n",
       "  {'class_name': 'Flatten',\n",
       "   'config': {'name': 'flatten_1',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'data_format': 'channels_last'}},\n",
       "  {'class_name': 'Dense',\n",
       "   'config': {'name': 'dense_1',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'units': 128,\n",
       "    'activation': 'relu',\n",
       "    'use_bias': True,\n",
       "    'kernel_initializer': {'class_name': 'VarianceScaling',\n",
       "     'config': {'scale': 1.0,\n",
       "      'mode': 'fan_avg',\n",
       "      'distribution': 'uniform',\n",
       "      'seed': None}},\n",
       "    'bias_initializer': {'class_name': 'Zeros', 'config': {}},\n",
       "    'kernel_regularizer': None,\n",
       "    'bias_regularizer': None,\n",
       "    'activity_regularizer': None,\n",
       "    'kernel_constraint': None,\n",
       "    'bias_constraint': None}},\n",
       "  {'class_name': 'Dense',\n",
       "   'config': {'name': 'dense_2',\n",
       "    'trainable': True,\n",
       "    'dtype': 'float32',\n",
       "    'units': 1,\n",
       "    'activation': 'sigmoid',\n",
       "    'use_bias': True,\n",
       "    'kernel_initializer': {'class_name': 'VarianceScaling',\n",
       "     'config': {'scale': 1.0,\n",
       "      'mode': 'fan_avg',\n",
       "      'distribution': 'uniform',\n",
       "      'seed': None}},\n",
       "    'bias_initializer': {'class_name': 'Zeros', 'config': {}},\n",
       "    'kernel_regularizer': None,\n",
       "    'bias_regularizer': None,\n",
       "    'activity_regularizer': None,\n",
       "    'kernel_constraint': None,\n",
       "    'bias_constraint': None}}]}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier.get_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you wanna see some of the trained weights of the Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from itertools import islice\n",
    "#print(*islice(classifier.get_weights(), 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving the Classifier for Later Use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved model to disk\n"
     ]
    }
   ],
   "source": [
    "classifier.save(\"pneumoniaDetector.h5\")\n",
    "print(\"Saved model to disk\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading in the Model just to confirm that it actually works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OMG YOU HAVE PNEUMONIA\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from keras.preprocessing import image\n",
    "from keras.models import load_model\n",
    "\n",
    "model = load_model(\"pneumoniaDetector.h5\")\n",
    "test_image = image.load_img(\"person2_bacteria_4.jpeg\", target_size = (64, 64))\n",
    "test_image = image.img_to_array(test_image)\n",
    "test_image = np.expand_dims(test_image, axis = 0)\n",
    "result = model.predict(test_image)\n",
    "training_set.class_indices\n",
    "if result[0][0] == 1:\n",
    "    prediction = \"OMG YOU HAVE PNEUMONIA\" \n",
    "else:\n",
    "    prediction = \"you good man, dw\"\n",
    "print(prediction) # Expected: \"OMG YOU HAVE PNEUMONIA\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analyzing the History of the Trained Convolutional Neural Network [Accuracy & Validation Accuracy]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Validation Test Set Accuracy and the Training Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('Model Accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Training set', 'Validation set'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test Set ended with an Accuracy of 97.27% on Training Set and 91.03% on Validation Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improvements that can be made"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding more convolutional layers would have helped because images were very high resolution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And obviously training with more epochs "
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}