chest_x_ray_pneumonia_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "LycyDIll5k8j"
   },
   "outputs": [],
   "source": [
    "# Importing the necessary libraries\n",
    "import os\n",
    "import cv2\n",
    "import keras\n",
    "import itertools\n",
    "\n",
    "import numpy as np \n",
    "import tensorflow as tf\n",
    "\n",
    "from PIL import Image\n",
    "from time import time\n",
    "from glob import glob\n",
    "from tqdm import tqdm\n",
    "from google.colab import files\n",
    "from keras.preprocessing import image\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.initializers import glorot_uniform\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping\n",
    "from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, Dense, Activation, Flatten\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 89,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/files.js": {
       "data": "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",
       "headers": [
        [
         "content-type",
         "application/javascript"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "id": "1-ZOCUPC6RYX",
    "outputId": "ea6253ca-adcf-43f8-c7d9-bcc915a8ad39"
   },
   "outputs": [],
   "source": [
    "# Install the kaggle client for directly downloading the dataset to colab\n",
    "!pip install -q kaggle\n",
    "files.upload()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4aP861Jz6f-O",
    "outputId": "b0355388-8753-45fd-ce46-076db57cbb7c"
   },
   "outputs": [],
   "source": [
    "# Download the chest-xray-pneumonia-dataset to the colab environment\n",
    "!mkdir ~/.kaggle\n",
    "!cp kaggle.json ~/.kaggle/\n",
    "!chmod 600 ~/.kaggle/kaggle.json\n",
    "!kaggle datasets list\n",
    "!kaggle datasets download -d 'paultimothymooney/chest-xray-pneumonia'\n",
    "!mkdir chest_xray_pneumonia\n",
    "!unzip chest-xray-pneumonia.zip -d chest_xray_pneumonia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jZZwp_Ja70dc"
   },
   "outputs": [],
   "source": [
    "def show_image(path: list, dataset:str, label:str, num_pics=2):\n",
    "  # Routine to plot the images\n",
    "  if num_pics > 1:\n",
    "    fig, ax = plt.subplots(1, num_pics, sharex=True)\n",
    "    plt.tight_layout()\n",
    "    ax = ax.ravel()\n",
    "    for idx, pth in enumerate(path[:num_pics]):\n",
    "      ax[idx].imshow(plt.imread(pth), cmap='gray')\n",
    "    fig.suptitle('Dataset: {}, Label: {}'.format(dataset, label))\n",
    "  elif num_pics == 1:\n",
    "    plt.imshow(plt.imread(path[:num_pics][0]), cmap='gray')\n",
    "    plt.title('Dataset: {}, Label: {}'.format(dataset, label))\n",
    "    plt.figure()\n",
    "\n",
    "def visualize_dataset_distribution(dataset: dict, x_label: str, y_label: str, title: str):\n",
    "  # Routine to visualize the per class distribution of the dataset\n",
    "  folders = list(dataset.keys())\n",
    "  folders_vals = list(map(lambda x: len(dataset[x]), folders))\n",
    "  folders_paths = ['_'.join(x.split(\"/\")[-2:]) for x in folders]\n",
    "  for idx, f in enumerate(folders_paths):\n",
    "    print('{}: contains {} images'.format(folders_paths[idx], folders_vals[idx]))\n",
    "  plt.bar(folders_paths, folders_vals, width = 0.5, color = 'blue', align = 'center', edgecolor = 'black')\n",
    "  plt.xticks(rotation=70)\n",
    "  plt.xlabel(x_label)\n",
    "  plt.ylabel(y_label)\n",
    "  plt.title(\"Distribution of images in the dataset\")\n",
    "  plt.show()\n",
    "\n",
    "def plot_confusion_matrix_self(cm, classes, title, cmap):\n",
    "  plt.figure(figsize=(8, 8))\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, rotation = 45)\n",
    "  plt.yticks(tick_marks, classes)\n",
    "  fmt = 'd'\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, format(cm[i, j], fmt),\n",
    "               horizontalalignment=\"center\",\n",
    "               color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "  plt.ylabel(ylabel = 'True label', labelpad = 25)\n",
    "  plt.xlabel(xlabel = 'Predicted label', labelpad = 25)\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AbnSu2q37ENo"
   },
   "outputs": [],
   "source": [
    "# Make separate handles for the paths of the train, test and validation sets\n",
    "# You can write the path below by manually scrolling to the chest_xray_pneumonia/chest_xray folder in the files section of this page\n",
    "# Right click the on chest_xray folder and select copy path to paste below\n",
    "path = \"/content/chest_xray_pneumonia/chest_xray\"\n",
    "train_NORMAL = os.path.join(path, 'train/NORMAL')\n",
    "train_PNEUMONIA = os.path.join(path, 'train/PNEUMONIA')\n",
    "test_NORMAL = os.path.join(path, 'test/NORMAL')\n",
    "test_PNEUMONIA = os.path.join(path, 'test/PNEUMONIA')\n",
    "val_NORMAL = os.path.join(path, 'val/NORMAL')\n",
    "val_PNEUMONIA = os.path.join(path, 'val/PNEUMONIA')\n",
    "train_NORMAL_DIR = [os.path.join(train_NORMAL, x) for x in os.listdir(train_NORMAL)]\n",
    "train_PNEUMONIA_DIR = [os.path.join(train_PNEUMONIA, x) for x in os.listdir(train_PNEUMONIA)]\n",
    "test_NORMAL_DIR = [os.path.join(test_NORMAL, x) for x in os.listdir(test_NORMAL)]\n",
    "test_PNEUMONIA_DIR = [os.path.join(test_PNEUMONIA, x) for x in os.listdir(test_PNEUMONIA)]\n",
    "val_NORMAL_DIR = [os.path.join(val_NORMAL, x) for x in os.listdir(val_NORMAL)]\n",
    "val_PNEUMONIA_DIR = [os.path.join(val_PNEUMONIA, x) for x in os.listdir(val_PNEUMONIA)]\n",
    "dataset = {\n",
    "    \"train_NORMAL\":train_NORMAL_DIR,\n",
    "    \"train_PNEUMONIA\":train_PNEUMONIA_DIR,\n",
    "    \"test_NORMAL\":test_NORMAL_DIR,\n",
    "    \"test_PNEUMONIA\":test_PNEUMONIA_DIR,\n",
    "    \"val_NORMAL\":val_NORMAL_DIR,\n",
    "    \"val_PNEUMONIA\":val_PNEUMONIA_DIR\n",
    "    }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "kQ6497rK7uzJ",
    "outputId": "267262f5-5884-4719-a13c-df92d6db1aec"
   },
   "outputs": [],
   "source": [
    "# Visualizing the first num_pics image in the train, test and val datasets \n",
    "show_image(dataset[\"train_NORMAL\"], num_pics=1, dataset=\"train\", label=\"NORMAL\")\n",
    "show_image(dataset[\"train_PNEUMONIA\"], num_pics=1, dataset=\"train\", label=\"PNEUMONIA\")\n",
    "\n",
    "show_image(dataset[\"test_NORMAL\"], num_pics=1, dataset=\"test\", label=\"NORMAL\")\n",
    "show_image(dataset[\"test_PNEUMONIA\"], num_pics=1, dataset=\"test\", label=\"PNEUMONIA\")\n",
    "\n",
    "show_image(dataset[\"val_NORMAL\"], num_pics=1, dataset=\"val\", label=\"NORMAL\")\n",
    "show_image(dataset[\"val_PNEUMONIA\"], num_pics=1, dataset=\"val\", label=\"PNEUMONIA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 479
    },
    "id": "G2ZI3oGJ8OxH",
    "outputId": "988f5744-22a0-447c-f79e-dcca48d22306"
   },
   "outputs": [],
   "source": [
    "# Visualizing the datasets\n",
    "x_label = \"Images\"\n",
    "y_label = \"Number of images\"\n",
    "title = \"Distribution of images in the dataset\"\n",
    "visualize_dataset_distribution(dataset=dataset, x_label=x_label, y_label=y_label, title=title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "390GpXZple3t"
   },
   "outputs": [],
   "source": [
    "def transform_dataset(normal_path:str, pneumonia_path:str):\n",
    "  # Routine to convert and return the X and y datasets as np.ndarrays after some preprocessing\n",
    "  X, y = [], []\n",
    "  for img in tqdm(glob(os.path.join(normal_path, \"*.jpeg\"))):\n",
    "    img = cv2.imread(str(img))\n",
    "    # Transform each stock image into a 224x224 RGB image and \n",
    "    # then into a vector of the same size but normalized between 0 and 1\n",
    "    img = cv2.resize(img, (224,224))\n",
    "    if img.shape[2] ==1:\n",
    "      img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = img.astype(np.float32)/255.\n",
    "    X.append(img)\n",
    "\n",
    "  initial = len(X)\n",
    "  # Target labels -> 1 = Pneumonia, 0 = Normal\n",
    "  y_a = np.zeros(initial)\n",
    "\n",
    "  for img in tqdm(glob(os.path.join(pneumonia_path, \"*.jpeg\"))):\n",
    "    img = cv2.imread(str(img))\n",
    "    img = cv2.resize(img, (224,224))\n",
    "    if img.shape[2] ==1:\n",
    "      img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = img.astype(np.float32)/255.\n",
    "    X.append(img)\n",
    "\n",
    "  final = len(X)\n",
    "  y = np.concatenate((y_a, np.ones(final-initial)))\n",
    "  y = np.reshape(y, (y.shape[0],1))\n",
    "  X = np.array(X)\n",
    "  return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jwpwJ_yzBXs3",
    "outputId": "2f299d26-52ea-458d-b7ee-2a20e68a0712"
   },
   "outputs": [],
   "source": [
    "# Generate the training sets\n",
    "X_train, y_train = transform_dataset(normal_path=train_NORMAL, pneumonia_path=train_PNEUMONIA)\n",
    "X_test, y_test = transform_dataset(normal_path=test_NORMAL, pneumonia_path=test_PNEUMONIA)\n",
    "X_val, y_val = transform_dataset(normal_path=val_NORMAL, pneumonia_path=val_PNEUMONIA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mFd89K8eXvKV",
    "outputId": "33070dfa-77b1-4f8c-a4cd-d70776ce8ced"
   },
   "outputs": [],
   "source": [
    "# Lets take a look at the shapes of our train matrices\n",
    "X_train = tf.convert_to_tensor(X_train)\n",
    "y_train = tf.convert_to_tensor(y_train)\n",
    "X_test = tf.convert_to_tensor(X_test)\n",
    "y_test = tf.convert_to_tensor(y_test)\n",
    "X_val = tf.convert_to_tensor(X_val)\n",
    "y_val = tf.convert_to_tensor(y_val)\n",
    "print(\"X_train has shape \", X_train.shape)\n",
    "print(\"y_train has shape \", y_train.shape)\n",
    "print(\"X_test has shape \", X_test.shape)\n",
    "print(\"y_test has shape \", y_test.shape)\n",
    "print(\"X_val has shape \", X_val.shape)\n",
    "print(\"y_val has shape \", y_val.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DrEdFBGEi_H9"
   },
   "outputs": [],
   "source": [
    "def model(input_shape:tuple=(224,224,3), classes=1, initializer=glorot_uniform):\n",
    "  # Routine to define the model architecture here\n",
    "\n",
    "  # Define the input to be a tensor of shape input_shape\n",
    "  input = Input(input_shape)\n",
    "\n",
    "  # First hidden layer\n",
    "  X = Conv2D(filters=32, kernel_size=(3,3), padding='same', activation = 'relu', kernel_initializer = initializer(seed=0))(input)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = MaxPooling2D((2,2))(X)\n",
    "\n",
    "  # Second hidden layer\n",
    "  X = Conv2D(filters=64, kernel_size=(3,3), padding='same', activation = 'relu', kernel_initializer = initializer(seed=0))(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = MaxPooling2D((2,2))(X)\n",
    "\n",
    "  # Third hidden layer\n",
    "  X = Conv2D(filters=64, kernel_size=(3,3), padding='same', activation = 'relu', kernel_initializer = initializer(seed=0))(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = MaxPooling2D((2,2))(X)\n",
    "\n",
    "  # Output layer\n",
    "  X = Conv2D(filters=128, kernel_size=(3,3), padding='same', activation = 'relu', kernel_initializer = initializer(seed=0))(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = Flatten()(X)\n",
    "  X = Dense(units=2048, activation='relu')(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = Dense(units=1024, activation='relu')(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  X = Dense(units=512, activation='relu')(X)\n",
    "  X = Dropout(rate=0.2)(X)\n",
    "  output = Dense(classes, activation='sigmoid', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "\n",
    "  # Create model\n",
    "  model = Model(inputs = input, outputs = output)\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "r75Sy2gozIbi",
    "outputId": "43a0dec7-411f-4f59-ffe7-8ebf11c26de2"
   },
   "outputs": [],
   "source": [
    "# Let's build the model and look at its summary\n",
    "XNet = model(input_shape=(224,224,3), initializer=glorot_uniform)\n",
    "XNet.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LtqKA5k11cRM"
   },
   "outputs": [],
   "source": [
    "# Define the optimizer and other hyperparameters and metrics and compile the model\n",
    "BATCH_SIZE = 32\n",
    "EPOCHS = 10\n",
    "checkpoint_filepath = \"best_model\"\n",
    "optimizer = Adam(learning_rate=0.0001, decay=1e-5)\n",
    "early_stopping = EarlyStopping(patience=5)\n",
    "checkpoint = ModelCheckpoint(filepath=checkpoint_filepath, monitor = 'val_accuracy', mode = \"max\", save_best_only=True, save_weights_only=True)\n",
    "XNet.compile(loss='binary_crossentropy', metrics=['accuracy'], optimizer=optimizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "frkr_Nn13apo",
    "outputId": "f76ca7af-16d5-459e-b74f-7f90946e2467"
   },
   "outputs": [],
   "source": [
    "num_training_steps = X_train.shape[0]//BATCH_SIZE\n",
    "num_validation_steps = len(X_val)\n",
    "print(\"Number of training steps: \", num_training_steps)\n",
    "print(\"Number of validation steps: \", num_validation_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cNX-psYs4Kgl",
    "outputId": "a6820bf3-09a0-468f-e2af-1f4810d3a7ba"
   },
   "outputs": [],
   "source": [
    "# Fit the model and save the history\n",
    "history = XNet.fit(\n",
    "    x = X_train, \n",
    "    y = y_train, \n",
    "    epochs = EPOCHS, \n",
    "    batch_size = BATCH_SIZE,\n",
    "    steps_per_epoch = num_training_steps,\n",
    "    validation_data = (X_val, y_val),\n",
    "    callbacks = [early_stopping, checkpoint]\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VJ945hq-FcrB",
    "outputId": "b88d9a4a-65fa-4744-9bbb-e55293bd40e4"
   },
   "outputs": [],
   "source": [
    "# Load the weights for the best performing model based on the set requirements\n",
    "XNet.load_weights(\"best_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C1cFIHX8GaZj",
    "outputId": "7fb92f23-088a-4280-9852-d9f40beafcfa"
   },
   "outputs": [],
   "source": [
    "# Evaluation on the test set\n",
    "test_loss, test_score = XNet.evaluate(\n",
    "    X_test, \n",
    "    y_test, \n",
    "    batch_size=BATCH_SIZE)\n",
    "print(\"Loss on test set: \", test_loss)\n",
    "print(\"Accuracy on test set: \", test_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "zp-DNIhMJBW2"
   },
   "outputs": [],
   "source": [
    "def infer_on_the_fly(model):\n",
    "  # Allow user to upload images for inference\n",
    "  uploaded = files.upload()\n",
    "  for file_name in uploaded.keys():\n",
    "    path = '/content/' + file_name\n",
    "    # Transform each stock image into a 224x224 RGB image and \n",
    "    # then into a vector of the same size but normalized between 0 and 1\n",
    "    img = cv2.imread(path)\n",
    "    img = cv2.resize(img, (224,224))\n",
    "    if img.shape[2] ==1:\n",
    "      img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = img.astype(np.float32)/255.\n",
    "    X = np.expand_dims(img, axis=0)\n",
    "    X = np.array(X)\n",
    "    X = tf.convert_to_tensor(X)\n",
    "\n",
    "    y = model.predict(X, batch_size = 32)\n",
    "    if y[0]> 0.5:\n",
    "      print(file_name + ' is pneumonia with {} probability'.format(y[0]))\n",
    "      plt.imshow(img)\n",
    "    else:\n",
    "      print(file_name + 'is normal with {} probability'.format(y[0]))\n",
    "      plt.imshow(img)\n",
    "        \n",
    "def infer(model, path):\n",
    "    # Transform each stock image into a 224x224 RGB image and \n",
    "    # then into a vector of the same size but normalized between 0 and 1\n",
    "    img = cv2.imread(path)\n",
    "    img = cv2.resize(img, (224,224))\n",
    "    if img.shape[2] ==1:\n",
    "        img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = img.astype(np.float32)/255.\n",
    "    X = np.expand_dims(img, axis=0)\n",
    "    X = np.array(X)\n",
    "    X = tf.convert_to_tensor(X)\n",
    "\n",
    "    y = model.predict(X, batch_size = 32)\n",
    "    file_name = os.path.basename(path)\n",
    "    if y[0]> 0.5:\n",
    "        print(file_name + ' is pneumonia with {} probability'.format(y[0]))\n",
    "        plt.imshow(img)\n",
    "    else:\n",
    "        print(file_name + ' is normal with {} probability'.format(1-y[0]))\n",
    "        plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 341,
     "resources": {
      "http://localhost:8080/nbextensions/google.colab/files.js": {
       "data": "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",
       "headers": [
        [
         "content-type",
         "application/javascript"
        ]
       ],
       "ok": true,
       "status": 200,
       "status_text": ""
      }
     }
    },
    "id": "5JiIO65XHKaR",
    "outputId": "ec13272c-f1e0-48bc-e435-5e24a7c1fb2e"
   },
   "outputs": [],
   "source": [
    "infer_on_the_fly(model=XNet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "gRpV_h3FIaIy",
    "outputId": "77ce1948-0962-418c-c07a-68ffc5822184"
   },
   "outputs": [],
   "source": [
    "# Lets plot the model's history including the confusion matrix\n",
    "\n",
    "# Summarize history for accuracy\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(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "# Summarize history for loss\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Model Loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "y_pred = XNet.predict(X_test)\n",
    "y_pred = (y_pred > 0.5)\n",
    "cnf_matrix = confusion_matrix(y_test, y_pred, labels = [0. , 1.])\n",
    "plot_confusion_matrix_self(cnf_matrix, classes = [\"Normal\" , \"Pneumonia\"], title = \"Confusion Matrix for CNN Model\", cmap = plt.cm.Blues)\n",
    "plt.show()\n",
    "\n",
    "# Calculate Precision and Recall\n",
    "tn, fp, fn, tp = cnf_matrix.ravel()\n",
    "precision = tp/(tp+fp)\n",
    "recall = tp/(tp+fn)\n",
    "\n",
    "print(\"Recall of the model is {:.2f}\".format(recall))\n",
    "print(\"Precision of the model is {:.2f}\".format(precision))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sFEN4_RQMBrl"
   },
   "outputs": [],
   "source": [
    "# Saving the model for Future Inferences\n",
    "XNet_json = XNet.to_json()\n",
    "with open(\"XNet/XNet.json\", \"w\") as json_file:\n",
    "    json_file.write(XNet_json)\n",
    "    \n",
    "# Serialize weights to HDF5\n",
    "XNet.save_weights(\"XNet/XNet.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Model from disk\n"
     ]
    }
   ],
   "source": [
    "# Loading the saved model for inference\n",
    "from keras.models import model_from_json \n",
    "\n",
    "# Opening and store file in a variable\n",
    "json_file = open('XNet/XNet.json','r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "\n",
    "# Use Keras model_from_json to make a loaded model\n",
    "loaded_model = model_from_json(loaded_model_json)\n",
    "\n",
    "# Load weights into new model\n",
    "loaded_model.load_weights(\"XNet/XNet.h5\")\n",
    "print(\"Loaded Model from disk\")\n",
    "\n",
    "# Compile and evaluate loaded model\n",
    "optimizer = Adam(learning_rate=0.0001, decay=1e-5)\n",
    "loaded_model.compile(loss='binary_crossentropy',optimizer=optimizer,metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pneumonia_2.jpeg is pneumonia with [0.9992484] probability\n"
     ]
    },
    {
     "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": [
    "infer(model = loaded_model, path = 'samples/pneumonia_2.jpeg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "chest_x_ray_pneumonia_classification.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python (env)",
   "language": "python",
   "name": "env"
  },
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}