Lung_nodule_malignancy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lung-nodule-malignancy.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "1Ta1bK3czZlYoldsjdcpN8WXhniy7UWqn",
      "authorship_tag": "ABX9TyMfYKMt1teQG8pIUdHEU5rM",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/galib96/lung-nodule-malignancy/blob/main/Lung_nodule_malignancy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "Xk-l8ayIBjTN"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "%matplotlib inline\n",
        "\n",
        "import h5py\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix, precision_score, recall_score, plot_confusion_matrix\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from keras.models import Sequential, Model\n",
        "from keras.layers import Dense, Dropout, Flatten, Activation, GlobalAveragePooling2D, ZeroPadding2D, Add\n",
        "from keras.layers import BatchNormalization, AveragePooling2D, Conv2D, MaxPooling2D, Input, ReLU\n",
        "from keras.callbacks import EarlyStopping, LambdaCallback\n",
        "from tensorflow.keras.optimizers import Adam"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# importing dataset\n",
        "img_data = h5py.File(\"/content/drive/MyDrive/Colab Notebooks/Lung Nodule Maliganancy/all_patches.hdf5\",'r')\n",
        "print(list(img_data.keys()))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uXQSsFDcB_yi",
        "outputId": "ab17b0da-2043-45e6-82f4-0d428476133f"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['ct_slices', 'slice_class']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualizing image\n",
        "ct_slices = img_data['ct_slices']\n",
        "slice_class = img_data['slice_class']\n",
        "\n",
        "plt.imshow(ct_slices[0], interpolation='nearest',cmap='gray')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "id": "9a4f0rQbEBoL",
        "outputId": "acc72187-fc87-4778-8ec4-669564901bc6"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(ct_slices.shape)\n",
        "print(slice_class.shape)\n",
        "print(ct_slices[0].min())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-2U0YuKIEslp",
        "outputId": "02554f69-685e-40fb-8a7f-0f6d02f47121"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(6691, 64, 64)\n",
            "(6691, 1)\n",
            "-1017.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ct_slices = np.array(ct_slices)\n",
        "slice_class = np.array(slice_class)\n",
        "ct_slices = ct_slices.reshape(6691, 64, 64, 1)\n",
        "\n",
        "# splitting data into train, validation and test set\n",
        "x_train, x_t, y_train, y_t = train_test_split(ct_slices, slice_class, test_size = 0.3, random_state=11)\n",
        "x_val, x_test, y_val, y_test = train_test_split(x_t, y_t, test_size = 0.5, random_state=11)\n",
        "\n",
        "y_train = keras.utils.to_categorical(y_train, num_classes=2)\n",
        "y_val = keras.utils.to_categorical(y_val, num_classes=2)\n",
        "y_test = keras.utils.to_categorical(y_test, num_classes=2)\n",
        "\n",
        "print(x_train.shape)\n",
        "print(x_test.shape)\n",
        "print(x_val.shape)\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)\n",
        "print(y_val.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ft8DQYWFMWSb",
        "outputId": "8fb53f82-488b-4685-9add-a8c35a3ed764"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(4683, 64, 64, 1)\n",
            "(1004, 64, 64, 1)\n",
            "(1004, 64, 64, 1)\n",
            "(4683, 2)\n",
            "(1004, 2)\n",
            "(1004, 2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def identity_block(X, f, filters, stage, block):\n",
        "    # defining names\n",
        "    conv_name = 'res'+str(stage)+block+'_branch'\n",
        "    bn_name = 'bn'+str(stage)+block+'_branch'\n",
        "\n",
        "    # retrieve filters\n",
        "    f1, f2, f3 = filters\n",
        "\n",
        "    # save the input values\n",
        "    X_skip = X\n",
        "\n",
        "    # 1st component of main path\n",
        "    X = Conv2D(filters=f1, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name+'2a')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2a')(X)\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    # 2nd component of main path\n",
        "    X = Conv2D(filters=f2, kernel_size=(f,f), strides=(1,1), padding='same', name=conv_name+'2b')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2b')(X)\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    # 3rd component of main path\n",
        "    X = Conv2D(filters=f3, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name+'2c')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2c')(X)\n",
        "    \n",
        "    # Final Step\n",
        "    X = Add()([X, X_skip])\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    return X"
      ],
      "metadata": {
        "id": "00WX0JVMkjrP"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def conv_block(X, f, filters, stage, block, s=2):\n",
        "    # defining names\n",
        "    conv_name = 'res'+str(stage)+block+'_branch'\n",
        "    bn_name = 'bn'+str(stage)+block+'_branch'\n",
        "\n",
        "    # retrieve filters\n",
        "    f1, f2, f3 = filters\n",
        "\n",
        "    # save the input values\n",
        "    X_skip = X\n",
        "\n",
        "    # 1st component of main path\n",
        "    X = Conv2D(filters=f1, kernel_size=(1,1), strides=(s,s), padding='valid', name=conv_name+'2a')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2a')(X)\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    # 2nd component of main path\n",
        "    X = Conv2D(filters=f2, kernel_size=(f,f), strides=(1,1), padding='same', name=conv_name+'2b')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2b')(X)\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    # 3rd component of main path\n",
        "    X = Conv2D(filters=f3, kernel_size=(1,1), strides=(1,1), padding='valid', name=conv_name+'2c')(X)\n",
        "    X = BatchNormalization(name=bn_name+'2c')(X)\n",
        "\n",
        "    # res skip connection path\n",
        "    X_skip = Conv2D(filters=f3, kernel_size=(1,1), strides=(s,s), padding='valid', name=conv_name+'1')(X_skip)\n",
        "    X_skip = BatchNormalization(name=bn_name+'1')(X_skip)\n",
        "    \n",
        "    # Final Step\n",
        "    X = Add()([X, X_skip])\n",
        "    X = Activation('relu')(X)\n",
        "\n",
        "    return X"
      ],
      "metadata": {
        "id": "BJRi1-YDnUkh"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def ResNet(input_shape = (64, 64, 1), classes = 2):\n",
        "    \n",
        "    # Define the input as a tensor with shape input_shape\n",
        "    X_input = Input(input_shape)\n",
        "\n",
        "    \n",
        "    # Zero-Padding\n",
        "    X = ZeroPadding2D((3, 3))(X_input)\n",
        "    \n",
        "    # Stage 1\n",
        "    X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1')(X)\n",
        "    X = BatchNormalization(axis = 3, name = 'bn_conv1')(X)\n",
        "    X = Activation('relu')(X)\n",
        "    X = MaxPooling2D((3, 3), strides=(2, 2))(X)\n",
        "\n",
        "    # Stage 2\n",
        "    X = conv_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s = 1)\n",
        "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')\n",
        "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')\n",
        "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='d')\n",
        "\n",
        "    # Stage 3\n",
        "    X = conv_block(X, f=3, filters=[128, 128, 512], stage=3, block='a', s=2)\n",
        "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')\n",
        "    \n",
        "\n",
        "    # Stage 4\n",
        "    X = conv_block(X, f=3, filters=[256, 256, 1024], stage=4, block='a', s=2)\n",
        "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')\n",
        "\n",
        "    # AVGPOOL\n",
        "    X = AveragePooling2D(pool_size=(2,2), padding='same')(X)\n",
        "\n",
        "    # Output layer\n",
        "    X = Flatten()(X)\n",
        "    X = Dense(classes, activation='softmax', name='fc' + str(classes))(X)\n",
        "    \n",
        "    \n",
        "    # Create model\n",
        "    model = Model(inputs = X_input, outputs = X, name='ResNet')\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "9MvI1a3D00P7"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating function to get a untrained model from tensorflow\n",
        "tf.keras.backend.clear_session()\n",
        "tf.random.set_seed(11)\n",
        "\n",
        "def get_model():\n",
        "  model = ResNet()\n",
        "  \n",
        "  model.compile(\n",
        "        loss='categorical_crossentropy',\n",
        "        optimizer='Adam',\n",
        "        metrics=['accuracy']\n",
        "    )\n",
        "  \n",
        "  return model\n",
        "\n",
        "summary = get_model().summary()\n",
        "summary"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "slH0szhYFkXg",
        "outputId": "62d66629-7d44-417f-8dc7-1da7d10020e8"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"ResNet\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_1 (InputLayer)           [(None, 64, 64, 1)]  0           []                               \n",
            "                                                                                                  \n",
            " zero_padding2d (ZeroPadding2D)  (None, 70, 70, 1)   0           ['input_1[0][0]']                \n",
            "                                                                                                  \n",
            " conv1 (Conv2D)                 (None, 32, 32, 64)   3200        ['zero_padding2d[0][0]']         \n",
            "                                                                                                  \n",
            " bn_conv1 (BatchNormalization)  (None, 32, 32, 64)   256         ['conv1[0][0]']                  \n",
            "                                                                                                  \n",
            " activation (Activation)        (None, 32, 32, 64)   0           ['bn_conv1[0][0]']               \n",
            "                                                                                                  \n",
            " max_pooling2d (MaxPooling2D)   (None, 15, 15, 64)   0           ['activation[0][0]']             \n",
            "                                                                                                  \n",
            " res2a_branch2a (Conv2D)        (None, 15, 15, 64)   4160        ['max_pooling2d[0][0]']          \n",
            "                                                                                                  \n",
            " bn2a_branch2a (BatchNormalizat  (None, 15, 15, 64)  256         ['res2a_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_1 (Activation)      (None, 15, 15, 64)   0           ['bn2a_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res2a_branch2b (Conv2D)        (None, 15, 15, 64)   36928       ['activation_1[0][0]']           \n",
            "                                                                                                  \n",
            " bn2a_branch2b (BatchNormalizat  (None, 15, 15, 64)  256         ['res2a_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_2 (Activation)      (None, 15, 15, 64)   0           ['bn2a_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res2a_branch2c (Conv2D)        (None, 15, 15, 256)  16640       ['activation_2[0][0]']           \n",
            "                                                                                                  \n",
            " res2a_branch1 (Conv2D)         (None, 15, 15, 256)  16640       ['max_pooling2d[0][0]']          \n",
            "                                                                                                  \n",
            " bn2a_branch2c (BatchNormalizat  (None, 15, 15, 256)  1024       ['res2a_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " bn2a_branch1 (BatchNormalizati  (None, 15, 15, 256)  1024       ['res2a_branch1[0][0]']          \n",
            " on)                                                                                              \n",
            "                                                                                                  \n",
            " add (Add)                      (None, 15, 15, 256)  0           ['bn2a_branch2c[0][0]',          \n",
            "                                                                  'bn2a_branch1[0][0]']           \n",
            "                                                                                                  \n",
            " activation_3 (Activation)      (None, 15, 15, 256)  0           ['add[0][0]']                    \n",
            "                                                                                                  \n",
            " res2b_branch2a (Conv2D)        (None, 15, 15, 64)   16448       ['activation_3[0][0]']           \n",
            "                                                                                                  \n",
            " bn2b_branch2a (BatchNormalizat  (None, 15, 15, 64)  256         ['res2b_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_4 (Activation)      (None, 15, 15, 64)   0           ['bn2b_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res2b_branch2b (Conv2D)        (None, 15, 15, 64)   36928       ['activation_4[0][0]']           \n",
            "                                                                                                  \n",
            " bn2b_branch2b (BatchNormalizat  (None, 15, 15, 64)  256         ['res2b_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_5 (Activation)      (None, 15, 15, 64)   0           ['bn2b_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res2b_branch2c (Conv2D)        (None, 15, 15, 256)  16640       ['activation_5[0][0]']           \n",
            "                                                                                                  \n",
            " bn2b_branch2c (BatchNormalizat  (None, 15, 15, 256)  1024       ['res2b_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " add_1 (Add)                    (None, 15, 15, 256)  0           ['bn2b_branch2c[0][0]',          \n",
            "                                                                  'activation_3[0][0]']           \n",
            "                                                                                                  \n",
            " activation_6 (Activation)      (None, 15, 15, 256)  0           ['add_1[0][0]']                  \n",
            "                                                                                                  \n",
            " res2c_branch2a (Conv2D)        (None, 15, 15, 64)   16448       ['activation_6[0][0]']           \n",
            "                                                                                                  \n",
            " bn2c_branch2a (BatchNormalizat  (None, 15, 15, 64)  256         ['res2c_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_7 (Activation)      (None, 15, 15, 64)   0           ['bn2c_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res2c_branch2b (Conv2D)        (None, 15, 15, 64)   36928       ['activation_7[0][0]']           \n",
            "                                                                                                  \n",
            " bn2c_branch2b (BatchNormalizat  (None, 15, 15, 64)  256         ['res2c_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_8 (Activation)      (None, 15, 15, 64)   0           ['bn2c_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res2c_branch2c (Conv2D)        (None, 15, 15, 256)  16640       ['activation_8[0][0]']           \n",
            "                                                                                                  \n",
            " bn2c_branch2c (BatchNormalizat  (None, 15, 15, 256)  1024       ['res2c_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " add_2 (Add)                    (None, 15, 15, 256)  0           ['bn2c_branch2c[0][0]',          \n",
            "                                                                  'activation_6[0][0]']           \n",
            "                                                                                                  \n",
            " activation_9 (Activation)      (None, 15, 15, 256)  0           ['add_2[0][0]']                  \n",
            "                                                                                                  \n",
            " res2d_branch2a (Conv2D)        (None, 15, 15, 64)   16448       ['activation_9[0][0]']           \n",
            "                                                                                                  \n",
            " bn2d_branch2a (BatchNormalizat  (None, 15, 15, 64)  256         ['res2d_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_10 (Activation)     (None, 15, 15, 64)   0           ['bn2d_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res2d_branch2b (Conv2D)        (None, 15, 15, 64)   36928       ['activation_10[0][0]']          \n",
            "                                                                                                  \n",
            " bn2d_branch2b (BatchNormalizat  (None, 15, 15, 64)  256         ['res2d_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_11 (Activation)     (None, 15, 15, 64)   0           ['bn2d_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res2d_branch2c (Conv2D)        (None, 15, 15, 256)  16640       ['activation_11[0][0]']          \n",
            "                                                                                                  \n",
            " bn2d_branch2c (BatchNormalizat  (None, 15, 15, 256)  1024       ['res2d_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " add_3 (Add)                    (None, 15, 15, 256)  0           ['bn2d_branch2c[0][0]',          \n",
            "                                                                  'activation_9[0][0]']           \n",
            "                                                                                                  \n",
            " activation_12 (Activation)     (None, 15, 15, 256)  0           ['add_3[0][0]']                  \n",
            "                                                                                                  \n",
            " res3a_branch2a (Conv2D)        (None, 8, 8, 128)    32896       ['activation_12[0][0]']          \n",
            "                                                                                                  \n",
            " bn3a_branch2a (BatchNormalizat  (None, 8, 8, 128)   512         ['res3a_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_13 (Activation)     (None, 8, 8, 128)    0           ['bn3a_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res3a_branch2b (Conv2D)        (None, 8, 8, 128)    147584      ['activation_13[0][0]']          \n",
            "                                                                                                  \n",
            " bn3a_branch2b (BatchNormalizat  (None, 8, 8, 128)   512         ['res3a_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_14 (Activation)     (None, 8, 8, 128)    0           ['bn3a_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res3a_branch2c (Conv2D)        (None, 8, 8, 512)    66048       ['activation_14[0][0]']          \n",
            "                                                                                                  \n",
            " res3a_branch1 (Conv2D)         (None, 8, 8, 512)    131584      ['activation_12[0][0]']          \n",
            "                                                                                                  \n",
            " bn3a_branch2c (BatchNormalizat  (None, 8, 8, 512)   2048        ['res3a_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " bn3a_branch1 (BatchNormalizati  (None, 8, 8, 512)   2048        ['res3a_branch1[0][0]']          \n",
            " on)                                                                                              \n",
            "                                                                                                  \n",
            " add_4 (Add)                    (None, 8, 8, 512)    0           ['bn3a_branch2c[0][0]',          \n",
            "                                                                  'bn3a_branch1[0][0]']           \n",
            "                                                                                                  \n",
            " activation_15 (Activation)     (None, 8, 8, 512)    0           ['add_4[0][0]']                  \n",
            "                                                                                                  \n",
            " res3b_branch2a (Conv2D)        (None, 8, 8, 128)    65664       ['activation_15[0][0]']          \n",
            "                                                                                                  \n",
            " bn3b_branch2a (BatchNormalizat  (None, 8, 8, 128)   512         ['res3b_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_16 (Activation)     (None, 8, 8, 128)    0           ['bn3b_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res3b_branch2b (Conv2D)        (None, 8, 8, 128)    147584      ['activation_16[0][0]']          \n",
            "                                                                                                  \n",
            " bn3b_branch2b (BatchNormalizat  (None, 8, 8, 128)   512         ['res3b_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_17 (Activation)     (None, 8, 8, 128)    0           ['bn3b_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res3b_branch2c (Conv2D)        (None, 8, 8, 512)    66048       ['activation_17[0][0]']          \n",
            "                                                                                                  \n",
            " bn3b_branch2c (BatchNormalizat  (None, 8, 8, 512)   2048        ['res3b_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " add_5 (Add)                    (None, 8, 8, 512)    0           ['bn3b_branch2c[0][0]',          \n",
            "                                                                  'activation_15[0][0]']          \n",
            "                                                                                                  \n",
            " activation_18 (Activation)     (None, 8, 8, 512)    0           ['add_5[0][0]']                  \n",
            "                                                                                                  \n",
            " res4a_branch2a (Conv2D)        (None, 4, 4, 256)    131328      ['activation_18[0][0]']          \n",
            "                                                                                                  \n",
            " bn4a_branch2a (BatchNormalizat  (None, 4, 4, 256)   1024        ['res4a_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_19 (Activation)     (None, 4, 4, 256)    0           ['bn4a_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res4a_branch2b (Conv2D)        (None, 4, 4, 256)    590080      ['activation_19[0][0]']          \n",
            "                                                                                                  \n",
            " bn4a_branch2b (BatchNormalizat  (None, 4, 4, 256)   1024        ['res4a_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_20 (Activation)     (None, 4, 4, 256)    0           ['bn4a_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res4a_branch2c (Conv2D)        (None, 4, 4, 1024)   263168      ['activation_20[0][0]']          \n",
            "                                                                                                  \n",
            " res4a_branch1 (Conv2D)         (None, 4, 4, 1024)   525312      ['activation_18[0][0]']          \n",
            "                                                                                                  \n",
            " bn4a_branch2c (BatchNormalizat  (None, 4, 4, 1024)  4096        ['res4a_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " bn4a_branch1 (BatchNormalizati  (None, 4, 4, 1024)  4096        ['res4a_branch1[0][0]']          \n",
            " on)                                                                                              \n",
            "                                                                                                  \n",
            " add_6 (Add)                    (None, 4, 4, 1024)   0           ['bn4a_branch2c[0][0]',          \n",
            "                                                                  'bn4a_branch1[0][0]']           \n",
            "                                                                                                  \n",
            " activation_21 (Activation)     (None, 4, 4, 1024)   0           ['add_6[0][0]']                  \n",
            "                                                                                                  \n",
            " res4b_branch2a (Conv2D)        (None, 4, 4, 256)    262400      ['activation_21[0][0]']          \n",
            "                                                                                                  \n",
            " bn4b_branch2a (BatchNormalizat  (None, 4, 4, 256)   1024        ['res4b_branch2a[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_22 (Activation)     (None, 4, 4, 256)    0           ['bn4b_branch2a[0][0]']          \n",
            "                                                                                                  \n",
            " res4b_branch2b (Conv2D)        (None, 4, 4, 256)    590080      ['activation_22[0][0]']          \n",
            "                                                                                                  \n",
            " bn4b_branch2b (BatchNormalizat  (None, 4, 4, 256)   1024        ['res4b_branch2b[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " activation_23 (Activation)     (None, 4, 4, 256)    0           ['bn4b_branch2b[0][0]']          \n",
            "                                                                                                  \n",
            " res4b_branch2c (Conv2D)        (None, 4, 4, 1024)   263168      ['activation_23[0][0]']          \n",
            "                                                                                                  \n",
            " bn4b_branch2c (BatchNormalizat  (None, 4, 4, 1024)  4096        ['res4b_branch2c[0][0]']         \n",
            " ion)                                                                                             \n",
            "                                                                                                  \n",
            " add_7 (Add)                    (None, 4, 4, 1024)   0           ['bn4b_branch2c[0][0]',          \n",
            "                                                                  'activation_21[0][0]']          \n",
            "                                                                                                  \n",
            " activation_24 (Activation)     (None, 4, 4, 1024)   0           ['add_7[0][0]']                  \n",
            "                                                                                                  \n",
            " average_pooling2d (AveragePool  (None, 2, 2, 1024)  0           ['activation_24[0][0]']          \n",
            " ing2D)                                                                                           \n",
            "                                                                                                  \n",
            " flatten (Flatten)              (None, 4096)         0           ['average_pooling2d[0][0]']      \n",
            "                                                                                                  \n",
            " fc2 (Dense)                    (None, 2)            8194        ['flatten[0][0]']                \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 3,610,754\n",
            "Trainable params: 3,594,754\n",
            "Non-trainable params: 16,000\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = get_model()\n",
        "\n",
        "# early stopping callback function\n",
        "early_stop = keras.callbacks.EarlyStopping(\n",
        "    monitor=\"val_loss\",\n",
        "    patience=10, mode=\"min\",\n",
        "    restore_best_weights=True,\n",
        ")\n",
        "\n",
        "# learning rate reduction\n",
        "lr_reduce = keras.callbacks.ReduceLROnPlateau(\n",
        "    monitor='val_loss', \n",
        "    factor=0.1, \n",
        "    patience=5, verbose=1, mode='min'\n",
        ")\n",
        "\n",
        "# training model\n",
        "history = model.fit(\n",
        "    x_train, y_train,\n",
        "    batch_size = 128,\n",
        "    validation_data=(x_val, y_val),\n",
        "    epochs=100,\n",
        "    callbacks = [early_stop, lr_reduce]\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "izCn9DOWQfPZ",
        "outputId": "ee9840ae-7c03-4693-9e71-67983dd7f29c"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "37/37 [==============================] - 7s 108ms/step - loss: 1.1811 - accuracy: 0.6485 - val_loss: 20.7686 - val_accuracy: 0.6175 - lr: 0.0010\n",
            "Epoch 2/100\n",
            "37/37 [==============================] - 3s 91ms/step - loss: 0.4375 - accuracy: 0.8012 - val_loss: 2.4147 - val_accuracy: 0.6116 - lr: 0.0010\n",
            "Epoch 3/100\n",
            "37/37 [==============================] - 3s 92ms/step - loss: 0.2622 - accuracy: 0.9005 - val_loss: 1.5497 - val_accuracy: 0.6245 - lr: 0.0010\n",
            "Epoch 4/100\n",
            "37/37 [==============================] - 3s 92ms/step - loss: 0.1660 - accuracy: 0.9340 - val_loss: 1.3155 - val_accuracy: 0.6315 - lr: 0.0010\n",
            "Epoch 5/100\n",
            "37/37 [==============================] - 3s 93ms/step - loss: 0.1472 - accuracy: 0.9438 - val_loss: 0.5795 - val_accuracy: 0.7351 - lr: 0.0010\n",
            "Epoch 6/100\n",
            "37/37 [==============================] - 3s 92ms/step - loss: 0.0832 - accuracy: 0.9684 - val_loss: 0.6561 - val_accuracy: 0.7500 - lr: 0.0010\n",
            "Epoch 7/100\n",
            "37/37 [==============================] - 3s 93ms/step - loss: 0.0657 - accuracy: 0.9767 - val_loss: 0.5686 - val_accuracy: 0.8137 - lr: 0.0010\n",
            "Epoch 8/100\n",
            "37/37 [==============================] - 3s 94ms/step - loss: 0.0458 - accuracy: 0.9836 - val_loss: 0.8751 - val_accuracy: 0.7659 - lr: 0.0010\n",
            "Epoch 9/100\n",
            "37/37 [==============================] - 3s 91ms/step - loss: 0.0962 - accuracy: 0.9665 - val_loss: 2.1435 - val_accuracy: 0.7151 - lr: 0.0010\n",
            "Epoch 10/100\n",
            "37/37 [==============================] - 3s 90ms/step - loss: 0.0723 - accuracy: 0.9729 - val_loss: 1.6110 - val_accuracy: 0.7669 - lr: 0.0010\n",
            "Epoch 11/100\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 0.0626 - accuracy: 0.9778 - val_loss: 1.3205 - val_accuracy: 0.7281 - lr: 0.0010\n",
            "Epoch 12/100\n",
            "36/37 [============================>.] - ETA: 0s - loss: 0.0365 - accuracy: 0.9865\n",
            "Epoch 12: ReduceLROnPlateau reducing learning rate to 0.00010000000474974513.\n",
            "37/37 [==============================] - 3s 90ms/step - loss: 0.0361 - accuracy: 0.9868 - val_loss: 0.7797 - val_accuracy: 0.8327 - lr: 0.0010\n",
            "Epoch 13/100\n",
            "37/37 [==============================] - 3s 91ms/step - loss: 0.0224 - accuracy: 0.9938 - val_loss: 0.2871 - val_accuracy: 0.9094 - lr: 1.0000e-04\n",
            "Epoch 14/100\n",
            "37/37 [==============================] - 3s 91ms/step - loss: 0.0029 - accuracy: 1.0000 - val_loss: 0.1986 - val_accuracy: 0.9353 - lr: 1.0000e-04\n",
            "Epoch 15/100\n",
            "37/37 [==============================] - 3s 90ms/step - loss: 0.0015 - accuracy: 1.0000 - val_loss: 0.1679 - val_accuracy: 0.9472 - lr: 1.0000e-04\n",
            "Epoch 16/100\n",
            "37/37 [==============================] - 3s 93ms/step - loss: 0.0013 - accuracy: 1.0000 - val_loss: 0.1592 - val_accuracy: 0.9502 - lr: 1.0000e-04\n",
            "Epoch 17/100\n",
            "37/37 [==============================] - 3s 90ms/step - loss: 0.0011 - accuracy: 1.0000 - val_loss: 0.1579 - val_accuracy: 0.9542 - lr: 1.0000e-04\n",
            "Epoch 18/100\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 8.7667e-04 - accuracy: 1.0000 - val_loss: 0.1580 - val_accuracy: 0.9552 - lr: 1.0000e-04\n",
            "Epoch 19/100\n",
            "37/37 [==============================] - 3s 88ms/step - loss: 0.0012 - accuracy: 0.9998 - val_loss: 0.1593 - val_accuracy: 0.9572 - lr: 1.0000e-04\n",
            "Epoch 20/100\n",
            "37/37 [==============================] - 3s 88ms/step - loss: 6.4868e-04 - accuracy: 1.0000 - val_loss: 0.1603 - val_accuracy: 0.9582 - lr: 1.0000e-04\n",
            "Epoch 21/100\n",
            "37/37 [==============================] - 3s 88ms/step - loss: 5.3482e-04 - accuracy: 1.0000 - val_loss: 0.1628 - val_accuracy: 0.9572 - lr: 1.0000e-04\n",
            "Epoch 22/100\n",
            "36/37 [============================>.] - ETA: 0s - loss: 6.1677e-04 - accuracy: 1.0000\n",
            "Epoch 22: ReduceLROnPlateau reducing learning rate to 1.0000000474974514e-05.\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 6.1074e-04 - accuracy: 1.0000 - val_loss: 0.1618 - val_accuracy: 0.9582 - lr: 1.0000e-04\n",
            "Epoch 23/100\n",
            "37/37 [==============================] - 3s 88ms/step - loss: 5.2484e-04 - accuracy: 1.0000 - val_loss: 0.1627 - val_accuracy: 0.9582 - lr: 1.0000e-05\n",
            "Epoch 24/100\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 6.7403e-04 - accuracy: 1.0000 - val_loss: 0.1629 - val_accuracy: 0.9582 - lr: 1.0000e-05\n",
            "Epoch 25/100\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 4.7714e-04 - accuracy: 1.0000 - val_loss: 0.1633 - val_accuracy: 0.9582 - lr: 1.0000e-05\n",
            "Epoch 26/100\n",
            "37/37 [==============================] - 3s 89ms/step - loss: 4.2212e-04 - accuracy: 1.0000 - val_loss: 0.1632 - val_accuracy: 0.9582 - lr: 1.0000e-05\n",
            "Epoch 27/100\n",
            "36/37 [============================>.] - ETA: 0s - loss: 5.0633e-04 - accuracy: 1.0000\n",
            "Epoch 27: ReduceLROnPlateau reducing learning rate to 1.0000000656873453e-06.\n",
            "37/37 [==============================] - 3s 91ms/step - loss: 5.1905e-04 - accuracy: 1.0000 - val_loss: 0.1633 - val_accuracy: 0.9582 - lr: 1.0000e-05\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(loss))\n",
        "\n",
        "plt.figure(figsize=(12,8))\n",
        "\n",
        "plt.plot(epochs, loss, 'r', label='Training Loss')\n",
        "plt.plot(epochs, val_loss, 'b', label='Validation Loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('No. of Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "\n",
        "#plt.savefig('/content'+'/Training and Validation Loss.png',dpi=300) ##########\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        },
        "id": "LXexNXv5SRXs",
        "outputId": "08caa6fc-44c0-43e9-bac9-cd191e6992e3"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# result of the model training\n",
        "\n",
        "accuracy = history.history['accuracy']\n",
        "val_accuracy = history.history['val_accuracy']\n",
        "\n",
        "epochs = range(len(loss))\n",
        "\n",
        "plt.figure(figsize=(12,8))\n",
        "\n",
        "plt.plot(epochs, accuracy, 'r', label='Training Accuracy')\n",
        "plt.plot(epochs, val_accuracy, 'b', label='Validation Accuracy')\n",
        "plt.title('Training and validation Accuracy')\n",
        "plt.xlabel('No. of Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "\n",
        "#plt.savefig('/content'+'/Training and Validation Accuracy.png',dpi=300) #########\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 513
        },
        "id": "oGupFcbVT-9s",
        "outputId": "2acbb311-0575-460c-8061-ae1bc7e05241"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# predicting classes for test set\n",
        "\n",
        "yhat_probs = model.predict(x_test)\n",
        "yhat_classes = np.argmax(yhat_probs,axis=1)\n",
        "yhat_classes"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QcP9uTEmZSeA",
        "outputId": "3290b65f-def1-4b82-95ce-3576f9cd290c"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 0, 0, ..., 0, 1, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# converting test set to classes\n",
        "y_test_class = np.argmax(y_test,axis=1)\n",
        "y_test_class"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BZCaVffsaZZL",
        "outputId": "c9e6e2c9-5015-439e-f31c-aba26166c81a"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 0, 0, ..., 0, 1, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# model evaluation by f1 score\n",
        "\n",
        "f1 = f1_score(y_test_class, yhat_classes)\n",
        "print(\"F1 accuracy of the model for test set: \", f1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "szbwnTdtavDK",
        "outputId": "565155f5-0e2e-4979-d501-f1f76e743dc7"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 accuracy of the model for test set:  0.9341772151898735\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# plotting confusion matrix\n",
        "\n",
        "cm = confusion_matrix(y_test_class, yhat_classes)\n",
        "\n",
        "ax = plt.subplot(1,1,1)\n",
        "sns.heatmap(cm, annot=True, ax = ax );\n",
        "\n",
        "# labels and titles\n",
        "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
        "ax.set_title('Confusion Matrix');\n",
        "ax.xaxis.set_ticklabels(['Normal', 'Abnormal']); \n",
        "ax.yaxis.set_ticklabels(['Normal', 'Abnormal']);\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "QteBWP6cbJqm",
        "outputId": "ae2f5601-fed9-4f3a-9269-dc345d995a6d"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q pyyaml h5py\n",
        "\n",
        "# saving model\n",
        "model.save('model.h5')"
      ],
      "metadata": {
        "id": "VWIFqgjNtCPX"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}