Paedetric_Pneumonia_Using_VGG19.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OBprXOITrNLU",
        "outputId": "6396e8b9-a872-4013-fe95-9e08c16ae33f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "# Mount Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5kZxcqOrC1m"
      },
      "source": [
        "## Transfer Learning using VGG-19 model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "CeGIAfZlrC1t"
      },
      "outputs": [],
      "source": [
        "#loading different libraries\n",
        "#TensorFlow is an open-sourced end-to-end platform, a library for multiple machine learning tasks,\n",
        "#while Keras is a high-level neural network library that runs on top of TensorFlow.\n",
        "#Both provide high-level APIs used for easily building and training models\n",
        "from tensorflow.keras import optimizers\n",
        "from keras import losses\n",
        "from keras import metrics\n",
        "import keras\n",
        "from keras.models import Model\n",
        "from keras.layers import Dense\n",
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "from keras.preprocessing import image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s5eGmmFPrC1y",
        "outputId": "a30e7721-ecf9-4dec-b8d9-e3d54472b241"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 4211 images belonging to 2 classes.\n",
            "Found 3452 images belonging to 2 classes.\n",
            "Found 624 images belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "# data loading, augmentation is optional\n",
        "#Generate batches of tensor image data with real-time data augmentation.\n",
        "\n",
        "##Training Data\n",
        "trdata = ImageDataGenerator()\n",
        "traindata = trdata.flow_from_directory(directory=r\"/content/drive/MyDrive/Data/train\",target_size=(224,224))\n",
        "##Validation Data\n",
        "valdata = ImageDataGenerator()\n",
        "validationdata = valdata.flow_from_directory(directory=r\"/content/drive/MyDrive/Data/val\", target_size=(224,224))\n",
        "##Test Data\n",
        "tsdata = ImageDataGenerator()\n",
        "testdata = tsdata.flow_from_directory(directory=r\"/content/drive/MyDrive/Data/test\", target_size=(224,224))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_KbyxXFlrC10",
        "outputId": "b0d31f2c-bf48-4036-94f5-af9b2149d5a2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"vgg19\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
            "                                                                 \n",
            " block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      \n",
            "                                                                 \n",
            " block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     \n",
            "                                                                 \n",
            " block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     \n",
            "                                                                 \n",
            " block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    \n",
            "                                                                 \n",
            " block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    \n",
            "                                                                 \n",
            " block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv4 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   \n",
            "                                                                 \n",
            " block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv4 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv4 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 25088)             0         \n",
            "                                                                 \n",
            " fc1 (Dense)                 (None, 4096)              102764544 \n",
            "                                                                 \n",
            " fc2 (Dense)                 (None, 4096)              16781312  \n",
            "                                                                 \n",
            " predictions (Dense)         (None, 1000)              4097000   \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 143667240 (548.05 MB)\n",
            "Trainable params: 143667240 (548.05 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "Model: \"model_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
            "                                                                 \n",
            " block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      \n",
            "                                                                 \n",
            " block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     \n",
            "                                                                 \n",
            " block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     \n",
            "                                                                 \n",
            " block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    \n",
            "                                                                 \n",
            " block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    \n",
            "                                                                 \n",
            " block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv4 (Conv2D)       (None, 56, 56, 256)       590080    \n",
            "                                                                 \n",
            " block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   \n",
            "                                                                 \n",
            " block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv4 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
            "                                                                 \n",
            " block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_conv4 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
            "                                                                 \n",
            " block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 25088)             0         \n",
            "                                                                 \n",
            " fc1 (Dense)                 (None, 4096)              102764544 \n",
            "                                                                 \n",
            " fc2 (Dense)                 (None, 4096)              16781312  \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 2)                 8194      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 139578434 (532.45 MB)\n",
            "Trainable params: 124273666 (474.07 MB)\n",
            "Non-trainable params: 15304768 (58.38 MB)\n",
            "_________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "## Transfer Learning using VGG-19 model\n",
        "from keras.applications.vgg19 import VGG19\n",
        "\n",
        "#Load VGG19 model previously trained on Imagenet dataset. It is already trained on large number of classes and generalised, so go to consider to train new dataset.\n",
        "vggmodel = VGG19(weights='imagenet', include_top=True)\n",
        "\n",
        "#It predicts the summary of the model in a tabular format\n",
        "vggmodel.summary()\n",
        "\n",
        "##Freezing all layers of the model. VGG19 model has 19 layers\n",
        "for layers in (vggmodel.layers)[:19]:\n",
        "    #print(layers)\n",
        "    layers.trainable = False\n",
        "\n",
        "##changing number of nodes in the last dense layer as per the number of classes.\n",
        "X= vggmodel.layers[-2].output\n",
        "predictions = Dense(2, activation=\"softmax\")(X)\n",
        "\n",
        "##Final model is the combination of inputs and defined model architecture i.e. VGG19\n",
        "#model_final = Model(input = vggmodel.input, output = predictions) ### previouscommand\n",
        "model_final = Model(vggmodel.input, predictions) ### updated command\n",
        "\n",
        "#It predicts the summary of the model in a tabular format\n",
        "model_final.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "Nqndnrz-rC11"
      },
      "outputs": [],
      "source": [
        "\n",
        "#This cell is to define the hyperparameters to train the model.\n",
        "\n",
        "#optimizer and learning rate. Adam is the optimizer, Learning rate: 1e-3\n",
        "optimizer = optimizers.Adam(learning_rate=1e-3)\n",
        "\n",
        "##compilation of the model with given optimzer. Accuracy is metric on which we can see the performance\n",
        "model_final.compile(loss = 'binary_crossentropy', optimizer = optimizer, metrics = ['accuracy'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eI7WH2cGrC13",
        "outputId": "41db3d51-4325-4e93-cb8f-e7a2ea3a443f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "132/132 [==============================] - 49s 335ms/step - loss: 1.5288 - accuracy: 0.8608 - val_loss: 0.1891 - val_accuracy: 0.9264\n",
            "Epoch 2/10\n",
            "132/132 [==============================] - 47s 359ms/step - loss: 0.1728 - accuracy: 0.9347 - val_loss: 0.1634 - val_accuracy: 0.9424\n",
            "Epoch 3/10\n",
            "132/132 [==============================] - 44s 331ms/step - loss: 0.5887 - accuracy: 0.9159 - val_loss: 0.1550 - val_accuracy: 0.9397\n",
            "Epoch 4/10\n",
            "132/132 [==============================] - 45s 341ms/step - loss: 0.1301 - accuracy: 0.9470 - val_loss: 0.1134 - val_accuracy: 0.9557\n",
            "Epoch 5/10\n",
            "132/132 [==============================] - 44s 331ms/step - loss: 0.1035 - accuracy: 0.9589 - val_loss: 0.1158 - val_accuracy: 0.9583\n",
            "Epoch 6/10\n",
            "132/132 [==============================] - 44s 334ms/step - loss: 0.0824 - accuracy: 0.9682 - val_loss: 0.1057 - val_accuracy: 0.9649\n",
            "Epoch 7/10\n",
            "132/132 [==============================] - 45s 339ms/step - loss: 0.0733 - accuracy: 0.9727 - val_loss: 0.0820 - val_accuracy: 0.9702\n",
            "Epoch 8/10\n",
            "132/132 [==============================] - 44s 336ms/step - loss: 0.0576 - accuracy: 0.9774 - val_loss: 0.0837 - val_accuracy: 0.9702\n",
            "Epoch 9/10\n",
            "132/132 [==============================] - 44s 333ms/step - loss: 0.0663 - accuracy: 0.9751 - val_loss: 0.0824 - val_accuracy: 0.9722\n",
            "Epoch 10/10\n",
            "132/132 [==============================] - 45s 337ms/step - loss: 0.0438 - accuracy: 0.9827 - val_loss: 0.1214 - val_accuracy: 0.9728\n"
          ]
        }
      ],
      "source": [
        "/#Model fitting. verbose is the choice that how you want to see the output of your Nural Network while it's training.\n",
        "#If you set verbose = 0, It will show nothing.\n",
        "#here you have to give the defined varaibles where data get stored i.e. traindata, validation data\n",
        "history = model_final.fit(\n",
        "    traindata,\n",
        "    epochs=10,\n",
        "    verbose=1,\n",
        "    validation_data=validationdata\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 962
        },
        "id": "9K_6u-d6rC13",
        "outputId": "ae9db60f-2a08-46b4-c3c5-1209c7d8ca44"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "#Matplotlib is a cross-platform, data visualization and graphical plotting library for Python and its numerical extension NumPy.\n",
        "#here it will plot accuracy and loss curve\n",
        "\n",
        "#loading libraries\n",
        "import matplotlib.image as mpimg\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#storing the string of array related to accuracy and loss (Training and Loss)\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "#number of epochs == length of array\n",
        "epochs = range(len(acc))\n",
        "\n",
        "#define the title and other information for the plotted graph\n",
        "plt.plot(epochs, acc, 'r')\n",
        "plt.plot(epochs, val_acc, 'b')\n",
        "plt.title('Training and Validation Accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.figure()\n",
        "\n",
        "plt.plot(epochs, loss, 'r')\n",
        "plt.plot(epochs, val_loss, 'b')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.title('Training and Validaion Loss')\n",
        "plt.figure()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LRSUXUnTvmPN"
      },
      "outputs": [],
      "source": [
        "!pip install"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HvGSe-aprC14",
        "outputId": "1f36fca8-e810-4502-f0ae-6b8fc5d8e79e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "==============TEST RESULTS============\n",
            "20/20 [==============================] - 3s 162ms/step\n",
            "Confusion Matrix\n",
            "[[ 24 210]\n",
            " [ 42 348]]\n",
            "Classification Report\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "      normal       0.36      0.10      0.16       234\n",
            "   pneumonia       0.62      0.89      0.73       390\n",
            "\n",
            "    accuracy                           0.60       624\n",
            "   macro avg       0.49      0.50      0.45       624\n",
            "weighted avg       0.53      0.60      0.52       624\n",
            "\n"
          ]
        }
      ],
      "source": [
        "##assessment of performance on the test set\n",
        "\n",
        "##loading libraries\n",
        "import numpy as np\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "from sklearn.metrics import confusion_matrix\n",
        "print(\"==============TEST RESULTS============\")\n",
        "from sklearn.metrics import confusion_matrix  ##for printing the confusion matrix\n",
        "y_pred = model_final.predict(testdata)      ##predicting the test data set using trained model i.e. model_final\n",
        "y_pred = np.argmax(y_pred, axis=1)\n",
        "print('Confusion Matrix')\n",
        "print(confusion_matrix(testdata.classes, y_pred))\n",
        "print('Classification Report')\n",
        "target_names = ['normal', 'pneumonia']      ##defining the classes\n",
        "print(classification_report(testdata.classes, y_pred, target_names=target_names))      ##printing the classification report"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "4T-s9ebfSCPy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4389188a-c21e-4aab-b3b6-175d9fea9d59"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20/20 [==============================] - 3s 151ms/step - loss: 1.9443 - accuracy: 0.7147\n",
            "Test Accuracy: 0.7147436141967773\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the model on the test dataset\n",
        "test_loss, test_accuracy = model_final.evaluate(testdata)\n",
        "\n",
        "print(\"Test Accuracy:\", test_accuracy)\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}