2class_n_pc_m2_6_7.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/husam1986/RAN_Chest_x_ray/blob/main/2class_n_pc_m2_6_7.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bG6KyHQThHAg"
      },
      "source": [
        "# **Husam Imad AbdulRazzaq**\n",
        "\n",
        "2 classes _ classify   n &   p c     method2 6/7\n",
        "\n",
        "new code for RAN\n",
        "\n",
        "ref:\n",
        "https://github.com/Jay4869/Deep-Learning\n",
        "\n",
        "https://github.com/husam1986/RAN_Chest_x_ray\n",
        "\n",
        "https://www.kaggle.com/code/ankan1998/covid19-detection-using-tensorflow-from-chest-xray\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ro8dPQOTjusJ"
      },
      "source": [
        "intialize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NnUjgvtZj86d"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras.layers import Conv2D\n",
        "from tensorflow.keras.layers import UpSampling2D\n",
        "from tensorflow.keras.layers import MaxPooling2D\n",
        "from tensorflow.keras.layers import Add\n",
        "from tensorflow.keras.layers import Activation\n",
        "from tensorflow.keras.layers import Lambda\n",
        "from tensorflow.keras.layers import Multiply\n",
        "\n",
        "from tensorflow.keras.layers import Input\n",
        "from tensorflow.keras.regularizers import l2\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "from tensorflow.keras.layers import AveragePooling2D\n",
        "\n",
        "from tensorflow.keras.layers import Flatten\n",
        "from tensorflow.keras.layers import Dropout\n",
        "from tensorflow.keras.layers import Dense\n",
        "from tensorflow.keras.models import Model\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import skimage.transform\n",
        "import time, os, datetime\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "sns.set_style('darkgrid')\n",
        "\n",
        "import os\n",
        "import random\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from tensorflow.keras.preprocessing.image import load_img\n",
        "from tensorflow.keras.preprocessing.image import img_to_array\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.optimizers import Adam, SGD\n",
        "from tensorflow.keras.callbacks import ReduceLROnPlateau, EarlyStopping,TensorBoard, LearningRateScheduler\n",
        "from tensorflow.keras.models import load_model\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dMGZW6F4ila4"
      },
      "source": [
        "1- Residual_Unit"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fzJ6r4MxhEc8"
      },
      "outputs": [],
      "source": [
        "\n",
        "\"\"\"\n",
        "Residual Unit is implemented above proposed Residual Block\n",
        "input >> BN >> ReLU >> Conv2DLayer(1,1)\n",
        "      >> BN >> ReLU >> Conv2DLayer(3,3)\n",
        "      >> BN >> ReLU >> Conv2DLayer(1,1) + identify\n",
        "      >> output\n",
        "\"\"\"\n",
        "\n",
        "def Residual_Unit(input, in_channel, out_channel, stride=1):\n",
        "\n",
        "    \"\"\"\n",
        "    :param input: The input of the Residual_Unit. Should be a 4D array like (batch_num, img_len, img_len, channel_num)\n",
        "    :param in_channel: The 4-th dimension (channel number) of input matrix. For example, in_channel=3 means the input contains 3 channels.\n",
        "    :param out_channel: The 4-th dimension (channel number) of output matrix. For example, out_channel=5 means the output contains 5 channels (feature maps).\n",
        "    :param stride: Integer. The number of pixels to move between 2 neighboring receptive fields.\n",
        "    \"\"\"\n",
        "\n",
        "    # initialize as the input (identity) data\n",
        "    shortcut = input\n",
        "    shortcut = Conv2D(out_channel, (1, 1), padding='same', strides=stride)(shortcut)\n",
        "\n",
        "    # RestNet module\n",
        "    x = BatchNormalization()(input)\n",
        "    x = Activation('relu')(x)\n",
        "    x = Conv2D(in_channel, (1, 1))(x)\n",
        "\n",
        "    x = BatchNormalization()(x)\n",
        "    x = Activation('relu')(x)\n",
        "    x = Conv2D(in_channel, (3, 3), padding='same', strides=stride)(x)\n",
        "\n",
        "    x = BatchNormalization()(x)\n",
        "    x = Activation('relu')(x)\n",
        "    x = Conv2D(out_channel, (1, 1), padding='same')(x)\n",
        "\n",
        "    # identity\n",
        "    x = Add()([x, shortcut])\n",
        "\n",
        "    return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovLfBAHJjLTH"
      },
      "source": [
        "2- Attention_Block"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0mKsGr7rjPBt"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "def Attention_Block(input, skip):\n",
        "\n",
        "    \"\"\"\n",
        "    :param input: The input of the Residual_Unit. Should be a 4D array like (batch_num, img_len, img_len, channel_num)\n",
        "    :param in_channel: The 4-th dimension (channel number) of input matrix. For example, in_channel=3 means the input contains 3 channels.\n",
        "    \"\"\"\n",
        "\n",
        "    # initial Attention Module parameters\n",
        "    p = 1\n",
        "    t = 2\n",
        "    r = 1\n",
        "    skip_connections = []\n",
        "    # calculate input and output channel based on previous layers\n",
        "    in_channel = input.shape[-1]\n",
        "    out_channel = in_channel\n",
        "\n",
        "    # pre-activation Residual Unit\n",
        "    for _ in range(p):\n",
        "        x = Residual_Unit(input, in_channel, out_channel)\n",
        "\n",
        "    # Trunk Branch\n",
        "    for _ in range(t):\n",
        "        Trunck_output = Residual_Unit(x, in_channel, out_channel)\n",
        "\n",
        "    # Soft Mask Branch\n",
        "    ## 1st down sampling\n",
        "    x = MaxPooling2D(padding='same')(x)\n",
        "    for _ in range(r):\n",
        "        x = Residual_Unit(x, in_channel, out_channel)\n",
        "\n",
        "    if x.shape[1] % 4 == 0:\n",
        "        for i in range(skip-1):\n",
        "            ## skip connections\n",
        "            skip_connections.append(Residual_Unit(x, in_channel, out_channel))\n",
        "\n",
        "            ## 2rd down sampling\n",
        "            x = MaxPooling2D(padding='same')(x)\n",
        "            for _ in range(r):\n",
        "                x = Residual_Unit(x, in_channel, out_channel)\n",
        "\n",
        "        skip_connections = list(reversed(skip_connections))\n",
        "\n",
        "        for i in range(skip-1):\n",
        "            ## 1st up sampling\n",
        "            for _ in range(r):\n",
        "                x = Residual_Unit(x, in_channel, out_channel)\n",
        "            x = UpSampling2D()(x)\n",
        "\n",
        "            # skip connections\n",
        "            x = Add()([x, skip_connections[i]])\n",
        "\n",
        "    ## 2rd up samplping\n",
        "    for i in range(r):\n",
        "        x = Residual_Unit(x, in_channel, out_channel)\n",
        "    x = UpSampling2D()(x)\n",
        "\n",
        "    ## output\n",
        "    x = Conv2D(out_channel, (1, 1))(x)\n",
        "    x = Conv2D(out_channel, (1, 1))(x)\n",
        "    soft_mask_output = Activation('sigmoid')(x)\n",
        "\n",
        "    # Attention: (1 + soft_mask_output) * Trunck_output\n",
        "    soft_mask_output = Lambda(lambda x: x + 1)(soft_mask_output)\n",
        "    output = Multiply()([soft_mask_output, Trunck_output])\n",
        "\n",
        "    # Last Residual Block\n",
        "    for i in range(p):\n",
        "        output = Residual_Unit(output, in_channel, out_channel)\n",
        "\n",
        "    return output\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mGPS8Q4LkCNU"
      },
      "source": [
        "*3*- AttentionResNet56"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BN8_p0x0kdVc"
      },
      "outputs": [],
      "source": [
        "def AttentionResNet56(shape, in_channel, kernel_size, n_classes, dropout=None, regularization=0.01):\n",
        "\n",
        "    \"\"\"\n",
        "    :param shape: The tuple of input data.\n",
        "    :param in_channel: The 4-th dimension (channel number) of input weight matrix. For example, in_channel=3 means the input contains 3 channels.\n",
        "    :param kernel_size: Integer. the shape of the kernel. For example, default kernel_size = 3 means you have a 3*3 kernel.\n",
        "    :param n_classes: Integer. The number of target classes. For example, n_classes = 10 means you have 10 class labels.\n",
        "    :param dropout: Float between 0 and 1. Fraction of the input units to drop.\n",
        "    :param regularization: Float. Fraction of the input units to drop.\n",
        "    \"\"\"\n",
        "    input_data = Input(shape=shape)  # 512x512x2\n",
        "    x = Conv2D(in_channel, kernel_size=kernel_size, padding='same')(input_data)  # 256x256x32\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 256x256x32\n",
        "\n",
        "    x = Attention_Block(x, skip=1)\n",
        "    out_channel = in_channel * 2  # 64\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 256x256x64\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 128x128x64\n",
        "\n",
        "    \"\"\"in_channel=out_channel\n",
        "    out_channel = in_channel * 2 # 128\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 64x64x128\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 32x32x128\n",
        "\"\"\"\n",
        "    x = Attention_Block(x, skip=1)\n",
        "\n",
        "    in_channel=out_channel\n",
        "    out_channel = in_channel * 2 # 128\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 128x128x128\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 64x64x128\n",
        "\n",
        "    x = Attention_Block(x, skip=1)\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 32x32x128\n",
        "\n",
        "    in_channel=out_channel\n",
        "    out_channel = in_channel * 2  # 256\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 32x32x256\n",
        "    x =  MaxPooling2D(pool_size=2, padding='same')(x)  # 16x16x256\n",
        "\n",
        "    in_channel=out_channel\n",
        "    out_channel = in_channel * 2\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 16x16x512\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 8x8x512\n",
        "\n",
        "    in_channel=out_channel\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 8x8x512\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 4x4x512\n",
        "\n",
        "    x = Residual_Unit(x, in_channel, out_channel)  # 4x4x512\n",
        "    x = MaxPooling2D(pool_size=2, padding='same')(x)  # 2x2x512\n",
        "    x = Flatten()(x) #\n",
        "\n",
        "    output = Dense(n_classes, kernel_regularizer=l2(regularization), activation='softmax')(x)\n",
        "    model = Model(input_data, output)\n",
        "\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xs23q1sFbAsI"
      },
      "source": [
        "4-1 hardwer info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l7Ya_vAy2IZC",
        "outputId": "b2e13c92-da3e-47b5-a8e2-d6798b090de8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Thu Jul  6 23:51:59 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 525.85.12    Driver Version: 525.85.12    CUDA Version: 12.0     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   37C    P8     9W /  70W |      0MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n",
            "Your runtime has 27.3 gigabytes of available RAM\n",
            "\n",
            "You are using a high-RAM runtime!\n",
            "TF version:  2.12.0\n",
            "Keras version: 2.12.0\n"
          ]
        }
      ],
      "source": [
        "gpu_info = !nvidia-smi\n",
        "gpu_info = '\\n'.join(gpu_info)\n",
        "if gpu_info.find('failed') >= 0:\n",
        "  print('Not connected to a GPU')\n",
        "else:\n",
        "  print(gpu_info)\n",
        "\n",
        "  from psutil import virtual_memory\n",
        "ram_gb = virtual_memory().total / 1e9\n",
        "print('Your runtime has {:.1f} gigabytes of available RAM\\n'.format(ram_gb))\n",
        "\n",
        "if ram_gb < 20:\n",
        "  print('Not using a high-RAM runtime')\n",
        "else:\n",
        "  print('You are using a high-RAM runtime!')\n",
        "\n",
        "\n",
        "\n",
        "print(\"TF version: \",tf.__version__)\n",
        "print(\"Keras version:\",tf.keras.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EMJQ-yjzXwZ4"
      },
      "source": [
        "Extracting Files"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NsGMjQURXy54"
      },
      "outputs": [],
      "source": [
        "c_tr = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/COVID/images'\n",
        "n_tr = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/Normal/images'\n",
        "p_tr = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/Viral Pneumonia/images'\n",
        "\n",
        "c_vld = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/COVID/out'\n",
        "n_vld = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/Normal/out'\n",
        "p_vld = '/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/Viral Pneumonia/out'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TTo7oz93YV_J"
      },
      "outputs": [],
      "source": [
        "random.seed(42) #edit\n",
        "C_filenames_train = os.listdir(c_tr)[1:550]\n",
        "P_filenames_train = os.listdir(p_tr)[1:550]\n",
        "N_filenames_train = os.listdir(n_tr)[1:1100]\n",
        "\n",
        "C_filenames_validation = os.listdir(c_vld)[1:123]\n",
        "P_filenames_validation = os.listdir(p_vld)[1:123]\n",
        "N_filenames_validation = os.listdir(n_vld)[1:245]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ykyrOxHVYanY"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lq39A1N5YkRe"
      },
      "outputs": [],
      "source": [
        "c_Zeros_tr = []\n",
        "for filename in N_filenames_train:\n",
        "    c_Zeros_tr.append(str(0))\n",
        "p_Oness_tr = []\n",
        "for filename in C_filenames_train:\n",
        "    p_Oness_tr.append(str(1))\n",
        "    p_Oness_tr.append(str(1))\n",
        "\n",
        "c_Zeros_vld = []\n",
        "for filename in N_filenames_validation:\n",
        "    c_Zeros_vld.append(str(0))\n",
        "p_Oness_vld = []\n",
        "for filename in C_filenames_validation:\n",
        "    p_Oness_vld.append(str(1))\n",
        "    p_Oness_vld.append(str(1))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAPF5um-Yqdy"
      },
      "source": [
        "Converting to Dataframe"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "v6iTUP_oYrgu",
        "outputId": "0678285c-2e92-4a90-ed3e-9d98afa1c3f9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                            filename category\n",
              "0  /content/drive/Othercomputers/Hp8570/GoogleDri...        0\n",
              "1  /content/drive/Othercomputers/Hp8570/GoogleDri...        0\n",
              "2  /content/drive/Othercomputers/Hp8570/GoogleDri...        0\n",
              "3  /content/drive/Othercomputers/Hp8570/GoogleDri...        0\n",
              "4  /content/drive/Othercomputers/Hp8570/GoogleDri...        0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-25607fb7-56f0-4447-b117-e1d42e524898\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>filename</th>\n",
              "      <th>category</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>/content/drive/Othercomputers/Hp8570/GoogleDri...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>/content/drive/Othercomputers/Hp8570/GoogleDri...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>/content/drive/Othercomputers/Hp8570/GoogleDri...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>/content/drive/Othercomputers/Hp8570/GoogleDri...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>/content/drive/Othercomputers/Hp8570/GoogleDri...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-25607fb7-56f0-4447-b117-e1d42e524898')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-25607fb7-56f0-4447-b117-e1d42e524898 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-25607fb7-56f0-4447-b117-e1d42e524898');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "from posix import remove\n",
        "\"\"\"c\"\"\"\n",
        "for i in range(len(C_filenames_train)):\n",
        "        C_filenames_train[i] = os.path.join(c_tr, C_filenames_train[i])\n",
        "for i in range(len(P_filenames_train)):\n",
        "        P_filenames_train[i] = os.path.join(p_tr, P_filenames_train[i])\n",
        "for i in range(len(N_filenames_train)):\n",
        "        N_filenames_train[i] = os.path.join(n_tr, N_filenames_train[i])\n",
        "\n",
        "for i in range(len(C_filenames_validation)):\n",
        "        C_filenames_validation[i] = os.path.join(c_vld, C_filenames_validation[i])\n",
        "for i in range(len(P_filenames_validation)):\n",
        "        P_filenames_validation[i] = os.path.join(p_vld, P_filenames_validation[i])\n",
        "for i in range(len(N_filenames_validation)):\n",
        "        N_filenames_validation[i] = os.path.join(n_vld, N_filenames_validation[i])\n",
        "\n",
        "df_all_tr = pd.DataFrame({\n",
        "    'filename': N_filenames_train+ P_filenames_train + C_filenames_train ,\n",
        "    'category': c_Zeros_tr + p_Oness_tr     #edit\n",
        "})\n",
        "\n",
        "df_all_tr.head()\n",
        "\n",
        "df_all_vld = pd.DataFrame({\n",
        "    'filename':  N_filenames_validation+ P_filenames_validation + C_filenames_validation ,\n",
        "    'category': c_Zeros_vld + p_Oness_vld  #edit\n",
        "})\n",
        "\"\"\"df = df_t.sample(frac=1)\"\"\"\n",
        "\n",
        "df_all_vld.head()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RJ0vwvqIY67C"
      },
      "source": [
        "Exploratory Data Analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 403
        },
        "id": "ntYtNmulY7-G",
        "outputId": "b57e5030-b23a-4f69-81d7-1e7e09e17462"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Dataset\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Dataset\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "\n",
        "print(\"Training Dataset\")\n",
        "plt.figure(figsize=(12,2))\n",
        "splot = sns.countplot(data = df_all_tr.sort_values(by='category'), y ='category', palette='cool', saturation=0.9)\n",
        "plt.bar_label(container=splot.containers[0],\n",
        "              labels=['Normal', ' COVID+ Viral Pneumonia'], #edit\n",
        "              label_type='center', size=15, color='w')\n",
        "plt.show()\n",
        "\n",
        "print(\"Validation Dataset\")\n",
        "plt.figure(figsize=(12,2))\n",
        "splot = sns.countplot(data = df_all_vld.sort_values(by='category'), y ='category', palette='cool', saturation=0.9)\n",
        "plt.bar_label(container=splot.containers[0],\n",
        "              labels=['Normal', ' COVID+ Viral Pneumonia'], #edit\n",
        "              label_type='center', size=15, color='w')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1f3wVp6ZLkG"
      },
      "source": [
        "Data Visualization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "57jf9jHMZM5y",
        "outputId": "7072860b-8f75-4cbc-d28b-d51fbd7b9ccf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/AI Work/COVID-19 Radiography Database/COVID-19_Radiography_Dataset/Viral Pneumonia/out/Viral Pneumonia-1194.png\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "\n",
        "sample = random.choice(df_all_vld['filename'])\n",
        "image = load_img(sample)\n",
        "print(sample)\n",
        "plt.imshow(image)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Var2ZvpZYLd"
      },
      "source": [
        "batchSize"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8AZdjJjxZZCw"
      },
      "outputs": [],
      "source": [
        "batchSize = 20\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dcI8IuF2Zj-A"
      },
      "source": [
        "no Data Augmentation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K7fPRcYoZk1P"
      },
      "outputs": [],
      "source": [
        "train_data_gen = ImageDataGenerator(\n",
        "    rotation_range=15,\n",
        "    rescale=1./255,\n",
        "    shear_range=0.1,\n",
        "    zoom_range=0.2,\n",
        "    horizontal_flip=True,\n",
        "    width_shift_range=0.1,\n",
        "    height_shift_range=0.1\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-TGAaGTuZsGQ",
        "outputId": "c9e4135f-0734-4f12-ff7e-442b7de25e1e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 2197 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "all_train_generator  = train_data_gen.flow_from_dataframe(\n",
        "    df_all_tr,\n",
        "    x_col='filename',\n",
        "    y_col='category',\n",
        "    target_size=(512,512),\n",
        "    class_mode='categorical',\n",
        "    batch_size=batchSize\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l2dK6RptZwrT",
        "outputId": "44663b00-c9de-42c0-9f61-81877e22601c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 488 validated image filenames belonging to 2 classes.\n"
          ]
        }
      ],
      "source": [
        "valid_data_gen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "all_valid_generator = valid_data_gen.flow_from_dataframe(\n",
        "    df_all_vld,\n",
        "    x_col='filename',\n",
        "    y_col='category',\n",
        "    target_size=(512,512),\n",
        "    class_mode='categorical',\n",
        "    batch_size=batchSize\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LqgfCSVFmhnY"
      },
      "source": [
        "7- Set Learning Rate and Optimizer\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "El6qDMoymksr",
        "outputId": "726852b7-d013-4332-92dc-7d5c224777d9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning rate: 0.001\n",
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_1 (InputLayer)           [(None, 512, 512, 3  0           []                               \n",
            "                                )]                                                                \n",
            "                                                                                                  \n",
            " conv2d (Conv2D)                (None, 512, 512, 32  896         ['input_1[0][0]']                \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " max_pooling2d (MaxPooling2D)   (None, 256, 256, 32  0           ['conv2d[0][0]']                 \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization (BatchNorm  (None, 256, 256, 32  128        ['max_pooling2d[0][0]']          \n",
            " alization)                     )                                                                 \n",
            "                                                                                                  \n",
            " activation (Activation)        (None, 256, 256, 32  0           ['batch_normalization[0][0]']    \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_2 (Conv2D)              (None, 256, 256, 32  1056        ['activation[0][0]']             \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_1 (BatchNo  (None, 256, 256, 32  128        ['conv2d_2[0][0]']               \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " activation_1 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_1[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_3 (Conv2D)              (None, 256, 256, 32  9248        ['activation_1[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_2 (BatchNo  (None, 256, 256, 32  128        ['conv2d_3[0][0]']               \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " activation_2 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_2[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_4 (Conv2D)              (None, 256, 256, 32  1056        ['activation_2[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_1 (Conv2D)              (None, 256, 256, 32  1056        ['max_pooling2d[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add (Add)                      (None, 256, 256, 32  0           ['conv2d_4[0][0]',               \n",
            "                                )                                 'conv2d_1[0][0]']               \n",
            "                                                                                                  \n",
            " max_pooling2d_1 (MaxPooling2D)  (None, 128, 128, 32  0          ['add[0][0]']                    \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_9 (BatchNo  (None, 128, 128, 32  128        ['max_pooling2d_1[0][0]']        \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " activation_9 (Activation)      (None, 128, 128, 32  0           ['batch_normalization_9[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_14 (Conv2D)             (None, 128, 128, 32  1056        ['activation_9[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_10 (BatchN  (None, 128, 128, 32  128        ['conv2d_14[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_10 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_10[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_15 (Conv2D)             (None, 128, 128, 32  9248        ['activation_10[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_11 (BatchN  (None, 128, 128, 32  128        ['conv2d_15[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_11 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_11[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_16 (Conv2D)             (None, 128, 128, 32  1056        ['activation_11[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_13 (Conv2D)             (None, 128, 128, 32  1056        ['max_pooling2d_1[0][0]']        \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_3 (Add)                    (None, 128, 128, 32  0           ['conv2d_16[0][0]',              \n",
            "                                )                                 'conv2d_13[0][0]']              \n",
            "                                                                                                  \n",
            " batch_normalization_12 (BatchN  (None, 128, 128, 32  128        ['add_3[0][0]']                  \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_12 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_12[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_18 (Conv2D)             (None, 128, 128, 32  1056        ['activation_12[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_13 (BatchN  (None, 128, 128, 32  128        ['conv2d_18[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_13 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_13[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_19 (Conv2D)             (None, 128, 128, 32  9248        ['activation_13[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_6 (BatchNo  (None, 256, 256, 32  128        ['add[0][0]']                    \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_14 (BatchN  (None, 128, 128, 32  128        ['conv2d_19[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_6 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_6[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_14 (Activation)     (None, 128, 128, 32  0           ['batch_normalization_14[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_10 (Conv2D)             (None, 256, 256, 32  1056        ['activation_6[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_20 (Conv2D)             (None, 128, 128, 32  1056        ['activation_14[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_17 (Conv2D)             (None, 128, 128, 32  1056        ['add_3[0][0]']                  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_7 (BatchNo  (None, 256, 256, 32  128        ['conv2d_10[0][0]']              \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " add_4 (Add)                    (None, 128, 128, 32  0           ['conv2d_20[0][0]',              \n",
            "                                )                                 'conv2d_17[0][0]']              \n",
            "                                                                                                  \n",
            " activation_7 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_7[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " up_sampling2d (UpSampling2D)   (None, 256, 256, 32  0           ['add_4[0][0]']                  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_11 (Conv2D)             (None, 256, 256, 32  9248        ['activation_7[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_21 (Conv2D)             (None, 256, 256, 32  1056        ['up_sampling2d[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_8 (BatchNo  (None, 256, 256, 32  128        ['conv2d_11[0][0]']              \n",
            " rmalization)                   )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_22 (Conv2D)             (None, 256, 256, 32  1056        ['conv2d_21[0][0]']              \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_8 (Activation)      (None, 256, 256, 32  0           ['batch_normalization_8[0][0]']  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_15 (Activation)     (None, 256, 256, 32  0           ['conv2d_22[0][0]']              \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_12 (Conv2D)             (None, 256, 256, 32  1056        ['activation_8[0][0]']           \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_9 (Conv2D)              (None, 256, 256, 32  1056        ['add[0][0]']                    \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " lambda (Lambda)                (None, 256, 256, 32  0           ['activation_15[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_2 (Add)                    (None, 256, 256, 32  0           ['conv2d_12[0][0]',              \n",
            "                                )                                 'conv2d_9[0][0]']               \n",
            "                                                                                                  \n",
            " multiply (Multiply)            (None, 256, 256, 32  0           ['lambda[0][0]',                 \n",
            "                                )                                 'add_2[0][0]']                  \n",
            "                                                                                                  \n",
            " batch_normalization_15 (BatchN  (None, 256, 256, 32  128        ['multiply[0][0]']               \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_16 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_15[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_24 (Conv2D)             (None, 256, 256, 32  1056        ['activation_16[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_16 (BatchN  (None, 256, 256, 32  128        ['conv2d_24[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_17 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_16[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_25 (Conv2D)             (None, 256, 256, 32  9248        ['activation_17[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_17 (BatchN  (None, 256, 256, 32  128        ['conv2d_25[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_18 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_17[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_26 (Conv2D)             (None, 256, 256, 32  1056        ['activation_18[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_23 (Conv2D)             (None, 256, 256, 32  1056        ['multiply[0][0]']               \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_5 (Add)                    (None, 256, 256, 32  0           ['conv2d_26[0][0]',              \n",
            "                                )                                 'conv2d_23[0][0]']              \n",
            "                                                                                                  \n",
            " batch_normalization_18 (BatchN  (None, 256, 256, 32  128        ['add_5[0][0]']                  \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_19 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_18[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_28 (Conv2D)             (None, 256, 256, 32  1056        ['activation_19[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_19 (BatchN  (None, 256, 256, 32  128        ['conv2d_28[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_20 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_19[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_29 (Conv2D)             (None, 256, 256, 32  9248        ['activation_20[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_20 (BatchN  (None, 256, 256, 32  128        ['conv2d_29[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_21 (Activation)     (None, 256, 256, 32  0           ['batch_normalization_20[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_30 (Conv2D)             (None, 256, 256, 64  2112        ['activation_21[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_27 (Conv2D)             (None, 256, 256, 64  2112        ['add_5[0][0]']                  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_6 (Add)                    (None, 256, 256, 64  0           ['conv2d_30[0][0]',              \n",
            "                                )                                 'conv2d_27[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_2 (MaxPooling2D)  (None, 128, 128, 64  0          ['add_6[0][0]']                  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_21 (BatchN  (None, 128, 128, 64  256        ['max_pooling2d_2[0][0]']        \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_22 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_21[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_32 (Conv2D)             (None, 128, 128, 64  4160        ['activation_22[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_22 (BatchN  (None, 128, 128, 64  256        ['conv2d_32[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_23 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_22[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_33 (Conv2D)             (None, 128, 128, 64  36928       ['activation_23[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_23 (BatchN  (None, 128, 128, 64  256        ['conv2d_33[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_24 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_23[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_34 (Conv2D)             (None, 128, 128, 64  4160        ['activation_24[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_31 (Conv2D)             (None, 128, 128, 64  4160        ['max_pooling2d_2[0][0]']        \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_7 (Add)                    (None, 128, 128, 64  0           ['conv2d_34[0][0]',              \n",
            "                                )                                 'conv2d_31[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_3 (MaxPooling2D)  (None, 64, 64, 64)  0           ['add_7[0][0]']                  \n",
            "                                                                                                  \n",
            " batch_normalization_30 (BatchN  (None, 64, 64, 64)  256         ['max_pooling2d_3[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_31 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_30[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_44 (Conv2D)             (None, 64, 64, 64)   4160        ['activation_31[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_31 (BatchN  (None, 64, 64, 64)  256         ['conv2d_44[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_32 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_31[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_45 (Conv2D)             (None, 64, 64, 64)   36928       ['activation_32[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_32 (BatchN  (None, 64, 64, 64)  256         ['conv2d_45[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_33 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_32[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_46 (Conv2D)             (None, 64, 64, 64)   4160        ['activation_33[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_43 (Conv2D)             (None, 64, 64, 64)   4160        ['max_pooling2d_3[0][0]']        \n",
            "                                                                                                  \n",
            " add_10 (Add)                   (None, 64, 64, 64)   0           ['conv2d_46[0][0]',              \n",
            "                                                                  'conv2d_43[0][0]']              \n",
            "                                                                                                  \n",
            " batch_normalization_33 (BatchN  (None, 64, 64, 64)  256         ['add_10[0][0]']                 \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_34 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_33[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_48 (Conv2D)             (None, 64, 64, 64)   4160        ['activation_34[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_34 (BatchN  (None, 64, 64, 64)  256         ['conv2d_48[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_35 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_34[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_49 (Conv2D)             (None, 64, 64, 64)   36928       ['activation_35[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_27 (BatchN  (None, 128, 128, 64  256        ['add_7[0][0]']                  \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_35 (BatchN  (None, 64, 64, 64)  256         ['conv2d_49[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_28 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_27[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_36 (Activation)     (None, 64, 64, 64)   0           ['batch_normalization_35[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_40 (Conv2D)             (None, 128, 128, 64  4160        ['activation_28[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_50 (Conv2D)             (None, 64, 64, 64)   4160        ['activation_36[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_47 (Conv2D)             (None, 64, 64, 64)   4160        ['add_10[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_28 (BatchN  (None, 128, 128, 64  256        ['conv2d_40[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " add_11 (Add)                   (None, 64, 64, 64)   0           ['conv2d_50[0][0]',              \n",
            "                                                                  'conv2d_47[0][0]']              \n",
            "                                                                                                  \n",
            " activation_29 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_28[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " up_sampling2d_1 (UpSampling2D)  (None, 128, 128, 64  0          ['add_11[0][0]']                 \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_41 (Conv2D)             (None, 128, 128, 64  36928       ['activation_29[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_51 (Conv2D)             (None, 128, 128, 64  4160        ['up_sampling2d_1[0][0]']        \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_29 (BatchN  (None, 128, 128, 64  256        ['conv2d_41[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_52 (Conv2D)             (None, 128, 128, 64  4160        ['conv2d_51[0][0]']              \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_30 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_29[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " activation_37 (Activation)     (None, 128, 128, 64  0           ['conv2d_52[0][0]']              \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_42 (Conv2D)             (None, 128, 128, 64  4160        ['activation_30[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_39 (Conv2D)             (None, 128, 128, 64  4160        ['add_7[0][0]']                  \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " lambda_1 (Lambda)              (None, 128, 128, 64  0           ['activation_37[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_9 (Add)                    (None, 128, 128, 64  0           ['conv2d_42[0][0]',              \n",
            "                                )                                 'conv2d_39[0][0]']              \n",
            "                                                                                                  \n",
            " multiply_1 (Multiply)          (None, 128, 128, 64  0           ['lambda_1[0][0]',               \n",
            "                                )                                 'add_9[0][0]']                  \n",
            "                                                                                                  \n",
            " batch_normalization_36 (BatchN  (None, 128, 128, 64  256        ['multiply_1[0][0]']             \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_38 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_36[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_54 (Conv2D)             (None, 128, 128, 64  4160        ['activation_38[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_37 (BatchN  (None, 128, 128, 64  256        ['conv2d_54[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_39 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_37[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_55 (Conv2D)             (None, 128, 128, 64  36928       ['activation_39[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_38 (BatchN  (None, 128, 128, 64  256        ['conv2d_55[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_40 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_38[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_56 (Conv2D)             (None, 128, 128, 64  4160        ['activation_40[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_53 (Conv2D)             (None, 128, 128, 64  4160        ['multiply_1[0][0]']             \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " add_12 (Add)                   (None, 128, 128, 64  0           ['conv2d_56[0][0]',              \n",
            "                                )                                 'conv2d_53[0][0]']              \n",
            "                                                                                                  \n",
            " batch_normalization_39 (BatchN  (None, 128, 128, 64  256        ['add_12[0][0]']                 \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_41 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_39[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_58 (Conv2D)             (None, 128, 128, 64  4160        ['activation_41[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_40 (BatchN  (None, 128, 128, 64  256        ['conv2d_58[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_42 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_40[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_59 (Conv2D)             (None, 128, 128, 64  36928       ['activation_42[0][0]']          \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " batch_normalization_41 (BatchN  (None, 128, 128, 64  256        ['conv2d_59[0][0]']              \n",
            " ormalization)                  )                                                                 \n",
            "                                                                                                  \n",
            " activation_43 (Activation)     (None, 128, 128, 64  0           ['batch_normalization_41[0][0]'] \n",
            "                                )                                                                 \n",
            "                                                                                                  \n",
            " conv2d_60 (Conv2D)             (None, 128, 128, 12  8320        ['activation_43[0][0]']          \n",
            "                                8)                                                                \n",
            "                                                                                                  \n",
            " conv2d_57 (Conv2D)             (None, 128, 128, 12  8320        ['add_12[0][0]']                 \n",
            "                                8)                                                                \n",
            "                                                                                                  \n",
            " add_13 (Add)                   (None, 128, 128, 12  0           ['conv2d_60[0][0]',              \n",
            "                                8)                                'conv2d_57[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_4 (MaxPooling2D)  (None, 64, 64, 128)  0          ['add_13[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_42 (BatchN  (None, 64, 64, 128)  512        ['max_pooling2d_4[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_44 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_42[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_62 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_44[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_43 (BatchN  (None, 64, 64, 128)  512        ['conv2d_62[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_45 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_43[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_63 (Conv2D)             (None, 64, 64, 128)  147584      ['activation_45[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_44 (BatchN  (None, 64, 64, 128)  512        ['conv2d_63[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_46 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_44[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_64 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_46[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_61 (Conv2D)             (None, 64, 64, 128)  16512       ['max_pooling2d_4[0][0]']        \n",
            "                                                                                                  \n",
            " add_14 (Add)                   (None, 64, 64, 128)  0           ['conv2d_64[0][0]',              \n",
            "                                                                  'conv2d_61[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_5 (MaxPooling2D)  (None, 32, 32, 128)  0          ['add_14[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_51 (BatchN  (None, 32, 32, 128)  512        ['max_pooling2d_5[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_53 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_51[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_74 (Conv2D)             (None, 32, 32, 128)  16512       ['activation_53[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_52 (BatchN  (None, 32, 32, 128)  512        ['conv2d_74[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_54 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_52[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_75 (Conv2D)             (None, 32, 32, 128)  147584      ['activation_54[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_53 (BatchN  (None, 32, 32, 128)  512        ['conv2d_75[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_55 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_53[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_76 (Conv2D)             (None, 32, 32, 128)  16512       ['activation_55[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_73 (Conv2D)             (None, 32, 32, 128)  16512       ['max_pooling2d_5[0][0]']        \n",
            "                                                                                                  \n",
            " add_17 (Add)                   (None, 32, 32, 128)  0           ['conv2d_76[0][0]',              \n",
            "                                                                  'conv2d_73[0][0]']              \n",
            "                                                                                                  \n",
            " batch_normalization_54 (BatchN  (None, 32, 32, 128)  512        ['add_17[0][0]']                 \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_56 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_54[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_78 (Conv2D)             (None, 32, 32, 128)  16512       ['activation_56[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_55 (BatchN  (None, 32, 32, 128)  512        ['conv2d_78[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_57 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_55[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_79 (Conv2D)             (None, 32, 32, 128)  147584      ['activation_57[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_48 (BatchN  (None, 64, 64, 128)  512        ['add_14[0][0]']                 \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " batch_normalization_56 (BatchN  (None, 32, 32, 128)  512        ['conv2d_79[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_50 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_48[0][0]'] \n",
            "                                                                                                  \n",
            " activation_58 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_56[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_70 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_50[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_80 (Conv2D)             (None, 32, 32, 128)  16512       ['activation_58[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_77 (Conv2D)             (None, 32, 32, 128)  16512       ['add_17[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_49 (BatchN  (None, 64, 64, 128)  512        ['conv2d_70[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " add_18 (Add)                   (None, 32, 32, 128)  0           ['conv2d_80[0][0]',              \n",
            "                                                                  'conv2d_77[0][0]']              \n",
            "                                                                                                  \n",
            " activation_51 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_49[0][0]'] \n",
            "                                                                                                  \n",
            " up_sampling2d_2 (UpSampling2D)  (None, 64, 64, 128)  0          ['add_18[0][0]']                 \n",
            "                                                                                                  \n",
            " conv2d_71 (Conv2D)             (None, 64, 64, 128)  147584      ['activation_51[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_81 (Conv2D)             (None, 64, 64, 128)  16512       ['up_sampling2d_2[0][0]']        \n",
            "                                                                                                  \n",
            " batch_normalization_50 (BatchN  (None, 64, 64, 128)  512        ['conv2d_71[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " conv2d_82 (Conv2D)             (None, 64, 64, 128)  16512       ['conv2d_81[0][0]']              \n",
            "                                                                                                  \n",
            " activation_52 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_50[0][0]'] \n",
            "                                                                                                  \n",
            " activation_59 (Activation)     (None, 64, 64, 128)  0           ['conv2d_82[0][0]']              \n",
            "                                                                                                  \n",
            " conv2d_72 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_52[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_69 (Conv2D)             (None, 64, 64, 128)  16512       ['add_14[0][0]']                 \n",
            "                                                                                                  \n",
            " lambda_2 (Lambda)              (None, 64, 64, 128)  0           ['activation_59[0][0]']          \n",
            "                                                                                                  \n",
            " add_16 (Add)                   (None, 64, 64, 128)  0           ['conv2d_72[0][0]',              \n",
            "                                                                  'conv2d_69[0][0]']              \n",
            "                                                                                                  \n",
            " multiply_2 (Multiply)          (None, 64, 64, 128)  0           ['lambda_2[0][0]',               \n",
            "                                                                  'add_16[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_57 (BatchN  (None, 64, 64, 128)  512        ['multiply_2[0][0]']             \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_60 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_57[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_84 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_60[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_58 (BatchN  (None, 64, 64, 128)  512        ['conv2d_84[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_61 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_58[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_85 (Conv2D)             (None, 64, 64, 128)  147584      ['activation_61[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_59 (BatchN  (None, 64, 64, 128)  512        ['conv2d_85[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_62 (Activation)     (None, 64, 64, 128)  0           ['batch_normalization_59[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_86 (Conv2D)             (None, 64, 64, 128)  16512       ['activation_62[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_83 (Conv2D)             (None, 64, 64, 128)  16512       ['multiply_2[0][0]']             \n",
            "                                                                                                  \n",
            " add_19 (Add)                   (None, 64, 64, 128)  0           ['conv2d_86[0][0]',              \n",
            "                                                                  'conv2d_83[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_6 (MaxPooling2D)  (None, 32, 32, 128)  0          ['add_19[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_60 (BatchN  (None, 32, 32, 128)  512        ['max_pooling2d_6[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_63 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_60[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_88 (Conv2D)             (None, 32, 32, 128)  16512       ['activation_63[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_61 (BatchN  (None, 32, 32, 128)  512        ['conv2d_88[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_64 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_61[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_89 (Conv2D)             (None, 32, 32, 128)  147584      ['activation_64[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_62 (BatchN  (None, 32, 32, 128)  512        ['conv2d_89[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_65 (Activation)     (None, 32, 32, 128)  0           ['batch_normalization_62[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_90 (Conv2D)             (None, 32, 32, 256)  33024       ['activation_65[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_87 (Conv2D)             (None, 32, 32, 256)  33024       ['max_pooling2d_6[0][0]']        \n",
            "                                                                                                  \n",
            " add_20 (Add)                   (None, 32, 32, 256)  0           ['conv2d_90[0][0]',              \n",
            "                                                                  'conv2d_87[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_7 (MaxPooling2D)  (None, 16, 16, 256)  0          ['add_20[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_63 (BatchN  (None, 16, 16, 256)  1024       ['max_pooling2d_7[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_66 (Activation)     (None, 16, 16, 256)  0           ['batch_normalization_63[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_92 (Conv2D)             (None, 16, 16, 256)  65792       ['activation_66[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_64 (BatchN  (None, 16, 16, 256)  1024       ['conv2d_92[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_67 (Activation)     (None, 16, 16, 256)  0           ['batch_normalization_64[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_93 (Conv2D)             (None, 16, 16, 256)  590080      ['activation_67[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_65 (BatchN  (None, 16, 16, 256)  1024       ['conv2d_93[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_68 (Activation)     (None, 16, 16, 256)  0           ['batch_normalization_65[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_94 (Conv2D)             (None, 16, 16, 512)  131584      ['activation_68[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_91 (Conv2D)             (None, 16, 16, 512)  131584      ['max_pooling2d_7[0][0]']        \n",
            "                                                                                                  \n",
            " add_21 (Add)                   (None, 16, 16, 512)  0           ['conv2d_94[0][0]',              \n",
            "                                                                  'conv2d_91[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_8 (MaxPooling2D)  (None, 8, 8, 512)   0           ['add_21[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_66 (BatchN  (None, 8, 8, 512)   2048        ['max_pooling2d_8[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_69 (Activation)     (None, 8, 8, 512)    0           ['batch_normalization_66[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_96 (Conv2D)             (None, 8, 8, 512)    262656      ['activation_69[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_67 (BatchN  (None, 8, 8, 512)   2048        ['conv2d_96[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_70 (Activation)     (None, 8, 8, 512)    0           ['batch_normalization_67[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_97 (Conv2D)             (None, 8, 8, 512)    2359808     ['activation_70[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_68 (BatchN  (None, 8, 8, 512)   2048        ['conv2d_97[0][0]']              \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_71 (Activation)     (None, 8, 8, 512)    0           ['batch_normalization_68[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_98 (Conv2D)             (None, 8, 8, 512)    262656      ['activation_71[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_95 (Conv2D)             (None, 8, 8, 512)    262656      ['max_pooling2d_8[0][0]']        \n",
            "                                                                                                  \n",
            " add_22 (Add)                   (None, 8, 8, 512)    0           ['conv2d_98[0][0]',              \n",
            "                                                                  'conv2d_95[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_9 (MaxPooling2D)  (None, 4, 4, 512)   0           ['add_22[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization_69 (BatchN  (None, 4, 4, 512)   2048        ['max_pooling2d_9[0][0]']        \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_72 (Activation)     (None, 4, 4, 512)    0           ['batch_normalization_69[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_100 (Conv2D)            (None, 4, 4, 512)    262656      ['activation_72[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_70 (BatchN  (None, 4, 4, 512)   2048        ['conv2d_100[0][0]']             \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_73 (Activation)     (None, 4, 4, 512)    0           ['batch_normalization_70[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_101 (Conv2D)            (None, 4, 4, 512)    2359808     ['activation_73[0][0]']          \n",
            "                                                                                                  \n",
            " batch_normalization_71 (BatchN  (None, 4, 4, 512)   2048        ['conv2d_101[0][0]']             \n",
            " ormalization)                                                                                    \n",
            "                                                                                                  \n",
            " activation_74 (Activation)     (None, 4, 4, 512)    0           ['batch_normalization_71[0][0]'] \n",
            "                                                                                                  \n",
            " conv2d_102 (Conv2D)            (None, 4, 4, 512)    262656      ['activation_74[0][0]']          \n",
            "                                                                                                  \n",
            " conv2d_99 (Conv2D)             (None, 4, 4, 512)    262656      ['max_pooling2d_9[0][0]']        \n",
            "                                                                                                  \n",
            " add_23 (Add)                   (None, 4, 4, 512)    0           ['conv2d_102[0][0]',             \n",
            "                                                                  'conv2d_99[0][0]']              \n",
            "                                                                                                  \n",
            " max_pooling2d_10 (MaxPooling2D  (None, 2, 2, 512)   0           ['add_23[0][0]']                 \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " flatten (Flatten)              (None, 2048)         0           ['max_pooling2d_10[0][0]']       \n",
            "                                                                                                  \n",
            " dense (Dense)                  (None, 2)            4098        ['flatten[0][0]']                \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 8,891,650\n",
            "Trainable params: 8,875,906\n",
            "Non-trainable params: 15,744\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "# define learning rate scheduler\n",
        "def lr_schedule(epoch):\n",
        "    lr = 1e-3\n",
        "    if epoch > 60:\n",
        "        lr *= 1e-3\n",
        "    elif epoch > 20:\n",
        "        lr *= 1e-2\n",
        "    elif epoch > 5:\n",
        "        lr *= 1e-1\n",
        "    print('Learning rate:', lr)\n",
        "    return lr\n",
        "lr_scheduler = LearningRateScheduler(lr_schedule)\n",
        "\n",
        "# define model     #edit\n",
        "model = AttentionResNet56(shape=(512,512,3), in_channel=32, kernel_size=3, n_classes=2, dropout=0.4, regularization=0.01)\n",
        "\n",
        "# define loss, metrics, optimizer\n",
        "# optimizer = SGD(lr = lr_schedule(0), momentum=0.9, nesterov=True)\n",
        "optimizer = Adam( lr_schedule(0) )\n",
        "model.compile(optimizer, loss='categorical_crossentropy', metrics=['accuracy'])\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MtD9A5K5mi-Y"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NDAd2yxumsA9"
      },
      "source": [
        "8-Training and Evaluation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4sJInmXemzck",
        "outputId": "544ae67f-4056-4950-876c-c2fcfee7cf6d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning rate: 0.001\n",
            "Epoch 1/10\n",
            "110/110 [==============================] - 659s 5s/step - loss: 2.5346 - accuracy: 0.7019 - val_loss: 5.4925 - val_accuracy: 0.5000 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 2/10\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.8916 - accuracy: 0.7774 - val_loss: 2.2151 - val_accuracy: 0.5000 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 3/10\n",
            "110/110 [==============================] - 167s 2s/step - loss: 0.7099 - accuracy: 0.7779 - val_loss: 2.0056 - val_accuracy: 0.5000 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 4/10\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.5098 - accuracy: 0.8166 - val_loss: 2.0070 - val_accuracy: 0.5000 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 5/10\n",
            "110/110 [==============================] - 159s 1s/step - loss: 0.4658 - accuracy: 0.8361 - val_loss: 1.5461 - val_accuracy: 0.4857 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 6/10\n",
            "110/110 [==============================] - 166s 2s/step - loss: 0.4583 - accuracy: 0.8257 - val_loss: 1.3933 - val_accuracy: 0.6803 - lr: 0.0010\n",
            "Learning rate: 0.0001\n",
            "Epoch 7/10\n",
            "110/110 [==============================] - 165s 1s/step - loss: 0.3440 - accuracy: 0.8753 - val_loss: 0.6120 - val_accuracy: 0.7070 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 8/10\n",
            "110/110 [==============================] - 171s 2s/step - loss: 0.3048 - accuracy: 0.8848 - val_loss: 0.5692 - val_accuracy: 0.7254 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 9/10\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.2791 - accuracy: 0.8917 - val_loss: 0.5337 - val_accuracy: 0.7500 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 10/10\n",
            "110/110 [==============================] - 167s 2s/step - loss: 0.2675 - accuracy: 0.8967 - val_loss: 0.5185 - val_accuracy: 0.7602 - lr: 1.0000e-04\n"
          ]
        }
      ],
      "source": [
        "# training\n",
        "epcPart1 = 10    #edit\n",
        "\n",
        "start = time.time()\n",
        "\n",
        "# usefull callbacks\n",
        "log_dir='Logs/' + '56full'\n",
        "tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
        "\n",
        "history = model.fit(all_train_generator,validation_data = all_valid_generator,epochs = epcPart1,\n",
        "          callbacks=[tensorboard_callback, lr_scheduler])\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "raIBAmNYHJY7"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-n-pc-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gTHkmhQfsIAj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0885d8f9-8d3f-458b-e4ab-371063c0bd43"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning rate: 0.0001\n",
            "Epoch 11/25\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.2147 - accuracy: 0.9153 - val_loss: 0.4099 - val_accuracy: 0.8074 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 12/25\n",
            "110/110 [==============================] - 159s 1s/step - loss: 0.2017 - accuracy: 0.9322 - val_loss: 0.4693 - val_accuracy: 0.7787 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 13/25\n",
            "110/110 [==============================] - 166s 2s/step - loss: 0.1880 - accuracy: 0.9267 - val_loss: 0.4576 - val_accuracy: 0.7828 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 14/25\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.2000 - accuracy: 0.9290 - val_loss: 0.4307 - val_accuracy: 0.8053 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 15/25\n",
            "110/110 [==============================] - 167s 2s/step - loss: 0.2018 - accuracy: 0.9308 - val_loss: 0.4150 - val_accuracy: 0.8094 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 16/25\n",
            "110/110 [==============================] - 170s 2s/step - loss: 0.1926 - accuracy: 0.9313 - val_loss: 0.3588 - val_accuracy: 0.8361 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 17/25\n",
            "110/110 [==============================] - 168s 2s/step - loss: 0.1767 - accuracy: 0.9404 - val_loss: 0.4195 - val_accuracy: 0.8074 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 18/25\n",
            "110/110 [==============================] - 164s 1s/step - loss: 0.1970 - accuracy: 0.9244 - val_loss: 0.4383 - val_accuracy: 0.8299 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 19/25\n",
            "110/110 [==============================] - 168s 2s/step - loss: 0.1756 - accuracy: 0.9381 - val_loss: 0.3863 - val_accuracy: 0.8238 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 20/25\n",
            "110/110 [==============================] - 167s 2s/step - loss: 0.1755 - accuracy: 0.9404 - val_loss: 0.4180 - val_accuracy: 0.8115 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 21/25\n",
            "110/110 [==============================] - 171s 2s/step - loss: 0.1815 - accuracy: 0.9345 - val_loss: 0.4232 - val_accuracy: 0.8094 - lr: 1.0000e-04\n",
            "Learning rate: 1e-05\n",
            "Epoch 22/25\n",
            "110/110 [==============================] - 168s 2s/step - loss: 0.1486 - accuracy: 0.9458 - val_loss: 0.4066 - val_accuracy: 0.8176 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 23/25\n",
            "110/110 [==============================] - 169s 2s/step - loss: 0.1568 - accuracy: 0.9472 - val_loss: 0.3831 - val_accuracy: 0.8238 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 24/25\n",
            "110/110 [==============================] - 166s 1s/step - loss: 0.1498 - accuracy: 0.9554 - val_loss: 0.3733 - val_accuracy: 0.8258 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 25/25\n",
            "110/110 [==============================] - 165s 1s/step - loss: 0.1426 - accuracy: 0.9536 - val_loss: 0.3756 - val_accuracy: 0.8299 - lr: 1.0000e-05\n"
          ]
        }
      ],
      "source": [
        "# training contenuis\n",
        "epcPart2 = epcPart1+15\n",
        "\n",
        "\n",
        "history = model.fit(all_train_generator,validation_data = all_valid_generator,epochs = epcPart2,\n",
        "          callbacks=[tensorboard_callback, lr_scheduler],initial_epoch= epcPart1)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vftg-0jRHOL9"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-n-pc-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZNHvRMszrvY7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fea7cb15-09ab-4d05-9a07-a040cd75d907"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning rate: 1e-05\n",
            "Epoch 26/40\n",
            "110/110 [==============================] - 167s 2s/step - loss: 0.1480 - accuracy: 0.9558 - val_loss: 0.3716 - val_accuracy: 0.8340 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 27/40\n",
            "110/110 [==============================] - 170s 2s/step - loss: 0.1374 - accuracy: 0.9518 - val_loss: 0.3624 - val_accuracy: 0.8361 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 28/40\n",
            "110/110 [==============================] - 168s 2s/step - loss: 0.1566 - accuracy: 0.9454 - val_loss: 0.3859 - val_accuracy: 0.8320 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 29/40\n",
            "110/110 [==============================] - 169s 2s/step - loss: 0.1376 - accuracy: 0.9536 - val_loss: 0.3690 - val_accuracy: 0.8443 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 30/40\n",
            "110/110 [==============================] - 161s 1s/step - loss: 0.1454 - accuracy: 0.9549 - val_loss: 0.3601 - val_accuracy: 0.8443 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 31/40\n",
            "110/110 [==============================] - 152s 1s/step - loss: 0.1365 - accuracy: 0.9531 - val_loss: 0.3726 - val_accuracy: 0.8320 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 32/40\n",
            "110/110 [==============================] - 147s 1s/step - loss: 0.1503 - accuracy: 0.9495 - val_loss: 0.3530 - val_accuracy: 0.8545 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 33/40\n",
            "110/110 [==============================] - 150s 1s/step - loss: 0.1310 - accuracy: 0.9586 - val_loss: 0.3750 - val_accuracy: 0.8443 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 34/40\n",
            "110/110 [==============================] - 149s 1s/step - loss: 0.1317 - accuracy: 0.9518 - val_loss: 0.3698 - val_accuracy: 0.8463 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 35/40\n",
            "110/110 [==============================] - 149s 1s/step - loss: 0.1392 - accuracy: 0.9499 - val_loss: 0.3623 - val_accuracy: 0.8484 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 36/40\n",
            "110/110 [==============================] - 149s 1s/step - loss: 0.1407 - accuracy: 0.9563 - val_loss: 0.3753 - val_accuracy: 0.8422 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 37/40\n",
            "110/110 [==============================] - 149s 1s/step - loss: 0.1362 - accuracy: 0.9540 - val_loss: 0.3736 - val_accuracy: 0.8443 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 38/40\n",
            "110/110 [==============================] - 149s 1s/step - loss: 0.1294 - accuracy: 0.9581 - val_loss: 0.3700 - val_accuracy: 0.8504 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 39/40\n",
            "110/110 [==============================] - 151s 1s/step - loss: 0.1377 - accuracy: 0.9549 - val_loss: 0.3692 - val_accuracy: 0.8463 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 40/40\n",
            "110/110 [==============================] - 152s 1s/step - loss: 0.1289 - accuracy: 0.9527 - val_loss: 0.3768 - val_accuracy: 0.8484 - lr: 1.0000e-05\n",
            "Time taken by above cell in minutes is 143.91114190419515.\n"
          ]
        }
      ],
      "source": [
        "# training contenuis\n",
        "epcPart3 = epcPart2+15\n",
        "\n",
        "\n",
        "history = model.fit(all_train_generator,validation_data = all_valid_generator,epochs = epcPart3,\n",
        "          callbacks=[tensorboard_callback, lr_scheduler],initial_epoch= epcPart2)\n",
        "\n",
        "end = time.time()\n",
        "print(\"Time taken by above cell in minutes is {}.\".format((end-start)/60))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OGDi8oDVbTvK"
      },
      "source": [
        "Saving Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PC8zkhoTbNzK"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-n-pc-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkOyHSL0heJ_"
      },
      "source": [
        "test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "JHaXJGyvhfdf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a797b7e8-9af2-4f7c-ce05-4daa7276a4ff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25/25 [==============================] - 7s 282ms/step - loss: 0.3768 - accuracy: 0.8484\n",
            "validation loss: 0.37681877613067627\n",
            "validation accuracy: 0.8483606576919556\n"
          ]
        }
      ],
      "source": [
        "\n",
        "# evaluation\n",
        "val_scores = model.evaluate_generator(all_valid_generator, verbose=1)\n",
        "print('validation loss:', val_scores[0])\n",
        "print('validation accuracy:', val_scores[1])\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7mrn1bYkbbhs"
      },
      "source": [
        "Plotting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "jTsf7L82bdJC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 818
        },
        "outputId": "0f9f213e-dcda-4d7d-88cf-609143b7109a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x1200 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 12))\n",
        "ax1.plot(history.history['loss'], color='b', label=\"Training loss\")\n",
        "ax1.plot(history.history['val_loss'], color='r', label=\"validation loss\")\n",
        "ax1.set_xticks(np.arange(1, epcPart3, 1))\n",
        "ax1.set_yticks(np.arange(0, 1, 0.1))\n",
        "\n",
        "ax2.plot(history.history['accuracy'], color='b', label=\"Training accuracy\")\n",
        "ax2.plot(history.history['val_accuracy'], color='r',label=\"Validation accuracy\")\n",
        "ax2.set_xticks(np.arange(1, epcPart3, 1))\n",
        "\n",
        "legend = plt.legend(loc='best', shadow=True)\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j6BiDC9Pm5PS"
      },
      "source": [
        "9-Performance Analysis\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kaerE17Mnesw"
      },
      "outputs": [],
      "source": [
        "%load_ext tensorboard\n",
        "%tensorboard --logdir Logs/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b3zUt0Yfbnuj"
      },
      "source": [
        "Model Testing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "w8hwmMMrbpgV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 539
        },
        "outputId": "5a73f773-434a-48f3-8a5b-5b404e185c87"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True value is : Viral Pneumonia\n",
            "1/1 [==============================] - 2s 2s/step\n",
            "[[0.06780254 0.93219745]]\n",
            "Prediction is:\n",
            "Viral Pneumonia\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f45ac4bd7e0>"
            ]
          },
          "metadata": {},
          "execution_count": 29
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "sample = random.choice(df_all_vld['filename'])\n",
        "\n",
        "fileLastname = sample.split('/')[-1:][0]\n",
        "category = fileLastname.split('-')[0]\n",
        "true = ''\n",
        "if category == 'COVID':\n",
        "    true = 'COVID'\n",
        "elif category == 'Viral Pneumonia':\n",
        "    true = 'Viral Pneumonia'\n",
        "elif category == 'Normal':\n",
        "    true = 'Normal'\n",
        "\n",
        "print(f'True value is : {true}')\n",
        "\n",
        "image = load_img(sample, target_size=(512, 512))\n",
        "img = img_to_array(image)\n",
        "img = img.reshape((1, 512, 512, 3))\n",
        "img=img.astype('float32')/ 255.0\n",
        "\n",
        "result = model.predict(img)\n",
        "print(result)\n",
        "result = np.argmax(result, axis=-1)\n",
        "print('Prediction is:')\n",
        "if result == 2:\n",
        "    print(\"Normal\")\n",
        "elif result == 1:\n",
        "    print(\"Viral Pneumonia\")\n",
        "elif result == 0:\n",
        "    print(\"COVID +\", result)\n",
        "else:\n",
        "  print(\"none\")\n",
        "plt.imshow(image)\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "T4",
      "mount_file_id": "1JWiEsatI_GDmd2srl7xmRs9LSrwTnl7x",
      "authorship_tag": "ABX9TyPuwwiahxWyvhrwmDvNCwu9",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}