covid19-detection-final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\" \n",
    "os.environ['CUDA_VISIBLE_DEVICES']=\"\"\n",
    "os.environ[\"PATH\"] += os.pathsep + 'C:/Program Files (x86)/Graphviz2.38/bin/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0326 22:50:20.362257 16052 __init__.py:308] Limited tf.compat.v2.summary API due to missing TensorBoard installation.\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.applications import VGG16,InceptionV3,ResNet50, MobileNetV2\n",
    "from keras.applications.vgg16 import preprocess_input\n",
    "#from keras.applications.mobilenetv2 import preprocess_input\n",
    "#from keras.applications.resnet50 import preprocess_input\n",
    "from keras.preprocessing import image\n",
    "from tensorflow.keras.layers import AveragePooling2D, Dropout,Flatten, Dense, Input\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import argparse\n",
    "import cv2\n",
    "import os\n",
    "import pandas as pd\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train and Test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_path = \"dataset\\\\train\"\n",
    "test_path = \"dataset\\\\test\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_labels = ['COVID-19','other']\n",
    "t_x, t_y = next(train_generator)\n",
    "fig, m_axs = plt.subplots(4, 4, figsize = (16, 16))\n",
    "for (c_x, c_y, c_ax) in zip(t_x, t_y, m_axs.flatten()):\n",
    "    c_ax.imshow(c_x[:,:,0], cmap = 'bone', vmin = -1.5, vmax = 1.5)\n",
    "    c_ax.set_title(', '.join([n_class for n_class, n_score in zip(all_labels, c_y) \n",
    "                             if n_score>0.5]))\n",
    "    c_ax.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating Train and Test Data Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\anaconda\\envs\\tf_gpu\\lib\\site-packages\\keras_preprocessing\\image\\image_data_generator.py:341: UserWarning: This ImageDataGenerator specifies `zca_whitening` which overrides setting of`featurewise_std_normalization`.\n",
      "  warnings.warn('This ImageDataGenerator specifies '\n"
     ]
    }
   ],
   "source": [
    "train_datagen = ImageDataGenerator(rescale=1./255,\n",
    " rotation_range=20,\n",
    " featurewise_center = True,\n",
    " featurewise_std_normalization = True,\n",
    " width_shift_range=0.2,\n",
    " height_shift_range=0.2,\n",
    " shear_range=0.25,\n",
    " zoom_range=0.1,\n",
    " zca_whitening = True,\n",
    " channel_shift_range = 20,\n",
    " horizontal_flip = True ,\n",
    " vertical_flip = True ,\n",
    " validation_split = 0.2)\n",
    "\n",
    "test_datagen = ImageDataGenerator(rescale = 1./255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_generator = train_datagen.flow_from_directory(train_path,\n",
    "    target_size = (224, 224),\n",
    "    shuffle=True,seed=42,class_mode=\"categorical\",\n",
    "    color_mode = 'rgb',\n",
    "    batch_size = 16)\n",
    "test_generator = test_datagen.flow_from_directory(test_path,\n",
    "    target_size = (224, 224),\n",
    "    color_mode = 'rgb',\n",
    "    batch_size = 1,seed=42,class_mode=\"categorical\",\n",
    "    shuffle = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Transfer learning and loading pretrained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basemodel = InceptionV3(weights=\"imagenet\", include_top=False,input_tensor=Input(shape=(224, 224, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adding additional layers and Building the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "headModel = basemodel.output\n",
    "headModel = AveragePooling2D(pool_size=(4, 4))(headModel)#pool_size=(4, 4)\n",
    "headModel = Flatten(name=\"flatten\")(headModel)\n",
    "#headModel = Dropout(0.5)(headModel)\n",
    "headModel = Dense(256, activation=\"relu\")(headModel)\n",
    "headModel = Dropout(0.5)(headModel)\n",
    "#headModel = Dense(256, activation=\"relu\")(headModel)\n",
    "#headModel = Dropout(0.3)(headModel)\n",
    "headModel = Dense(2, activation=\"softmax\")(headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(inputs=basemodel.input, outputs=headModel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in basemodel.layers:\n",
    "    layer.trainable = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model parameters, compiling and Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs= 80\n",
    "lr = 1e-4\n",
    "BS = 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=\"categorical_crossentropy\", optimizer=Adam(lr=1e-4,decay=lr/epochs),metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#history = model.fit_generator(train_datagen.flow(X_train, Y_train, batch_size=BS),steps_per_epoch=len(X_train) // BS,validation_data=(X_test, Y_test),validation_steps=len(X_test) // BS,epochs=epochs)\n",
    "model.fit_generator(train_generator,\n",
    "                    steps_per_epoch = 318//BS,\n",
    "                    epochs = epochs,\n",
    "                    validation_data = test_generator,\n",
    "                    validation_steps = 48//BS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluationg model on Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = model.evaluate_generator(test_generator,\n",
    " steps = np.ceil(len(test_generator) // BS),\n",
    " use_multiprocessing = False,\n",
    " verbose = 1,\n",
    " workers=1\n",
    " )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#eval_generator.reset() \n",
    "pred = model.predict_generator(test_generator,1000,verbose=1)\n",
    "print(\"Predictions finished\")\n",
    "import cv2\n",
    "import matplotlib.image as mpimg\n",
    "for index, probability in enumerate(pred):\n",
    " image_path = test_path + \"/\" +test_generator.filenames[index]\n",
    " image = mpimg.imread(image_path)\n",
    " #BGR TO RGB conversion using CV2\n",
    " image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    " pixels = np.array(image)\n",
    " plt.imshow(pixels)\n",
    " print(\"prob:{}\".format(probability))\n",
    " print(test_generator.filenames[index])\n",
    " if probability[1] > 0.5:\n",
    "     plt.title('%.2f' % (probability[1]*100) + '% Other')\n",
    " else:\n",
    "     plt.title('%.2f' % ((1-probability[1])*100) + '% COVID-19')\n",
    " plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Test loss:' , x[0])\n",
    "print('Test accuracy:',x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading the saved model for prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From d:\\anaconda\\envs\\tf_gpu\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From d:\\anaconda\\envs\\tf_gpu\\lib\\site-packages\\tensorflow\\python\\keras\\layers\\core.py:143: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From d:\\anaconda\\envs\\tf_gpu\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "from keras.models import load_model\n",
    "model_ = tf.keras.models.load_model('vgg16_model_95.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_test = Image.open(\"images/auntminnie-a-2020_01_28_23_51_6665_2020_01_28_Vietnam_coronavirus.jpeg\").convert('RGB')\n",
    "image_test = image_test.resize((224,224))\n",
    "data_test = np.asarray(image_test)\n",
    "img = np.reshape(data_test,[1,224,224,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(image_test)\n",
    "model_.predict(img).tolist()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.utils import plot_model\n",
    "plot_model(model_, to_file='model.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix,plot_confusion_matrix\n",
    "Y_pred = model_.predict_generator(test_generator, np.ceil(len(test_generator) // BS))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = np.argmax(Y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[20  1]\n",
      " [ 1 26]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(test_generator.classes, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": [
    "from sklearn import metrics\n",
    "fpr, tpr, thresholds = metrics.roc_curve(test_generator.classes, y_pred)\n",
    "\n",
    "plt.plot(fpr, tpr)\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.0])\n",
    "plt.rcParams['font.size'] = 12\n",
    "plt.title('ROC curve for COVID-19 classifier')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Frequency')"
      ]
     },
     "execution_count": 35,
     "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": [
    "plt.hist(y_pred, bins=8)\n",
    "\n",
    "# x-axis limit from 0 to 1\n",
    "plt.xlim(0,1)\n",
    "plt.title('Histogram of predicted probabilities')\n",
    "plt.xlabel('Predicted probability of COVID-19')\n",
    "plt.ylabel('Frequency')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "    COVID-19       0.95      0.95      0.95        21\n",
      "       other       0.96      0.96      0.96        27\n",
      "\n",
      "    accuracy                           0.96        48\n",
      "   macro avg       0.96      0.96      0.96        48\n",
      "weighted avg       0.96      0.96      0.96        48\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('Classification Report')\n",
    "target_names = ['COVID-19','other']\n",
    "print(classification_report(test_generator.classes, y_pred, target_names=target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "    normalize=False,\n",
    "    title='Confusion matrix',\n",
    "    cmap=plt.cm.Blues):\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)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "    \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",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_true=test_generator.classes, y_pred=y_pred)\n",
    "cm_plot_labels= ['COVID-19','other']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[20  1]\n",
      " [ 1 26]]\n"
     ]
    },
    {
     "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": [
    "plot_confusion_matrix(cm=cm, classes=cm_plot_labels, title='Confusion Matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[20  1]\n",
      " [ 1 26]]\n",
      "Normalized confusion matrix\n",
      "[[0.95 0.05]\n",
      " [0.04 0.96]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "\n",
    "\n",
    "def plot_confusion_matrix(y_true, y_pred, classes,\n",
    "\n",
    "                          normalize=False,\n",
    "\n",
    "                          title=None,\n",
    "\n",
    "                          cmap=plt.cm.Blues):\n",
    "\n",
    "\n",
    "    if not title:\n",
    "\n",
    "        if normalize:\n",
    "\n",
    "            title = 'Normalized confusion matrix'\n",
    "\n",
    "        else:\n",
    "\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "\n",
    " \n",
    "\n",
    "\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    if normalize:\n",
    "\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "        print(\"Normalized confusion matrix\")\n",
    "\n",
    "    else:\n",
    "\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    " \n",
    "\n",
    "    print(cm)\n",
    "\n",
    " \n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "\n",
    "    # We want to show all ticks...\n",
    "\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "\n",
    "           # ... and label them with the respective list entries\n",
    "\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "\n",
    "           title=title,\n",
    "\n",
    "           ylabel='True label',\n",
    "\n",
    "           xlabel='Predicted label')\n",
    "\n",
    " \n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "\n",
    "             rotation_mode=\"anchor\")\n",
    "\n",
    " \n",
    "\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "\n",
    "    thresh = cm.max() / 2.\n",
    "\n",
    "    for i in range(cm.shape[0]):\n",
    "\n",
    "        for j in range(cm.shape[1]):\n",
    "\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "\n",
    "                    ha=\"center\", va=\"center\",\n",
    "\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    fig.tight_layout()\n",
    "\n",
    "    return ax\n",
    "\n",
    " \n",
    "\n",
    " \n",
    "cm = confusion_matrix(y_true=test_generator.classes, y_pred=y_pred)\n",
    "cm_plot_labels= ['COVID-19','other']\n",
    "\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    " \n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "\n",
    "plot_confusion_matrix(test_generator.classes, y_pred, target_names,\n",
    "\n",
    "                      title='Confusion matrix, without normalization')\n",
    "\n",
    " \n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "\n",
    "plot_confusion_matrix(test_generator.classes, y_pred, target_names, normalize=True,\n",
    "\n",
    "                      title='Normalized confusion matrix')\n",
    "\n",
    " \n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}