{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Aleksandra Jonas, Aleksandra Gronowska, Iwona Christop\n", "# Zadanie 9-10, zadanie 1 - VGG16 + ResNet on train_test_sw " ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Przygotowanie danych" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "from IPython.display import Image, display" ] }, { "cell_type": "code", "execution_count": 41, "id": "2fe63b50", "metadata": {}, "outputs": [], "source": [ "import sys\n", "import subprocess\n", "import pkg_resources\n", "import numpy as np\n", "\n", "required = { 'scikit-image'}\n", "installed = {pkg.key for pkg in pkg_resources.working_set}\n", "missing = required - installed\n", "# VGG16 requires images to be of dim = (224, 224, 3)\n", "newSize = (224,224)\n", "\n", "if missing: \n", " python = sys.executable\n", " subprocess.check_call([python, '-m', 'pip', 'install', *missing], stdout=subprocess.DEVNULL)\n", "\n", "def load_train_data(input_dir):\n", " import numpy as np\n", " import pandas as pd\n", " import os\n", " from skimage.io import imread\n", " import cv2 as cv\n", " from pathlib import Path\n", " import random\n", " from shutil import copyfile, rmtree\n", " import json\n", "\n", " import seaborn as sns\n", " import matplotlib.pyplot as plt\n", "\n", " import matplotlib\n", " \n", " image_dir = Path(input_dir)\n", " categories_name = []\n", " for file in os.listdir(image_dir):\n", " d = os.path.join(image_dir, file)\n", " if os.path.isdir(d):\n", " categories_name.append(file)\n", "\n", " folders = [directory for directory in image_dir.iterdir() if directory.is_dir()]\n", "\n", " train_img = []\n", " categories_count=[]\n", " labels=[]\n", " for i, direc in enumerate(folders):\n", " count = 0\n", " for obj in direc.iterdir():\n", " if os.path.isfile(obj) and os.path.basename(os.path.normpath(obj)) != 'desktop.ini':\n", " labels.append(os.path.basename(os.path.normpath(direc)))\n", " count += 1\n", " img = imread(obj)#zwraca ndarry postaci xSize x ySize x colorDepth\n", " img = img[:, :, :3]\n", " img = cv.resize(img, newSize, interpolation=cv.INTER_AREA)# zwraca ndarray\n", " img = img / 255 #normalizacja\n", " train_img.append(img)\n", " categories_count.append(count)\n", " X={}\n", " X[\"values\"] = np.array(train_img)\n", " X[\"categories_name\"] = categories_name\n", " X[\"categories_count\"] = categories_count\n", " X[\"labels\"]=labels\n", " return X\n", "\n", "def load_test_data(input_dir):\n", " import numpy as np\n", " import pandas as pd\n", " import os\n", " from skimage.io import imread\n", " import cv2 as cv\n", " from pathlib import Path\n", " import random\n", " from shutil import copyfile, rmtree\n", " import json\n", "\n", " import seaborn as sns\n", " import matplotlib.pyplot as plt\n", "\n", " import matplotlib\n", "\n", " image_path = Path(input_dir)\n", "\n", " labels_path = image_path.parents[0] / 'test_labels.json'\n", "\n", " jsonString = labels_path.read_text()\n", " objects = json.loads(jsonString)\n", "\n", " categories_name = []\n", " categories_count=[]\n", " count = 0\n", " c = objects[0]['value']\n", " for e in objects:\n", " if e['value'] != c:\n", " categories_count.append(count)\n", " c = e['value']\n", " count = 1\n", " else:\n", " count += 1\n", " if not e['value'] in categories_name:\n", " categories_name.append(e['value'])\n", "\n", " categories_count.append(count)\n", " \n", " test_img = []\n", "\n", " labels=[]\n", " for e in objects:\n", " p = image_path / e['filename']\n", " img = imread(p)#zwraca ndarry postaci xSize x ySize x colorDepth\n", " img = img[:, :, :3]\n", " img = cv.resize(img, newSize, interpolation=cv.INTER_AREA)# zwraca ndarray\n", " img = img / 255#normalizacja\n", " test_img.append(img)\n", " labels.append(e['value'])\n", "\n", " X={}\n", " X[\"values\"] = np.array(test_img)\n", " X[\"categories_name\"] = categories_name\n", " X[\"categories_count\"] = categories_count\n", " X[\"labels\"]=labels\n", " return X" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "def create_tf_ds(X_train, y_train_enc, X_validate, y_validate_enc, X_test, y_test_enc):\n", " import tensorflow as tf\n", " \n", " train_ds = tf.data.Dataset.from_tensor_slices((X_train, y_train_enc))\n", " validation_ds = tf.data.Dataset.from_tensor_slices((X_validate, y_validate_enc))\n", " test_ds = tf.data.Dataset.from_tensor_slices((X_test, y_test_enc))\n", "\n", " train_ds_size = tf.data.experimental.cardinality(train_ds).numpy()\n", " test_ds_size = tf.data.experimental.cardinality(test_ds).numpy()\n", " validation_ds_size = tf.data.experimental.cardinality(validation_ds).numpy()\n", "\n", " print(\"Training data size:\", train_ds_size)\n", " print(\"Test data size:\", test_ds_size)\n", " print(\"Validation data size:\", validation_ds_size)\n", "\n", " train_ds = (train_ds\n", " .shuffle(buffer_size=train_ds_size)\n", " .batch(batch_size=32, drop_remainder=True))\n", " test_ds = (test_ds\n", " .shuffle(buffer_size=train_ds_size)\n", " .batch(batch_size=32, drop_remainder=True))\n", " validation_ds = (validation_ds\n", " .shuffle(buffer_size=train_ds_size)\n", " .batch(batch_size=32, drop_remainder=True))\n", " \n", " return train_ds, test_ds, validation_ds" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "def get_run_logdir(root_logdir):\n", " import os\n", " import time\n", "\n", " run_id = time.strftime(\"run_%Y_%m_%d-%H_%M_%S\")\n", " return os.path.join(root_logdir, run_id)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "def diagram_setup(model_name):\n", " from tensorflow import keras\n", " import os\n", " \n", " root_logdir = os.path.join(os.curdir, f\"logs\\\\fit\\\\{model_name}\\\\\")\n", " \n", " run_logdir = get_run_logdir(root_logdir)\n", " tensorboard_cb = keras.callbacks.TensorBoard(run_logdir)" ] }, { "cell_type": "code", "execution_count": 45, "id": "cc941c5a", "metadata": {}, "outputs": [], "source": [ "# Data load\n", "data_train = load_train_data(\"./train_test_sw/train_sw\")\n", "values_train = data_train['values']\n", "labels_train = data_train['labels']\n", "\n", "data_test = load_test_data(\"./train_test_sw/test_sw\")\n", "X_test = data_test['values']\n", "y_test = data_test['labels']" ] }, { "cell_type": "code", "execution_count": 46, "id": "25040ac9", "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "X_train, X_validate, y_train, y_validate = train_test_split(values_train, labels_train, test_size=0.2, random_state=42)" ] }, { "cell_type": "code", "execution_count": 47, "id": "a1fe47e6", "metadata": {}, "outputs": [], "source": [ "from sklearn.preprocessing import LabelEncoder\n", "class_le = LabelEncoder()\n", "y_train_enc = class_le.fit_transform(y_train)\n", "y_validate_enc = class_le.fit_transform(y_validate)\n", "y_test_enc = class_le.fit_transform(y_test)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training data size: 821\n", "Test data size: 259\n", "Validation data size: 206\n" ] } ], "source": [ "train_ds, test_ds, validation_ds = create_tf_ds(X_train, y_train_enc, X_validate, y_validate_enc, X_test, y_test_enc)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## VGG16" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [], "source": [ "diagram_setup('vgg_sw')" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"model_3\"\n", "_________________________________________________________________\n", " Layer (type) Output Shape Param # \n", "=================================================================\n", " input_4 (InputLayer) [(None, 224, 224, 3)] 0 \n", " \n", " block1_conv1 (Conv2D) (None, 224, 224, 64) 1792 \n", " \n", " block1_conv2 (Conv2D) (None, 224, 224, 64) 36928 \n", " \n", " block1_pool (MaxPooling2D) (None, 112, 112, 64) 0 \n", " \n", " block2_conv1 (Conv2D) (None, 112, 112, 128) 73856 \n", " \n", " block2_conv2 (Conv2D) (None, 112, 112, 128) 147584 \n", " \n", " block2_pool (MaxPooling2D) (None, 56, 56, 128) 0 \n", " \n", " block3_conv1 (Conv2D) (None, 56, 56, 256) 295168 \n", " \n", " block3_conv2 (Conv2D) (None, 56, 56, 256) 590080 \n", " \n", " block3_conv3 (Conv2D) (None, 56, 56, 256) 590080 \n", " \n", " block3_pool (MaxPooling2D) (None, 28, 28, 256) 0 \n", " \n", " block4_conv1 (Conv2D) (None, 28, 28, 512) 1180160 \n", " \n", " block4_conv2 (Conv2D) (None, 28, 28, 512) 2359808 \n", " \n", " block4_conv3 (Conv2D) (None, 28, 28, 512) 2359808 \n", " \n", " block4_pool (MaxPooling2D) (None, 14, 14, 512) 0 \n", " \n", " block5_conv1 (Conv2D) (None, 14, 14, 512) 2359808 \n", " \n", " block5_conv2 (Conv2D) (None, 14, 14, 512) 2359808 \n", " \n", " block5_conv3 (Conv2D) (None, 14, 14, 512) 2359808 \n", " \n", " block5_pool (MaxPooling2D) (None, 7, 7, 512) 0 \n", " \n", " flatten_3 (Flatten) (None, 25088) 0 \n", " \n", " dense_3 (Dense) (None, 5) 125445 \n", " \n", "=================================================================\n", "Total params: 14,840,133\n", "Trainable params: 125,445\n", "Non-trainable params: 14,714,688\n", "_________________________________________________________________\n", "Epoch 1/25\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/3r/c8tg1h051m18qhsdccdysrt40000gn/T/ipykernel_11345/3456911324.py:75: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", " vggr = model.fit_generator(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "25/25 [==============================] - 117s 5s/step - loss: 1.4384 - accuracy: 0.4363 - val_loss: 0.8596 - val_accuracy: 0.6719\n", "Epoch 2/25\n", "25/25 [==============================] - 121s 5s/step - loss: 0.6040 - accuracy: 0.7975 - val_loss: 0.6615 - val_accuracy: 0.7552\n", "Epoch 3/25\n", "25/25 [==============================] - 126s 5s/step - loss: 0.3955 - accuracy: 0.9000 - val_loss: 0.5536 - val_accuracy: 0.7969\n", "Epoch 4/25\n", "25/25 [==============================] - 124s 5s/step - loss: 0.3278 - accuracy: 0.9237 - val_loss: 0.5154 - val_accuracy: 0.8438\n", "Epoch 5/25\n", "25/25 [==============================] - 124s 5s/step - loss: 0.2700 - accuracy: 0.9350 - val_loss: 0.5352 - val_accuracy: 0.7969\n", "Epoch 6/25\n", "25/25 [==============================] - 119s 5s/step - loss: 0.2109 - accuracy: 0.9538 - val_loss: 0.3983 - val_accuracy: 0.8854\n", "Epoch 7/25\n", "25/25 [==============================] - 117s 5s/step - loss: 0.1713 - accuracy: 0.9812 - val_loss: 0.3841 - val_accuracy: 0.8802\n", "Epoch 8/25\n", "25/25 [==============================] - 115s 5s/step - loss: 0.1519 - accuracy: 0.9850 - val_loss: 0.3871 - val_accuracy: 0.8854\n", "Epoch 9/25\n", "25/25 [==============================] - 117s 5s/step - loss: 0.1412 - accuracy: 0.9800 - val_loss: 0.4005 - val_accuracy: 0.8958\n", "Epoch 10/25\n", "25/25 [==============================] - 116s 5s/step - loss: 0.1176 - accuracy: 0.9900 - val_loss: 0.3657 - val_accuracy: 0.9062\n", "Epoch 11/25\n", "25/25 [==============================] - 116s 5s/step - loss: 0.1200 - accuracy: 0.9825 - val_loss: 0.3862 - val_accuracy: 0.8646\n", "Epoch 12/25\n", "25/25 [==============================] - 116s 5s/step - loss: 0.0958 - accuracy: 0.9912 - val_loss: 0.3412 - val_accuracy: 0.9010\n", "Epoch 13/25\n", "25/25 [==============================] - 113s 5s/step - loss: 0.0914 - accuracy: 0.9925 - val_loss: 0.3484 - val_accuracy: 0.8854\n", "Epoch 14/25\n", "25/25 [==============================] - 115s 5s/step - loss: 0.0799 - accuracy: 0.9950 - val_loss: 0.3406 - val_accuracy: 0.8906\n", "Epoch 15/25\n", "25/25 [==============================] - 118s 5s/step - loss: 0.0714 - accuracy: 0.9975 - val_loss: 0.3355 - val_accuracy: 0.8958\n", "Epoch 16/25\n", "25/25 [==============================] - 121s 5s/step - loss: 0.0728 - accuracy: 0.9950 - val_loss: 0.3384 - val_accuracy: 0.9062\n", "Epoch 17/25\n", "25/25 [==============================] - 120s 5s/step - loss: 0.0674 - accuracy: 0.9962 - val_loss: 0.3627 - val_accuracy: 0.8958\n", "Epoch 18/25\n", "25/25 [==============================] - 118s 5s/step - loss: 0.0580 - accuracy: 0.9962 - val_loss: 0.3231 - val_accuracy: 0.9115\n", "Epoch 19/25\n", "25/25 [==============================] - 118s 5s/step - loss: 0.0509 - accuracy: 0.9987 - val_loss: 0.3387 - val_accuracy: 0.8958\n", "Epoch 20/25\n", "25/25 [==============================] - 119s 5s/step - loss: 0.0492 - accuracy: 0.9987 - val_loss: 0.3076 - val_accuracy: 0.8906\n", "Epoch 21/25\n", "25/25 [==============================] - 1405s 58s/step - loss: 0.0458 - accuracy: 0.9987 - val_loss: 0.3350 - val_accuracy: 0.8854\n", "Epoch 22/25\n", "25/25 [==============================] - 1635s 68s/step - loss: 0.0458 - accuracy: 0.9975 - val_loss: 0.3148 - val_accuracy: 0.9062\n", "Epoch 23/25\n", "25/25 [==============================] - 103s 4s/step - loss: 0.0384 - accuracy: 1.0000 - val_loss: 0.3446 - val_accuracy: 0.8750\n", "Epoch 24/25\n", "25/25 [==============================] - 106s 4s/step - loss: 0.0387 - accuracy: 0.9987 - val_loss: 0.2885 - val_accuracy: 0.9062\n", "Epoch 25/25\n", "25/25 [==============================] - 109s 4s/step - loss: 0.0335 - accuracy: 1.0000 - val_loss: 0.2845 - val_accuracy: 0.8958\n" ] } ], "source": [ "import keras,os\n", "from keras.models import Sequential\n", "from keras.layers import Dense, Conv2D, MaxPool2D , Flatten\n", "from keras.preprocessing.image import ImageDataGenerator\n", "import numpy as np\n", "from keras.applications import VGG16\n", "from keras.layers import Input, Lambda, Dense, Flatten\n", "from keras.models import Model\n", "from keras.preprocessing import image\n", "from keras.preprocessing.image import ImageDataGenerator\n", "from keras.models import Sequential\n", "import numpy as np\n", "from glob import glob\n", "import matplotlib.pyplot as plt\n", "import ssl\n", "ssl._create_default_https_context = ssl._create_unverified_context\n", "\n", "# model = keras.models.Sequential([\n", "# keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu', input_shape=(224,224,3), padding=\"same\"),\n", "# keras.layers.Conv2D(filters=64, kernel_size=(3,3), activation='relu', input_shape=(224,224,3), padding=\"same\"),\n", "# keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", "# keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", "# keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"),\n", "# keras.layers.Flatten(),\n", "# keras.layers.Dense(units = 4096, activation='relu'),\n", "# keras.layers.Dense(units = 4096, activation='relu'),\n", "# keras.layers.Dense(units = 5, activation='softmax')\n", "# ])\n", "\n", "# re-size all the images to this\n", "IMAGE_SIZE = [224, 224]\n", "\n", "# add preprocessing layer to the front of resnet\n", "vgg2 = VGG16(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)\n", "\n", "# don't train existing weights\n", "for layer in vgg2.layers:\n", " layer.trainable = False\n", " \n", " # useful for getting number of classes\n", "classes = 5\n", " \n", "\n", "# our layers - you can add more if you want\n", "x = Flatten()(vgg2.output)\n", "# x = Dense(1000, activation='relu')(x)\n", "prediction = Dense(5, activation='softmax')(x)\n", "\n", "# create a model object\n", "model = Model(inputs=vgg2.input, outputs=prediction)\n", "\n", "# view the structure of the model\n", "model.summary()\n", "# tell the model what cost and optimization method to use\n", "model.compile(\n", " loss='sparse_categorical_crossentropy',\n", " optimizer='adam',\n", " metrics=['accuracy']\n", ")\n", "\n", "#train_ds_vgg_sw, test_ds_vgg_sw, validation_ds_vgg_sw\n", "# fit the model\n", "vggr = model.fit_generator(\n", " train_ds,\n", " validation_data=validation_ds,\n", " epochs=25,\n", " steps_per_epoch=len(train_ds),\n", " validation_steps=len(validation_ds)\n", ")" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(vggr.history[\"accuracy\"])\n", "plt.plot(vggr.history['val_accuracy'])\n", "plt.plot(vggr.history['loss'])\n", "plt.plot(vggr.history['val_loss'])\n", "plt.title(\"Model accuracy\")\n", "plt.ylabel(\"Value\")\n", "plt.xlabel(\"Epoch\")\n", "plt.legend([\"Accuracy\",\"Validation Accuracy\",\"Loss\",\"Validation Loss\"])\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8/8 [==============================] - 29s 4s/step - loss: 0.3817 - accuracy: 0.8633\n" ] }, { "data": { "text/plain": [ "[0.38167834281921387, 0.86328125]" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.evaluate(test_ds)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## ResNet101V2" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [], "source": [ "from keras.layers import Input, Lambda, Dense, Flatten\n", "from keras.models import Model\n", "from keras.preprocessing import image\n", "from keras.preprocessing.image import ImageDataGenerator\n", "from keras.models import Sequential\n", "import numpy as np\n", "from glob import glob\n", "import matplotlib.pyplot as plt\n", "import ssl\n", "ssl._create_default_https_context = ssl._create_unverified_context\n", "from keras.applications import ResNet101V2\n", "\n", "# re-size all the images to this\n", "IMAGE_SIZE = [224, 224]\n", "\n", "# add preprocessing layer to the front of resnet\n", "resnet = ResNet101V2(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)\n", "\n", "# don't train existing weights\n", "for layer in resnet.layers:\n", " layer.trainable = False\n", " \n", " # useful for getting number of classes\n", "classes = 5\n", " \n", "\n", "# our layers - you can add more if you want\n", "x = Flatten()(resnet.output)\n", "# x = Dense(1000, activation='relu')(x)\n", "prediction = Dense(5, activation='softmax')(x)" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model: \"model_4\"\n", "__________________________________________________________________________________________________\n", " Layer (type) Output Shape Param # Connected to \n", "==================================================================================================\n", " input_5 (InputLayer) [(None, 224, 224, 3 0 [] \n", " )] \n", " \n", " conv1_pad (ZeroPadding2D) (None, 230, 230, 3) 0 ['input_5[0][0]'] \n", " \n", " conv1_conv (Conv2D) (None, 112, 112, 64 9472 ['conv1_pad[0][0]'] \n", " ) \n", " \n", " pool1_pad (ZeroPadding2D) (None, 114, 114, 64 0 ['conv1_conv[0][0]'] \n", " ) \n", " \n", " pool1_pool (MaxPooling2D) (None, 56, 56, 64) 0 ['pool1_pad[0][0]'] \n", " \n", " conv2_block1_preact_bn (BatchN (None, 56, 56, 64) 256 ['pool1_pool[0][0]'] \n", " ormalization) \n", " \n", " conv2_block1_preact_relu (Acti (None, 56, 56, 64) 0 ['conv2_block1_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv2_block1_1_conv (Conv2D) (None, 56, 56, 64) 4096 ['conv2_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv2_block1_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block1_1_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block1_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block1_1_bn[0][0]'] \n", " n) \n", " \n", " conv2_block1_2_pad (ZeroPaddin (None, 58, 58, 64) 0 ['conv2_block1_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv2_block1_2_conv (Conv2D) (None, 56, 56, 64) 36864 ['conv2_block1_2_pad[0][0]'] \n", " \n", " conv2_block1_2_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block1_2_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block1_2_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block1_2_bn[0][0]'] \n", " n) \n", " \n", " conv2_block1_0_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv2_block1_3_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block1_2_relu[0][0]'] \n", " \n", " conv2_block1_out (Add) (None, 56, 56, 256) 0 ['conv2_block1_0_conv[0][0]', \n", " 'conv2_block1_3_conv[0][0]'] \n", " \n", " conv2_block2_preact_bn (BatchN (None, 56, 56, 256) 1024 ['conv2_block1_out[0][0]'] \n", " ormalization) \n", " \n", " conv2_block2_preact_relu (Acti (None, 56, 56, 256) 0 ['conv2_block2_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv2_block2_1_conv (Conv2D) (None, 56, 56, 64) 16384 ['conv2_block2_preact_relu[0][0]'\n", " ] \n", " \n", " conv2_block2_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block2_1_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block2_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block2_1_bn[0][0]'] \n", " n) \n", " \n", " conv2_block2_2_pad (ZeroPaddin (None, 58, 58, 64) 0 ['conv2_block2_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv2_block2_2_conv (Conv2D) (None, 56, 56, 64) 36864 ['conv2_block2_2_pad[0][0]'] \n", " \n", " conv2_block2_2_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block2_2_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block2_2_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block2_2_bn[0][0]'] \n", " n) \n", " \n", " conv2_block2_3_conv (Conv2D) (None, 56, 56, 256) 16640 ['conv2_block2_2_relu[0][0]'] \n", " \n", " conv2_block2_out (Add) (None, 56, 56, 256) 0 ['conv2_block1_out[0][0]', \n", " 'conv2_block2_3_conv[0][0]'] \n", " \n", " conv2_block3_preact_bn (BatchN (None, 56, 56, 256) 1024 ['conv2_block2_out[0][0]'] \n", " ormalization) \n", " \n", " conv2_block3_preact_relu (Acti (None, 56, 56, 256) 0 ['conv2_block3_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv2_block3_1_conv (Conv2D) (None, 56, 56, 64) 16384 ['conv2_block3_preact_relu[0][0]'\n", " ] \n", " \n", " conv2_block3_1_bn (BatchNormal (None, 56, 56, 64) 256 ['conv2_block3_1_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block3_1_relu (Activatio (None, 56, 56, 64) 0 ['conv2_block3_1_bn[0][0]'] \n", " n) \n", " \n", " conv2_block3_2_pad (ZeroPaddin (None, 58, 58, 64) 0 ['conv2_block3_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv2_block3_2_conv (Conv2D) (None, 28, 28, 64) 36864 ['conv2_block3_2_pad[0][0]'] \n", " \n", " conv2_block3_2_bn (BatchNormal (None, 28, 28, 64) 256 ['conv2_block3_2_conv[0][0]'] \n", " ization) \n", " \n", " conv2_block3_2_relu (Activatio (None, 28, 28, 64) 0 ['conv2_block3_2_bn[0][0]'] \n", " n) \n", " \n", " max_pooling2d_3 (MaxPooling2D) (None, 28, 28, 256) 0 ['conv2_block2_out[0][0]'] \n", " \n", " conv2_block3_3_conv (Conv2D) (None, 28, 28, 256) 16640 ['conv2_block3_2_relu[0][0]'] \n", " \n", " conv2_block3_out (Add) (None, 28, 28, 256) 0 ['max_pooling2d_3[0][0]', \n", " 'conv2_block3_3_conv[0][0]'] \n", " \n", " conv3_block1_preact_bn (BatchN (None, 28, 28, 256) 1024 ['conv2_block3_out[0][0]'] \n", " ormalization) \n", " \n", " conv3_block1_preact_relu (Acti (None, 28, 28, 256) 0 ['conv3_block1_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv3_block1_1_conv (Conv2D) (None, 28, 28, 128) 32768 ['conv3_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv3_block1_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block1_1_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block1_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block1_1_bn[0][0]'] \n", " n) \n", " \n", " conv3_block1_2_pad (ZeroPaddin (None, 30, 30, 128) 0 ['conv3_block1_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv3_block1_2_conv (Conv2D) (None, 28, 28, 128) 147456 ['conv3_block1_2_pad[0][0]'] \n", " \n", " conv3_block1_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block1_2_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block1_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block1_2_bn[0][0]'] \n", " n) \n", " \n", " conv3_block1_0_conv (Conv2D) (None, 28, 28, 512) 131584 ['conv3_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv3_block1_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block1_2_relu[0][0]'] \n", " \n", " conv3_block1_out (Add) (None, 28, 28, 512) 0 ['conv3_block1_0_conv[0][0]', \n", " 'conv3_block1_3_conv[0][0]'] \n", " \n", " conv3_block2_preact_bn (BatchN (None, 28, 28, 512) 2048 ['conv3_block1_out[0][0]'] \n", " ormalization) \n", " \n", " conv3_block2_preact_relu (Acti (None, 28, 28, 512) 0 ['conv3_block2_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv3_block2_1_conv (Conv2D) (None, 28, 28, 128) 65536 ['conv3_block2_preact_relu[0][0]'\n", " ] \n", " \n", " conv3_block2_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block2_1_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block2_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block2_1_bn[0][0]'] \n", " n) \n", " \n", " conv3_block2_2_pad (ZeroPaddin (None, 30, 30, 128) 0 ['conv3_block2_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv3_block2_2_conv (Conv2D) (None, 28, 28, 128) 147456 ['conv3_block2_2_pad[0][0]'] \n", " \n", " conv3_block2_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block2_2_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block2_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block2_2_bn[0][0]'] \n", " n) \n", " \n", " conv3_block2_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block2_2_relu[0][0]'] \n", " \n", " conv3_block2_out (Add) (None, 28, 28, 512) 0 ['conv3_block1_out[0][0]', \n", " 'conv3_block2_3_conv[0][0]'] \n", " \n", " conv3_block3_preact_bn (BatchN (None, 28, 28, 512) 2048 ['conv3_block2_out[0][0]'] \n", " ormalization) \n", " \n", " conv3_block3_preact_relu (Acti (None, 28, 28, 512) 0 ['conv3_block3_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv3_block3_1_conv (Conv2D) (None, 28, 28, 128) 65536 ['conv3_block3_preact_relu[0][0]'\n", " ] \n", " \n", " conv3_block3_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block3_1_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block3_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block3_1_bn[0][0]'] \n", " n) \n", " \n", " conv3_block3_2_pad (ZeroPaddin (None, 30, 30, 128) 0 ['conv3_block3_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv3_block3_2_conv (Conv2D) (None, 28, 28, 128) 147456 ['conv3_block3_2_pad[0][0]'] \n", " \n", " conv3_block3_2_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block3_2_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block3_2_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block3_2_bn[0][0]'] \n", " n) \n", " \n", " conv3_block3_3_conv (Conv2D) (None, 28, 28, 512) 66048 ['conv3_block3_2_relu[0][0]'] \n", " \n", " conv3_block3_out (Add) (None, 28, 28, 512) 0 ['conv3_block2_out[0][0]', \n", " 'conv3_block3_3_conv[0][0]'] \n", " \n", " conv3_block4_preact_bn (BatchN (None, 28, 28, 512) 2048 ['conv3_block3_out[0][0]'] \n", " ormalization) \n", " \n", " conv3_block4_preact_relu (Acti (None, 28, 28, 512) 0 ['conv3_block4_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv3_block4_1_conv (Conv2D) (None, 28, 28, 128) 65536 ['conv3_block4_preact_relu[0][0]'\n", " ] \n", " \n", " conv3_block4_1_bn (BatchNormal (None, 28, 28, 128) 512 ['conv3_block4_1_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block4_1_relu (Activatio (None, 28, 28, 128) 0 ['conv3_block4_1_bn[0][0]'] \n", " n) \n", " \n", " conv3_block4_2_pad (ZeroPaddin (None, 30, 30, 128) 0 ['conv3_block4_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv3_block4_2_conv (Conv2D) (None, 14, 14, 128) 147456 ['conv3_block4_2_pad[0][0]'] \n", " \n", " conv3_block4_2_bn (BatchNormal (None, 14, 14, 128) 512 ['conv3_block4_2_conv[0][0]'] \n", " ization) \n", " \n", " conv3_block4_2_relu (Activatio (None, 14, 14, 128) 0 ['conv3_block4_2_bn[0][0]'] \n", " n) \n", " \n", " max_pooling2d_4 (MaxPooling2D) (None, 14, 14, 512) 0 ['conv3_block3_out[0][0]'] \n", " \n", " conv3_block4_3_conv (Conv2D) (None, 14, 14, 512) 66048 ['conv3_block4_2_relu[0][0]'] \n", " \n", " conv3_block4_out (Add) (None, 14, 14, 512) 0 ['max_pooling2d_4[0][0]', \n", " 'conv3_block4_3_conv[0][0]'] \n", " \n", " conv4_block1_preact_bn (BatchN (None, 14, 14, 512) 2048 ['conv3_block4_out[0][0]'] \n", " ormalization) \n", " \n", " conv4_block1_preact_relu (Acti (None, 14, 14, 512) 0 ['conv4_block1_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv4_block1_1_conv (Conv2D) (None, 14, 14, 256) 131072 ['conv4_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block1_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block1_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block1_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block1_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block1_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block1_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block1_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block1_2_pad[0][0]'] \n", " \n", " conv4_block1_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block1_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block1_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block1_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block1_0_conv (Conv2D) (None, 14, 14, 1024 525312 ['conv4_block1_preact_relu[0][0]'\n", " ) ] \n", " \n", " conv4_block1_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block1_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block1_out (Add) (None, 14, 14, 1024 0 ['conv4_block1_0_conv[0][0]', \n", " ) 'conv4_block1_3_conv[0][0]'] \n", " \n", " conv4_block2_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block1_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block2_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block2_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block2_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block2_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block2_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block2_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block2_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block2_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block2_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block2_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block2_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block2_2_pad[0][0]'] \n", " \n", " conv4_block2_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block2_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block2_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block2_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block2_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block2_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block2_out (Add) (None, 14, 14, 1024 0 ['conv4_block1_out[0][0]', \n", " ) 'conv4_block2_3_conv[0][0]'] \n", " \n", " conv4_block3_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block2_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block3_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block3_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block3_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block3_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block3_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block3_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block3_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block3_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block3_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block3_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block3_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block3_2_pad[0][0]'] \n", " \n", " conv4_block3_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block3_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block3_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block3_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block3_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block3_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block3_out (Add) (None, 14, 14, 1024 0 ['conv4_block2_out[0][0]', \n", " ) 'conv4_block3_3_conv[0][0]'] \n", " \n", " conv4_block4_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block3_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block4_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block4_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block4_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block4_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block4_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block4_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block4_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block4_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block4_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block4_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block4_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block4_2_pad[0][0]'] \n", " \n", " conv4_block4_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block4_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block4_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block4_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block4_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block4_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block4_out (Add) (None, 14, 14, 1024 0 ['conv4_block3_out[0][0]', \n", " ) 'conv4_block4_3_conv[0][0]'] \n", " \n", " conv4_block5_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block4_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block5_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block5_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block5_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block5_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block5_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block5_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block5_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block5_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block5_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block5_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block5_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block5_2_pad[0][0]'] \n", " \n", " conv4_block5_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block5_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block5_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block5_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block5_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block5_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block5_out (Add) (None, 14, 14, 1024 0 ['conv4_block4_out[0][0]', \n", " ) 'conv4_block5_3_conv[0][0]'] \n", " \n", " conv4_block6_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block5_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block6_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block6_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block6_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block6_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block6_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block6_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block6_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block6_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block6_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block6_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block6_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block6_2_pad[0][0]'] \n", " \n", " conv4_block6_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block6_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block6_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block6_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block6_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block6_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block6_out (Add) (None, 14, 14, 1024 0 ['conv4_block5_out[0][0]', \n", " ) 'conv4_block6_3_conv[0][0]'] \n", " \n", " conv4_block7_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block6_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block7_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block7_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block7_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block7_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block7_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block7_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block7_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block7_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block7_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block7_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block7_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block7_2_pad[0][0]'] \n", " \n", " conv4_block7_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block7_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block7_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block7_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block7_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block7_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block7_out (Add) (None, 14, 14, 1024 0 ['conv4_block6_out[0][0]', \n", " ) 'conv4_block7_3_conv[0][0]'] \n", " \n", " conv4_block8_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block7_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block8_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block8_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block8_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block8_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block8_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block8_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block8_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block8_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block8_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block8_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block8_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block8_2_pad[0][0]'] \n", " \n", " conv4_block8_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block8_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block8_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block8_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block8_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block8_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block8_out (Add) (None, 14, 14, 1024 0 ['conv4_block7_out[0][0]', \n", " ) 'conv4_block8_3_conv[0][0]'] \n", " \n", " conv4_block9_preact_bn (BatchN (None, 14, 14, 1024 4096 ['conv4_block8_out[0][0]'] \n", " ormalization) ) \n", " \n", " conv4_block9_preact_relu (Acti (None, 14, 14, 1024 0 ['conv4_block9_preact_bn[0][0]'] \n", " vation) ) \n", " \n", " conv4_block9_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block9_preact_relu[0][0]'\n", " ] \n", " \n", " conv4_block9_1_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block9_1_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block9_1_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block9_1_bn[0][0]'] \n", " n) \n", " \n", " conv4_block9_2_pad (ZeroPaddin (None, 16, 16, 256) 0 ['conv4_block9_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv4_block9_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block9_2_pad[0][0]'] \n", " \n", " conv4_block9_2_bn (BatchNormal (None, 14, 14, 256) 1024 ['conv4_block9_2_conv[0][0]'] \n", " ization) \n", " \n", " conv4_block9_2_relu (Activatio (None, 14, 14, 256) 0 ['conv4_block9_2_bn[0][0]'] \n", " n) \n", " \n", " conv4_block9_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block9_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block9_out (Add) (None, 14, 14, 1024 0 ['conv4_block8_out[0][0]', \n", " ) 'conv4_block9_3_conv[0][0]'] \n", " \n", " conv4_block10_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block9_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block10_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block10_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block10_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block10_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block10_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block10_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block10_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block10_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block10_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block10_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block10_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block10_2_pad[0][0]'] \n", " \n", " conv4_block10_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block10_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block10_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block10_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block10_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block10_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block10_out (Add) (None, 14, 14, 1024 0 ['conv4_block9_out[0][0]', \n", " ) 'conv4_block10_3_conv[0][0]'] \n", " \n", " conv4_block11_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block10_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block11_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block11_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block11_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block11_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block11_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block11_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block11_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block11_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block11_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block11_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block11_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block11_2_pad[0][0]'] \n", " \n", " conv4_block11_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block11_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block11_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block11_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block11_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block11_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block11_out (Add) (None, 14, 14, 1024 0 ['conv4_block10_out[0][0]', \n", " ) 'conv4_block11_3_conv[0][0]'] \n", " \n", " conv4_block12_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block11_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block12_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block12_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block12_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block12_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block12_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block12_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block12_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block12_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block12_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block12_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block12_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block12_2_pad[0][0]'] \n", " \n", " conv4_block12_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block12_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block12_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block12_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block12_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block12_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block12_out (Add) (None, 14, 14, 1024 0 ['conv4_block11_out[0][0]', \n", " ) 'conv4_block12_3_conv[0][0]'] \n", " \n", " conv4_block13_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block12_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block13_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block13_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block13_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block13_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block13_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block13_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block13_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block13_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block13_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block13_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block13_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block13_2_pad[0][0]'] \n", " \n", " conv4_block13_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block13_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block13_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block13_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block13_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block13_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block13_out (Add) (None, 14, 14, 1024 0 ['conv4_block12_out[0][0]', \n", " ) 'conv4_block13_3_conv[0][0]'] \n", " \n", " conv4_block14_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block13_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block14_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block14_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block14_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block14_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block14_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block14_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block14_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block14_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block14_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block14_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block14_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block14_2_pad[0][0]'] \n", " \n", " conv4_block14_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block14_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block14_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block14_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block14_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block14_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block14_out (Add) (None, 14, 14, 1024 0 ['conv4_block13_out[0][0]', \n", " ) 'conv4_block14_3_conv[0][0]'] \n", " \n", " conv4_block15_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block14_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block15_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block15_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block15_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block15_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block15_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block15_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block15_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block15_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block15_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block15_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block15_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block15_2_pad[0][0]'] \n", " \n", " conv4_block15_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block15_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block15_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block15_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block15_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block15_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block15_out (Add) (None, 14, 14, 1024 0 ['conv4_block14_out[0][0]', \n", " ) 'conv4_block15_3_conv[0][0]'] \n", " \n", " conv4_block16_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block15_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block16_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block16_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block16_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block16_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block16_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block16_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block16_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block16_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block16_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block16_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block16_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block16_2_pad[0][0]'] \n", " \n", " conv4_block16_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block16_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block16_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block16_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block16_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block16_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block16_out (Add) (None, 14, 14, 1024 0 ['conv4_block15_out[0][0]', \n", " ) 'conv4_block16_3_conv[0][0]'] \n", " \n", " conv4_block17_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block16_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block17_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block17_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block17_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block17_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block17_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block17_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block17_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block17_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block17_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block17_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block17_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block17_2_pad[0][0]'] \n", " \n", " conv4_block17_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block17_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block17_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block17_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block17_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block17_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block17_out (Add) (None, 14, 14, 1024 0 ['conv4_block16_out[0][0]', \n", " ) 'conv4_block17_3_conv[0][0]'] \n", " \n", " conv4_block18_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block17_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block18_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block18_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block18_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block18_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block18_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block18_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block18_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block18_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block18_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block18_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block18_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block18_2_pad[0][0]'] \n", " \n", " conv4_block18_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block18_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block18_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block18_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block18_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block18_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block18_out (Add) (None, 14, 14, 1024 0 ['conv4_block17_out[0][0]', \n", " ) 'conv4_block18_3_conv[0][0]'] \n", " \n", " conv4_block19_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block18_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block19_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block19_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block19_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block19_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block19_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block19_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block19_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block19_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block19_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block19_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block19_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block19_2_pad[0][0]'] \n", " \n", " conv4_block19_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block19_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block19_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block19_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block19_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block19_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block19_out (Add) (None, 14, 14, 1024 0 ['conv4_block18_out[0][0]', \n", " ) 'conv4_block19_3_conv[0][0]'] \n", " \n", " conv4_block20_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block19_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block20_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block20_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block20_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block20_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block20_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block20_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block20_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block20_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block20_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block20_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block20_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block20_2_pad[0][0]'] \n", " \n", " conv4_block20_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block20_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block20_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block20_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block20_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block20_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block20_out (Add) (None, 14, 14, 1024 0 ['conv4_block19_out[0][0]', \n", " ) 'conv4_block20_3_conv[0][0]'] \n", " \n", " conv4_block21_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block20_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block21_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block21_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block21_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block21_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block21_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block21_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block21_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block21_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block21_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block21_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block21_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block21_2_pad[0][0]'] \n", " \n", " conv4_block21_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block21_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block21_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block21_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block21_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block21_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block21_out (Add) (None, 14, 14, 1024 0 ['conv4_block20_out[0][0]', \n", " ) 'conv4_block21_3_conv[0][0]'] \n", " \n", " conv4_block22_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block21_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block22_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block22_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block22_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block22_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block22_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block22_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block22_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block22_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block22_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block22_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block22_2_conv (Conv2D) (None, 14, 14, 256) 589824 ['conv4_block22_2_pad[0][0]'] \n", " \n", " conv4_block22_2_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block22_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block22_2_relu (Activati (None, 14, 14, 256) 0 ['conv4_block22_2_bn[0][0]'] \n", " on) \n", " \n", " conv4_block22_3_conv (Conv2D) (None, 14, 14, 1024 263168 ['conv4_block22_2_relu[0][0]'] \n", " ) \n", " \n", " conv4_block22_out (Add) (None, 14, 14, 1024 0 ['conv4_block21_out[0][0]', \n", " ) 'conv4_block22_3_conv[0][0]'] \n", " \n", " conv4_block23_preact_bn (Batch (None, 14, 14, 1024 4096 ['conv4_block22_out[0][0]'] \n", " Normalization) ) \n", " \n", " conv4_block23_preact_relu (Act (None, 14, 14, 1024 0 ['conv4_block23_preact_bn[0][0]']\n", " ivation) ) \n", " \n", " conv4_block23_1_conv (Conv2D) (None, 14, 14, 256) 262144 ['conv4_block23_preact_relu[0][0]\n", " '] \n", " \n", " conv4_block23_1_bn (BatchNorma (None, 14, 14, 256) 1024 ['conv4_block23_1_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block23_1_relu (Activati (None, 14, 14, 256) 0 ['conv4_block23_1_bn[0][0]'] \n", " on) \n", " \n", " conv4_block23_2_pad (ZeroPaddi (None, 16, 16, 256) 0 ['conv4_block23_1_relu[0][0]'] \n", " ng2D) \n", " \n", " conv4_block23_2_conv (Conv2D) (None, 7, 7, 256) 589824 ['conv4_block23_2_pad[0][0]'] \n", " \n", " conv4_block23_2_bn (BatchNorma (None, 7, 7, 256) 1024 ['conv4_block23_2_conv[0][0]'] \n", " lization) \n", " \n", " conv4_block23_2_relu (Activati (None, 7, 7, 256) 0 ['conv4_block23_2_bn[0][0]'] \n", " on) \n", " \n", " max_pooling2d_5 (MaxPooling2D) (None, 7, 7, 1024) 0 ['conv4_block22_out[0][0]'] \n", " \n", " conv4_block23_3_conv (Conv2D) (None, 7, 7, 1024) 263168 ['conv4_block23_2_relu[0][0]'] \n", " \n", " conv4_block23_out (Add) (None, 7, 7, 1024) 0 ['max_pooling2d_5[0][0]', \n", " 'conv4_block23_3_conv[0][0]'] \n", " \n", " conv5_block1_preact_bn (BatchN (None, 7, 7, 1024) 4096 ['conv4_block23_out[0][0]'] \n", " ormalization) \n", " \n", " conv5_block1_preact_relu (Acti (None, 7, 7, 1024) 0 ['conv5_block1_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv5_block1_1_conv (Conv2D) (None, 7, 7, 512) 524288 ['conv5_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv5_block1_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block1_1_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block1_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block1_1_bn[0][0]'] \n", " n) \n", " \n", " conv5_block1_2_pad (ZeroPaddin (None, 9, 9, 512) 0 ['conv5_block1_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv5_block1_2_conv (Conv2D) (None, 7, 7, 512) 2359296 ['conv5_block1_2_pad[0][0]'] \n", " \n", " conv5_block1_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block1_2_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block1_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block1_2_bn[0][0]'] \n", " n) \n", " \n", " conv5_block1_0_conv (Conv2D) (None, 7, 7, 2048) 2099200 ['conv5_block1_preact_relu[0][0]'\n", " ] \n", " \n", " conv5_block1_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block1_2_relu[0][0]'] \n", " \n", " conv5_block1_out (Add) (None, 7, 7, 2048) 0 ['conv5_block1_0_conv[0][0]', \n", " 'conv5_block1_3_conv[0][0]'] \n", " \n", " conv5_block2_preact_bn (BatchN (None, 7, 7, 2048) 8192 ['conv5_block1_out[0][0]'] \n", " ormalization) \n", " \n", " conv5_block2_preact_relu (Acti (None, 7, 7, 2048) 0 ['conv5_block2_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv5_block2_1_conv (Conv2D) (None, 7, 7, 512) 1048576 ['conv5_block2_preact_relu[0][0]'\n", " ] \n", " \n", " conv5_block2_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block2_1_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block2_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block2_1_bn[0][0]'] \n", " n) \n", " \n", " conv5_block2_2_pad (ZeroPaddin (None, 9, 9, 512) 0 ['conv5_block2_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv5_block2_2_conv (Conv2D) (None, 7, 7, 512) 2359296 ['conv5_block2_2_pad[0][0]'] \n", " \n", " conv5_block2_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block2_2_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block2_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block2_2_bn[0][0]'] \n", " n) \n", " \n", " conv5_block2_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block2_2_relu[0][0]'] \n", " \n", " conv5_block2_out (Add) (None, 7, 7, 2048) 0 ['conv5_block1_out[0][0]', \n", " 'conv5_block2_3_conv[0][0]'] \n", " \n", " conv5_block3_preact_bn (BatchN (None, 7, 7, 2048) 8192 ['conv5_block2_out[0][0]'] \n", " ormalization) \n", " \n", " conv5_block3_preact_relu (Acti (None, 7, 7, 2048) 0 ['conv5_block3_preact_bn[0][0]'] \n", " vation) \n", " \n", " conv5_block3_1_conv (Conv2D) (None, 7, 7, 512) 1048576 ['conv5_block3_preact_relu[0][0]'\n", " ] \n", " \n", " conv5_block3_1_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block3_1_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block3_1_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block3_1_bn[0][0]'] \n", " n) \n", " \n", " conv5_block3_2_pad (ZeroPaddin (None, 9, 9, 512) 0 ['conv5_block3_1_relu[0][0]'] \n", " g2D) \n", " \n", " conv5_block3_2_conv (Conv2D) (None, 7, 7, 512) 2359296 ['conv5_block3_2_pad[0][0]'] \n", " \n", " conv5_block3_2_bn (BatchNormal (None, 7, 7, 512) 2048 ['conv5_block3_2_conv[0][0]'] \n", " ization) \n", " \n", " conv5_block3_2_relu (Activatio (None, 7, 7, 512) 0 ['conv5_block3_2_bn[0][0]'] \n", " n) \n", " \n", " conv5_block3_3_conv (Conv2D) (None, 7, 7, 2048) 1050624 ['conv5_block3_2_relu[0][0]'] \n", " \n", " conv5_block3_out (Add) (None, 7, 7, 2048) 0 ['conv5_block2_out[0][0]', \n", " 'conv5_block3_3_conv[0][0]'] \n", " \n", " post_bn (BatchNormalization) (None, 7, 7, 2048) 8192 ['conv5_block3_out[0][0]'] \n", " \n", " post_relu (Activation) (None, 7, 7, 2048) 0 ['post_bn[0][0]'] \n", " \n", " flatten_4 (Flatten) (None, 100352) 0 ['post_relu[0][0]'] \n", " \n", " dense_4 (Dense) (None, 5) 501765 ['flatten_4[0][0]'] \n", " \n", "==================================================================================================\n", "Total params: 43,128,325\n", "Trainable params: 501,765\n", "Non-trainable params: 42,626,560\n", "__________________________________________________________________________________________________\n" ] } ], "source": [ "# create a model object\n", "model = Model(inputs=resnet.input, outputs=prediction)\n", "\n", "# view the structure of the model\n", "model.summary()" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/25\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/var/folders/3r/c8tg1h051m18qhsdccdysrt40000gn/T/ipykernel_11345/3602206220.py:10: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", " r = model.fit_generator(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "25/25 [==============================] - 59s 2s/step - loss: 3.6952 - accuracy: 0.7675 - val_loss: 1.0397 - val_accuracy: 0.9427\n", "Epoch 2/25\n", "25/25 [==============================] - 55s 2s/step - loss: 0.2606 - accuracy: 0.9688 - val_loss: 0.6033 - val_accuracy: 0.9479\n", "Epoch 3/25\n", "25/25 [==============================] - 55s 2s/step - loss: 0.0624 - accuracy: 0.9887 - val_loss: 0.7021 - val_accuracy: 0.9323\n", "Epoch 4/25\n", "25/25 [==============================] - 55s 2s/step - loss: 0.0150 - accuracy: 0.9987 - val_loss: 0.4405 - val_accuracy: 0.9688\n", "Epoch 5/25\n", "25/25 [==============================] - 56s 2s/step - loss: 0.0123 - accuracy: 0.9975 - val_loss: 0.3344 - val_accuracy: 0.9740\n", "Epoch 6/25\n", "25/25 [==============================] - 56s 2s/step - loss: 1.9117e-07 - accuracy: 1.0000 - val_loss: 0.1343 - val_accuracy: 0.9844\n", "Epoch 7/25\n", "25/25 [==============================] - 56s 2s/step - loss: 4.4405e-08 - accuracy: 1.0000 - val_loss: 0.2787 - val_accuracy: 0.9844\n", "Epoch 8/25\n", "25/25 [==============================] - 56s 2s/step - loss: 3.5911e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 9/25\n", "25/25 [==============================] - 57s 2s/step - loss: 2.7716e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 10/25\n", "25/25 [==============================] - 57s 2s/step - loss: 2.2948e-08 - accuracy: 1.0000 - val_loss: 0.1292 - val_accuracy: 0.9896\n", "Epoch 11/25\n", "25/25 [==============================] - 57s 2s/step - loss: 2.0563e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 12/25\n", "25/25 [==============================] - 57s 2s/step - loss: 1.7583e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 13/25\n", "25/25 [==============================] - 60s 2s/step - loss: 1.5646e-08 - accuracy: 1.0000 - val_loss: 0.2775 - val_accuracy: 0.9844\n", "Epoch 14/25\n", "25/25 [==============================] - 57s 2s/step - loss: 1.4305e-08 - accuracy: 1.0000 - val_loss: 0.1950 - val_accuracy: 0.9896\n", "Epoch 15/25\n", "25/25 [==============================] - 57s 2s/step - loss: 1.3560e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 16/25\n", "25/25 [==============================] - 57s 2s/step - loss: 1.1921e-08 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 17/25\n", "25/25 [==============================] - 57s 2s/step - loss: 1.1176e-08 - accuracy: 1.0000 - val_loss: 0.1318 - val_accuracy: 0.9896\n", "Epoch 18/25\n", "25/25 [==============================] - 59s 2s/step - loss: 1.0431e-08 - accuracy: 1.0000 - val_loss: 0.2776 - val_accuracy: 0.9844\n", "Epoch 19/25\n", "25/25 [==============================] - 58s 2s/step - loss: 9.8347e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 20/25\n", "25/25 [==============================] - 58s 2s/step - loss: 9.2387e-09 - accuracy: 1.0000 - val_loss: 0.2775 - val_accuracy: 0.9844\n", "Epoch 21/25\n", "25/25 [==============================] - 60s 2s/step - loss: 8.7917e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 22/25\n", "25/25 [==============================] - 58s 2s/step - loss: 8.3446e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 23/25\n", "25/25 [==============================] - 57s 2s/step - loss: 5.5134e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 24/25\n", "25/25 [==============================] - 56s 2s/step - loss: 7.5996e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n", "Epoch 25/25\n", "25/25 [==============================] - 57s 2s/step - loss: 7.3016e-09 - accuracy: 1.0000 - val_loss: 0.2785 - val_accuracy: 0.9844\n" ] } ], "source": [ "# tell the model what cost and optimization method to use\n", "model.compile(\n", " loss='sparse_categorical_crossentropy',\n", " optimizer='adam',\n", " metrics=['accuracy']\n", ")\n", "\n", "#train_ds_vgg_sw, test_ds_vgg_sw, validation_ds_vgg_sw\n", "# fit the model\n", "r = model.fit_generator(\n", " train_ds,\n", " validation_data=validation_ds,\n", " epochs=25,\n", " steps_per_epoch=len(train_ds),\n", " validation_steps=len(validation_ds)\n", ")" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# loss\n", "plt.plot(r.history[\"accuracy\"])\n", "plt.plot(r.history['val_accuracy'])\n", "plt.plot(r.history['loss'])\n", "plt.plot(r.history['val_loss'])\n", "plt.title(\"Model accuracy\")\n", "plt.ylabel(\"Value\")\n", "plt.xlabel(\"Epoch\")\n", "plt.legend([\"Accuracy\",\"Validation Accuracy\",\"Loss\",\"Validation Loss\"])\n", "plt.show()\n", "\n", "model.save('resnet_1.h5')" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "8/8 [==============================] - 15s 2s/step - loss: 0.7370 - accuracy: 0.9414\n" ] }, { "data": { "text/plain": [ "[0.7369823455810547, 0.94140625]" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.evaluate(test_ds)" ] } ], "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.10.1 (v3.10.1:2cd268a3a9, Dec 6 2021, 14:28:59) [Clang 13.0.0 (clang-1300.0.29.3)]" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" } } }, "nbformat": 4, "nbformat_minor": 2 }