Resnet from scratch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from keras import layers\n",
    "from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D\n",
    "from keras.models import Model, load_model\n",
    "from keras.preprocessing import image\n",
    "from keras.utils import layer_utils\n",
    "from keras.utils.data_utils import get_file\n",
    "from keras.applications.imagenet_utils import preprocess_input\n",
    "import pydot\n",
    "from IPython.display import SVG\n",
    "from keras.utils.vis_utils import model_to_dot\n",
    "from keras.utils import plot_model\n",
    "#from resnets_utils import *\n",
    "from keras.initializers import glorot_uniform\n",
    "import scipy.misc\n",
    "from matplotlib.pyplot import imshow\n",
    "%matplotlib inline\n",
    "\n",
    "import keras.backend as K\n",
    "K.set_image_data_format('channels_last')\n",
    "K.set_learning_phase(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def identity_block(X, f, filters, stage, block):\n",
    "    \"\"\"\n",
    "    Implementation of the identity block as defined in Figure 3\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the identity block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value. You'll need this later to add back to the main path. \n",
    "    X_shortcut = X\n",
    "    \n",
    "    # First component of main path\n",
    "    X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Second component of main path (≈3 lines)\n",
    "    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    # Third component of main path (≈2 lines)\n",
    "    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'same', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = layers.Add()([X, X_shortcut])\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out = [0.19716819 0.         1.3561226  2.1713073  0.         1.3324987 ]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as test:\n",
    "    np.random.seed(1)\n",
    "    A_prev = tf.placeholder(\"float\", [3, 4, 4, 6])\n",
    "    X = np.random.randn(3, 4, 4, 6)\n",
    "    A = identity_block(A_prev, f = 2, filters = [2, 4, 6], stage = 1, block = 'a')\n",
    "    test.run(tf.global_variables_initializer())\n",
    "    out = test.run([A], feed_dict={A_prev: X, K.learning_phase(): 0})\n",
    "    print(\"out = \" + str(out[0][1][1][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convolutional_block(X, f, filters, stage, block, s = 2):\n",
    "    \"\"\"\n",
    "    Implementation of the convolutional block as defined in Figure 4\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    s -- Integer, specifying the stride to be used\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value\n",
    "    X_shortcut = X\n",
    "\n",
    "\n",
    "    ##### MAIN PATH #####\n",
    "    # First component of main path \n",
    "    X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "\n",
    "    # Second component of main path (≈3 lines)\n",
    "    X = Conv2D(F2, (f, f), strides = (1, 1), padding='same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    # Third component of main path (≈2 lines)\n",
    "    X = Conv2D(F3, (1, 1), strides = (1, 1), padding='valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "    \n",
    "    ##### SHORTCUT PATH #### (≈2 lines)\n",
    "    X_shortcut = Conv2D(F3, (1, 1), strides = (s, s), padding='valid', name = conv_name_base + '1', kernel_initializer = glorot_uniform(seed=0))(X_shortcut)\n",
    "    X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = layers.add([X_shortcut, X])\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out = [0.09018463 1.2348979  0.46822023 0.03671762 0.         0.65516603]\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as test:\n",
    "    np.random.seed(1)\n",
    "    A_prev = tf.placeholder(\"float\", [3, 4, 4, 6])\n",
    "    X = np.random.randn(3, 4, 4, 6)\n",
    "    A = convolutional_block(A_prev, f = 2, filters = [2, 4, 6], stage = 1, block = 'a')\n",
    "    test.run(tf.global_variables_initializer())\n",
    "    out = test.run([A], feed_dict={A_prev: X, K.learning_phase(): 0})\n",
    "    print(\"out = \" + str(out[0][1][1][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ResNet50(input_shape = (64, 64, 3), classes = 6):\n",
    "    \"\"\"\n",
    "    Implementation of the popular ResNet50 the following architecture:\n",
    "    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3\n",
    "    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER\n",
    "\n",
    "    Arguments:\n",
    "    input_shape -- shape of the images of the dataset\n",
    "    classes -- integer, number of classes\n",
    "\n",
    "    Returns:\n",
    "    model -- a Model() instance in Keras\n",
    "    \"\"\"\n",
    "    \n",
    "    # Define the input as a tensor with shape input_shape\n",
    "    X_input = Input(input_shape)\n",
    "\n",
    "    \n",
    "    # Zero-Padding\n",
    "    X = ZeroPadding2D((3, 3))(X_input)\n",
    "    \n",
    "    # Stage 1\n",
    "    X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = 'bn_conv1')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    X = MaxPooling2D((3, 3), strides=(2, 2))(X)\n",
    "\n",
    "    # Stage 2\n",
    "    X = convolutional_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s=1)\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')\n",
    "\n",
    "    ### START CODE HERE ###\n",
    "    # The convolutional block uses three set of filters of size [128,128,512], \"f\" is 3, \"s\" is 2 and the block is \"a\".\n",
    "    # The 3 identity blocks use three set of filters of size [128,128,512], \"f\" is 3 and the blocks are \"b\", \"c\" and \"d\".\n",
    "\n",
    "    # Stage 3 (≈4 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [128, 128, 512], stage = 3, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')\n",
    "\n",
    "    # Stage 4 (≈6 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [256, 256, 1024], stage = 4, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')\n",
    "\n",
    "    # Stage 5 (≈3 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [512, 512, 2048], stage = 5, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')\n",
    "    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')\n",
    "\n",
    "    # AVGPOOL (≈1 line). Use \"X = AveragePooling2D(...)(X)\"\n",
    "    X = AveragePooling2D(pool_size=(2, 2), name='avg_pool')(X)\n",
    "    \n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # output layer\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    \n",
    "    \n",
    "    # Create model\n",
    "    model = Model(inputs = X_input, outputs = X, name='ResNet50')\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ResNet50(input_shape = (64, 64, 3), classes = 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_one_hot(A,C):\n",
    "    A=np.eye(C)[A.reshape(-1)].T\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "\n",
    "    train_dataset = h5py.File('C:\\\\Users\\\\G50\\\\ml jupyter notebooks\\\\train_signs.h5', \"r\")\n",
    "\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "\n",
    "\n",
    "    test_dataset = h5py.File('C:\\\\Users\\\\G50\\\\ml jupyter notebooks\\\\test_signs.h5', \"r\")\n",
    "\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "\n",
    "    \n",
    "\n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "\n",
    "    \n",
    "\n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of training examples = 1080\n",
      "number of test examples = 120\n",
      "X_train shape: (1080, 64, 64, 3)\n",
      "Y_train shape: (1080, 6)\n",
      "X_test shape: (120, 64, 64, 3)\n",
      "Y_test shape: (120, 6)\n"
     ]
    }
   ],
   "source": [
    "import h5py\n",
    "X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()\n",
    "\n",
    "# Normalize image vectors\n",
    "X_train = X_train_orig/255.\n",
    "X_test = X_test_orig/255.\n",
    "\n",
    "# Convert training and test labels to one hot matrices\n",
    "Y_train = convert_to_one_hot(Y_train_orig, 6).T\n",
    "Y_test = convert_to_one_hot(Y_test_orig, 6).T\n",
    "\n",
    "print (\"number of training examples = \" + str(X_train.shape[0]))\n",
    "print (\"number of test examples = \" + str(X_test.shape[0]))\n",
    "print (\"X_train shape: \" + str(X_train.shape))\n",
    "print (\"Y_train shape: \" + str(Y_train.shape))\n",
    "print (\"X_test shape: \" + str(X_test.shape))\n",
    "print (\"Y_test shape: \" + str(Y_test.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "  64/1080 [>.............................] - ETA: 1:17:45 - loss: 2.6796 - acc: 0.3438"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\g50\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\keras\\callbacks.py:120: UserWarning: Method on_batch_end() is slow compared to the batch update (15.956348). Check your callbacks.\n",
      "  % delta_t_median)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1080/1080 [==============================] - 872s 807ms/step - loss: 2.8674 - acc: 0.2435\n",
      "Epoch 2/2\n",
      "1080/1080 [==============================] - 475s 440ms/step - loss: 2.3930 - acc: 0.3139\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0xc830caa6d8>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, Y_train, epochs = 2, batch_size = 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120/120 [==============================] - 81s 677ms/step\n",
      "Loss = 5.962173239390055\n",
      "Test Accuracy = 0.18333333134651184\n"
     ]
    }
   ],
   "source": [
    "preds = model.evaluate(X_test, Y_test)\n",
    "print (\"Loss = \" + str(preds[0]))\n",
    "print (\"Test Accuracy = \" + str(preds[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\g50\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\keras\\models.py:291: UserWarning: Error in loading the saved optimizer state. As a result, your model is starting with a freshly initialized optimizer.\n",
      "  warnings.warn('Error in loading the saved optimizer '\n"
     ]
    }
   ],
   "source": [
    "model = load_model('C:\\\\Users\\\\G50\\\\ml jupyter notebooks\\\\ResNet50.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120/120 [==============================] - 19s 158ms/step\n",
      "Loss = 0.5301783164342244\n",
      "Test Accuracy = 0.8666666626930237\n"
     ]
    }
   ],
   "source": [
    "preds = model.evaluate(X_test, Y_test)\n",
    "print (\"Loss = \" + str(preds[0]))\n",
    "print (\"Test Accuracy = \" + str(preds[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input image shape: (1, 64, 64, 3)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\g50\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\ipykernel_launcher.py:18: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class prediction vector [p(0), p(1), p(2), p(3), p(4), p(5)] = \n",
      "[[1. 0. 0. 0. 0. 0.]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_path = 'C:\\\\Users\\\\G50\\\\ml jupyter notebooks\\\\resnets\\\\IMG_20180322_182750.jpg'\n",
    "#img = image.load_img(img_path, target_size=(64, 64))\n",
    "img=tf.keras.preprocessing.image.load_img(\n",
    "    img_path,\n",
    "    grayscale=False,\n",
    "    target_size=(64,64),\n",
    "    interpolation='nearest'\n",
    ")\n",
    "#x = image.img_to_array(img)\n",
    "x=tf.keras.preprocessing.image.img_to_array(\n",
    "    img,\n",
    "    data_format=None\n",
    ")\n",
    "\n",
    "x = np.expand_dims(x, axis=0)\n",
    "x = preprocess_input(x)\n",
    "print('Input image shape:', x.shape)\n",
    "my_image = scipy.misc.imread(img_path)\n",
    "imshow(my_image)\n",
    "print(\"class prediction vector [p(0), p(1), p(2), p(3), p(4), p(5)] = \")\n",
    "print(model.predict(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_1 (InputLayer)            (None, 64, 64, 3)    0                                            \n",
      "__________________________________________________________________________________________________\n",
      "zero_padding2d_1 (ZeroPadding2D (None, 70, 70, 3)    0           input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "conv1 (Conv2D)                  (None, 32, 32, 64)   9472        zero_padding2d_1[0][0]           \n",
      "__________________________________________________________________________________________________\n",
      "bn_conv1 (BatchNormalization)   (None, 32, 32, 64)   256         conv1[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "activation_4 (Activation)       (None, 32, 32, 64)   0           bn_conv1[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2D)  (None, 15, 15, 64)   0           activation_4[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "res2a_branch2a (Conv2D)         (None, 15, 15, 64)   4160        max_pooling2d_1[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "bn2a_branch2a (BatchNormalizati (None, 15, 15, 64)   256         res2a_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_5 (Activation)       (None, 15, 15, 64)   0           bn2a_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2a_branch2b (Conv2D)         (None, 15, 15, 64)   36928       activation_5[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "bn2a_branch2b (BatchNormalizati (None, 15, 15, 64)   256         res2a_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_6 (Activation)       (None, 15, 15, 64)   0           bn2a_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2a_branch2c (Conv2D)         (None, 15, 15, 256)  16640       activation_6[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "res2a_branch1 (Conv2D)          (None, 15, 15, 256)  16640       max_pooling2d_1[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "bn2a_branch2c (BatchNormalizati (None, 15, 15, 256)  1024        res2a_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "bn2a_branch1 (BatchNormalizatio (None, 15, 15, 256)  1024        res2a_branch1[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "add_2 (Add)                     (None, 15, 15, 256)  0           bn2a_branch2c[0][0]              \n",
      "                                                                 bn2a_branch1[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "activation_7 (Activation)       (None, 15, 15, 256)  0           add_2[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res2b_branch2a (Conv2D)         (None, 15, 15, 64)   16448       activation_7[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "bn2b_branch2a (BatchNormalizati (None, 15, 15, 64)   256         res2b_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_8 (Activation)       (None, 15, 15, 64)   0           bn2b_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2b_branch2b (Conv2D)         (None, 15, 15, 64)   36928       activation_8[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "bn2b_branch2b (BatchNormalizati (None, 15, 15, 64)   256         res2b_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_9 (Activation)       (None, 15, 15, 64)   0           bn2b_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2b_branch2c (Conv2D)         (None, 15, 15, 256)  16640       activation_9[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "bn2b_branch2c (BatchNormalizati (None, 15, 15, 256)  1024        res2b_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_3 (Add)                     (None, 15, 15, 256)  0           bn2b_branch2c[0][0]              \n",
      "                                                                 activation_7[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "activation_10 (Activation)      (None, 15, 15, 256)  0           add_3[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res2c_branch2a (Conv2D)         (None, 15, 15, 64)   16448       activation_10[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn2c_branch2a (BatchNormalizati (None, 15, 15, 64)   256         res2c_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_11 (Activation)      (None, 15, 15, 64)   0           bn2c_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2c_branch2b (Conv2D)         (None, 15, 15, 64)   36928       activation_11[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn2c_branch2b (BatchNormalizati (None, 15, 15, 64)   256         res2c_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_12 (Activation)      (None, 15, 15, 64)   0           bn2c_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res2c_branch2c (Conv2D)         (None, 15, 15, 256)  16640       activation_12[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn2c_branch2c (BatchNormalizati (None, 15, 15, 256)  1024        res2c_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_4 (Add)                     (None, 15, 15, 256)  0           bn2c_branch2c[0][0]              \n",
      "                                                                 activation_10[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_13 (Activation)      (None, 15, 15, 256)  0           add_4[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res3a_branch2a (Conv2D)         (None, 8, 8, 128)    32896       activation_13[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3a_branch2a (BatchNormalizati (None, 8, 8, 128)    512         res3a_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_14 (Activation)      (None, 8, 8, 128)    0           bn3a_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3a_branch2b (Conv2D)         (None, 8, 8, 128)    147584      activation_14[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3a_branch2b (BatchNormalizati (None, 8, 8, 128)    512         res3a_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_15 (Activation)      (None, 8, 8, 128)    0           bn3a_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3a_branch2c (Conv2D)         (None, 8, 8, 512)    66048       activation_15[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3a_branch1 (Conv2D)          (None, 8, 8, 512)    131584      activation_13[0][0]              \n",
      "__________________________________________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bn3a_branch2c (BatchNormalizati (None, 8, 8, 512)    2048        res3a_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "bn3a_branch1 (BatchNormalizatio (None, 8, 8, 512)    2048        res3a_branch1[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "add_5 (Add)                     (None, 8, 8, 512)    0           bn3a_branch2c[0][0]              \n",
      "                                                                 bn3a_branch1[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "activation_16 (Activation)      (None, 8, 8, 512)    0           add_5[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res3b_branch2a (Conv2D)         (None, 8, 8, 128)    65664       activation_16[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3b_branch2a (BatchNormalizati (None, 8, 8, 128)    512         res3b_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_17 (Activation)      (None, 8, 8, 128)    0           bn3b_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3b_branch2b (Conv2D)         (None, 8, 8, 128)    147584      activation_17[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3b_branch2b (BatchNormalizati (None, 8, 8, 128)    512         res3b_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_18 (Activation)      (None, 8, 8, 128)    0           bn3b_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3b_branch2c (Conv2D)         (None, 8, 8, 512)    66048       activation_18[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3b_branch2c (BatchNormalizati (None, 8, 8, 512)    2048        res3b_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_6 (Add)                     (None, 8, 8, 512)    0           bn3b_branch2c[0][0]              \n",
      "                                                                 activation_16[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_19 (Activation)      (None, 8, 8, 512)    0           add_6[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res3c_branch2a (Conv2D)         (None, 8, 8, 128)    65664       activation_19[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3c_branch2a (BatchNormalizati (None, 8, 8, 128)    512         res3c_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_20 (Activation)      (None, 8, 8, 128)    0           bn3c_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3c_branch2b (Conv2D)         (None, 8, 8, 128)    147584      activation_20[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3c_branch2b (BatchNormalizati (None, 8, 8, 128)    512         res3c_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_21 (Activation)      (None, 8, 8, 128)    0           bn3c_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3c_branch2c (Conv2D)         (None, 8, 8, 512)    66048       activation_21[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3c_branch2c (BatchNormalizati (None, 8, 8, 512)    2048        res3c_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_7 (Add)                     (None, 8, 8, 512)    0           bn3c_branch2c[0][0]              \n",
      "                                                                 activation_19[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_22 (Activation)      (None, 8, 8, 512)    0           add_7[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res3d_branch2a (Conv2D)         (None, 8, 8, 128)    65664       activation_22[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3d_branch2a (BatchNormalizati (None, 8, 8, 128)    512         res3d_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_23 (Activation)      (None, 8, 8, 128)    0           bn3d_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3d_branch2b (Conv2D)         (None, 8, 8, 128)    147584      activation_23[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3d_branch2b (BatchNormalizati (None, 8, 8, 128)    512         res3d_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_24 (Activation)      (None, 8, 8, 128)    0           bn3d_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res3d_branch2c (Conv2D)         (None, 8, 8, 512)    66048       activation_24[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn3d_branch2c (BatchNormalizati (None, 8, 8, 512)    2048        res3d_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_8 (Add)                     (None, 8, 8, 512)    0           bn3d_branch2c[0][0]              \n",
      "                                                                 activation_22[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_25 (Activation)      (None, 8, 8, 512)    0           add_8[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res4a_branch2a (Conv2D)         (None, 4, 4, 256)    131328      activation_25[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4a_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4a_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_26 (Activation)      (None, 4, 4, 256)    0           bn4a_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4a_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_26[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4a_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4a_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_27 (Activation)      (None, 4, 4, 256)    0           bn4a_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4a_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_27[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4a_branch1 (Conv2D)          (None, 4, 4, 1024)   525312      activation_25[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4a_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4a_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bn4a_branch1 (BatchNormalizatio (None, 4, 4, 1024)   4096        res4a_branch1[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "add_9 (Add)                     (None, 4, 4, 1024)   0           bn4a_branch2c[0][0]              \n",
      "                                                                 bn4a_branch1[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "activation_28 (Activation)      (None, 4, 4, 1024)   0           add_9[0][0]                      \n",
      "__________________________________________________________________________________________________\n",
      "res4b_branch2a (Conv2D)         (None, 4, 4, 256)    262400      activation_28[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4b_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4b_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_29 (Activation)      (None, 4, 4, 256)    0           bn4b_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4b_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_29[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4b_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4b_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_30 (Activation)      (None, 4, 4, 256)    0           bn4b_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4b_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_30[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4b_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4b_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_10 (Add)                    (None, 4, 4, 1024)   0           bn4b_branch2c[0][0]              \n",
      "                                                                 activation_28[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_31 (Activation)      (None, 4, 4, 1024)   0           add_10[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res4c_branch2a (Conv2D)         (None, 4, 4, 256)    262400      activation_31[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4c_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4c_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_32 (Activation)      (None, 4, 4, 256)    0           bn4c_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4c_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_32[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4c_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4c_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_33 (Activation)      (None, 4, 4, 256)    0           bn4c_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4c_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_33[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4c_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4c_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_11 (Add)                    (None, 4, 4, 1024)   0           bn4c_branch2c[0][0]              \n",
      "                                                                 activation_31[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_34 (Activation)      (None, 4, 4, 1024)   0           add_11[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res4d_branch2a (Conv2D)         (None, 4, 4, 256)    262400      activation_34[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4d_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4d_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_35 (Activation)      (None, 4, 4, 256)    0           bn4d_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4d_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_35[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4d_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4d_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_36 (Activation)      (None, 4, 4, 256)    0           bn4d_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4d_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_36[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4d_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4d_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_12 (Add)                    (None, 4, 4, 1024)   0           bn4d_branch2c[0][0]              \n",
      "                                                                 activation_34[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_37 (Activation)      (None, 4, 4, 1024)   0           add_12[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res4e_branch2a (Conv2D)         (None, 4, 4, 256)    262400      activation_37[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4e_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4e_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_38 (Activation)      (None, 4, 4, 256)    0           bn4e_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4e_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_38[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4e_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4e_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_39 (Activation)      (None, 4, 4, 256)    0           bn4e_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4e_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_39[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4e_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4e_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_13 (Add)                    (None, 4, 4, 1024)   0           bn4e_branch2c[0][0]              \n",
      "                                                                 activation_37[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_40 (Activation)      (None, 4, 4, 1024)   0           add_13[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res4f_branch2a (Conv2D)         (None, 4, 4, 256)    262400      activation_40[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4f_branch2a (BatchNormalizati (None, 4, 4, 256)    1024        res4f_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_41 (Activation)      (None, 4, 4, 256)    0           bn4f_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4f_branch2b (Conv2D)         (None, 4, 4, 256)    590080      activation_41[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4f_branch2b (BatchNormalizati (None, 4, 4, 256)    1024        res4f_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_42 (Activation)      (None, 4, 4, 256)    0           bn4f_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res4f_branch2c (Conv2D)         (None, 4, 4, 1024)   263168      activation_42[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn4f_branch2c (BatchNormalizati (None, 4, 4, 1024)   4096        res4f_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_14 (Add)                    (None, 4, 4, 1024)   0           bn4f_branch2c[0][0]              \n",
      "                                                                 activation_40[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_43 (Activation)      (None, 4, 4, 1024)   0           add_14[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res5a_branch2a (Conv2D)         (None, 2, 2, 512)    524800      activation_43[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5a_branch2a (BatchNormalizati (None, 2, 2, 512)    2048        res5a_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_44 (Activation)      (None, 2, 2, 512)    0           bn5a_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5a_branch2b (Conv2D)         (None, 2, 2, 512)    2359808     activation_44[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5a_branch2b (BatchNormalizati (None, 2, 2, 512)    2048        res5a_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_45 (Activation)      (None, 2, 2, 512)    0           bn5a_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5a_branch2c (Conv2D)         (None, 2, 2, 2048)   1050624     activation_45[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5a_branch1 (Conv2D)          (None, 2, 2, 2048)   2099200     activation_43[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5a_branch2c (BatchNormalizati (None, 2, 2, 2048)   8192        res5a_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "bn5a_branch1 (BatchNormalizatio (None, 2, 2, 2048)   8192        res5a_branch1[0][0]              \n",
      "__________________________________________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add_15 (Add)                    (None, 2, 2, 2048)   0           bn5a_branch2c[0][0]              \n",
      "                                                                 bn5a_branch1[0][0]               \n",
      "__________________________________________________________________________________________________\n",
      "activation_46 (Activation)      (None, 2, 2, 2048)   0           add_15[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res5b_branch2a (Conv2D)         (None, 2, 2, 512)    1049088     activation_46[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5b_branch2a (BatchNormalizati (None, 2, 2, 512)    2048        res5b_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_47 (Activation)      (None, 2, 2, 512)    0           bn5b_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5b_branch2b (Conv2D)         (None, 2, 2, 512)    2359808     activation_47[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5b_branch2b (BatchNormalizati (None, 2, 2, 512)    2048        res5b_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_48 (Activation)      (None, 2, 2, 512)    0           bn5b_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5b_branch2c (Conv2D)         (None, 2, 2, 2048)   1050624     activation_48[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5b_branch2c (BatchNormalizati (None, 2, 2, 2048)   8192        res5b_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_16 (Add)                    (None, 2, 2, 2048)   0           bn5b_branch2c[0][0]              \n",
      "                                                                 activation_46[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_49 (Activation)      (None, 2, 2, 2048)   0           add_16[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "res5c_branch2a (Conv2D)         (None, 2, 2, 512)    1049088     activation_49[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5c_branch2a (BatchNormalizati (None, 2, 2, 512)    2048        res5c_branch2a[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_50 (Activation)      (None, 2, 2, 512)    0           bn5c_branch2a[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5c_branch2b (Conv2D)         (None, 2, 2, 512)    2359808     activation_50[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5c_branch2b (BatchNormalizati (None, 2, 2, 512)    2048        res5c_branch2b[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "activation_51 (Activation)      (None, 2, 2, 512)    0           bn5c_branch2b[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "res5c_branch2c (Conv2D)         (None, 2, 2, 2048)   1050624     activation_51[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "bn5c_branch2c (BatchNormalizati (None, 2, 2, 2048)   8192        res5c_branch2c[0][0]             \n",
      "__________________________________________________________________________________________________\n",
      "add_17 (Add)                    (None, 2, 2, 2048)   0           bn5c_branch2c[0][0]              \n",
      "                                                                 activation_49[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "activation_52 (Activation)      (None, 2, 2, 2048)   0           add_17[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "avg_pool (AveragePooling2D)     (None, 1, 1, 2048)   0           activation_52[0][0]              \n",
      "__________________________________________________________________________________________________\n",
      "flatten_1 (Flatten)             (None, 2048)         0           avg_pool[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "fc6 (Dense)                     (None, 6)            12294       flatten_1[0][0]                  \n",
      "==================================================================================================\n",
      "Total params: 23,600,006\n",
      "Trainable params: 23,546,886\n",
      "Non-trainable params: 53,120\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}