main.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    },
    "colab": {
      "name": "res_attention2.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukUF48URuqFh"
      },
      "source": [
        "import network_parts\n",
        "import metrics\n",
        "from network_parts import *\n",
        "from metrics import *\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import sklearn.model_selection\n",
        "import cv2 \n",
        "import time\n",
        "import tqdm\n",
        "\n",
        "from tensorflow.keras.utils import plot_model\n",
        "import os\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "import PIL\n",
        "import importlib\n",
        "import tensorflow as tf\n",
        "import tensorflow.keras as keras\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import sklearn.model_selection\n",
        "import cv2 \n",
        "import time\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "from tensorflow.keras.models import *\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras import backend as K\n",
        "from tensorflow.keras.optimizers import *\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from sklearn.model_selection import train_test_split\n",
        "import os\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import nibabel as nib\n",
        "from skimage.exposure import equalize_hist\n",
        "from skimage.exposure import match_histograms\n",
        "from tqdm import tqdm\n",
        "from numpy import load\n",
        "from numpy import zeros\n",
        "from numpy import ones\n",
        "import numpy as np\n",
        "from numpy.random import randint\n",
        "from keras.optimizers import Adam\n",
        "from keras.initializers import RandomNormal\n",
        "from keras.models import Model\n",
        "from keras.models import Input\n",
        "from keras.layers import Conv2D\n",
        "from keras.layers import Conv2DTranspose\n",
        "from keras.layers import LeakyReLU\n",
        "from keras.layers import Activation\n",
        "from keras.layers import Concatenate\n",
        "from keras.layers import Dropout\n",
        "from keras.layers import BatchNormalization\n",
        "from keras.layers import LeakyReLU\n",
        "from matplotlib import pyplot\n",
        "from os import listdir\n",
        "from numpy import asarray\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "from numpy import vstack\n",
        "from keras.preprocessing.image import img_to_array\n",
        "from keras.preprocessing.image import load_img\n",
        "from numpy import savez_compressed"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YZMbxoou59f",
        "outputId": "ece2d635-c9a3-4163-ff5e-c1e53a921335"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eCfAwQEjuqFh",
        "outputId": "5ad4c137-672c-4fa6-fc0b-7c22ac009d06"
      },
      "source": [
        "# preparing dat\n",
        "fold_number = 5\n",
        "x_test = np.load(f'drive/MyDrive/data/covid/x_test{str(fold_number)}.npy').reshape(-1,256,256).astype('float16')\n",
        "y_test = np.load(f'drive/MyDrive/data/covid/y_test{str(fold_number)}.npy').reshape(-1,2,256,256).astype('float16')\n",
        "\n",
        "\n",
        "x_train = np.load(f'drive/MyDrive/data/covid/x_train{str(fold_number)}.npy').reshape(-1,256,256).astype('float16')\n",
        "y_train = np.load(f'drive/MyDrive/data/covid/y_train{str(fold_number)}.npy').reshape(-1,2,256,256).astype('float16')\n",
        "\n",
        "x_train, x_val, y_train , y_val= train_test_split(x_train,y_train,test_size= 0.2,random_state=47)\n",
        "print('val :',len(x_val))\n",
        "\n",
        "print(x_train.shape)\n",
        "print(x_test.shape)\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "val : 565\n",
            "(2256, 256, 256)\n",
            "(699, 256, 256)\n",
            "(2256, 2, 256, 256)\n",
            "(699, 2, 256, 256)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kRMRFwEUeS_K"
      },
      "source": [
        "tempx = []\n",
        "templ = []\n",
        "tempc = []\n",
        "for i in range(len(x_train)):\n",
        "  if y_train[i,1].sum() > 300 and np.mean(x_train[i]) < 0.07:\n",
        "    # tempx.append(x_train[i].reshape(256,256))\n",
        "    # templ.append(y_train[i,0].reshape(256,256))\n",
        "    # tempc.append(y_train[i,1].reshape(256,256))\n",
        "    mask = np.uint8(y_train[i,1]*255).copy()\n",
        "    covid = np.uint8(y_train[i,1]*x_train[i]*255).copy()\n",
        "    res = np.concatenate([mask,covid],axis=1)\n",
        "    cv2.imwrite(f'maps/train/{str(i)}.png',res)\n",
        "len(tempx)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KUeMXbvfeWtr"
      },
      "source": [
        "\n",
        " \n",
        "# define the discriminator model\n",
        "def define_discriminator(image_shape):\n",
        "\t# weight initialization\n",
        "\tinit = RandomNormal(stddev=0.02)\n",
        "\t# source image input\n",
        "\tin_src_image = Input(shape=image_shape)\n",
        "\t# target image input\n",
        "\tin_target_image = Input(shape=image_shape)\n",
        "\t# concatenate images channel-wise\n",
        "\tmerged = Concatenate()([in_src_image, in_target_image])\n",
        "\t# C64\n",
        "\td = Conv2D(64, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(merged)\n",
        "\td = LeakyReLU(alpha=0.2)(d)\n",
        "\t# C128\n",
        "\td = Conv2D(128, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n",
        "\td = BatchNormalization()(d)\n",
        "\td = LeakyReLU(alpha=0.2)(d)\n",
        "\t# C256\n",
        "\td = Conv2D(256, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n",
        "\td = BatchNormalization()(d)\n",
        "\td = LeakyReLU(alpha=0.2)(d)\n",
        "\t# C512\n",
        "\td = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d)\n",
        "\td = BatchNormalization()(d)\n",
        "\td = LeakyReLU(alpha=0.2)(d)\n",
        "\t# second last output layer\n",
        "\td = Conv2D(512, (4,4), padding='same', kernel_initializer=init)(d)\n",
        "\td = BatchNormalization()(d)\n",
        "\td = LeakyReLU(alpha=0.2)(d)\n",
        "\t# patch output\n",
        "\td = Conv2D(1, (4,4), padding='same', kernel_initializer=init)(d)\n",
        "\tpatch_out = Activation('sigmoid')(d)\n",
        "\t# define model\n",
        "\tmodel = Model([in_src_image, in_target_image], patch_out)\n",
        "\t# compile model\n",
        "\topt = Adam(lr=0.0002, beta_1=0.5)\n",
        "\tmodel.compile(loss='binary_crossentropy', optimizer=opt, loss_weights=[0.5])\n",
        "\treturn model\n",
        " \n",
        "# define an encoder block\n",
        "def define_encoder_block(layer_in, n_filters, batchnorm=True):\n",
        "\t# weight initialization\n",
        "\tinit = RandomNormal(stddev=0.02)\n",
        "\t# add downsampling layer\n",
        "\tg = Conv2D(n_filters, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(layer_in)\n",
        "\t# conditionally add batch normalization\n",
        "\tif batchnorm:\n",
        "\t\tg = BatchNormalization()(g, training=True)\n",
        "\t# leaky relu activation\n",
        "\tg = LeakyReLU(alpha=0.2)(g)\n",
        "\treturn g\n",
        " \n",
        "# define a decoder block\n",
        "def decoder_block(layer_in, skip_in, n_filters, dropout=True):\n",
        "\t# weight initialization\n",
        "\tinit = RandomNormal(stddev=0.02)\n",
        "\t# add upsampling layer\n",
        "\tg = Conv2DTranspose(n_filters, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(layer_in)\n",
        "\t# add batch normalization\n",
        "\tg = BatchNormalization()(g, training=True)\n",
        "\t# conditionally add dropout\n",
        "\tif dropout:\n",
        "\t\tg = Dropout(0.5)(g, training=True)\n",
        "\t# merge with skip connection\n",
        "\tg = Concatenate()([g, skip_in])\n",
        "\t# relu activation\n",
        "\tg = Activation('relu')(g)\n",
        "\treturn g\n",
        " \n",
        "# define the standalone generator model\n",
        "def define_generator(image_shape=(256,256,3)):\n",
        "\t# weight initialization\n",
        "\tinit = RandomNormal(stddev=0.02)\n",
        "\t# image input\n",
        "\tin_image = Input(shape=image_shape)\n",
        "\t# encoder model\n",
        "\te1 = define_encoder_block(in_image, 64, batchnorm=False)\n",
        "\te2 = define_encoder_block(e1, 128)\n",
        "\te3 = define_encoder_block(e2, 256)\n",
        "\te4 = define_encoder_block(e3, 512)\n",
        "\te5 = define_encoder_block(e4, 512)\n",
        "\te6 = define_encoder_block(e5, 512)\n",
        "\te7 = define_encoder_block(e6, 512)\n",
        "\t# bottleneck, no batch norm and relu\n",
        "\tb = Conv2D(512, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(e7)\n",
        "\tb = Activation('relu')(b)\n",
        "\t# decoder model\n",
        "\td1 = decoder_block(b, e7, 512)\n",
        "\td2 = decoder_block(d1, e6, 512)\n",
        "\td3 = decoder_block(d2, e5, 512)\n",
        "\td4 = decoder_block(d3, e4, 512, dropout=False)\n",
        "\td5 = decoder_block(d4, e3, 256, dropout=False)\n",
        "\td6 = decoder_block(d5, e2, 128, dropout=False)\n",
        "\td7 = decoder_block(d6, e1, 64, dropout=False)\n",
        "\t# output\n",
        "\tg = Conv2DTranspose(3, (4,4), strides=(2,2), padding='same', kernel_initializer=init)(d7)\n",
        "\tout_image = Activation('tanh')(g)\n",
        "\t# define model\n",
        "\tmodel = Model(in_image, out_image)\n",
        "\treturn model\n",
        " \n",
        "# define the combined generator and discriminator model, for updating the generator\n",
        "def define_gan(g_model, d_model, image_shape):\n",
        "\t# make weights in the discriminator not trainable\n",
        "\td_model.trainable = False\n",
        "\t# define the source image\n",
        "\tin_src = Input(shape=image_shape)\n",
        "\t# connect the source image to the generator input\n",
        "\tgen_out = g_model(in_src)\n",
        "\t# connect the source input and generator output to the discriminator input\n",
        "\tdis_out = d_model([in_src, gen_out])\n",
        "\t# src image as input, generated image and classification output\n",
        "\tmodel = Model(in_src, [dis_out, gen_out])\n",
        "\t# compile model\n",
        "\topt = Adam(lr=0.0002, beta_1=0.5)\n",
        "\tmodel.compile(loss=['binary_crossentropy', 'mae'], optimizer=opt, loss_weights=[1,100])\n",
        "\treturn model\n",
        " \n",
        "# load and prepare training images\n",
        "def load_real_samples(filename):\n",
        "\t# load compressed arrays\n",
        "\tdata = load(filename)\n",
        "\t# unpack arrays\n",
        "\tX1, X2 = data['arr_0'], data['arr_1']\n",
        "\t# scale from [0,255] to [-1,1]\n",
        "\tX1 = (X1 - 127.5) / 127.5\n",
        "\tX2 = (X2 - 127.5) / 127.5\n",
        "\treturn [X1, X2]\n",
        " \n",
        "# select a batch of random samples, returns images and target\n",
        "def generate_real_samples(dataset, n_samples, patch_shape):\n",
        "\t# unpack dataset\n",
        "\ttrainA, trainB = dataset\n",
        "\t# choose random instances\n",
        "\tix = randint(0, trainA.shape[0], n_samples)\n",
        "\t# retrieve selected images\n",
        "\tX1, X2 = trainA[ix], trainB[ix]\n",
        "\t# generate 'real' class labels (1)\n",
        "\ty = ones((n_samples, patch_shape, patch_shape, 1))\n",
        "\treturn [X1, X2], y\n",
        " \n",
        "# generate a batch of images, returns images and targets\n",
        "def generate_fake_samples(g_model, samples, patch_shape):\n",
        "\t# generate fake instance\n",
        "\tX = g_model.predict(samples)\n",
        "\t# create 'fake' class labels (0)\n",
        "\ty = zeros((len(X), patch_shape, patch_shape, 1))\n",
        "\treturn X, y\n",
        " \n",
        "# generate samples and save as a plot and save the model\n",
        "def summarize_performance(step, g_model, dataset, n_samples=3):\n",
        "  # select a sample of input images\n",
        "  [X_realA, X_realB], _ = generate_real_samples(dataset, n_samples, 1)\n",
        "  # generate a batch of fake samples\n",
        "  X_fakeB, _ = generate_fake_samples(g_model, X_realA, 1)\n",
        "  # scale all pixels from [-1,1] to [0,1]\n",
        "  X_realA = (X_realA + 1) / 2.0\n",
        "  X_realB = (X_realB + 1) / 2.0\n",
        "  X_fakeB = (X_fakeB + 1) / 2.0\n",
        "  # plot real source images\n",
        "  for i in range(n_samples):\n",
        "  \tpyplot.subplot(3, n_samples, 1 + i)\n",
        "  \tpyplot.axis('off')\n",
        "  \tpyplot.imshow(X_realA[i])\n",
        "  for i in range(n_samples):\n",
        "    pyplot.subplot(3, n_samples, 1 + n_samples + i)\n",
        "    pyplot.axis('off')\n",
        "    pyplot.imshow(X_fakeB[i])\n",
        "  for i in range(n_samples):\n",
        "    pyplot.subplot(3, n_samples, 1 + n_samples*2 + i)\n",
        "    pyplot.axis('off')\n",
        "    pyplot.imshow(X_realB[i])\n",
        "\t# save plot to file\n",
        "  filename1 = 'plot_%06d.png' % (step+1)\n",
        "  pyplot.savefig(filename1)\n",
        "  pyplot.close()\n",
        "  # save the generator model\n",
        "  filename2 = 'drive/MyDrive/weights/gan_fold5.h5'\n",
        "  g_model.save(filename2)\n",
        "  print('>Saved: %s and %s' % (filename1, filename2))\n",
        " \n",
        "# train pix2pix models\n",
        "def train(d_model, g_model, gan_model, dataset, n_epochs=600, n_batch=16):\n",
        "\t# determine the output square shape of the discriminator\n",
        "\tn_patch = d_model.output_shape[1]\n",
        "\t# unpack dataset\n",
        "\ttrainA, trainB = dataset\n",
        "\t# calculate the number of batches per training epoch\n",
        "\tbat_per_epo = int(len(trainA) / n_batch)\n",
        "\t# calculate the number of training iterations\n",
        "\tn_steps = bat_per_epo * n_epochs\n",
        "\t# manually enumerate epochs\n",
        "\tfor i in range(n_steps):\n",
        "\t\t# select a batch of real samples\n",
        "\t\t[X_realA, X_realB], y_real = generate_real_samples(dataset, n_batch, n_patch)\n",
        "\t\t# generate a batch of fake samples\n",
        "\t\tX_fakeB, y_fake = generate_fake_samples(g_model, X_realA, n_patch)\n",
        "\t\t# update discriminator for real samples\n",
        "\t\td_loss1 = d_model.train_on_batch([X_realA, X_realB], y_real)\n",
        "\t\t# update discriminator for generated samples\n",
        "\t\td_loss2 = d_model.train_on_batch([X_realA, X_fakeB], y_fake)\n",
        "\t\t# update the generator\n",
        "\t\tg_loss, _, _ = gan_model.train_on_batch(X_realA, [y_real, X_realB])\n",
        "\t\t# summarize performance\n",
        "\t\t#print('>%d, d1[%.3f] d2[%.3f] g[%.3f]' % (i+1, d_loss1, d_loss2, g_loss))\n",
        "\t\t# summarize model performance\n",
        "\t\tif (i+1) % (bat_per_epo * 10) == 0:\n",
        "\t\t\tsummarize_performance(i, g_model, dataset)\n",
        " \n",
        "dataset = load_real_samples('maps_256.npz')\n",
        "print('Loaded', dataset[0].shape, dataset[1].shape)\n",
        "# define input shape based on the loaded dataset\n",
        "image_shape = dataset[0].shape[1:]\n",
        "print(image_shape)\n",
        "# define the models\n",
        "image_shape = (256,256,3)\n",
        "d_model = define_discriminator(image_shape)\n",
        "g_model = define_generator(image_shape)\n",
        "# define the composite model\n",
        "gan_model = define_gan(g_model, d_model, image_shape)\n",
        "# train model\n",
        "train(d_model, g_model, gan_model, dataset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5jjcI6zmeWv-"
      },
      "source": [
        "for i in range(len(tempc)):\n",
        "  t = tempc[i].copy()\n",
        "  t = np.expand_dims(t,axis=2)\n",
        "  t = np.repeat(t,3,axis=2)\n",
        "  tempc[i] = t.copy()\n",
        "\n",
        "c_aug = np.array(tempc).astype(np.float16)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KxJkntvkeWzR"
      },
      "source": [
        "src_image = np.uint8(c_aug*255).copy()\n",
        "src_image = (src_image - 127.5) / 127.5\n",
        "\n",
        "src_image = src_image.reshape(len(tempc),256,256,3)\n",
        "\n",
        "model = load_model('weights/gan_fold5.h5')\n",
        "gen_image = model.predict(src_image)\n",
        "gen_image = (gen_image + 1) / 2.0\n",
        "gen_image = gen_image*2\n",
        "aug_covid = np.zeros([len(tempc),256,256])\n",
        "for i in range(len(gen_image)):\n",
        "  aug_covid[i] = np.mean(gen_image[i],axis=2).copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qt_0dUX6eW3H"
      },
      "source": [
        "for i in range(len(tempc)):\n",
        "  tempc[i] = np.mean(tempc[i],axis=2)\n",
        "\n",
        "for i in range(len(tempx)):\n",
        "  tempx[i] = np.where(tempc[i] == 1,aug_covid[i].copy(),tempx[i])\n",
        "\n",
        "tempx = np.array(tempx)\n",
        "tempc = np.array(tempc)\n",
        "templ = np.array(templ)\n",
        "\n",
        "tempx = tempx*tempc"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vqhbw14WeW6Z"
      },
      "source": [
        "plt.imshow(aug_covid[12].astype(np.float32),'gray',vmin=0,vmax=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3eQYMy3UeW8H"
      },
      "source": [
        "del(aug_covid,gen_image,src_image)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2jgMq_mvemua"
      },
      "source": [
        "# X_train = np.zeros([x_train.shape[0],256,256])\n",
        "Y_train = np.zeros([y_train.shape[0]+len(tempc),2,256,256])\n",
        "\n",
        "X_train = np.concatenate([x_train,tempx],axis=0)\n",
        "del(x_train,tempx)\n",
        "y1 = np.concatenate([y_train[:,0],templ],axis=0)\n",
        "y2 = np.concatenate([y_train[:,1],tempc],axis=0)\n",
        "del(y_train)\n",
        "del(templ,tempc)\n",
        "del(model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BmSCT6r7emw-"
      },
      "source": [
        "Y_train[:,0] = y1\n",
        "Y_train[:,1] = y2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m5lbbAT7emys"
      },
      "source": [
        "X_train = X_train.reshape(len(X_train), 256, 256,1).astype(np.float16)\n",
        "Y_train = Y_train.astype(np.float16)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dv-d31r6em1E"
      },
      "source": [
        "k = 2277\n",
        "plt.imshow(np.concatenate([Y_train[k,0].astype(np.float32),\n",
        "                           X_train[k].reshape(256,256).astype(np.float32),\n",
        "                           Y_train[k,1].astype(np.float32)],1),'gray',vmin=0,vmax=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xbMc4EZjezQs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-x5cBCQezTb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PNoCce43em3F"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 440
        },
        "id": "LLxt2BbluqFi",
        "outputId": "72ed4f89-d57a-47a0-f0b4-19a7152d9f25"
      },
      "source": [
        "i=np.random.randint(len(x_train))\n",
        "\n",
        "\n",
        "x1= x_train[i].reshape([256,256]).astype('float32')\n",
        "x2= y_train[i,0].reshape([256,256]).astype('float32')\n",
        "x3= y_train[i,1].reshape([256,256]).astype('float32')\n",
        "\n",
        "plt.figure(figsize=(20,20))\n",
        "plt.imshow(np.concatenate([x1,x2,x3],1),vmin=0,vmax=1,cmap='gray')\n",
        "# plt.imshow(x1.reshape([256,256]),'gray',vmin=0,vmax=1)\n",
        "x_train.max(), x_train.min()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.914, 0.0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x1440 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZmvA0ZtcuqFj",
        "outputId": "e129aec5-1769-492c-a479-ac939a61864c"
      },
      "source": [
        "strategy = tf.distribute.MirroredStrategy()\n",
        "with strategy.scope():    \n",
        "\n",
        "    inp = Input([256,256,1])\n",
        "    [E1,E2,E3,E4]=u_encoder(nOf_filters=[50,90,180,320,600],inp_layer=inp)                                                                     \n",
        "                                                                                                  \n",
        "    ###########\n",
        "    #LUNG SEGMENTATION512\n",
        "    ###########\n",
        "    lung_fm = u_pipe([E1,E2,E3,E4],[16,32,50,64,128])\n",
        "    out_lung = Conv2D( 1,1, activation = 'sigmoid', padding = 'same',\n",
        "                      kernel_initializer = 'he_normal',name= 'lung')(lung_fm)\n",
        "    ###########\n",
        "    #COVID SEGMENTATION\n",
        "    ###########\n",
        "    covid_fm = u_pipe(nOf_filters=[50,70,128,256,512],encoder_lines=[E1,E2,E3,E4])\n",
        "    drop = Dropout(0.3)(covid_fm)\n",
        "    wire = Conv2D( 32,3, activation = 'relu', padding = 'same',\n",
        "                       kernel_initializer = 'he_normal')(drop)\n",
        "    wire = Conv2D( 16,3, activation = 'relu', padding = 'same',\n",
        "                       kernel_initializer = 'he_normal')(wire)\n",
        "    out_covid = Conv2D( 1,1, activation = 'sigmoid', padding = 'same',\n",
        "                       kernel_initializer = 'he_normal',name= 'covid')(wire)\n",
        "    \n",
        "    ##########\n",
        "    #FINALLY\n",
        "    #########\n",
        "\n",
        "    cc_F    = concatenate([covid_fm,out_covid,inp,E1],axis= 3,name='cc_F')\n",
        "    mul     = mask_layer(inp_layer= cc_F,mask= out_lung)\n",
        "\n",
        "    \n",
        "    \n",
        "    final   = xconv2D(32,3,inp_layer=mul)\n",
        "    final   = Conv2D( 32,1, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(final)\n",
        "    final   = Conv2D( 16,3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(final)\n",
        "    final   = Conv2D( 1,1, activation = 'sigmoid', padding = 'same', kernel_initializer = 'he_normal',name='final')(final)\n",
        "\n",
        "    xmtl = Model(inp,[out_lung,out_covid,final])\n",
        "    xmtl.compile(optimizer=Adam(0.0004, decay=1e-4),loss = 'binary_crossentropy',\n",
        "                 metrics= [f1_m],loss_weights=[1,1,2])\n",
        "    xmtl.summary()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n",
            "max pool (None, 128, 128, 1)\n",
            "avg pool (None, 128, 128, 1)\n",
            "concat (None, 128, 128, 2)\n",
            "final  (None, 128, 128, 1)\n",
            "max pool (None, 64, 64, 1)\n",
            "avg pool (None, 64, 64, 1)\n",
            "concat (None, 64, 64, 2)\n",
            "final  (None, 64, 64, 1)\n",
            "max pool (None, 32, 32, 1)\n",
            "avg pool (None, 32, 32, 1)\n",
            "concat (None, 32, 32, 2)\n",
            "final  (None, 32, 32, 1)\n",
            "Model: \"functional_1\"\n",
            "__________________________________________________________________________________________________\n",
            "Layer (type)                    Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            "input_1 (InputLayer)            [(None, 256, 256, 1) 0                                            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d (Conv2D)                 (None, 256, 256, 50) 500         input_1[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_1 (Conv2D)               (None, 256, 256, 25) 11275       conv2d[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_3 (Conv2D)               (None, 256, 256, 25) 61275       conv2d[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_5 (Conv2D)               (None, 256, 256, 25) 101275      conv2d[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_2 (Conv2D)               (None, 256, 256, 25) 5650        conv2d_1[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_4 (Conv2D)               (None, 256, 256, 25) 15650       conv2d_3[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_6 (Conv2D)               (None, 256, 256, 25) 30650       conv2d_5[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d (MaxPooling2D)    (None, 256, 256, 50) 0           conv2d[0][0]                     \n",
            "__________________________________________________________________________________________________\n",
            "concatenate (Concatenate)       (None, 256, 256, 175 0           conv2d[0][0]                     \n",
            "                                                                 conv2d_2[0][0]                   \n",
            "                                                                 conv2d_4[0][0]                   \n",
            "                                                                 conv2d_6[0][0]                   \n",
            "                                                                 max_pooling2d[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "dropout (Dropout)               (None, 256, 256, 175 0           concatenate[0][0]                \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_7 (Conv2D)               (None, 256, 256, 75) 118200      dropout[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_8 (Conv2D)               (None, 256, 256, 50) 33800       conv2d_7[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling2d (Globa (None, 50)           0           conv2d_8[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "global_max_pooling2d (GlobalMax (None, 50)           0           conv2d_8[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "reshape (Reshape)               (None, 1, 50, 1)     0           global_average_pooling2d[0][0]   \n",
            "__________________________________________________________________________________________________\n",
            "reshape_1 (Reshape)             (None, 1, 50, 1)     0           global_max_pooling2d[0][0]       \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_1 (Concatenate)     (None, 2, 50, 1)     0           reshape[0][0]                    \n",
            "                                                                 reshape_1[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_9 (Conv2D)               (None, 1, 50, 8)     24          concatenate_1[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_10 (Conv2D)              (None, 1, 50, 1)     9           conv2d_9[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "reshape_2 (Reshape)             (None, 1, 1, 50)     0           conv2d_10[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dense (Dense)                   (None, 1, 1, 70)     3570        reshape_2[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_1 (Dropout)             (None, 1, 1, 70)     0           dense[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dense_1 (Dense)                 (None, 1, 1, 50)     3550        dropout_1[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply (Multiply)             (None, 256, 256, 50) 0           conv2d_8[0][0]                   \n",
            "                                                                 dense_1[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "pool1_E (MaxPooling2D)          (None, 128, 128, 50) 0           multiply[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "dropout_2 (Dropout)             (None, 128, 128, 50) 0           pool1_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_11 (Conv2D)              (None, 128, 128, 90) 40590       dropout_2[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_12 (Conv2D)              (None, 128, 128, 90) 72990       conv2d_11[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2_E (Conv2D)                (None, 128, 128, 180 145980      conv2d_12[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling2d_1 (Glo (None, 180)          0           conv2_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "global_max_pooling2d_1 (GlobalM (None, 180)          0           conv2_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "reshape_3 (Reshape)             (None, 1, 180, 1)    0           global_average_pooling2d_1[0][0] \n",
            "__________________________________________________________________________________________________\n",
            "reshape_4 (Reshape)             (None, 1, 180, 1)    0           global_max_pooling2d_1[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_2 (Concatenate)     (None, 2, 180, 1)    0           reshape_3[0][0]                  \n",
            "                                                                 reshape_4[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_13 (Conv2D)              (None, 1, 180, 8)    24          concatenate_2[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_14 (Conv2D)              (None, 1, 180, 1)    9           conv2d_13[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "reshape_5 (Reshape)             (None, 1, 1, 180)    0           conv2d_14[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dense_2 (Dense)                 (None, 1, 1, 251)    45431       reshape_5[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_3 (Dropout)             (None, 1, 1, 251)    0           dense_2[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dense_3 (Dense)                 (None, 1, 1, 180)    45360       dropout_3[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_1 (Multiply)           (None, 128, 128, 180 0           conv2_E[0][0]                    \n",
            "                                                                 dense_3[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_15 (Conv2D)              (None, 128, 128, 180 291780      multiply_1[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Mean (TensorFlowOpL [(None, 128, 128, 1) 0           conv2d_15[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Max (TensorFlowOpLa [(None, 128, 128, 1) 0           conv2d_15[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_3 (Concatenate)     (None, 128, 128, 2)  0           tf_op_layer_Mean[0][0]           \n",
            "                                                                 tf_op_layer_Max[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_16 (Conv2D)              (None, 128, 128, 8)  152         concatenate_3[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_17 (Conv2D)              (None, 128, 128, 4)  292         conv2d_16[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_18 (Conv2D)              (None, 128, 128, 1)  5           conv2d_17[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_4 (Concatenate)     (None, 128, 128, 180 0           conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "                                                                 conv2d_18[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_2 (Multiply)           (None, 128, 128, 180 0           conv2d_15[0][0]                  \n",
            "                                                                 concatenate_4[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "add (Add)                       (None, 128, 128, 180 0           conv2_E[0][0]                    \n",
            "                                                                 multiply_2[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "pool2_E (MaxPooling2D)          (None, 64, 64, 180)  0           add[0][0]                        \n",
            "__________________________________________________________________________________________________\n",
            "dropout_4 (Dropout)             (None, 64, 64, 180)  0           pool2_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_19 (Conv2D)              (None, 64, 64, 180)  291780      dropout_4[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_20 (Conv2D)              (None, 64, 64, 180)  291780      conv2d_19[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv3_E (Conv2D)                (None, 64, 64, 320)  518720      conv2d_20[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling2d_2 (Glo (None, 320)          0           conv3_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "global_max_pooling2d_2 (GlobalM (None, 320)          0           conv3_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "reshape_6 (Reshape)             (None, 1, 320, 1)    0           global_average_pooling2d_2[0][0] \n",
            "__________________________________________________________________________________________________\n",
            "reshape_7 (Reshape)             (None, 1, 320, 1)    0           global_max_pooling2d_2[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_5 (Concatenate)     (None, 2, 320, 1)    0           reshape_6[0][0]                  \n",
            "                                                                 reshape_7[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_21 (Conv2D)              (None, 1, 320, 8)    24          concatenate_5[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_22 (Conv2D)              (None, 1, 320, 1)    9           conv2d_21[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "reshape_8 (Reshape)             (None, 1, 1, 320)    0           conv2d_22[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dense_4 (Dense)                 (None, 1, 1, 448)    143808      reshape_8[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_5 (Dropout)             (None, 1, 1, 448)    0           dense_4[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dense_5 (Dense)                 (None, 1, 1, 320)    143680      dropout_5[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_3 (Multiply)           (None, 64, 64, 320)  0           conv3_E[0][0]                    \n",
            "                                                                 dense_5[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_23 (Conv2D)              (None, 64, 64, 320)  921920      multiply_3[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Mean_1 (TensorFlowO [(None, 64, 64, 1)]  0           conv2d_23[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Max_1 (TensorFlowOp [(None, 64, 64, 1)]  0           conv2d_23[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_6 (Concatenate)     (None, 64, 64, 2)    0           tf_op_layer_Mean_1[0][0]         \n",
            "                                                                 tf_op_layer_Max_1[0][0]          \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_24 (Conv2D)              (None, 64, 64, 8)    152         concatenate_6[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_25 (Conv2D)              (None, 64, 64, 4)    292         conv2d_24[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_26 (Conv2D)              (None, 64, 64, 1)    5           conv2d_25[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_7 (Concatenate)     (None, 64, 64, 320)  0           conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "                                                                 conv2d_26[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_4 (Multiply)           (None, 64, 64, 320)  0           conv2d_23[0][0]                  \n",
            "                                                                 concatenate_7[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "add_1 (Add)                     (None, 64, 64, 320)  0           conv3_E[0][0]                    \n",
            "                                                                 multiply_4[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "pool3_E (MaxPooling2D)          (None, 32, 32, 320)  0           add_1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "dropout_6 (Dropout)             (None, 32, 32, 320)  0           pool3_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_27 (Conv2D)              (None, 32, 32, 320)  921920      dropout_6[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_28 (Conv2D)              (None, 32, 32, 320)  921920      conv2d_27[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv4_E (Conv2D)                (None, 32, 32, 600)  1728600     conv2d_28[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "global_average_pooling2d_3 (Glo (None, 600)          0           conv4_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "global_max_pooling2d_3 (GlobalM (None, 600)          0           conv4_E[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "reshape_9 (Reshape)             (None, 1, 600, 1)    0           global_average_pooling2d_3[0][0] \n",
            "__________________________________________________________________________________________________\n",
            "reshape_10 (Reshape)            (None, 1, 600, 1)    0           global_max_pooling2d_3[0][0]     \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_8 (Concatenate)     (None, 2, 600, 1)    0           reshape_9[0][0]                  \n",
            "                                                                 reshape_10[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_29 (Conv2D)              (None, 1, 600, 8)    24          concatenate_8[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_30 (Conv2D)              (None, 1, 600, 1)    9           conv2d_29[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "reshape_11 (Reshape)            (None, 1, 1, 600)    0           conv2d_30[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dense_6 (Dense)                 (None, 1, 1, 840)    504840      reshape_11[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "dropout_7 (Dropout)             (None, 1, 1, 840)    0           dense_6[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "dense_7 (Dense)                 (None, 1, 1, 600)    504600      dropout_7[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_5 (Multiply)           (None, 32, 32, 600)  0           conv4_E[0][0]                    \n",
            "                                                                 dense_7[0][0]                    \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_31 (Conv2D)              (None, 32, 32, 600)  3240600     multiply_5[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Mean_2 (TensorFlowO [(None, 32, 32, 1)]  0           conv2d_31[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "tf_op_layer_Max_2 (TensorFlowOp [(None, 32, 32, 1)]  0           conv2d_31[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_9 (Concatenate)     (None, 32, 32, 2)    0           tf_op_layer_Mean_2[0][0]         \n",
            "                                                                 tf_op_layer_Max_2[0][0]          \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_32 (Conv2D)              (None, 32, 32, 8)    152         concatenate_9[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_33 (Conv2D)              (None, 32, 32, 4)    292         conv2d_32[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_34 (Conv2D)              (None, 32, 32, 1)    5           conv2d_33[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_10 (Concatenate)    (None, 32, 32, 600)  0           conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "                                                                 conv2d_34[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "multiply_6 (Multiply)           (None, 32, 32, 600)  0           conv2d_31[0][0]                  \n",
            "                                                                 concatenate_10[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "add_2 (Add)                     (None, 32, 32, 600)  0           conv4_E[0][0]                    \n",
            "                                                                 multiply_6[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d_3 (UpSampling2D)  (None, 64, 64, 600)  0           add_2[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_58 (Conv2D)              (None, 64, 64, 512)  2765312     up_sampling2d_3[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_59 (Conv2D)              (None, 64, 64, 256)  1179904     conv2d_58[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d (UpSampling2D)    (None, 64, 64, 600)  0           add_2[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_60 (Conv2D)              (None, 64, 64, 256)  590080      conv2d_59[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_35 (Conv2D)              (None, 64, 64, 128)  691328      up_sampling2d[0][0]              \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_15 (Concatenate)    (None, 64, 64, 576)  0           conv2d_60[0][0]                  \n",
            "                                                                 add_1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_36 (Conv2D)              (None, 64, 64, 64)   73792       conv2d_35[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_61 (Conv2D)              (None, 64, 64, 256)  1327360     concatenate_15[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_37 (Conv2D)              (None, 64, 64, 64)   36928       conv2d_36[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_62 (Conv2D)              (None, 64, 64, 128)  295040      conv2d_61[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_11 (Concatenate)    (None, 64, 64, 384)  0           conv2d_37[0][0]                  \n",
            "                                                                 add_1[0][0]                      \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d_4 (UpSampling2D)  (None, 128, 128, 128 0           conv2d_62[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_38 (Conv2D)              (None, 64, 64, 64)   221248      concatenate_11[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "dropout_11 (Dropout)            (None, 128, 128, 128 0           up_sampling2d_4[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_39 (Conv2D)              (None, 64, 64, 50)   28850       conv2d_38[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_63 (Conv2D)              (None, 128, 128, 128 147584      dropout_11[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d_1 (UpSampling2D)  (None, 128, 128, 50) 0           conv2d_39[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_64 (Conv2D)              (None, 128, 128, 70) 80710       conv2d_63[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_8 (Dropout)             (None, 128, 128, 50) 0           up_sampling2d_1[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_65 (Conv2D)              (None, 128, 128, 70) 44170       conv2d_64[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_40 (Conv2D)              (None, 128, 128, 50) 22550       dropout_8[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_16 (Concatenate)    (None, 128, 128, 250 0           conv2d_65[0][0]                  \n",
            "                                                                 add[0][0]                        \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_41 (Conv2D)              (None, 128, 128, 32) 14432       conv2d_40[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_66 (Conv2D)              (None, 128, 128, 128 288128      concatenate_16[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_42 (Conv2D)              (None, 128, 128, 32) 9248        conv2d_41[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_67 (Conv2D)              (None, 128, 128, 70) 80710       conv2d_66[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_12 (Concatenate)    (None, 128, 128, 212 0           conv2d_42[0][0]                  \n",
            "                                                                 add[0][0]                        \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d_5 (UpSampling2D)  (None, 256, 256, 70) 0           conv2d_67[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_43 (Conv2D)              (None, 128, 128, 50) 95450       concatenate_12[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "dropout_12 (Dropout)            (None, 256, 256, 70) 0           up_sampling2d_5[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_44 (Conv2D)              (None, 128, 128, 32) 14432       conv2d_43[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_68 (Conv2D)              (None, 256, 256, 128 80768       dropout_12[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "up_sampling2d_2 (UpSampling2D)  (None, 256, 256, 32) 0           conv2d_44[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_69 (Conv2D)              (None, 256, 256, 70) 80710       conv2d_68[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_9 (Dropout)             (None, 256, 256, 32) 0           up_sampling2d_2[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_70 (Conv2D)              (None, 256, 256, 70) 44170       conv2d_69[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_45 (Conv2D)              (None, 256, 256, 50) 14450       dropout_9[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_17 (Concatenate)    (None, 256, 256, 120 0           conv2d_70[0][0]                  \n",
            "                                                                 multiply[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_46 (Conv2D)              (None, 256, 256, 32) 14432       conv2d_45[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_71 (Conv2D)              (None, 256, 256, 70) 75670       concatenate_17[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_47 (Conv2D)              (None, 256, 256, 32) 9248        conv2d_46[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_72 (Conv2D)              (None, 256, 256, 70) 44170       conv2d_71[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_13 (Concatenate)    (None, 256, 256, 82) 0           conv2d_47[0][0]                  \n",
            "                                                                 multiply[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_73 (Conv2D)              (None, 256, 256, 25) 15775       conv2d_72[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_75 (Conv2D)              (None, 256, 256, 25) 85775       conv2d_72[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_77 (Conv2D)              (None, 256, 256, 25) 141775      conv2d_72[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_48 (Conv2D)              (None, 256, 256, 32) 23648       concatenate_13[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_74 (Conv2D)              (None, 256, 256, 25) 5650        conv2d_73[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_76 (Conv2D)              (None, 256, 256, 25) 15650       conv2d_75[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_78 (Conv2D)              (None, 256, 256, 25) 30650       conv2d_77[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_2 (MaxPooling2D)  (None, 256, 256, 70) 0           conv2d_72[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_49 (Conv2D)              (None, 256, 256, 32) 9248        conv2d_48[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_18 (Concatenate)    (None, 256, 256, 215 0           conv2d_72[0][0]                  \n",
            "                                                                 conv2d_74[0][0]                  \n",
            "                                                                 conv2d_76[0][0]                  \n",
            "                                                                 conv2d_78[0][0]                  \n",
            "                                                                 max_pooling2d_2[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_50 (Conv2D)              (None, 256, 256, 8)  2312        conv2d_49[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_52 (Conv2D)              (None, 256, 256, 8)  12552       conv2d_49[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_54 (Conv2D)              (None, 256, 256, 8)  20744       conv2d_49[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_13 (Dropout)            (None, 256, 256, 215 0           concatenate_18[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_51 (Conv2D)              (None, 256, 256, 8)  584         conv2d_50[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_53 (Conv2D)              (None, 256, 256, 8)  1608        conv2d_52[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_55 (Conv2D)              (None, 256, 256, 8)  3144        conv2d_54[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_1 (MaxPooling2D)  (None, 256, 256, 32) 0           conv2d_49[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_79 (Conv2D)              (None, 256, 256, 75) 145200      dropout_13[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_14 (Concatenate)    (None, 256, 256, 88) 0           conv2d_49[0][0]                  \n",
            "                                                                 conv2d_51[0][0]                  \n",
            "                                                                 conv2d_53[0][0]                  \n",
            "                                                                 conv2d_55[0][0]                  \n",
            "                                                                 max_pooling2d_1[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_80 (Conv2D)              (None, 256, 256, 50) 33800       conv2d_79[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "dropout_10 (Dropout)            (None, 256, 256, 88) 0           concatenate_14[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "dropout_14 (Dropout)            (None, 256, 256, 50) 0           conv2d_80[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_56 (Conv2D)              (None, 256, 256, 24) 19032       dropout_10[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_81 (Conv2D)              (None, 256, 256, 32) 14432       dropout_14[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_57 (Conv2D)              (None, 256, 256, 16) 3472        conv2d_56[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_82 (Conv2D)              (None, 256, 256, 16) 4624        conv2d_81[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "lung (Conv2D)                   (None, 256, 256, 1)  17          conv2d_57[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "covid (Conv2D)                  (None, 256, 256, 1)  17          conv2d_82[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "cc_F (Concatenate)              (None, 256, 256, 102 0           conv2d_80[0][0]                  \n",
            "                                                                 covid[0][0]                      \n",
            "                                                                 input_1[0][0]                    \n",
            "                                                                 multiply[0][0]                   \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_19 (Concatenate)    (None, 256, 256, 102 0           lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "                                                                 lung[0][0]                       \n",
            "__________________________________________________________________________________________________\n",
            "multiply_7 (Multiply)           (None, 256, 256, 102 0           cc_F[0][0]                       \n",
            "                                                                 concatenate_19[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_83 (Conv2D)              (None, 256, 256, 16) 14704       multiply_7[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_85 (Conv2D)              (None, 256, 256, 16) 79984       multiply_7[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_87 (Conv2D)              (None, 256, 256, 16) 132208      multiply_7[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_84 (Conv2D)              (None, 256, 256, 16) 2320        conv2d_83[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_86 (Conv2D)              (None, 256, 256, 16) 6416        conv2d_85[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_88 (Conv2D)              (None, 256, 256, 16) 12560       conv2d_87[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "max_pooling2d_3 (MaxPooling2D)  (None, 256, 256, 102 0           multiply_7[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "concatenate_20 (Concatenate)    (None, 256, 256, 252 0           multiply_7[0][0]                 \n",
            "                                                                 conv2d_84[0][0]                  \n",
            "                                                                 conv2d_86[0][0]                  \n",
            "                                                                 conv2d_88[0][0]                  \n",
            "                                                                 max_pooling2d_3[0][0]            \n",
            "__________________________________________________________________________________________________\n",
            "dropout_15 (Dropout)            (None, 256, 256, 252 0           concatenate_20[0][0]             \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_89 (Conv2D)              (None, 256, 256, 48) 108912      dropout_15[0][0]                 \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_90 (Conv2D)              (None, 256, 256, 32) 13856       conv2d_89[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_91 (Conv2D)              (None, 256, 256, 32) 1056        conv2d_90[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "conv2d_92 (Conv2D)              (None, 256, 256, 16) 4624        conv2d_91[0][0]                  \n",
            "__________________________________________________________________________________________________\n",
            "final (Conv2D)                  (None, 256, 256, 1)  17          conv2d_92[0][0]                  \n",
            "==================================================================================================\n",
            "Total params: 20,500,413\n",
            "Trainable params: 20,500,413\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rkNy3mzauqFk"
      },
      "source": [
        "best_finder = ModelCheckpoint(filepath='drive/MyDrive/weights/res_attention_fold5.h5',monitor='val_final_f1_m', mode='max', verbose=1, save_best_only=True)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qK4ts-RfuqFk"
      },
      "source": [
        "x_train=x_train.reshape(-1,256,256,1)\n",
        "y_train=y_train.reshape(-1,2,256,256,1)\n",
        "x_test=x_test.reshape(-1,256,256,1)\n",
        "y_test=y_test.reshape(-1,2,256,256,1)\n",
        "x_val=x_val.reshape(-1,256,256,1)\n",
        "y_val=y_val.reshape(-1,2,256,256,1)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCvCnsvQM9jO"
      },
      "source": [
        "xmtl.load_weights('drive/MyDrive/weights/res_attention_fold5.h5')"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W6aPa9A6uqFk",
        "outputId": "48d56801-ca94-4786-c68a-317da67567e8"
      },
      "source": [
        "history= xmtl.fit(x_train,[y_train[:,0],y_train[:,1],y_train[:,1]],\n",
        "                  validation_data=(x_val,[y_val[:,0],y_val[:,1],y_val[:,1]]),\n",
        "        epochs =24 ,batch_size=7,callbacks=[best_finder])\n",
        "\n",
        "# history= xmtl.fit(x_train,[y_train[:,0],y_train[:,1],y_train[:,1]],epochs =60 ,batch_size=10)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0297 - lung_loss: 0.0085 - covid_loss: 0.0087 - final_loss: 0.0063 - lung_f1_m: 0.9828 - covid_f1_m: 0.7793 - final_f1_m: 0.8319\n",
            "Epoch 00001: val_final_f1_m improved from -inf to 0.81941, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 820s 3s/step - loss: 0.0297 - lung_loss: 0.0085 - covid_loss: 0.0087 - final_loss: 0.0063 - lung_f1_m: 0.9828 - covid_f1_m: 0.7793 - final_f1_m: 0.8319 - val_loss: 0.0338 - val_lung_loss: 0.0080 - val_covid_loss: 0.0105 - val_final_loss: 0.0076 - val_lung_f1_m: 0.9838 - val_covid_f1_m: 0.7661 - val_final_f1_m: 0.8194\n",
            "Epoch 2/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0283 - lung_loss: 0.0079 - covid_loss: 0.0082 - final_loss: 0.0061 - lung_f1_m: 0.9836 - covid_f1_m: 0.7856 - final_f1_m: 0.8354\n",
            "Epoch 00002: val_final_f1_m did not improve from 0.81941\n",
            "323/323 [==============================] - 800s 2s/step - loss: 0.0283 - lung_loss: 0.0079 - covid_loss: 0.0082 - final_loss: 0.0061 - lung_f1_m: 0.9836 - covid_f1_m: 0.7856 - final_f1_m: 0.8354 - val_loss: 0.0316 - val_lung_loss: 0.0077 - val_covid_loss: 0.0091 - val_final_loss: 0.0074 - val_lung_f1_m: 0.9839 - val_covid_f1_m: 0.7668 - val_final_f1_m: 0.8137\n",
            "Epoch 3/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0331 - lung_loss: 0.0080 - covid_loss: 0.0097 - final_loss: 0.0077 - lung_f1_m: 0.9829 - covid_f1_m: 0.7681 - final_f1_m: 0.8260\n",
            "Epoch 00003: val_final_f1_m did not improve from 0.81941\n",
            "323/323 [==============================] - 800s 2s/step - loss: 0.0331 - lung_loss: 0.0080 - covid_loss: 0.0097 - final_loss: 0.0077 - lung_f1_m: 0.9829 - covid_f1_m: 0.7681 - final_f1_m: 0.8260 - val_loss: 0.0520 - val_lung_loss: 0.0117 - val_covid_loss: 0.0173 - val_final_loss: 0.0115 - val_lung_f1_m: 0.9774 - val_covid_f1_m: 0.6456 - val_final_f1_m: 0.7364\n",
            "Epoch 4/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0735 - lung_loss: 0.0321 - covid_loss: 0.0157 - final_loss: 0.0129 - lung_f1_m: 0.9418 - covid_f1_m: 0.6571 - final_f1_m: 0.7226\n",
            "Epoch 00004: val_final_f1_m did not improve from 0.81941\n",
            "323/323 [==============================] - 799s 2s/step - loss: 0.0735 - lung_loss: 0.0321 - covid_loss: 0.0157 - final_loss: 0.0129 - lung_f1_m: 0.9418 - covid_f1_m: 0.6571 - final_f1_m: 0.7226 - val_loss: 0.0390 - val_lung_loss: 0.0104 - val_covid_loss: 0.0116 - val_final_loss: 0.0085 - val_lung_f1_m: 0.9803 - val_covid_f1_m: 0.7461 - val_final_f1_m: 0.7996\n",
            "Epoch 5/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0303 - lung_loss: 0.0090 - covid_loss: 0.0089 - final_loss: 0.0062 - lung_f1_m: 0.9819 - covid_f1_m: 0.7695 - final_f1_m: 0.8329\n",
            "Epoch 00005: val_final_f1_m improved from 0.81941 to 0.82795, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 802s 2s/step - loss: 0.0303 - lung_loss: 0.0090 - covid_loss: 0.0089 - final_loss: 0.0062 - lung_f1_m: 0.9819 - covid_f1_m: 0.7695 - final_f1_m: 0.8329 - val_loss: 0.0309 - val_lung_loss: 0.0085 - val_covid_loss: 0.0089 - val_final_loss: 0.0068 - val_lung_f1_m: 0.9832 - val_covid_f1_m: 0.7754 - val_final_f1_m: 0.8280\n",
            "Epoch 6/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0335 - lung_loss: 0.0107 - covid_loss: 0.0094 - final_loss: 0.0067 - lung_f1_m: 0.9792 - covid_f1_m: 0.7492 - final_f1_m: 0.8184\n",
            "Epoch 00006: val_final_f1_m did not improve from 0.82795\n",
            "323/323 [==============================] - 799s 2s/step - loss: 0.0335 - lung_loss: 0.0107 - covid_loss: 0.0094 - final_loss: 0.0067 - lung_f1_m: 0.9792 - covid_f1_m: 0.7492 - final_f1_m: 0.8184 - val_loss: 0.0400 - val_lung_loss: 0.0108 - val_covid_loss: 0.0115 - val_final_loss: 0.0088 - val_lung_f1_m: 0.9795 - val_covid_f1_m: 0.6985 - val_final_f1_m: 0.7944\n",
            "Epoch 7/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0311 - lung_loss: 0.0093 - covid_loss: 0.0090 - final_loss: 0.0064 - lung_f1_m: 0.9815 - covid_f1_m: 0.7678 - final_f1_m: 0.8336\n",
            "Epoch 00007: val_final_f1_m did not improve from 0.82795\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0311 - lung_loss: 0.0093 - covid_loss: 0.0090 - final_loss: 0.0064 - lung_f1_m: 0.9815 - covid_f1_m: 0.7678 - final_f1_m: 0.8336 - val_loss: 0.0309 - val_lung_loss: 0.0080 - val_covid_loss: 0.0089 - val_final_loss: 0.0070 - val_lung_f1_m: 0.9838 - val_covid_f1_m: 0.7697 - val_final_f1_m: 0.8274\n",
            "Epoch 8/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0259 - lung_loss: 0.0077 - covid_loss: 0.0075 - final_loss: 0.0054 - lung_f1_m: 0.9836 - covid_f1_m: 0.7982 - final_f1_m: 0.8508\n",
            "Epoch 00008: val_final_f1_m improved from 0.82795 to 0.83434, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 802s 2s/step - loss: 0.0259 - lung_loss: 0.0077 - covid_loss: 0.0075 - final_loss: 0.0054 - lung_f1_m: 0.9836 - covid_f1_m: 0.7982 - final_f1_m: 0.8508 - val_loss: 0.0304 - val_lung_loss: 0.0075 - val_covid_loss: 0.0089 - val_final_loss: 0.0070 - val_lung_f1_m: 0.9846 - val_covid_f1_m: 0.7878 - val_final_f1_m: 0.8343\n",
            "Epoch 9/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0261 - lung_loss: 0.0075 - covid_loss: 0.0077 - final_loss: 0.0055 - lung_f1_m: 0.9845 - covid_f1_m: 0.7954 - final_f1_m: 0.8496\n",
            "Epoch 00009: val_final_f1_m did not improve from 0.83434\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0261 - lung_loss: 0.0075 - covid_loss: 0.0077 - final_loss: 0.0055 - lung_f1_m: 0.9845 - covid_f1_m: 0.7954 - final_f1_m: 0.8496 - val_loss: 0.0291 - val_lung_loss: 0.0073 - val_covid_loss: 0.0084 - val_final_loss: 0.0067 - val_lung_f1_m: 0.9849 - val_covid_f1_m: 0.7864 - val_final_f1_m: 0.8318\n",
            "Epoch 10/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0253 - lung_loss: 0.0072 - covid_loss: 0.0074 - final_loss: 0.0053 - lung_f1_m: 0.9846 - covid_f1_m: 0.7971 - final_f1_m: 0.8502\n",
            "Epoch 00010: val_final_f1_m improved from 0.83434 to 0.83623, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 801s 2s/step - loss: 0.0253 - lung_loss: 0.0072 - covid_loss: 0.0074 - final_loss: 0.0053 - lung_f1_m: 0.9846 - covid_f1_m: 0.7971 - final_f1_m: 0.8502 - val_loss: 0.0284 - val_lung_loss: 0.0071 - val_covid_loss: 0.0084 - val_final_loss: 0.0065 - val_lung_f1_m: 0.9852 - val_covid_f1_m: 0.7822 - val_final_f1_m: 0.8362\n",
            "Epoch 11/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0244 - lung_loss: 0.0070 - covid_loss: 0.0071 - final_loss: 0.0051 - lung_f1_m: 0.9853 - covid_f1_m: 0.8084 - final_f1_m: 0.8596\n",
            "Epoch 00011: val_final_f1_m improved from 0.83623 to 0.84543, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 801s 2s/step - loss: 0.0244 - lung_loss: 0.0070 - covid_loss: 0.0071 - final_loss: 0.0051 - lung_f1_m: 0.9853 - covid_f1_m: 0.8084 - final_f1_m: 0.8596 - val_loss: 0.0279 - val_lung_loss: 0.0071 - val_covid_loss: 0.0081 - val_final_loss: 0.0063 - val_lung_f1_m: 0.9854 - val_covid_f1_m: 0.7974 - val_final_f1_m: 0.8454\n",
            "Epoch 12/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0240 - lung_loss: 0.0069 - covid_loss: 0.0071 - final_loss: 0.0051 - lung_f1_m: 0.9852 - covid_f1_m: 0.8115 - final_f1_m: 0.8600\n",
            "Epoch 00012: val_final_f1_m did not improve from 0.84543\n",
            "323/323 [==============================] - 799s 2s/step - loss: 0.0240 - lung_loss: 0.0069 - covid_loss: 0.0071 - final_loss: 0.0051 - lung_f1_m: 0.9852 - covid_f1_m: 0.8115 - final_f1_m: 0.8600 - val_loss: 0.0306 - val_lung_loss: 0.0071 - val_covid_loss: 0.0091 - val_final_loss: 0.0072 - val_lung_f1_m: 0.9853 - val_covid_f1_m: 0.7630 - val_final_f1_m: 0.8260\n",
            "Epoch 13/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0243 - lung_loss: 0.0069 - covid_loss: 0.0072 - final_loss: 0.0051 - lung_f1_m: 0.9852 - covid_f1_m: 0.8103 - final_f1_m: 0.8621\n",
            "Epoch 00013: val_final_f1_m improved from 0.84543 to 0.84798, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 801s 2s/step - loss: 0.0243 - lung_loss: 0.0069 - covid_loss: 0.0072 - final_loss: 0.0051 - lung_f1_m: 0.9852 - covid_f1_m: 0.8103 - final_f1_m: 0.8621 - val_loss: 0.0275 - val_lung_loss: 0.0070 - val_covid_loss: 0.0080 - val_final_loss: 0.0062 - val_lung_f1_m: 0.9854 - val_covid_f1_m: 0.8031 - val_final_f1_m: 0.8480\n",
            "Epoch 14/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0233 - lung_loss: 0.0068 - covid_loss: 0.0067 - final_loss: 0.0049 - lung_f1_m: 0.9854 - covid_f1_m: 0.8180 - final_f1_m: 0.8617\n",
            "Epoch 00014: val_final_f1_m did not improve from 0.84798\n",
            "323/323 [==============================] - 799s 2s/step - loss: 0.0233 - lung_loss: 0.0068 - covid_loss: 0.0067 - final_loss: 0.0049 - lung_f1_m: 0.9854 - covid_f1_m: 0.8180 - final_f1_m: 0.8617 - val_loss: 0.0274 - val_lung_loss: 0.0071 - val_covid_loss: 0.0078 - val_final_loss: 0.0063 - val_lung_f1_m: 0.9856 - val_covid_f1_m: 0.7994 - val_final_f1_m: 0.8414\n",
            "Epoch 15/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0275 - lung_loss: 0.0084 - covid_loss: 0.0080 - final_loss: 0.0056 - lung_f1_m: 0.9829 - covid_f1_m: 0.7970 - final_f1_m: 0.8510\n",
            "Epoch 00015: val_final_f1_m did not improve from 0.84798\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0275 - lung_loss: 0.0084 - covid_loss: 0.0080 - final_loss: 0.0056 - lung_f1_m: 0.9829 - covid_f1_m: 0.7970 - final_f1_m: 0.8510 - val_loss: 0.0280 - val_lung_loss: 0.0073 - val_covid_loss: 0.0079 - val_final_loss: 0.0064 - val_lung_f1_m: 0.9849 - val_covid_f1_m: 0.8018 - val_final_f1_m: 0.8435\n",
            "Epoch 16/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0231 - lung_loss: 0.0069 - covid_loss: 0.0067 - final_loss: 0.0048 - lung_f1_m: 0.9851 - covid_f1_m: 0.8224 - final_f1_m: 0.8685\n",
            "Epoch 00016: val_final_f1_m did not improve from 0.84798\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0231 - lung_loss: 0.0069 - covid_loss: 0.0067 - final_loss: 0.0048 - lung_f1_m: 0.9851 - covid_f1_m: 0.8224 - final_f1_m: 0.8685 - val_loss: 0.0276 - val_lung_loss: 0.0069 - val_covid_loss: 0.0077 - val_final_loss: 0.0065 - val_lung_f1_m: 0.9857 - val_covid_f1_m: 0.8056 - val_final_f1_m: 0.8420\n",
            "Epoch 17/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0232 - lung_loss: 0.0070 - covid_loss: 0.0066 - final_loss: 0.0048 - lung_f1_m: 0.9851 - covid_f1_m: 0.8292 - final_f1_m: 0.8709\n",
            "Epoch 00017: val_final_f1_m did not improve from 0.84798\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0232 - lung_loss: 0.0070 - covid_loss: 0.0066 - final_loss: 0.0048 - lung_f1_m: 0.9851 - covid_f1_m: 0.8292 - final_f1_m: 0.8709 - val_loss: 0.0287 - val_lung_loss: 0.0070 - val_covid_loss: 0.0086 - val_final_loss: 0.0065 - val_lung_f1_m: 0.9857 - val_covid_f1_m: 0.7892 - val_final_f1_m: 0.8400\n",
            "Epoch 18/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0234 - lung_loss: 0.0070 - covid_loss: 0.0068 - final_loss: 0.0048 - lung_f1_m: 0.9852 - covid_f1_m: 0.8202 - final_f1_m: 0.8687\n",
            "Epoch 00018: val_final_f1_m improved from 0.84798 to 0.85146, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 801s 2s/step - loss: 0.0234 - lung_loss: 0.0070 - covid_loss: 0.0068 - final_loss: 0.0048 - lung_f1_m: 0.9852 - covid_f1_m: 0.8202 - final_f1_m: 0.8687 - val_loss: 0.0267 - val_lung_loss: 0.0068 - val_covid_loss: 0.0075 - val_final_loss: 0.0062 - val_lung_f1_m: 0.9861 - val_covid_f1_m: 0.8119 - val_final_f1_m: 0.8515\n",
            "Epoch 19/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0223 - lung_loss: 0.0068 - covid_loss: 0.0064 - final_loss: 0.0046 - lung_f1_m: 0.9825 - covid_f1_m: 0.8311 - final_f1_m: 0.8736\n",
            "Epoch 00019: val_final_f1_m did not improve from 0.85146\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0223 - lung_loss: 0.0068 - covid_loss: 0.0064 - final_loss: 0.0046 - lung_f1_m: 0.9825 - covid_f1_m: 0.8311 - final_f1_m: 0.8736 - val_loss: 0.0277 - val_lung_loss: 0.0070 - val_covid_loss: 0.0078 - val_final_loss: 0.0064 - val_lung_f1_m: 0.9853 - val_covid_f1_m: 0.8034 - val_final_f1_m: 0.8448\n",
            "Epoch 20/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0229 - lung_loss: 0.0066 - covid_loss: 0.0067 - final_loss: 0.0048 - lung_f1_m: 0.9857 - covid_f1_m: 0.8248 - final_f1_m: 0.8678\n",
            "Epoch 00020: val_final_f1_m did not improve from 0.85146\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0229 - lung_loss: 0.0066 - covid_loss: 0.0067 - final_loss: 0.0048 - lung_f1_m: 0.9857 - covid_f1_m: 0.8248 - final_f1_m: 0.8678 - val_loss: 0.0270 - val_lung_loss: 0.0067 - val_covid_loss: 0.0076 - val_final_loss: 0.0064 - val_lung_f1_m: 0.9863 - val_covid_f1_m: 0.8107 - val_final_f1_m: 0.8486\n",
            "Epoch 21/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0252 - lung_loss: 0.0083 - covid_loss: 0.0069 - final_loss: 0.0050 - lung_f1_m: 0.9837 - covid_f1_m: 0.8149 - final_f1_m: 0.8614\n",
            "Epoch 00021: val_final_f1_m did not improve from 0.85146\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0252 - lung_loss: 0.0083 - covid_loss: 0.0069 - final_loss: 0.0050 - lung_f1_m: 0.9837 - covid_f1_m: 0.8149 - final_f1_m: 0.8614 - val_loss: 0.0272 - val_lung_loss: 0.0071 - val_covid_loss: 0.0076 - val_final_loss: 0.0062 - val_lung_f1_m: 0.9854 - val_covid_f1_m: 0.8125 - val_final_f1_m: 0.8509\n",
            "Epoch 22/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0220 - lung_loss: 0.0068 - covid_loss: 0.0064 - final_loss: 0.0044 - lung_f1_m: 0.9855 - covid_f1_m: 0.8355 - final_f1_m: 0.8785\n",
            "Epoch 00022: val_final_f1_m did not improve from 0.85146\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0220 - lung_loss: 0.0068 - covid_loss: 0.0064 - final_loss: 0.0044 - lung_f1_m: 0.9855 - covid_f1_m: 0.8355 - final_f1_m: 0.8785 - val_loss: 0.0281 - val_lung_loss: 0.0067 - val_covid_loss: 0.0076 - val_final_loss: 0.0069 - val_lung_f1_m: 0.9860 - val_covid_f1_m: 0.8069 - val_final_f1_m: 0.8363\n",
            "Epoch 23/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0217 - lung_loss: 0.0067 - covid_loss: 0.0063 - final_loss: 0.0044 - lung_f1_m: 0.9859 - covid_f1_m: 0.8335 - final_f1_m: 0.8772\n",
            "Epoch 00023: val_final_f1_m did not improve from 0.85146\n",
            "323/323 [==============================] - 798s 2s/step - loss: 0.0217 - lung_loss: 0.0067 - covid_loss: 0.0063 - final_loss: 0.0044 - lung_f1_m: 0.9859 - covid_f1_m: 0.8335 - final_f1_m: 0.8772 - val_loss: 0.0273 - val_lung_loss: 0.0066 - val_covid_loss: 0.0079 - val_final_loss: 0.0064 - val_lung_f1_m: 0.9863 - val_covid_f1_m: 0.8105 - val_final_f1_m: 0.8512\n",
            "Epoch 24/24\n",
            "323/323 [==============================] - ETA: 0s - loss: 0.0209 - lung_loss: 0.0065 - covid_loss: 0.0060 - final_loss: 0.0042 - lung_f1_m: 0.9862 - covid_f1_m: 0.8322 - final_f1_m: 0.8733\n",
            "Epoch 00024: val_final_f1_m improved from 0.85146 to 0.85735, saving model to drive/MyDrive/weights/res_attention_fold5.h5\n",
            "323/323 [==============================] - 801s 2s/step - loss: 0.0209 - lung_loss: 0.0065 - covid_loss: 0.0060 - final_loss: 0.0042 - lung_f1_m: 0.9862 - covid_f1_m: 0.8322 - final_f1_m: 0.8733 - val_loss: 0.0261 - val_lung_loss: 0.0067 - val_covid_loss: 0.0072 - val_final_loss: 0.0061 - val_lung_f1_m: 0.9861 - val_covid_f1_m: 0.8206 - val_final_f1_m: 0.8573\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KDn27u4uuqFk"
      },
      "source": [
        "plt.figure(figsize=[15,7])\n",
        "plt.plot(history.history['final_f1_m'][:])\n",
        "# plt.plot(history.history['val_final_dice_score'])\n",
        "plt.plot(history.history['val_final_f1_m'][:])\n",
        "\n",
        "history.history.keys()\n",
        "len(history.history['loss'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KABmJmxHuqFk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "eabd3bbe-7e24-43eb-a5b4-ca7dc5277eef"
      },
      "source": [
        "pred = xmtl.predict(x_val)\n",
        "th = find_thresh(f1_m,y_val[:,1].astype(np.float32),pred[2].astype(np.float32))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.05      0.778\n",
            "0.1      0.811\n",
            "0.15      0.83\n",
            "0.2      0.842\n",
            "0.25      0.852\n",
            "0.3      0.859\n",
            "0.35      0.865\n",
            "0.4      0.869\n",
            "0.45      0.872\n",
            "0.5      0.873\n",
            "0.55      0.873\n",
            "0.6      0.872\n",
            "0.65      0.869\n",
            "0.7      0.864\n",
            "0.75      0.856\n",
            "0.8      0.847\n",
            "0.85      0.832\n",
            "0.9      0.81\n",
            "0.95      0.769\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTFCcXhYuqFk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cc76456-62ab-4fd1-f04b-b5cc5a3ec521"
      },
      "source": [
        "temp = xmtl.predict(x_test)\n",
        "pred = np.where(temp[2]>0.60,1,0).astype(np.bool)\n",
        "# pred_l = temp[0]\n",
        "\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "Use `tf.data.Iterator.get_next_as_optional()` instead.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6VglS7cyuqFk"
      },
      "source": [
        "for i in range(len(pred)):\n",
        "    if np.sum(pred[i]) < 80:\n",
        "        pred[i] = 0"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ukASVkYuqFk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cfe58ece-267f-45eb-911d-cc5cfcaf2898"
      },
      "source": [
        "p = metricss(y_test[:,1],pred)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 699/699 [00:22<00:00, 31.65it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "iou       :  0.737454433983476\n",
            "f1_score  :  0.7986083496766728\n",
            "ppv       :  0.8494818159813283\n",
            "sensivity :  0.769597697022739\n",
            "specifity :  0.9992141660307585\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pb6eSUhSeKlq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}