2class_c_pn_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_c_pn_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   c & p n   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": "283e3ba5-78f4-4057-cf97-1640d49058c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fri Jul  7 16:30:02 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   35C    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 13.6 gigabytes of available RAM\n",
            "\n",
            "Not 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:1100]\n",
        "P_filenames_train = os.listdir(p_tr)[1:550]\n",
        "N_filenames_train = os.listdir(n_tr)[1:550]\n",
        "\n",
        "C_filenames_validation = os.listdir(c_vld)[1:245]\n",
        "P_filenames_validation = os.listdir(p_vld)[1:123]\n",
        "N_filenames_validation = os.listdir(n_vld)[1:123]\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 C_filenames_train:\n",
        "    c_Zeros_tr.append(str(0))\n",
        "p_Oness_tr = []\n",
        "for filename in P_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 C_filenames_validation:\n",
        "    c_Zeros_vld.append(str(0))\n",
        "p_Oness_vld = []\n",
        "for filename in P_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": "7b20d187-adf3-4e28-ed53-e98b9829a2ff"
      },
      "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-a7fa3924-b267-4b0f-ac20-f802d41c3650\">\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-a7fa3924-b267-4b0f-ac20-f802d41c3650')\"\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-a7fa3924-b267-4b0f-ac20-f802d41c3650 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-a7fa3924-b267-4b0f-ac20-f802d41c3650');\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': C_filenames_train + P_filenames_train + N_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': C_filenames_validation + P_filenames_validation + N_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": 448
        },
        "id": "ntYtNmulY7-G",
        "outputId": "aaef3585-2ed0-4ef3-9049-cdefd8bfc41a"
      },
      "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=['COVID', 'Viral Pneumonia + Normal'], #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=['COVID', 'Viral Pneumonia + Normal'], #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": "990395a2-b25b-4fce-9e74-06f6ea082fee"
      },
      "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 = 15\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": "a58427e4-2ddd-4c6d-bbc8-656f8d2ea5f8"
      },
      "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": "7b756b2e-87fa-4946-b08f-bda6e41aab18"
      },
      "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": "e580d771-30d9-4f89-9a5d-56a573fc775d"
      },
      "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",
      "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"
      ],
      "metadata": {
        "id": "PBNy8VU9NI9x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4sJInmXemzck",
        "outputId": "e9fab812-ea51-4aec-9a11-e9e68e56a722"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Learning rate: 0.001\n",
            "Epoch 1/10\n",
            "147/147 [==============================] - 803s 5s/step - loss: 2.0664 - accuracy: 0.7610 - val_loss: 0.9239 - val_accuracy: 0.5266 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 2/10\n",
            "147/147 [==============================] - 228s 2s/step - loss: 0.6059 - accuracy: 0.8311 - val_loss: 0.6434 - val_accuracy: 0.7090 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 3/10\n",
            "147/147 [==============================] - 227s 2s/step - loss: 0.4534 - accuracy: 0.8644 - val_loss: 0.7329 - val_accuracy: 0.5389 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 4/10\n",
            "147/147 [==============================] - 228s 2s/step - loss: 0.3601 - accuracy: 0.8798 - val_loss: 0.6949 - val_accuracy: 0.6270 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 5/10\n",
            "147/147 [==============================] - 226s 2s/step - loss: 0.3340 - accuracy: 0.8848 - val_loss: 0.4869 - val_accuracy: 0.7910 - lr: 0.0010\n",
            "Learning rate: 0.001\n",
            "Epoch 6/10\n",
            "147/147 [==============================] - 227s 2s/step - loss: 0.2808 - accuracy: 0.9049 - val_loss: 0.8444 - val_accuracy: 0.6270 - lr: 0.0010\n",
            "Learning rate: 0.0001\n",
            "Epoch 7/10\n",
            "147/147 [==============================] - 258s 2s/step - loss: 0.2266 - accuracy: 0.9213 - val_loss: 0.4082 - val_accuracy: 0.8176 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 8/10\n",
            "147/147 [==============================] - 221s 2s/step - loss: 0.2020 - accuracy: 0.9349 - val_loss: 0.3971 - val_accuracy: 0.7869 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 9/10\n",
            "147/147 [==============================] - 239s 2s/step - loss: 0.1971 - accuracy: 0.9322 - val_loss: 0.3991 - val_accuracy: 0.8053 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 10/10\n",
            "147/147 [==============================] - 228s 2s/step - loss: 0.1858 - accuracy: 0.9413 - val_loss: 0.3552 - val_accuracy: 0.8422 - lr: 1.0000e-04\n"
          ]
        }
      ],
      "source": [
        "# training\n",
        "\n",
        "history = model.fit(all_train_generator,validation_data = all_valid_generator,epochs = epcPart1,\n",
        "          callbacks=[tensorboard_callback, lr_scheduler])\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T7wmScKcDl1n"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-c-pn-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "idIpsHrGDnFN",
        "outputId": "73484c5b-8685-4fc4-f1d5-c8baa372ecb3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Learning rate: 0.0001\n",
            "Epoch 11/25\n",
            "147/147 [==============================] - 229s 2s/step - loss: 0.1795 - accuracy: 0.9349 - val_loss: 0.4161 - val_accuracy: 0.8258 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 12/25\n",
            "147/147 [==============================] - 228s 2s/step - loss: 0.1697 - accuracy: 0.9467 - val_loss: 0.3756 - val_accuracy: 0.8258 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 13/25\n",
            "147/147 [==============================] - 232s 2s/step - loss: 0.1767 - accuracy: 0.9449 - val_loss: 0.3510 - val_accuracy: 0.8361 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 14/25\n",
            "147/147 [==============================] - 226s 2s/step - loss: 0.1663 - accuracy: 0.9440 - val_loss: 0.5148 - val_accuracy: 0.8115 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 15/25\n",
            "147/147 [==============================] - 226s 2s/step - loss: 0.1565 - accuracy: 0.9504 - val_loss: 0.3509 - val_accuracy: 0.8299 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 16/25\n",
            "147/147 [==============================] - 227s 2s/step - loss: 0.1677 - accuracy: 0.9449 - val_loss: 0.4023 - val_accuracy: 0.8074 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 17/25\n",
            "147/147 [==============================] - 224s 2s/step - loss: 0.1650 - accuracy: 0.9445 - val_loss: 0.2734 - val_accuracy: 0.8893 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 18/25\n",
            "147/147 [==============================] - 224s 2s/step - loss: 0.1583 - accuracy: 0.9436 - val_loss: 0.3409 - val_accuracy: 0.8402 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 19/25\n",
            "147/147 [==============================] - 221s 1s/step - loss: 0.1499 - accuracy: 0.9527 - val_loss: 0.3489 - val_accuracy: 0.8422 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 20/25\n",
            "147/147 [==============================] - 218s 1s/step - loss: 0.1381 - accuracy: 0.9572 - val_loss: 0.4186 - val_accuracy: 0.7951 - lr: 1.0000e-04\n",
            "Learning rate: 0.0001\n",
            "Epoch 21/25\n",
            "147/147 [==============================] - 220s 1s/step - loss: 0.1559 - accuracy: 0.9472 - val_loss: 0.3765 - val_accuracy: 0.8525 - lr: 1.0000e-04\n",
            "Learning rate: 1e-05\n",
            "Epoch 22/25\n",
            "147/147 [==============================] - 218s 1s/step - loss: 0.1400 - accuracy: 0.9563 - val_loss: 0.3055 - val_accuracy: 0.8811 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 23/25\n",
            "147/147 [==============================] - 216s 1s/step - loss: 0.1241 - accuracy: 0.9668 - val_loss: 0.2925 - val_accuracy: 0.8955 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 24/25\n",
            "147/147 [==============================] - 216s 1s/step - loss: 0.1160 - accuracy: 0.9654 - val_loss: 0.2824 - val_accuracy: 0.8934 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 25/25\n",
            "147/147 [==============================] - 214s 1s/step - loss: 0.1140 - accuracy: 0.9672 - val_loss: 0.2861 - val_accuracy: 0.8955 - lr: 1.0000e-05\n"
          ]
        }
      ],
      "source": [
        "# training contenuis\n",
        "epcPart2 = epcPart1+15\n",
        "\n",
        "\n",
        "history2 = model.fit(all_train_generator,validation_data = all_valid_generator,epochs = epcPart2,\n",
        "          callbacks=[tensorboard_callback, lr_scheduler],initial_epoch= epcPart1)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "QrNsZKhrDkFO"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-c-pn-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#temp code\n",
        "#\n",
        "#\n",
        "#\n",
        "epcPart2=25\n",
        "model = load_model('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-c-pn-m2-6-7.h5')\n",
        "\n",
        "#"
      ],
      "metadata": {
        "id": "eJ5X5MydMp15"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tXjqhF7RDlYn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b5f56b83-d3bf-4e87-ff4e-61aa173c010b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Learning rate: 1e-05\n",
            "Epoch 26/40\n",
            "147/147 [==============================] - 963s 6s/step - loss: 0.1241 - accuracy: 0.9650 - val_loss: 0.2825 - val_accuracy: 0.8893 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 27/40\n",
            "147/147 [==============================] - 191s 1s/step - loss: 0.1090 - accuracy: 0.9750 - val_loss: 0.2807 - val_accuracy: 0.8996 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 28/40\n",
            "147/147 [==============================] - 192s 1s/step - loss: 0.1104 - accuracy: 0.9677 - val_loss: 0.2959 - val_accuracy: 0.8791 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 29/40\n",
            "147/147 [==============================] - 193s 1s/step - loss: 0.1106 - accuracy: 0.9640 - val_loss: 0.3236 - val_accuracy: 0.8402 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 30/40\n",
            "147/147 [==============================] - 196s 1s/step - loss: 0.1078 - accuracy: 0.9645 - val_loss: 0.2892 - val_accuracy: 0.8873 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 31/40\n",
            "147/147 [==============================] - 194s 1s/step - loss: 0.1000 - accuracy: 0.9709 - val_loss: 0.2788 - val_accuracy: 0.8955 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 32/40\n",
            "147/147 [==============================] - 193s 1s/step - loss: 0.1081 - accuracy: 0.9695 - val_loss: 0.2629 - val_accuracy: 0.9078 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 33/40\n",
            "147/147 [==============================] - 194s 1s/step - loss: 0.1084 - accuracy: 0.9713 - val_loss: 0.2806 - val_accuracy: 0.8934 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 34/40\n",
            "147/147 [==============================] - 194s 1s/step - loss: 0.1037 - accuracy: 0.9718 - val_loss: 0.2623 - val_accuracy: 0.8996 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 35/40\n",
            "147/147 [==============================] - 195s 1s/step - loss: 0.1091 - accuracy: 0.9677 - val_loss: 0.2625 - val_accuracy: 0.9160 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 36/40\n",
            "147/147 [==============================] - 197s 1s/step - loss: 0.1055 - accuracy: 0.9718 - val_loss: 0.2922 - val_accuracy: 0.8873 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 37/40\n",
            "147/147 [==============================] - 194s 1s/step - loss: 0.0967 - accuracy: 0.9759 - val_loss: 0.2521 - val_accuracy: 0.9098 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 38/40\n",
            "147/147 [==============================] - 192s 1s/step - loss: 0.1015 - accuracy: 0.9731 - val_loss: 0.2694 - val_accuracy: 0.9098 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 39/40\n",
            "147/147 [==============================] - 189s 1s/step - loss: 0.0978 - accuracy: 0.9718 - val_loss: 0.2786 - val_accuracy: 0.8996 - lr: 1.0000e-05\n",
            "Learning rate: 1e-05\n",
            "Epoch 40/40\n",
            "147/147 [==============================] - 189s 1s/step - loss: 0.1057 - accuracy: 0.9672 - val_loss: 0.2647 - val_accuracy: 0.9078 - lr: 1.0000e-05\n",
            "Time taken by above cell in minutes is 62.927289779980974.\n"
          ]
        }
      ],
      "source": [
        "# training contenuis\n",
        "epcPart3 = epcPart2+15\n",
        "\n",
        "\n",
        "history3 = 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": 23,
      "metadata": {
        "id": "PC8zkhoTbNzK"
      },
      "outputs": [],
      "source": [
        "model.save('/content/drive/Othercomputers/Hp8570/GoogleDrive_Hp8570/2class-c-pn-m2-6-7.h5')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkOyHSL0heJ_"
      },
      "source": [
        "test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "JHaXJGyvhfdf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "525d3379-41eb-44ac-b5e7-db2278e1e28c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "33/33 [==============================] - 8s 229ms/step - loss: 0.2647 - accuracy: 0.9078\n",
            "validation loss: 0.26473474502563477\n",
            "validation accuracy: 0.9077869057655334\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": 25,
      "metadata": {
        "id": "jTsf7L82bdJC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 236
        },
        "outputId": "80bbe272-6b23-482c-f917-48449b516241"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-25-aa1ebfccf402>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhistoryX\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mhistory\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mhistory2\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mhistory3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0max1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m12\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0max1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhistoryX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'loss'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Training loss\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0max1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhistoryX\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhistory\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'val_loss'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'r'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"validation loss\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'history' is not defined"
          ]
        }
      ],
      "source": [
        "historyX= history + history2+history3\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 12))\n",
        "ax1.plot(historyX.history['loss'], color='b', label=\"Training loss\")\n",
        "ax1.plot(historyX.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(historyX.history['accuracy'], color='b', label=\"Training accuracy\")\n",
        "ax2.plot(historyX.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": null,
      "metadata": {
        "id": "w8hwmMMrbpgV"
      },
      "outputs": [],
      "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(\"Viral Pneumonia+ Normal\")\n",
        "\n",
        "elif result == 0:\n",
        "    print(\"COVID +\", result)\n",
        "else:\n",
        "  print(\"none\")\n",
        "plt.imshow(image)\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "mount_file_id": "1OEdiL-_f-i-1MGK0K8mXEpJfJXd2Kn2H",
      "authorship_tag": "ABX9TyOne/QZ+lOk32lKQdLLb9cA",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}