def EEGNet_fusion(nb_classes, Chans=64, Samples=128,
dropoutRate=0.5, norm_rate=0.25, dropoutType='Dropout', cpu=False):
if dropoutType == 'SpatialDropout2D':
dropoutType = SpatialDropout2D
elif dropoutType == 'Dropout':
dropoutType = Dropout
else:
raise ValueError('dropoutType must be one of SpatialDropout2D '
'or Dropout, passed as a string.')
if cpu:
input_shape = (Samples, Chans, 1)
conv_filters = (64, 1)
conv_filters2 = (96, 1)
conv_filters3 = (128, 1)
depth_filters = (1, Chans)
pool_size = (4, 1)
pool_size2 = (8, 1)
separable_filters = (8, 1)
separable_filters2 = (16, 1)
separable_filters3 = (32, 1)
axis = -1
else:
input_shape = (1, Chans, Samples)
conv_filters = (1, 64)
conv_filters2 = (1, 96)
conv_filters3 = (1, 128)
depth_filters = (Chans, 1)
pool_size = (1, 4)
pool_size2 = (1, 8)
separable_filters = (1, 8)
separable_filters2 = (1, 16)
separable_filters3 = (1, 32)
axis = 1
F1 = 8
F1_2 = 16
F1_3 = 32
F2 = 16
F2_2 = 32
F2_3 = 64
D = 2
D2 = 2
D3 = 2
input1 = Input(shape=input_shape)
block1 = Conv2D(F1, conv_filters, padding='same',
input_shape=input_shape,
use_bias=False)(input1)
block1 = BatchNormalization(axis=axis)(block1)
block1 = DepthwiseConv2D(depth_filters, use_bias=False,
depth_multiplier=D,
depthwise_constraint=max_norm(1.))(block1)
block1 = BatchNormalization(axis=axis)(block1)
block1 = Activation('elu')(block1)
block1 = AveragePooling2D(pool_size)(block1)
block1 = dropoutType(dropoutRate)(block1)
block2 = SeparableConv2D(F2, separable_filters,
use_bias=False, padding='same')(block1) # 8
block2 = BatchNormalization(axis=axis)(block2)
block2 = Activation('elu')(block2)
block2 = AveragePooling2D(pool_size2)(block2)
block2 = dropoutType(dropoutRate)(block2)
block2 = Flatten()(block2) # 13
# 8 - 13
input2 = Input(shape=input_shape)
block3 = Conv2D(F1_2, conv_filters2, padding='same',
input_shape=input_shape,
use_bias=False)(input2)
block3 = BatchNormalization(axis=axis)(block3)
block3 = DepthwiseConv2D(depth_filters, use_bias=False,
depth_multiplier=D2,
depthwise_constraint=max_norm(1.))(block3)
block3 = BatchNormalization(axis=axis)(block3)
block3 = Activation('elu')(block3)
block3 = AveragePooling2D(pool_size)(block3)
block3 = dropoutType(dropoutRate)(block3)
block4 = SeparableConv2D(F2_2, separable_filters2,
use_bias=False, padding='same')(block3) # 22
block4 = BatchNormalization(axis=axis)(block4)
block4 = Activation('elu')(block4)
block4 = AveragePooling2D(pool_size2)(block4)
block4 = dropoutType(dropoutRate)(block4)
block4 = Flatten()(block4) # 27
# 22 - 27
input3 = Input(shape=input_shape)
block5 = Conv2D(F1_3, conv_filters3, padding='same',
input_shape=input_shape,
use_bias=False)(input3)
block5 = BatchNormalization(axis=axis)(block5)
block5 = DepthwiseConv2D(depth_filters, use_bias=False,
depth_multiplier=D3,
depthwise_constraint=max_norm(1.))(block5)
block5 = BatchNormalization(axis=axis)(block5)
block5 = Activation('elu')(block5)
block5 = AveragePooling2D(pool_size)(block5)
block5 = dropoutType(dropoutRate)(block5)
block6 = SeparableConv2D(F2_3, separable_filters3,
use_bias=False, padding='same')(block5) # 36
block6 = BatchNormalization(axis=axis)(block6)
block6 = Activation('elu')(block6)
block6 = AveragePooling2D(pool_size2)(block6)
block6 = dropoutType(dropoutRate)(block6)
block6 = Flatten()(block6) # 41
# 36 - 41
merge_one = concatenate([block2, block4])
merge_two = concatenate([merge_one, block6])
flatten = Flatten()(merge_two)
dense = Dense(nb_classes, name='dense',
kernel_constraint=max_norm(norm_rate))(flatten)
softmax = Activation('softmax', name='softmax')(dense)
return Model(inputs=[input1, input2, input3], outputs=softmax)
def build(width, height, depth, classes):
# init the input shape to be the channel last and the channels
# dimension itself
input_shape = height, width, depth
chan_dim = -1
if K.image_data_format() == 'channel_first':
input_shape = depth, height, width
chan_dim = 1
# define model input
inputs = Input(shape=input_shape)
x = MiniGoogleNet.conv_module(x=inputs,
k=96,
kx=3,
ky=3,
stride=(1, 1),
chan_dim=chan_dim)
# two inception modules followed by downsample module
x = MiniGoogleNet.inception_module(x=x,
numx1=32,
numx3=32,
chan_dim=chan_dim)
x = MiniGoogleNet.inception_module(x=x,
numx1=32,
numx3=48,
chan_dim=chan_dim)
x = MiniGoogleNet.downsample_module(x=x, k=80, chan_dim=chan_dim)
# 4 inception then downsample
x = MiniGoogleNet.inception_module(x=x,
numx1=112,
numx3=48,
chan_dim=chan_dim)
x = MiniGoogleNet.inception_module(x=x,
numx1=96,
numx3=64,
chan_dim=chan_dim)
x = MiniGoogleNet.inception_module(x=x,
numx1=80,
numx3=80,
chan_dim=chan_dim)
x = MiniGoogleNet.inception_module(x=x,
numx1=48,
numx3=96,
chan_dim=chan_dim)
x = MiniGoogleNet.downsample_module(x=x, k=96, chan_dim=chan_dim)
# two inception modules followed by global pool and dropout
x = MiniGoogleNet.inception_module(x=x,
numx1=176,
numx3=160,
chan_dim=chan_dim)
x = MiniGoogleNet.inception_module(x=x,
numx1=176,
numx3=160,
chan_dim=chan_dim)
x = AveragePooling2D(pool_size=(7, 7))(x)
x = Dropout(0.5)(x)
# softmax classifier
x = Flatten()(x)
x = Dense(classes)(x)
x = Activation("softmax")(x)
# create the model
model = Model(inputs, x, name="googlenet")
return model
def ASPP(tensor):
'''atrous spatial pyramid pooling'''
dims = K.int_shape(tensor)
y_pool = AveragePooling2D(pool_size=(dims[1], dims[2]),
name='average_pooling')(tensor)
y_pool = Conv2D(filters=256,
kernel_size=1,
padding='same',
kernel_initializer='he_normal',
name='pool_1x1conv2d',
use_bias=False)(y_pool)
y_pool = BatchNormalization(name=f'bn_1')(y_pool)
y_pool = Activation('relu', name=f'relu_1')(y_pool)
y_pool = Upsample(tensor=y_pool, size=[dims[1], dims[2]])
y_1 = Conv2D(filters=256,
kernel_size=1,
dilation_rate=1,
padding='same',
kernel_initializer='he_normal',
name='ASPP_conv2d_d1',
use_bias=False)(tensor)
y_1 = BatchNormalization(name=f'bn_2')(y_1)
y_1 = Activation('relu', name=f'relu_2')(y_1)
y_6 = Conv2D(filters=256,
kernel_size=3,
dilation_rate=6,
padding='same',
kernel_initializer='he_normal',
name='ASPP_conv2d_d6',
use_bias=False)(tensor)
y_6 = BatchNormalization(name=f'bn_3')(y_6)
y_6 = Activation('relu', name=f'relu_3')(y_6)
y_12 = Conv2D(filters=256,
kernel_size=3,
dilation_rate=12,
padding='same',
kernel_initializer='he_normal',
name='ASPP_conv2d_d12',
use_bias=False)(tensor)
y_12 = BatchNormalization(name=f'bn_4')(y_12)
y_12 = Activation('relu', name=f'relu_4')(y_12)
y_18 = Conv2D(filters=256,
kernel_size=3,
dilation_rate=18,
padding='same',
kernel_initializer='he_normal',
name='ASPP_conv2d_d18',
use_bias=False)(tensor)
y_18 = BatchNormalization(name=f'bn_5')(y_18)
y_18 = Activation('relu', name=f'relu_5')(y_18)
y = concatenate([y_pool, y_1, y_6, y_12, y_18], name='ASPP_concat')
y = Conv2D(filters=256,
kernel_size=1,
dilation_rate=1,
padding='same',
kernel_initializer='he_normal',
name='ASPP_conv2d_final',
use_bias=False)(y)
y = BatchNormalization(name=f'bn_final')(y)
y = Activation('relu', name=f'relu_final')(y)
return y
# initialize the training data augmentation object
trainAug = ImageDataGenerator(
rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
fill_mode="nearest")
baseModel = VGG16(weights="imagenet", include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
# construct the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(4, 4))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(64, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(3, activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# loop over all layers in the base model and freeze them so they will
# *not* be updated during the first training process
for layer in baseModel.layers:
layer.trainable = False
# compile our model
def EEGNet(nb_classes,
Chans=64,
Samples=128,
dropoutRate=0.5,
kernLength=64,
F1=8,
D=2,
F2=16,
norm_rate=0.25,
EnK=True,
dropoutType='Dropout'):
if dropoutType == 'SpatialDropout2D':
dropoutType = SpatialDropout2D
elif dropoutType == 'Dropout':
dropoutType = Dropout
else:
raise ValueError('dropoutType must be one of SpatialDropout2D '
'or Dropout, passed as a string.')
# with tf.Graph().as_default() as g:
input1 = Input(shape=(1, Chans, Samples))
block1 = Conv2D(F1, (1, kernLength),
padding='same',
input_shape=(1, Chans, Samples),
use_bias=False,
data_format='channels_first')(input1)
block1 = EnKLayer(filter=F1,
EnK=EnK,
InputData_shape=(1, Chans, Samples),
output_dimension=(1, 1, kernLength),
conv2DOutput=block1)(input1)
block1 = BatchNormalization(axis=1)(block1)
block1 = DepthwiseConv2D((Chans, 1),
use_bias=False,
depth_multiplier=D,
data_format='channels_first',
depthwise_constraint=max_norm(1.))(block1)
block1 = BatchNormalization(axis=1)(block1) # changed by avinash
block1 = Activation('elu')(block1)
block1 = AveragePooling2D(
(1, 4),
data_format='channels_first',
)(block1)
block1 = dropoutType(dropoutRate)(block1)
block2 = SeparableConv2D(
F2,
(1, 16), # changed by avinash
data_format='channels_first',
use_bias=False,
padding='same')(block1)
block2 = BatchNormalization(axis=1)(block2)
block2 = Activation('elu')(block2)
block2 = AveragePooling2D(
(1, 8),
data_format='channels_first',
)(block2)
block2 = dropoutType(dropoutRate)(block2)
flatten = Flatten(name='flatten', data_format='channels_first')(block2)
dense = Dense(nb_classes,
name='dense',
kernel_constraint=max_norm(norm_rate))(flatten)
softmax = Activation('softmax', name='softmax')(dense)
return Model(inputs=input1, outputs=softmax)
def ResNet(input_shape,
num_classes=1000,
block_fn=_residual_block_basic,
repetitions=(2, 2, 2, 2),
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=regulizers.l2(1e-4)):
"""
Build a ResNet model for classification.
:param input_shape: Input shape (e.g. (224, 224, 3))
:param num_classes: Number of classes to predict
:param block_fn: Block layer method to be used.
:param repetitions: List of repetitions for each macro-blocks the network should contain.
:param use_bias: Flag to use bias or not in Conv layer.
:param kernel_initializer: Kernel initialisation method name.
:param kernel_regularizer: Kernel regularizer.
:return: ResNet model.
"""
# Input and 1st layers:
inputs = Input(shape=input_shape)
conv = _res_conv(filters=64,
kernel_size=7,
strides=2,
use_relu=True,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(inputs)
maxpool = MaxPooling2D(pool_size=3, strides=2, padding='same')(conv)
# Chain of residual blocks:
filters = 64
strides = 2
res_block = maxpool
for i, repet in enumerate(repetitions):
# We do not further reduce the input size for the 1st block (max-pool applied just before):
block_strides = strides if i != 0 else 1
macroblock_name = "block_{}".format(i)
res_block = _residual_macroblock(
block_fn=block_fn,
repetitions=repet,
name=macroblock_name,
filters=filters,
strides_1st_block=block_strides,
use_bias=use_bias,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer)(res_block)
filters = min(filters * 2, 1024) # we limit to 1024 filters max
# Final layers for prediction:
res_spatial_dim = tf.keras.backend.int_shape(res_block)[1:3]
avg_pool = AveragePooling2D(pool_size=res_spatial_dim,
strides=1)(res_block)
flatten = Flatten()(avg_pool)
predictions = Dense(units=num_classes,
kernel_initializer=kernel_initializer,
activation='softmax')(flatten)
# Model:
model = Model(inputs=inputs, outputs=predictions)
return model
def resnet18(input_shape=(224,224,3), classes=1000):
inputs = Input(shape=input_shape)
# conv1
layer1 = resnet_layer(inputs=inputs,num_filters=64, strides=(2,2), kernel_size=(7,7),activation='relu')
conv1_zero_pad = ZeroPadding2D(padding=(1, 1))(layer1)
pool1_helper = PoolHelper()(conv1_zero_pad)
pool_1 = MaxPooling2D(pool_size=(3,3), strides=(2,2), padding='valid', name='pool1/3x3_s2')(pool1_helper)
# 변수, layer_a_b_c 에서 a : conv number , b : block number , c : layer number 이다.
# 변수, res_a_b 에서 a : conv number , b : block number ( = res number) 이다.
# 변수, acti_a_b 에서 a : conv number , b : number between blocks 이다.
# 이 사실을 기억하고, 아래의 변수들을 해석한다.
# conv2_x
layer_2_1_1 = resnet_layer(inputs=pool_1, num_filters=64, strides=(1,1), kernel_size=(3,3), activation='relu')
layer_2_1_2 = resnet_layer(inputs=layer_2_1_1, num_filters=64, strides=(1,1), kernel_size=(3,3), activation=None)
res_2_1 = add([pool_1, layer_2_1_2]) # block 1
acti_2_1 = Activation("relu")(res_2_1)
layer_2_2_1 = resnet_layer(inputs=acti_2_1, num_filters=64, strides=(1,1), kernel_size=(3,3), activation='relu')
layer_2_2_2 = resnet_layer(inputs=layer_2_2_1, num_filters=64, strides=(1,1), kernel_size=(3,3), activation=None)
res_2_2 = add([acti_2_1, layer_2_2_2]) # block 2 // 그리고 이런 규칙은 아래에서도 적용된다.
acti_2_output = Activation('relu')(res_2_2)
# 변수 identi_3_input 은 conv3_x 묶음에 처음으로 들어올 input이다. 이 값은 변환 없이 자기 자신을 유지한 채로 간다.
# conv3_x
identi_3_input = Conv2D(128, (1, 1), strides=(2, 2), padding='valid')(acti_2_output) # 차원을 맞춰주기 위해 convolution 연산 추가. (그대로 가는것)
#identi_3_input = BatchNormalization()(identi_3_input) # 모든 conv.뒤에는 bn을 적용.
layer_3_1_1 = resnet_layer(inputs=acti_2_output, num_filters=128, strides=(2,2), kernel_size=(3,3),activation='relu') #이 아래 두층은 rensnet층
layer_3_1_2 = resnet_layer(inputs=layer_3_1_1, num_filters=128, strides=(1,1), kernel_size=(3,3), activation=None)
res_3_1 = add([identi_3_input, layer_3_1_2])
acti_3_1 = Activation("relu")(res_3_1)
layer_3_2_1 = resnet_layer(inputs=acti_3_1,num_filters=128, strides=(1,1), kernel_size=(3,3), activation='relu') #이 아래 두층은 rensnet층
layer_3_2_2 = resnet_layer(inputs=layer_3_2_1, num_filters=128, strides=(1,1), kernel_size=(3,3), activation=None)
res_3_2 = add([acti_3_1, layer_3_2_2])
acti_3_output = Activation('relu')(res_3_2)
# conv4_x
identi_4_input = Conv2D(256, (1, 1), strides=(2, 2), padding='valid')(acti_3_output) # 차원을 맞춰주기 위해 convolution 연산 추가. (그대로 가는것)
#identi_4_input = BatchNormalization()(identi_4_input) # 모든 conv.뒤에는 bn을 적용.
layer_4_1_1 = resnet_layer(inputs=acti_3_output, num_filters=256, strides=(2,2), kernel_size=(3,3),activation='relu') #이 아래 두층은 rensnet층
layer_4_1_2 = resnet_layer(inputs=layer_4_1_1, num_filters=256, strides=(1,1), kernel_size=(3,3), activation=None)
res_4_1 = add([identi_4_input, layer_4_1_2])
acti_4_1 = Activation("relu")(res_4_1)
layer_4_2_1 = resnet_layer(inputs=acti_4_1,num_filters=256, strides=(1,1), kernel_size=(3,3), activation='relu') #이 아래 두층은 rensnet층
layer_4_2_2 = resnet_layer(inputs=layer_4_2_1, num_filters=256, strides=(1,1), kernel_size=(3,3), activation=None)
res_4_2 = add([acti_4_1, layer_4_2_2])
acti_4_output = Activation('relu')(res_4_2)
# conv5_x
identi_5_input = Conv2D(512, (1, 1), strides=(2, 2), padding='valid')(acti_4_output) # 차원을 맞춰주기 위해 convolution 연산 추가. (그대로 가는것)
#identi_5_input = BatchNormalization()(identi_5_input) # 모든 conv.뒤에는 bn을 적용.
layer_5_1_1 = resnet_layer(inputs=acti_4_output, num_filters=512, strides=(2,2), kernel_size=(3,3),activation='relu') #이 아래 두층은 rensnet층
layer_5_1_2 = resnet_layer(inputs=layer_5_1_1, num_filters=512, strides=(1,1), kernel_size=(3,3), activation=None)
res_5_1 = add([identi_5_input, layer_5_1_2])
acti_5_1 = Activation("relu")(res_5_1)
layer_5_2_1 = resnet_layer(inputs=acti_5_1,num_filters=512, strides=(1,1), kernel_size=(3,3), activation='relu') #이 아래 두층은 rensnet층
layer_5_2_2 = resnet_layer(inputs=layer_5_2_1, num_filters=512, strides=(1,1), kernel_size=(3,3), activation=None)
res_5_2 = add([acti_5_1, layer_5_2_2])
acti_5_output = Activation('relu')(res_5_2)
# 마지막 1층
y=AveragePooling2D(pool_size=(7, 7), strides=(1, 1), name='loss1/ave_pool')(acti_5_output)
y = Flatten()(y)
outputs = Dense(classes, activation='softmax', kernel_initializer='he_normal')(y)
model = Model(inputs=inputs, outputs=outputs)
return model
# construct training image generator for data augmentation
dataAug = ImageDataGenerator(rotation_range=20,
zoom_range=0.15,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.15,
fill_mode="nearest")
# load the MobileNetV2 network leaving off head FC layer sets
modelBase = MobileNetV2(weights="imagenet",
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
# construct head of model
modelHead = modelBase.output
modelHead = AveragePooling2D(pool_size=(7, 7))(modelHead)
modelHead = Flatten(name="flatten")(modelHead)
modelHead = Dense(128, activation="relu")(modelHead)
modelHead = Dropout(0.5)(modelHead)
modelHead = Dense(16, activation="softmax")(modelHead)
# place head FC model on top of base model
model = Model(inputs=modelBase.input, outputs=modelHead)
# loop over all layers in the base model and freeze them
for layer in modelBase.layers:
layer.trainable = False
# compile model
opt = Adam(lr=INIT_LR)
model.compile(loss="categorical_crossentropy",
def ResNet(input_shape, nb_classes=1000, block_func=_residual_block_basic, repetitions=(2, 2, 2, 2),
use_bias=False, use_dropout=False, kernel_initialiser='he_normal', kernel_regulariser=regulisers.l2(1e-5)):
""" This builds the ResNet Model for the Classification task.
Parameters:
- input_shape, is the input data shape such as (224, 224, 3).
- nb_classes, is the number of classes to be predicted.
- block_func, is the Block Layer method to be used.
- repetitions, is the List of repetitions for each macro-blocks the network should build/contain.
- use_bias, is a Flag to use or not the bias in the convolution layer.
- use_dropout, is a Flag to use or not the dropout in the Fully-connected layer.
- kernel_initialiser, is the kernel initialisation method name.
- kernel_regulariser, is the kernel regulariser.
Returns:
- returns the ResNet model.
"""
# ResNet's Input layer:
inputs = Input(shape=input_shape)
conv = _res_conv(filters=64,
kernel_size=7,
strides=2,
use_relu=True,
use_bias=use_bias,
kernel_initialiser=kernel_initialiser,
kernel_regulariser=kernel_regulariser
)(inputs)
maxpool = MaxPooling2D(pool_size=3,
strides=2,
padding='same')(conv)
# Resnet's chain of Residual Blocks (Repetition Layers):
filters = 64
strides = 2
res_block = maxpool
for i, repet in enumerate(repetitions):
# NOTE: no further input size reduction for the 1st block, as max-pooling was applied prior.
block_strides = strides if i != 0 else 1
macroblock_name = "block_{}".format(i)
res_block = _residual_macroblock(block_func=block_func,
filters=filters,
repetitions=repet,
strides_1stBlock=block_strides,
use_bias=use_bias,
kernel_initialiser=kernel_initialiser,
kernel_regulariser=kernel_regulariser,
name=macroblock_name
)(res_block)
# Limit the number of filters to 1024 as the maximum:
filters = min(filters * 2, 1024)
# Resnet's Final/Output Layer:
res_spatial_dimen = tf.keras.backend.int_shape(res_block)[1:3]
avg_pool = AveragePooling2D(pool_size=res_spatial_dimen,
strides=1
)(res_block)
flatten = Flatten()(avg_pool)
# # Adding a fully connected layer having 1024 neurons
# FC_layer = Dense(units=1024,
# activation='relu',
# use_bias=True,
# kernel_initializer='glorot_uniform')(flatten)
# Adding the 1st hidden fully connected layer having 256 neurons:
FC_layer_1 = Dense(units=256,
activation='relu',
use_bias=True,
kernel_initializer='glorot_uniform')(flatten)
# Adding dropout, if True:
if use_dropout:
FC_layer_1 = Dropout(rate=0.3)(FC_layer_1)
# Adding the 2nd hidden fully connected layer having 256 neurons:
FC_layer_2 = Dense(units=128,
activation='relu',
use_bias=True,
kernel_initializer='glorot_uniform')(FC_layer_1)
# Adding dropout, if True:
if use_dropout:
FC_layer_2 = Dropout(rate=0.2)(FC_layer_2)
predictions = Dense(units=nb_classes,
activation='softmax',
kernel_initializer=kernel_initialiser
)(FC_layer_2)
# Model (Keras API):
model = Model(inputs=inputs,
outputs=predictions)
# Return the model configurations:
return model
def main(args):
config_path = os.path.expanduser(args.config_path)
weights_path = os.path.expanduser(args.weights_path)
assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format(
config_path)
assert weights_path.endswith(
'.weights'), '{} is not a .weights file'.format(weights_path)
output_path = os.path.expanduser(args.output_path)
#assert output_path.endswith(
#'.h5'), 'output path {} is not a .h5 file'.format(output_path)
output_root = os.path.splitext(output_path)[0]
# Load weights and config.
print('Loading weights.')
weights_file = open(weights_path, 'rb')
major, minor, revision = np.ndarray(
shape=(3, ), dtype='int32', buffer=weights_file.read(12))
if (major*10+minor)>=2 and major<1000 and minor<1000:
seen = np.ndarray(shape=(1,), dtype='int64', buffer=weights_file.read(8))
else:
seen = np.ndarray(shape=(1,), dtype='int32', buffer=weights_file.read(4))
print('Weights Header: ', major, minor, revision, seen)
print('Parsing Darknet config.')
unique_config_file = unique_config_sections(config_path)
cfg_parser = configparser.ConfigParser()
cfg_parser.read_file(unique_config_file)
weight_decay = float(cfg_parser['net_0']['decay']) if 'net_0' in cfg_parser.sections() else 5e-4
# Parase model input width, height
width = int(cfg_parser['net_0']['width']) if 'net_0' in cfg_parser.sections() else None
height = int(cfg_parser['net_0']['height']) if 'net_0' in cfg_parser.sections() else None
print('Creating Keras model.')
if width and height and args.fixed_input_shape:
input_layer = Input(shape=(height, width, 3), name='image_input')
else:
input_layer = Input(shape=(None, None, 3), name='image_input')
prev_layer = input_layer
all_layers = []
count = 0
out_index = []
anchors = None
for section in cfg_parser.sections():
print('Parsing section {}'.format(section))
if section.startswith('convolutional'):
filters = int(cfg_parser[section]['filters'])
size = int(cfg_parser[section]['size'])
stride = int(cfg_parser[section]['stride'])
pad = int(cfg_parser[section]['pad'])
activation = cfg_parser[section]['activation']
batch_normalize = 'batch_normalize' in cfg_parser[section]
padding = 'same' if pad == 1 and stride == 1 else 'valid'
# support DepthwiseConv2D with "groups"
# option in conv section
if 'groups' in cfg_parser[section]:
groups = int(cfg_parser[section]['groups'])
# Now only support DepthwiseConv2D with "depth_multiplier=1",
# which means conv groups should be same as filters
assert groups == filters, 'Only support groups is same as filters.'
depthwise = True
depth_multiplier = 1
else:
depthwise = False
# Setting weights.
# Darknet serializes convolutional weights as:
# [bias/beta, [gamma, mean, variance], conv_weights]
prev_layer_shape = K.int_shape(prev_layer)
if depthwise:
# DepthwiseConv2D weights shape in TF:
# (kernel_size, kernel_size, in_channels, depth_multiplier).
weights_shape = (size, size, prev_layer_shape[-1], depth_multiplier)
darknet_w_shape = (depth_multiplier, weights_shape[2], size, size)
weights_size = np.product(weights_shape)
print('depthwiseconv2d', 'bn'
if batch_normalize else ' ', activation, weights_shape)
else:
weights_shape = (size, size, prev_layer_shape[-1], filters)
darknet_w_shape = (filters, weights_shape[2], size, size)
weights_size = np.product(weights_shape)
print('conv2d', 'bn'
if batch_normalize else ' ', activation, weights_shape)
conv_bias = np.ndarray(
shape=(filters, ),
dtype='float32',
buffer=weights_file.read(filters * 4))
count += filters
if batch_normalize:
bn_weights = np.ndarray(
shape=(3, filters),
dtype='float32',
buffer=weights_file.read(filters * 12))
count += 3 * filters
bn_weight_list = [
bn_weights[0], # scale gamma
conv_bias, # shift beta
bn_weights[1], # running mean
bn_weights[2] # running var
]
conv_weights = np.ndarray(
shape=darknet_w_shape,
dtype='float32',
buffer=weights_file.read(weights_size * 4))
count += weights_size
# DarkNet conv_weights are serialized Caffe-style:
# (out_dim, in_dim, height, width)
# We would like to set these to Tensorflow order:
# (height, width, in_dim, out_dim)
conv_weights = np.transpose(conv_weights, [2, 3, 1, 0])
conv_weights = [conv_weights] if batch_normalize else [
conv_weights, conv_bias
]
# Handle activation.
act_fn = None
if activation == 'leaky':
pass # Add advanced activation later.
elif activation == 'relu':
pass # Add advanced activation later.
elif activation == 'mish':
pass # Add advanced activation later.
elif activation == 'logistic':
pass # Add advanced activation later.
elif activation != 'linear':
raise ValueError(
'Unknown activation function `{}` in section {}'.format(
activation, section))
# Create Conv2D layer
if stride>1:
# Darknet uses left and top padding instead of 'same' mode
prev_layer = ZeroPadding2D(((1,0),(1,0)))(prev_layer)
if depthwise:
conv_layer = (DepthwiseConv2D(
(size, size),
strides=(stride, stride),
depth_multiplier=depth_multiplier,
kernel_regularizer=l2(weight_decay),
use_bias=not batch_normalize,
weights=conv_weights,
activation=act_fn,
padding=padding))(prev_layer)
else:
conv_layer = (Conv2D(
filters, (size, size),
strides=(stride, stride),
kernel_regularizer=l2(weight_decay),
use_bias=not batch_normalize,
weights=conv_weights,
activation=act_fn,
padding=padding))(prev_layer)
if batch_normalize:
conv_layer = (BatchNormalization(
weights=bn_weight_list))(conv_layer)
prev_layer = conv_layer
if activation == 'linear':
all_layers.append(prev_layer)
elif activation == 'mish':
act_layer = Activation(mish)(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif activation == 'leaky':
act_layer = LeakyReLU(alpha=0.1)(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif activation == 'relu':
act_layer = ReLU()(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif activation == 'logistic':
act_layer = Activation('sigmoid')(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif section.startswith('route'):
ids = [int(i) for i in cfg_parser[section]['layers'].split(',')]
layers = [all_layers[i] for i in ids]
if ('groups' in cfg_parser[section]):
# support route with groups, which is for splitting input tensor into group
# Reference comment (from AlexeyAB):
#
# https://github.com/lutzroeder/netron/issues/531
#
assert 'group_id' in cfg_parser[section], 'route with groups should have group_id.'
assert len(layers) == 1, 'route with groups should have 1 input layer.'
groups = int(cfg_parser[section]['groups'])
group_id = int(cfg_parser[section]['group_id'])
route_layer = layers[0] # group route only have 1 input layer
print('Split {} to {} groups and pick id {}'.format(route_layer, groups, group_id))
all_layers.append(
Lambda(
# tf.split implementation for groups route
lambda x: tf.split(x, num_or_size_splits=groups, axis=-1)[group_id],
name='group_route_'+str(len(all_layers)))(route_layer))
prev_layer = all_layers[-1]
else:
if len(layers) > 1:
print('Concatenating route layers:', layers)
concatenate_layer = Concatenate()(layers)
all_layers.append(concatenate_layer)
prev_layer = concatenate_layer
else:
skip_layer = layers[0] # only one layer to route
all_layers.append(skip_layer)
prev_layer = skip_layer
elif section.startswith('maxpool'):
size = int(cfg_parser[section]['size'])
stride = int(cfg_parser[section]['stride'])
all_layers.append(
MaxPooling2D(
pool_size=(size, size),
strides=(stride, stride),
padding='same')(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('avgpool'):
all_layers.append(
AveragePooling2D()(prev_layer))
prev_layer = all_layers[-1]
# support GAP and Reshape layer for se block
# Reference:
#
# https://github.com/gitE0Z9/keras-YOLOv3-model-set/commit/67ed826f2ce00f28296fcf88c03c86f1d86b8b9e
#
elif section.startswith('gap'):
all_layers.append(
GlobalAveragePooling2D()(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('reshape'):
all_layers.append(
Reshape((1, 1, K.int_shape(prev_layer)[-1]))(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('shortcut'):
index = int(cfg_parser[section]['from'])
activation = cfg_parser[section]['activation']
assert activation == 'linear', 'Only linear activation supported.'
all_layers.append(Add()([all_layers[index], prev_layer]))
prev_layer = all_layers[-1]
elif section.startswith('sam'):
# support SAM (Modified Spatial Attention Module in YOLOv4) layer
# Reference comment:
#
# https://github.com/AlexeyAB/darknet/issues/3708
#
index = int(cfg_parser[section]['from'])
all_layers.append(Multiply()([all_layers[index], prev_layer]))
prev_layer = all_layers[-1]
elif section.startswith('dropout'):
rate = float(cfg_parser[section]['probability'])
assert rate >= 0 and rate <= 1, 'Dropout rate should be between 0 and 1, got {}.'.format(rate)
all_layers.append(Dropout(rate=rate)(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('upsample'):
stride = int(cfg_parser[section]['stride'])
assert stride%2 == 0, 'upsample stride should be multiples of 2'
all_layers.append(UpSampling2D(stride)(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('reorg'):
block_size = int(cfg_parser[section]['stride'])
assert block_size == 2, 'Only reorg with stride 2 supported.'
all_layers.append(
Lambda(
#space_to_depth_x2,
#output_shape=space_to_depth_x2_output_shape,
lambda x: tf.nn.space_to_depth(x, block_size=2),
name='space_to_depth_x2')(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('region'):
# YOLOv2 anchors parse, here we convert origin
# grid-reference value to pixel size value
anchors_line = cfg_parser[section]['anchors']
anchors_list = list(map(float, anchors_line.split(',')))
anchors_line = [str(anchor * 32) for anchor in anchors_list]
anchors = ', '.join(anchors_line)
elif section.startswith('yolo'):
out_index.append(len(all_layers)-1)
all_layers.append(None)
prev_layer = all_layers[-1]
# YOLOv3/v4 anchors parse
anchors = cfg_parser[section]['anchors']
elif (section.startswith('net') or section.startswith('cost') or
section.startswith('softmax')):
pass
else:
raise ValueError(
'Unsupported section header type: {}'.format(section))
# Create and save model.
if len(out_index)==0: out_index.append(len(all_layers)-1)
if args.yolo4_reorder:
# reverse the output tensor index for YOLOv4 cfg & weights,
# since it use a different yolo outout order
out_index.reverse()
model = Model(inputs=input_layer, outputs=[all_layers[i] for i in out_index])
print(model.summary())
if args.weights_only:
model.save_weights('{}'.format(output_path))
print('Saved Keras weights to {}'.format(output_path))
else:
model.save('{}'.format(output_path))
print('Saved Keras model to {}'.format(output_path))
# Check to see if all weights have been read.
remaining_weights = len(weights_file.read()) / 4
weights_file.close()
print('Read {} of {} from Darknet weights.'.format(count, count +
remaining_weights))
if remaining_weights > 0:
print('Warning: {} unused weights'.format(remaining_weights))
if anchors:
with open('{}_anchors.txt'.format(output_root), 'w') as f:
print(anchors, file=f)
print('Saved anchors to {}_anchors.txt'.format(output_root))
if args.plot_model:
plot(model, to_file='{}.png'.format(output_root), show_shapes=True)
print('Saved model plot to {}.png'.format(output_root))
def build_fn(model_struct):
if model_struct == 'LeNet':
model = Sequential([
Conv2D(filters=6,
kernel_size=(3, 3),
activation='relu',
input_shape=(224, 224, 1)), # input shape 1 or 3?
AveragePooling2D(),
Conv2D(filters=16, kernel_size=(3, 3), activation='relu'),
AveragePooling2D(),
Flatten(),
Dense(
units=60, activation='relu'
), # TODO change Units because we only have 2 classes to predict
Dense(
units=42, activation='relu'
), # TODO change Units because we only have 2 classes to predict
Dense(
units=1, activation='sigmoid'
) # TODO change Units because we only have 2 classes to predict
])
return model.get_config()
elif model_struct == 'AlexNet':
model = Sequential([
Conv2D(filters=96,
input_shape=(224, 224, 1),
kernel_size=(11, 11),
activation='relu',
strides=(4, 4),
padding='valid'), # Should input shape be 1 or 3?
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'),
Conv2D(filters=256,
kernel_size=(11, 11),
activation='relu',
strides=(1, 1),
padding='valid'),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'),
Conv2D(filters=384,
kernel_size=(3, 3),
activation='relu',
strides=(1, 1),
padding='valid'),
Conv2D(filters=384,
kernel_size=(3, 3),
activation='relu',
strides=(1, 1),
padding='valid'),
Conv2D(filters=256,
kernel_size=(3, 3),
activation='relu',
strides=(1, 1),
padding='valid'),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'),
Flatten(),
Dense(4096, input_shape=(224 * 224, ), activation='relu'),
Dropout(0.4),
Dense(
4096, activation='relu'
), # TODO change Units because we only have 2 classes to predict
Dropout(0.4),
Dense(
1000, activation='relu'
), # TODO change Units because we only have 2 classes to predict
Dropout(0.4),
Dense(
1, activation='sigmoid'
) # TODO change Units because we only have 2 classes to predict
])
return model.get_config()
elif model_struct == 'Random':
model = Sequential()
model.add(random_conv(224, True))
while True:
rand_val = random.random()
try:
if not any(isinstance(x, Flatten) for x in
model.layers): # if there's not a Flatten layer yet
input_size = min(model.layers[-1].output_shape[1],
model.layers[-1].output_shape[2])
if input_size < 2 or len(model.layers) > 6:
model.add(Flatten())
continue
if rand_val < 0.3:
model.add(random_conv(input_size, False))
elif rand_val < 0.6:
model.add(random_pool(input_size, 'max'))
elif rand_val < 0.9:
model.add(random_pool(input_size, 'average'))
else:
model.add(Flatten())
else: # if there is a Flatten layer already
if rand_val < 0.35:
model.add(random_dropout())
elif rand_val < 0.7:
model.add(random_dense(False))
else:
break
except tensorflow.errors.ResourceExhaustedError:
print("Initial Architecture went OOM, retrying...")
model.add(random_dense(True))
return model.get_config()
print("model was not LeNet, AlexNet, or Random")
'weights_1000/siamese_neural_congas_1_Mixed7a_Branch_1_Conv2d_1d_3x3_Conv2D_weights'
).transpose(1, 2, 3, 0)),
bias_initializer=Constant(
np.load(
'weights_1000/siamese_neural_congas_1_Mixed7a_Branch_1_Conv2d_1d_3x3_Conv2D_bias'
)))(relu3_5)
relu3_6 = ReLU(max_value=6.)(conv3_6)
maxpool3_1 = MaxPool2D(pool_size=[3, 3], strides=[2, 2],
padding='same')(concat2_1)
concat3_1 = Concatenate(axis=3)([relu3_2, relu3_6, maxpool3_1])
# Block_04
avgpool4_1 = AveragePooling2D(pool_size=[4, 4],
strides=[1, 1],
padding='valid')(concat3_1)
conv4_1 = Conv2D(
filters=40,
kernel_size=[1, 1],
strides=[1, 1],
padding="same",
dilation_rate=[1, 1],
kernel_initializer=Constant(
np.load(
'weights_1000/siamese_neural_congas_1_feature_compression_Conv2d_0a_Conv2D_weights'
).transpose(1, 2, 3, 0)),
bias_initializer=Constant(
np.load(
'weights_1000/siamese_neural_congas_1_feature_compression_Conv2d_0a_Conv2D_bias'
)))(avgpool4_1)
def call(self, inputs, training=None, mask=None, end_at="logits", add_inbetween_endpoints=False):
end_points = {"4a" : None, "5a" : None, "6e" : None, "7c" : None, "fc" : None}
# 299 x 299 x 3
x = self.Conv2d_1a_3x3(inputs)
# 149 x 149 x 32
x = self.Conv2d_2a_3x3(x)
# 147 x 147 x 32
x = self.Conv2d_2b_3x3(x)
# 147 x 147 x 64
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
# 73 x 73 x 64
x = self.Conv2d_3b_1x1(x)
# 73 x 73 x 80
x = self.Conv2d_4a_3x3(x)
if add_inbetween_endpoints or end_at=="4a":
end_points["4a"] = x
if end_at == "4a":
return end_points
# 71 x 71 x 192
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
# 35 x 35 x 192
x = self.Mixed_5b(x)
# 35 x 35 x 256
x = self.Mixed_5c(x)
# 35 x 35 x 288
x = self.Mixed_5d(x)
if add_inbetween_endpoints or end_at=="5d":
end_points["5d"] = x
if end_at == "5d":
return end_points
# 35 x 35 x 288
x = self.Mixed_6a(x)
# 17 x 17 x 768
x = self.Mixed_6b(x)
# 17 x 17 x 768
x = self.Mixed_6c(x)
# 17 x 17 x 768
x = self.Mixed_6d(x)
# 17 x 17 x 768
x = self.Mixed_6e(x)
if add_inbetween_endpoints or end_at=="6e":
end_points["6e"] = x
if end_at == "6e":
return end_points
# 17 x 17 x 768
x = self.Mixed_7a(x)
# 8 x 8 x 1280
x = self.Mixed_7b(x)
# 8 x 8 x 2048
x = self.Mixed_7c(x)
if add_inbetween_endpoints or end_at=="7c":
end_points["7c"] = x
if end_at == "7c":
return end_points
# 8 x 8 x 2048
kernel_size = x.shape[1]
x = AveragePooling2D(kernel_size, padding='same')(x)
# 1 x 1 x 2048
x = layers.Dropout(0.2)(x)
# 1 x 1 x 2048
x = tf.keras.layers.Flatten()(x)
if add_inbetween_endpoints or end_at=="features":
end_points["features"] = x
if end_at == "features":
return end_points
# 2048
x = self.fc(x)
end_points["logits"] = x
return end_points
def get_xception_abbreviated_clsresidual(self,
input_shape=(1, 1024, 26),
gpu_device="/gpu:1"):
r"""Returns the TensorFlow 2.2 implementation of Xception (Abbreviated w/ CLS Residual).
Inspired by Chollet 2017 : http://arxiv.org/abs/1610.02357
Args:
input_shape (tuple, optional): Shape of the input tensor. Defaults to (1, 1024, 26).
gpu_device (str, optional): If GPU devices are available, defines which one to utilize. Defaults to "/gpu:0".
verbose (bool, optional): Log details to console. Defaults to True.
Returns:
tf.keras.Model: returns a TensorFlow 2.20 model (compiled, untrained)
"""
# Input validation
self.__require_params(input_shape=input_shape)
if (not gpu_device) or self.__GPU_count == 0:
gpu_device = "/cpu:0"
# Model hyperparameters and metadata
model_name = 'Binary Classification Xception (Abbreviated w/ CLS Residual)'
opt = Adam(lr=1e-3, beta_1=0.9, beta_2=0.999, epsilon=1e-8)
loss = CategoricalCrossentropy(from_logits=True)
metrics = ['accuracy']
# Construct model & compile
with tf.device(gpu_device):
# input image size
input_img = layers.Input(shape=input_shape, dtype=tf.float32)
# pull the last channel layer for residual connection layer
inp_seq = input_img[:, :, :, -1]
inp_seq = tf.squeeze(inp_seq, axis=1)
# Block 1
x = Conv2D(64, (1, 3), strides=(1, 3), use_bias=False)(input_img)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(128, (1, 3), use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
residual = Conv2D(512, (1, 1),
strides=(1, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
# Block 2
x = SeparableConv2D(256, (1, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = SeparableConv2D(512, (1, 3), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
# Block 2 Pool
x = AveragePooling2D((1, 3), strides=(1, 2), padding='same')(x)
x = layers.add([x, residual])
# Fully Connected Layer
x = GlobalAveragePooling2D()(x)
# add the skip level residual back to the last CLS token
x = layers.concatenate([x, inp_seq])
x = layers.Dense(2, dtype=tf.float32, name='dense_2_final')(x)
model = models.Model(input_img, x, name=model_name)
model.compile(loss=loss, optimizer=opt, metrics=metrics)
# Print verbose output to console
if verbose:
self.__verbose_print(model, model_name, input_shape, opt, loss,
metrics)
return model
def ResNet(input_shape, classes):
_input = Input(shape=input_shape)
res = ZeroPadding2D([3, 3])(_input)
# stage 1
res = Conv2D(filters=64,
kernel_size=(7, 7),
strides=(2, 2),
name="res_stage_1_conv",
kernel_initializer=glorot_uniform(seed=0))(res)
res = BatchNormalization(axis=3, name="res_stage_1_BN")(res)
res = Activation('relu')(res)
res = MaxPooling2D((3, 3), strides=(2, 2))(res)
# stage 2
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stride=1,
stage="2a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stage="2b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[64, 64, 256],
stage="2c")
# stage 3
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stride=2,
stage="3a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3c")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[128, 128, 512],
stage="3d")
# stage 4
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stride=2,
stage="4a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4c")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4d")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4e")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[256, 256, 1024],
stage="4f")
# stage 5
res = conv_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stride=2,
stage="5a")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stage="5b")
res = id_block(input_tensor=res,
kernel_size=3,
filters=[512, 512, 2048],
stage="5c")
res = AveragePooling2D(pool_size=(2, 2), padding='same')(res)
res = Flatten()(res)
res = Dense(classes,
activation='softmax',
name='output_fc_layer',
kernel_initializer=glorot_uniform(seed=0))(res)
model = Model(inputs=_input, outputs=res, name='ResNet')
return model
# This section creates a simple CNN using Keras, and trains it
# with backpropagation. There are no spikes involved at this point.
input_shape = x_train.shape[1:]
input_layer = Input(input_shape)
layer = Conv2D(filters=16,
kernel_size=(5, 5),
strides=(2, 2),
activation='relu',
use_bias=False)(input_layer)
layer = Conv2D(filters=32,
kernel_size=(3, 3),
activation='relu',
use_bias=False)(layer)
layer = AveragePooling2D()(layer)
layer = Conv2D(filters=8,
kernel_size=(3, 3),
padding='same',
activation='relu',
use_bias=False)(layer)
layer = Flatten()(layer)
layer = Dropout(0.01)(layer)
layer = Dense(units=10,
activation='softmax',
use_bias=False)(layer)
model = Model(input_layer, layer)
model.summary()
def InceptionV3(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the Inception v3 architecture.
Optionally loads weights pre-trained
on ImageNet. Note that when using TensorFlow,
for best performance you should set
`image_data_format='channels_last'` in your Keras config
at ~/.keras/keras.json.
The model and the weights are compatible with both
TensorFlow and Theano. The data format
convention used by the model is the one
specified in your Keras config file.
Note that the default input image size for this model is 299x299.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(299, 299, 3)` (with `channels_last` data format)
or `(3, 299, 299)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 139.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(
input_shape,
default_size=299,
min_size=139,
data_format=K.image_data_format(),
require_flatten=False,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = 3
x = conv2d_bn(img_input, 32, 3, 3, strides=(2, 2), padding='same')
x = conv2d_bn(x, 32, 3, 3, padding='same')
x = conv2d_bn(x, 64, 3, 3)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = conv2d_bn(x, 80, 1, 1, padding='same')
x = conv2d_bn(x, 192, 3, 3, padding='same')
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
# mixed 0, 1, 2: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 32, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed0')
# mixed 1: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed1')
# mixed 2: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed2')
# mixed 3: 17 x 17 x 768
branch3x3 = conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='same')
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(
branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='same')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.concatenate(
[branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3')
# mixed 4: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 128, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 128, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 128, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed4')
# mixed 5, 6: 17 x 17 x 768
for i in range(2):
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 160, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 160, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 160, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 192, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 192, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed7')
# mixed 8: 8 x 8 x 1280
branch3x3 = conv2d_bn(x, 192, 1, 1)
branch3x3 = conv2d_bn(branch3x3, 320, 3, 3,
strides=(2, 2), padding='same')
branch7x7x3 = conv2d_bn(x, 192, 1, 1)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 1, 7)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 7, 1)
branch7x7x3 = conv2d_bn(
branch7x7x3, 192, 3, 3, strides=(2, 2), padding='same')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = layers.concatenate(
[branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
branch1x1 = conv2d_bn(x, 320, 1, 1)
branch3x3 = conv2d_bn(x, 384, 1, 1)
branch3x3_1 = conv2d_bn(branch3x3, 384, 1, 3)
branch3x3_2 = conv2d_bn(branch3x3, 384, 3, 1)
branch3x3 = layers.concatenate(
[branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i))
branch3x3dbl = conv2d_bn(x, 448, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 384, 3, 3)
branch3x3dbl_1 = conv2d_bn(branch3x3dbl, 384, 1, 3)
branch3x3dbl_2 = conv2d_bn(branch3x3dbl, 384, 3, 1)
branch3x3dbl = layers.concatenate(
[branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(9 + i))
if include_top:
# Classification block
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='inception_v3')
# load weights
if weights == 'imagenet':
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
if include_top:
weights_path = get_file(
'inception_v3_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
file_hash='9a0d58056eeedaa3f26cb7ebd46da564')
else:
weights_path = get_file(
'inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='bcbd6486424b2319ff4ef7d526e38f63')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
# perform one-hot encoding on the labels lb = LabelBinarizer() labels = lb.fit_transform(labels) labels = to_categorical(labels) (trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=0.20, stratify=labels, random_state=42) # initialize the training data augmentation object trainAug = ImageDataGenerator(rotation_range=15,fill_mode="nearest") baseModel = DenseNet121(weights="imagenet", include_top=False,input_tensor=Input(shape=(224, 224, 3))) headModel = baseModel.output headModel = AveragePooling2D(pool_size=(3, 3))(headModel) headModel = Flatten(name="flatten")(headModel) headModel = Dense(64, activation="relu")(headModel) headModel = Dropout(0.5)(headModel) headModel = Dense(2, activation="softmax")(headModel) model = Model(inputs=baseModel.input, outputs=headModel) for layer in baseModel.layers: layer.trainable = False opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])
def __init__(self):
super(PhraseDiscriminatorModel,
self).__init__(name='phrase_discriminator')
self.x1_1_1 = Conv2D(filters=16,
kernel_size=[1, 4],
strides=[1, 2],
activation='relu',
padding='same')
self.x1_1_2 = Conv2D(filters=16,
kernel_size=[4, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.x1_2_1 = Conv2D(filters=16,
kernel_size=[4, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.x1_2_2 = Conv2D(filters=16,
kernel_size=[1, 4],
strides=[1, 2],
activation='relu',
padding='same')
self.x2 = Conv2D(filters=32,
kernel_size=[3, 3],
strides=[2, 2],
activation='relu',
padding='same')
self.x3 = Conv2D(filters=64,
kernel_size=[3, 3],
strides=[2, 2],
activation='relu',
padding='same')
self.x4 = Conv2D(filters=128,
kernel_size=[3, 3],
strides=[2, 2],
activation='relu',
padding='same')
self.chord_x1 = Conv2D(filters=16,
kernel_size=[3, 3],
strides=[2, 1],
activation='relu',
padding='same')
self.chord_x2 = Conv2D(filters=32,
kernel_size=[3, 3],
strides=[2, 1],
activation='relu',
padding='same')
self.chord_x3 = Conv2D(filters=64,
kernel_size=[3, 3],
strides=[2, 1],
activation='relu',
padding='same')
self.chord_x4 = Conv2D(filters=128,
kernel_size=[3, 3],
strides=[2, 2],
activation='relu',
padding='same')
self.on_off_x1 = Conv2D(filters=16,
kernel_size=[3, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.on_off_x2 = Conv2D(filters=32,
kernel_size=[3, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.on_off_x3 = Conv2D(filters=64,
kernel_size=[3, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.on_off_x4 = Conv2D(filters=128,
kernel_size=[3, 1],
strides=[2, 1],
activation='relu',
padding='same')
self.x_avg = AveragePooling2D([24, 6])
self.chord_avg = AveragePooling2D([24, 6])
self.on_off_avg = AveragePooling2D([24, 1])
self.feature1 = Conv2D(filters=128,
kernel_size=[1, 1],
strides=[1, 1],
activation='relu',
padding='same')
self.feature2 = Conv2D(filters=1,
kernel_size=[1, 1],
strides=[1, 1],
activation='sigmoid',
padding='same')
self.flatten = tf.keras.layers.Flatten()
def get_cifar_backbone(embeded_dim, model_type="mlp", norm_type="bn", acti_type="relu"):
""" For `cifar10` and `cifar100` dataset
Args:
embeded_dim (int): 10 or 100
Returns:
encoder: (32, 32, 3) -> (1, 1, 10) or (1, 1, 100)
decoder: (1, 1, 10) or (1, 1, 100) -> (32, 32, 3)
"""
input_shape = (32, 32, 3)
init = "he_normal"
if model_type == "mlp":
return get_mlp_backbones(input_shape, embeded_dim, norm_type, acti_type, kernel_initializer=init)
elif model_type == "allconv":
acti = acti_type
encoder_input = Input(shape=input_shape)
encoder_layers = []
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=32, kernel_size=5, strides=2,
padding="same", kernel_initializer=init)) # 16
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=64, kernel_size=5, strides=2,
padding="same", kernel_initializer=init)) # 8
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=128, kernel_size=3, strides=2,
padding="valid", kernel_initializer=init)) # 3
encoder_layers.append(Conv2D(embeded_dim, 3, activation=None, kernel_initializer=init)) # 1
encoder_output = encoder_input
for layer in encoder_layers:
encoder_output = layer(encoder_output)
decoder_input = Input(shape=(1, 1, embeded_dim))
decoder_layers = []
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=128, kernel_size=3,
kernel_initializer=init)) # 3
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=64, kernel_size=3, output_padding=1,
strides=2, padding="valid", kernel_initializer=init)) # 8
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=32, kernel_size=5,
strides=2, padding="same", kernel_initializer=init)) # 16
decoder_layers.append(Conv2DTranspose(input_shape[-1], 5, strides=2, padding="same",
activation="sigmoid", kernel_initializer=init)) # 32
decoder_output = decoder_input
for layer in decoder_layers:
decoder_output = layer(decoder_output)
encoder = Model(inputs=encoder_input, outputs=encoder_output, name="allconvbn_encoder")
decoder = Model(inputs=decoder_input, outputs=decoder_output, name="allconvbn_decoder")
return encoder, decoder
elif model_type == "conv":
# 与原文cifar10_2保持一致的encoder结构
acti = acti_type
encoder_input = Input(shape=input_shape)
encoder_layers = []
encoder_layers.extend(n_conv_norm(3, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 26,26,64
encoder_layers.append(MaxPool2D(2, 2, padding="valid")) # 13
encoder_layers.extend(n_conv_norm(3, norm_type, acti,
filters=128, kernel_size=3,
padding="valid", kernel_initializer=init)) # 7,7,128
encoder_layers.append(MaxPool2D(2, 2, padding="valid")) # 3,3,128
encoder_layers.extend(n_conv_norm(1, norm_type, acti,
filters=embeded_dim, kernel_size=1,
padding="valid", kernel_initializer=init)) # 3,3,10
encoder_layers.append(AveragePooling2D(3))
encoder_output = encoder_input
for layer in encoder_layers:
encoder_output = layer(encoder_output)
decoder_input = Input(shape=(1, 1, embeded_dim))
decoder_layers = []
decoder_layers.append(UpSampling2D(3)) # 3
decoder_layers.extend(n_deconv_norm(1, norm_type, acti,
filters=128, kernel_size=1,
padding="valid", kernel_initializer=init)) # 3
decoder_layers.extend(n_deconv_norm(1, norm_type, acti,
filters=128, kernel_size=3, strides=2,
padding="valid", kernel_initializer=init)) # 7
decoder_layers.extend(n_deconv_norm(2, norm_type, acti,
filters=128, kernel_size=3,
padding="valid", kernel_initializer=init)) # 11
decoder_layers.extend(n_deconv_norm(1, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 13
decoder_layers.append(UpSampling2D(2))
decoder_layers.extend(n_deconv_norm(2, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 30
decoder_layers.append(Conv2DTranspose(3, kernel_size=3, kernel_initializer=init)) # 32, (no bn)
decoder_output = decoder_input
for layer in decoder_layers:
decoder_output = layer(decoder_output)
encoder = Model(inputs=encoder_input, outputs=encoder_output, name="conv_encoder")
decoder = Model(inputs=decoder_input, outputs=decoder_output, name="conv_encoder")
return encoder, decoder
def resnet(input_shape=(224, 224, 3), num_filters=64, classes=1000, num_blocks=[0, 0, 0, 0], version=None):
# num_blocks 는 list로 받는 인자. conv3_x ~ conv5_x의 block의 수를 앞에서부터 차례로 넣어주면 된다.
# num_filters 는 초기의 filters를 의미한다.
if len(num_blocks) != 4:
raise NameError("Please input the number of blocks from conv2_x to conv5_x in the 'num_blocks' variable.")
if version == "v1": # resnet 18, 34에 해당. (블록이 같음)
block = block_v1
elif version == "v2": # resnet 50, 101, 152에 해당. (블록이 같음)
block = block_v2
else:
raise NameError("Please input the string 'v1' or 'v2' in the 'version' variable. ")
inputs = Input(shape=input_shape)
# conv1
layer1 = resnet_layer(inputs=inputs, num_filters=num_filters, strides=(2, 2), kernel_size=(7, 7), activation='relu')
conv1_zero_pad = ZeroPadding2D(padding=(1, 1))(layer1)
pool1_helper = PoolHelper()(conv1_zero_pad)
cum_block = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', name='pool1/3x3_s2')(pool1_helper)
# cum_block 변수에 하나씩 residual block을 누적시켜보자.
for stack in range(4):
if stack == 0:
# 우리가 누적시킬 변수, cum_block을 정의하고, 이 변수에 누적시켜가면서 모형을 출력한다.
# 이 아래 for문은 conv2_x
# 들어가기 전에, block_v2라면 input과 output의 filter size를 동일하게 해주는 작업을 한다. 덧셈이 가능해야 하므로, 반드시!
if version == 'v2':
cum_block = Conv2D(4 * num_filters, kernel_size=(1, 1), strides=(1, 1), padding='same',
kernel_initializer='he_normal')(cum_block)
# cum_block = BatchNormalization()(cum_block) # 모든 conv.뒤에는 bn을 적용.
for res_block in range(num_blocks[stack]):
cum_block = block(input_shape=cum_block, num_filters=num_filters, identi=cum_block, half=False)
else:
# 이 아래는 conv3_x ~ conv5_x 까지.
num_filters *= 2
if version == 'v2':
x = Conv2D(4 * num_filters, kernel_size=(1, 1), strides=(2, 2), padding='valid',
kernel_initializer='he_normal')(cum_block) # block_v2라면, input에 해당하는 x를 덧셈이 가능하게 맞춰준다.
# x = BatchNormalization()(x) # 모든 conv.뒤에는 bn을 적용.
else:
x = Conv2D(num_filters, (1, 1), strides=(2, 2), padding='valid')(
cum_block) # identi_input 에 해당 // rxc가 각각 반토막남.
# 즉, 위 x는 결국 이어질 conv 층의 input임.
for res_block in range(num_blocks[stack]):
if res_block == 0:
cum_block = block(input_shape=cum_block, num_filters=num_filters, identi=x, half=True) # block 갱신
else:
cum_block = block(input_shape=cum_block, num_filters=num_filters, identi=cum_block,
half=False) # block 갱신
# 마지막 1층
y = AveragePooling2D(pool_size=(7, 7), strides=(1, 1), name='loss1/ave_pool')(cum_block)
y = Flatten()(y)
outputs = Dense(classes, activation='softmax', kernel_initializer='he_normal')(y)
model = Model(inputs=inputs, outputs=outputs)
return model
def get_mnist_backbone(embeded_dim, model_type="mlp", norm_type="bn", acti_type="relu"):
""" For `mnist` and `fashion-mnist` dataset
Args:
embeded_dim (int): 10
Returns:
encoder: (28, 28, 1) -> (1, 1, 10)
decoder: (1, 1, 10) -> (28, 28, 1)
"""
input_shape = (28, 28, 1)
init = "he_normal"
if model_type == "mlp":
return get_mlp_backbones(input_shape, embeded_dim, norm_type, acti_type, kernel_initializer=init)
elif model_type == "conv":
# 与原论文略有不同
acti = acti_type
encoder_input = Input(shape=input_shape)
encoder_layers = []
encoder_layers.extend(n_conv_norm(3, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 22,22,64
encoder_layers.append(MaxPool2D(2, 2, padding="valid")) # 11
encoder_layers.extend(n_conv_norm(4, norm_type, acti,
filters=128, kernel_size=3,
padding="valid", kernel_initializer=init)) # 3,3,128
# encoder_layers.append(MaxPool2D(2, 2, padding="valid"))
encoder_layers.extend(n_conv_norm(1, norm_type, acti,
filters=embeded_dim, kernel_size=1,
padding="valid", kernel_initializer=init)) # 3,3,10
# encoder_layers.append(AveragePooling2D(2)) # 1, 1, 10
encoder_layers.append(AveragePooling2D(3)) # 1, 1, 10
encoder_output = encoder_input
for layer in encoder_layers:
encoder_output = layer(encoder_output)
decoder_input = Input(shape=(1, 1, embeded_dim))
decoder_layers = []
decoder_layers.append(UpSampling2D(3)) # 3
decoder_layers.extend(n_deconv_norm(1, norm_type, acti,
filters=128, kernel_size=1,
padding="valid", kernel_initializer=init)) # 3
decoder_layers.extend(n_deconv_norm(3, norm_type, acti,
filters=128, kernel_size=3,
padding="valid", kernel_initializer=init)) # 9
decoder_layers.extend(n_deconv_norm(1, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 11
decoder_layers.append(UpSampling2D(2))
decoder_layers.extend(n_deconv_norm(2, norm_type, acti,
filters=64, kernel_size=3,
padding="valid", kernel_initializer=init)) # 26
decoder_layers.append(Conv2DTranspose(1, 3, kernel_initializer=init)) # 28, (no bn)
decoder_output = decoder_input
for layer in decoder_layers:
decoder_output = layer(decoder_output)
encoder = Model(inputs=encoder_input, outputs=encoder_output, name="conv_encoder")
decoder = Model(inputs=decoder_input, outputs=decoder_output, name="conv_encoder")
return encoder, decoder
elif model_type == "allconv":
acti = acti_type
encoder_input = Input(shape=input_shape)
encoder_layers = []
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=32, kernel_size=5, strides=2,
padding="same", kernel_initializer=init)) # 14
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=64, kernel_size=5, strides=2,
padding="same", kernel_initializer=init)) # 7
encoder_layers.extend(n_conv_norm(1, norm_type, acti, filters=128, kernel_size=3, strides=2,
padding="valid", kernel_initializer=init)) # 3
encoder_layers.append(Conv2D(embeded_dim, 3, activation="relu", kernel_initializer=init)) # 1
encoder_output = encoder_input
for layer in encoder_layers:
encoder_output = layer(encoder_output)
decoder_input = Input(shape=(1, 1, embeded_dim))
decoder_layers = []
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=128, kernel_size=3,
kernel_initializer=init)) # 3
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=64, kernel_size=3,
strides=2, padding="valid", kernel_initializer=init)) # 7
decoder_layers.extend(n_deconv_norm(1, norm_type, acti, filters=32, kernel_size=5,
strides=2, padding="same", kernel_initializer=init)) # 14
decoder_layers.append(Conv2DTranspose(input_shape[-1], 5, strides=2, padding="same",
activation="relu", kernel_initializer=init)) # 28
decoder_output = decoder_input
for layer in decoder_layers:
decoder_output = layer(decoder_output)
encoder = Model(inputs=encoder_input, outputs=encoder_output, name="allconvbn_encoder")
decoder = Model(inputs=decoder_input, outputs=decoder_output, name="allconvbn_decoder")
return encoder, decoder
else:
print('Not defined model: ', model_type)
exit(0)
def build():
"""Instantiates ResNet32 model """
# Parameters for Resnet32 on Cifar-100
num_blocks = 5
classes = 100
training = False
input_shape = (32, 32, 3)
img_input = layers.Input(shape=input_shape)
x = img_input
bn_axis = 1
if tf.keras.backend.image_data_format() == "channels_last":
bn_axis = 3
else:
bn_axis = 1
x = ZeroPadding2D(padding=(1, 1))(x)
x = Conv2D(
16,
(3, 3),
strides=(1, 1),
padding="valid",
kernel_initializer="he_normal",
kernel_regularizer=l2(L2_WEIGHT_DECAY),
bias_regularizer=l2(L2_WEIGHT_DECAY),
)(x)
x = BatchNormalization(
axis=bn_axis, momentum=BATCH_NORM_DECAY, epsilon=BATCH_NORM_EPSILON, fused=True
)(x, training=training)
x = Activation("approx_activation")(x)
x = resnet_block(
x,
size=num_blocks,
kernel_size=3,
filters=[16, 16],
stage=2,
conv_strides=(1, 1),
training=training,
)
x = resnet_block(
x,
size=num_blocks,
kernel_size=3,
filters=[32, 32],
stage=3,
conv_strides=(2, 2),
training=training,
)
x = resnet_block(
x,
size=num_blocks,
kernel_size=3,
filters=[64, 64],
stage=4,
conv_strides=(2, 2),
training=training,
)
x = AveragePooling2D(pool_size=(8, 8), strides=(1, 1), padding="VALID")(x)
x = Lambda(lambda w: tf.keras.backend.squeeze(w, 1))(x)
x = Lambda(lambda w: tf.keras.backend.squeeze(w, 1))(x)
x = Dense(
classes,
activation="softmax",
kernel_initializer="he_normal",
kernel_regularizer=l2(L2_WEIGHT_DECAY),
bias_regularizer=l2(L2_WEIGHT_DECAY),
)(x)
inputs = img_input
# Create model.
model = tf.keras.models.Model(inputs, x)
return model
def InceptionResNetV2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the Inception-ResNet v2 architecture.
Optionally loads weights pre-trained on ImageNet.
Note that when using TensorFlow, for best performance you should
set `"image_data_format": "channels_last"` in your Keras config
at `~/.keras/keras.json`.
The model and the weights are compatible with both TensorFlow and Theano
backends (but not CNTK). The data format convention used by the model is
the one specified in your Keras config file.
Note that the default input image size for this model is 299x299, instead
of 224x224 as in the VGG16 and ResNet models. For preprocessing use:
```
image = ...
image /= 127.5
image -= 1.0
# 'RGB'->'BGR'
x = x[..., ::-1]
# substract mean
mean = [103.939, 116.779, 123.68]
x[..., 0] -= mean[0]
x[..., 1] -= mean[1]
x[..., 2] -= mean[2]
```
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or `'imagenet'` (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is `False` (otherwise the input shape
has to be `(299, 299, 3)` (with `'channels_last'` data format)
or `(3, 299, 299)` (with `'channels_first'` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 139.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the last convolutional layer.
- `'avg'` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `'max'` means that global max pooling will be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is `True`, and
if no `weights` argument is specified.
# Returns
A Keras `Model` instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
RuntimeError: If attempting to run this model with an unsupported backend.
"""
if K.backend() in {'cntk'}:
raise RuntimeError(K.backend() +
' backend is currently unsupported for this model.')
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=139,
data_format=K.image_data_format(),
require_flatten=False,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='same')
x = conv2d_bn(x, 32, 3, padding='same')
x = conv2d_bn(x, 64, 3)
x = MaxPooling2D(3, strides=2, padding="same")(x)
x = conv2d_bn(x, 80, 1, padding='same')
x = conv2d_bn(x, 192, 3, padding='same')
x = MaxPooling2D(3, strides=2, padding='same')(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1)
branch_1 = conv2d_bn(x, 48, 1)
branch_1 = conv2d_bn(branch_1, 64, 5)
branch_2 = conv2d_bn(x, 64, 1)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_pool = AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
x = Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(x,
scale=0.17,
block_type='block35',
block_idx=block_idx)
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='same')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 256, 3)
branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx)
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1)
branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='same')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='same')
branch_2 = conv2d_bn(x, 256, 1)
branch_2 = conv2d_bn(branch_2, 288, 3)
branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(x,
scale=0.2,
block_type='block8',
block_idx=block_idx)
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=10)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b')
if include_top:
# Classification block
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model
model = Model(inputs, x, name='inception_resnet_v2')
# Load weights
if weights == 'imagenet':
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
if include_top:
weights_filename = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
weights_path = get_file(
weights_filename,
BASE_WEIGHT_URL + weights_filename,
cache_subdir='models',
md5_hash='e693bd0210a403b3192acc6073ad2e96')
else:
weights_filename = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5'
weights_path = get_file(
weights_filename,
BASE_WEIGHT_URL + weights_filename,
cache_subdir='models',
md5_hash='d19885ff4a710c122648d3b5c3b684e4')
model.load_weights(weights_path)
return model
def minigooglenet_functional(width, height, depth, classes):
def conv_module(x, K, kX, kY, stride, chanDim, padding="same"):
# define a CONV => BN => RELU pattern
x = Conv2D(K, (kX, kY), strides=stride, padding=padding)(x)
x = BatchNormalization(axis=chanDim)(x)
x = Activation("relu")(x)
# return the block
return x
def inception_module(x, numK1x1, numK3x3, chanDim):
# define two CONV modules, then concatenate across the
# channel dimension
conv_1x1 = conv_module(x, numK1x1, 1, 1, (1, 1), chanDim)
conv_3x3 = conv_module(x, numK3x3, 3, 3, (1, 1), chanDim)
x = concatenate([conv_1x1, conv_3x3], axis=chanDim)
# return the block
return x
def downsample_module(x, K, chanDim):
# define the CONV module and POOL, then concatenate
# across the channel dimensions
conv_3x3 = conv_module(x, K, 3, 3, (2, 2), chanDim, padding="valid")
pool = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = concatenate([conv_3x3, pool], axis=chanDim)
# return the block
return x
# initialize the input shape to be "channels last" and the
# channels dimension itself
inputShape = (height, width, depth)
chanDim = -1
# define the model input and first CONV module
inputs = Input(shape=inputShape)
x = conv_module(inputs, 96, 3, 3, (1, 1), chanDim)
# two Inception modules followed by a downsample module
x = inception_module(x, 32, 32, chanDim)
x = inception_module(x, 32, 48, chanDim)
x = downsample_module(x, 80, chanDim)
# four Inception modules followed by a downsample module
x = inception_module(x, 112, 48, chanDim)
x = inception_module(x, 96, 64, chanDim)
x = inception_module(x, 80, 80, chanDim)
x = inception_module(x, 48, 96, chanDim)
x = downsample_module(x, 96, chanDim)
# two Inception modules followed by global POOL and dropout
x = inception_module(x, 176, 160, chanDim)
x = inception_module(x, 176, 160, chanDim)
x = AveragePooling2D((7, 7))(x)
x = Dropout(0.5)(x)
# softmax classifier
x = Flatten()(x)
x = Dense(classes)(x)
x = Activation("softmax")(x)
# create the model
model = Model(inputs, x, name="minigooglenet")
# return the constructed network architecture
return model
def BisenetV2(include_top=True,
input_tensor=None,
input_shape=(224, 224, 3),
weights=None
):
if K.backend() != 'tensorflow':
raise RuntimeError('Only tensorflow supported for now')
name = "bisenetv2"
input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=28, require_flatten=include_top,
data_format=K.image_data_format())
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
img_input1 = Conv2D(16, kernel_size=(3, 3), strides=2, padding="same", use_bias=False, name="stem_block/conv_block_1")(img_input)
img_input1 = BatchNormalization(axis=-1, name="stem_block/conv_block_1/bn_1")(img_input1)
img_input1 = Activation(activation="relu", name="stem_block/conv_block_1/activate_1")(img_input1)
branch_left_output = Conv2D(int(16/2), kernel_size=(1, 1), strides=1, padding="same", use_bias=False, name="stem_block/downsample_branch_left/1x1_conv_block")(img_input1)
branch_left_output = BatchNormalization(axis=-1, name="stem_block/downsample_branch_left/1x1_conv_block/bn_1")(branch_left_output)
branch_left_output = Activation(activation="relu", name="stem_block/downsample_branch_left/1x1_conv_block/activate_1")(branch_left_output)
branch_left_output = Conv2D(16, kernel_size=(3, 3), strides=2, padding="same", use_bias=False,
name="stem_block/downsample_branch_left/3x3_conv_block")(branch_left_output)
branch_left_output = BatchNormalization(axis=-1, name="stem_block/downsample_branch_left/3x3_conv_block/bn_1")(branch_left_output)
branch_left_output = Activation(activation="relu", name="stem_block/downsample_branch_left/3x3_conv_block/activate_1")(branch_left_output)
branch_right_output = MaxPool2D(pool_size=(3, 3), strides=2, padding='same', name="stem_block/downsample_branch_right/maxpooling_block")(img_input1)
stem_result = Concatenate(axis=-1, name="stem_block/concate_features")([branch_left_output, branch_right_output])
stem_result = Conv2D(16, kernel_size=(3, 3), strides=1, padding="same", use_bias=False, name="stem_block/final_conv_block")(stem_result)
stem_result = BatchNormalization(axis=-1, name="stem_block/final_conv_block/bn_1")(stem_result)
stem_result = Activation(activation="relu", name="stem_block/final_conv_block/activate_1")(stem_result)
# k_reduce_mean = Lambda(lambda x: tf.reduce_mean(x, axis=[1, 2], keepdims=True, name='global_avg_pooling'))
# embedding_result=k_reduce_mean(stem_result)
# embedding_result = K.mean(stem_result, axis=[1, 2], keepdims=True)
embedding_result = KerasReduceMean(axis=(1, 2), keep_dim=True, name="global_avg_pooling")(stem_result)
embedding_result = BatchNormalization(axis=-1, name="context_embedding_block/bn")(embedding_result)
output_channels = stem_result.get_shape().as_list()[-1]
embedding_result = Conv2D(output_channels, kernel_size=(1, 1), strides=1, padding="same", use_bias=False,
name="context_embedding_block/conv_block_1")(embedding_result)
embedding_result = BatchNormalization(axis=-1, name="context_embedding_block/conv_block_1/bn_1")(embedding_result)
embedding_result = Activation(activation="relu", name="context_embedding_block/conv_block_1/activate_1")(embedding_result)
embedding_result = Add(name="context_embedding_block/fused_features")([embedding_result, stem_result])
embedding_result = Conv2D(output_channels, kernel_size=(3, 3), strides=1, padding="same", use_bias=False, name="context_embedding_block/final_conv_block")(embedding_result)
output_channels = embedding_result.get_shape().as_list()[-1]
gather_expansion_result = Conv2D(output_channels, kernel_size=(3, 3), strides=1, padding="same", use_bias=False,
name="ge_block_with_stride_1/stride_equal_one_module/3x3_conv_block")(embedding_result)
gather_expansion_result = BatchNormalization(axis=-1, name="ge_block_with_stride_1/stride_equal_one_module/3x3_conv_block/bn_1")(gather_expansion_result)
gather_expansion_result = Activation(activation="relu", name="ge_block_with_stride_1/stride_equal_one_module/3x3_conv_block/activate_1")(gather_expansion_result)
gather_expansion_result = DepthwiseConv2D(kernel_size=3, strides=1, depth_multiplier=6, padding='same',
name="ge_block_with_stride_1/stride_equal_one_module/depthwise_conv_block")(gather_expansion_result)
gather_expansion_result = BatchNormalization(axis=-1, name="ge_block_with_stride_1/stride_equal_one_module/dw_bn")(gather_expansion_result)
gather_expansion_result = Conv2D(output_channels, kernel_size=(1, 1), strides=1, padding="same", use_bias=False,
name="ge_block_with_stride_1/stride_equal_one_module/1x1_conv_block")(gather_expansion_result)
gather_expansion_result = Add(name="ge_block_with_stride_1/stride_equal_one_module/fused_features")([embedding_result, gather_expansion_result])
gather_expansion_result = Activation(activation="relu", name="ge_block_with_stride_1/stride_equal_one_module/ge_output")(gather_expansion_result)
gather_expansion_proj_result = DepthwiseConv2D(kernel_size=3, depth_multiplier=1, strides=2, padding="same",
name="ge_block_with_stride_2/stride_equal_two_module/input_project_dw_conv_block")(gather_expansion_result)
gather_expansion_proj_result = BatchNormalization(axis=-1, name="ge_block_with_stride_2/stride_equal_two_module/input_project_bn")(gather_expansion_proj_result)
gather_expansion_proj_result = Conv2D(128, kernel_size=(1, 1), strides=1, padding="same", use_bias=False, activation=None)(gather_expansion_proj_result)
input_tensor_channels = gather_expansion_result.get_shape().as_list()[-1]
gather_expansion_stride2_result = Conv2D(input_tensor_channels, kernel_size=(3, 3), strides=1, padding="same",
use_bias=False, name="ge_block_with_stride_2/stride_equal_two_module/3x3_conv_block")(gather_expansion_result)
gather_expansion_stride2_result = BatchNormalization(axis=-1, name="ge_block_with_stride_2/stride_equal_two_module/3x3_conv_block/bn_1")(gather_expansion_stride2_result)
gather_expansion_stride2_result = Activation(activation="relu", name="ge_block_with_stride_2/stride_equal_two_module/3x3_conv_block/activate_1")(gather_expansion_stride2_result)
gather_expansion_stride2_result = DepthwiseConv2D(kernel_size=3, depth_multiplier=6, strides=2, padding="same",
name="ge_block_with_stride_2/stride_equal_two_module/depthwise_conv_block_1")(gather_expansion_stride2_result)
gather_expansion_stride2_result = BatchNormalization(axis=-1, name="ge_block_with_stride_2/stride_equal_two_module/dw_bn_1")(gather_expansion_stride2_result)
gather_expansion_stride2_result = DepthwiseConv2D(kernel_size=3, depth_multiplier=1, strides=1, padding="same",
name="ge_block_with_stride_2/stride_equal_two_module/depthwise_conv_block_2")(gather_expansion_stride2_result)
gather_expansion_stride2_result = BatchNormalization(axis=-1, name="ge_block_with_stride_2/stride_equal_two_module/dw_bn_2")(gather_expansion_stride2_result)
gather_expansion_stride2_result = Conv2D(128, kernel_size=(1, 1), strides=1, padding="same",
use_bias=False, activation=None, name="ge_block_with_stride_2/stride_equal_two_module/1x1_conv_block")(gather_expansion_stride2_result)
gather_expansion_total_result = Add(name="ge_block_with_stride_2/stride_equal_two_module/fused_features")([gather_expansion_proj_result, gather_expansion_stride2_result])
gather_expansion_total_result = Activation(activation="relu", name="ge_block_with_stride_2/stride_equal_two_module/ge_output")(gather_expansion_total_result)
gather_expansion_proj2_result = DepthwiseConv2D(kernel_size=3, depth_multiplier=1, strides=2, padding="same",
name="ge_block_with_stride_2_repeat/stride_equal_two_module/input_project_dw_conv_block")(gather_expansion_total_result)
gather_expansion_proj2_result = BatchNormalization(axis=-1, name="ge_block_with_stride_2_repeat/stride_equal_two_module/input_project_bn")(gather_expansion_proj2_result)
gather_expansion_proj2_result = Conv2D(128, kernel_size=(1, 1), strides=1, padding="same", use_bias=False, activation=None)(gather_expansion_proj2_result)
input_tensor_channels = gather_expansion_total_result.get_shape().as_list()[-1]
gather_expansion_stride2_result_repeat = Conv2D(input_tensor_channels, kernel_size=(3, 3), strides=1, padding="same",
use_bias=False, name="ge_block_with_stride_2_repeat/stride_equal_two_module/3x3_conv_block")(gather_expansion_total_result)
gather_expansion_stride2_result_repeat = BatchNormalization(axis=-1, name="ge_block_with_stride_2_repeat/stride_equal_two_module/3x3_conv_block/bn_1")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = Activation(activation="relu", name="ge_block_with_stride_2_repeat/stride_equal_two_module/3x3_conv_block/activate_1")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = DepthwiseConv2D(kernel_size=3, depth_multiplier=6, strides=2, padding="same",
name="ge_block_with_stride_2_repeat/stride_equal_two_module/depthwise_conv_block_1")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = BatchNormalization(axis=-1, name="ge_block_with_stride_2_repeat/stride_equal_two_module/dw_bn_1")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = DepthwiseConv2D(kernel_size=3, depth_multiplier=1, strides=1, padding="same",
name="ge_block_with_stride_2_repeat/stride_equal_two_module/depthwise_conv_block_2")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = BatchNormalization(axis=-1, name="ge_block_with_stride_2_repeat/stride_equal_two_module/dw_bn_2")(gather_expansion_stride2_result_repeat)
gather_expansion_stride2_result_repeat = Conv2D(128, kernel_size=(1, 1), strides=1, padding="same",
use_bias=False, activation=None, name="ge_block_with_stride_2_repeat/stride_equal_two_module/1x1_conv_block")(gather_expansion_stride2_result_repeat)
gather_expansion_total_result_repeat = Add(name="ge_block_with_stride_2_repeat/stride_equal_two_module/fused_features")([gather_expansion_proj2_result, gather_expansion_stride2_result_repeat])
gather_expansion_total_result_repeat = Activation(activation="relu", name="ge_block_with_stride_2_repeat/stride_equal_two_module/ge_output")(gather_expansion_total_result_repeat)
detail_input_tensor = stem_result
semantic_input_tensor = gather_expansion_total_result_repeat
output_channels = stem_result.get_shape().as_list()[-1]
detail_branch_remain = DepthwiseConv2D(kernel_size=3, strides=1, padding="same", depth_multiplier=1,
name="guided_aggregation_block/detail_branch/3x3_dw_conv_block")(detail_input_tensor)
detail_branch_remain = BatchNormalization(axis=-1, name="guided_aggregation_block/detail_branch/bn_1")(detail_branch_remain)
detail_branch_remain = Conv2D(output_channels, kernel_size=(1, 1), padding="same", strides=1, use_bias=False,
name="guided_aggregation_block/detail_branch/1x1_conv_block")(detail_branch_remain)
detail_branch_downsample = Conv2D(output_channels, kernel_size=(3, 3), strides=2, use_bias=False, activation=None,
padding="same", name="guided_aggregation_block/detail_branch/3x3_conv_block")(detail_input_tensor)
detail_branch_downsample = AveragePooling2D(pool_size=(3, 3), strides=2, padding="same", name="guided_aggregation_block/detail_branch/avg_pooling_block")(detail_branch_downsample)
semantic_branch_remain = DepthwiseConv2D(kernel_size=3, strides=1, padding="same", depth_multiplier=1,
name="guided_aggregation_block/semantic_branch/3x3_dw_conv_block")(semantic_input_tensor)
semantic_branch_remain = BatchNormalization(axis=-1, name="guided_aggregation_block/semantic_branch/bn_1")(semantic_branch_remain)
semantic_branch_remain = Conv2D(output_channels, kernel_size=(1, 1), strides=1, use_bias=False, activation=None, padding="same",
name="guided_aggregation_block/semantic_branch/1x1_conv_block")(semantic_branch_remain)
# semantic_branch_remain = sigmoid(semantic_branch_remain)
# keras_sigmoid = Lambda(lambda x: tf.nn.sigmoid(x, name="guided_aggregation_block/semantic_branch/semantic_remain_sigmoid"))
# semantic_branch_remain = keras_sigmoid(semantic_branch_remain)
semantic_branch_remain = Activation("sigmoid", name="guided_aggregation_block/semantic_branch/semantic_remain_sigmoid")(semantic_branch_remain)
semantic_branch_upsample = Conv2D(output_channels, kernel_size=(3, 3), strides=1, padding="same", use_bias=False,
activation=None, name="guided_aggregation_block/semantic_branch/3x3_conv_block")(semantic_input_tensor)
# semantic_branch_upsample = resize_images(semantic_branch_upsample, 4, 4, data_format="channels_last", interpolation='bilinear')
# upsample_bilinear0 = Lambda(lambda x: tf.image.resize_bilinear(x, size=stem_result.get_shape().as_list()[1:3],
# name="guided_aggregation_block/semantic_branch/semantic_upsample_features"))
# semantic_branch_upsample = upsample_bilinear0(semantic_branch_upsample)
semantic_branch_upsample = BilinearUpSampling2D((4, 4), name="guided_aggregation_block/semantic_branch/semantic_upsample_features")(semantic_branch_upsample)
semantic_branch_upsample = Activation("sigmoid", name="guided_aggregation_block/semantic_branch/semantic_branch_upsample_sigmoid")(semantic_branch_upsample)
# keras_sigmoid_1 = Lambda(lambda x: tf.nn.sigmoid(x, name="guided_aggregation_block/semantic_branch/semantic_branch_upsample_sigmoid"))
# semantic_branch_upsample = keras_sigmoid_1(semantic_branch_upsample)
# semantic_branch_upsample = sigmoid(semantic_branch_upsample)
guided_features_remain = Multiply(name="guided_aggregation_block/aggregation_features/guided_detail_features")([detail_branch_remain, semantic_branch_upsample])
guided_features_downsample = Multiply(name="guided_aggregation_block/aggregation_features/guided_semantic_features")([detail_branch_downsample, semantic_branch_remain])
# upsample_bilinear1 = Lambda(lambda x: tf.image.resize_bilinear(x, size=stem_result.get_shape().as_list()[1:3],
# name="guided_aggregation_block/aggregation_features/guided_upsample_features"))
#
# guided_features_upsample = upsample_bilinear1(guided_features_downsample)
guided_features_upsample = BilinearUpSampling2D((4, 4), name="guided_aggregation_block/aggregation_features/guided_upsample_features")(guided_features_downsample)
# guided_features_upsample = resize_images(guided_features_downsample, 4, 4, data_format="channels_last", interpolation='bilinear')
guided_features = Add(name="guided_aggregation_block/aggregation_features/fused_features")([guided_features_remain, guided_features_upsample])
guided_features = Conv2D(output_channels, kernel_size=(3, 3), strides=1, use_bias=False, padding="same",
name="guided_aggregation_block/aggregation_features/aggregation_feature_output")(guided_features)
guided_features = BatchNormalization(axis=-1, name="guided_aggregation_block/aggregation_features/aggregation_feature_output/bn_1")(guided_features)
guided_features = Activation(activation="relu", name="guided_aggregation_block/aggregation_features/aggregation_feature_output/activate_1")(guided_features)
# input_tensor_size = [int(tmp * 4)for tmp in guided_features.get_shape().as_list()[1:3]]
result = Conv2D(8, kernel_size=(3, 3), strides=1, use_bias=False, padding="same", name="seg_head_block/3x3_conv_block")(guided_features)
result = BatchNormalization(axis=-1, name="seg_head_block/bn_1")(result)
result = Activation("relu", name="seg_head_block/activate_1")(result)
# upsample_bilinear2 = Lambda(lambda x: tf.image.resize_bilinear(x, size=input_tensor_size, name="seg_head_block/segmentation_head_logits"))
# result = upsample_bilinear2(result)
result = BilinearUpSampling2D((4, 4), name="seg_head_block/segmentation_head_upsample")(result)
# result = resize_images(result, 4, 4, data_format="channels_last", interpolation='bilinear')
result = Conv2D(1, kernel_size=(1, 1), strides=1, use_bias=False, padding="same",
name="seg_head_block/1x1_conv_block")(result)
if input_tensor:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
model = Model(inputs, result, name=name)
if weights:
model.load_weights(weights, by_name=True)
return model
zoom_range=0.15,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.15,
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
#building neural network using mobileNetV2 and 5 layers
baseModel = MobileNetV2(weights='imagenet',
include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
baseModel.summary()
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
headModel = Flatten(name='Flatten')(headModel)
headModel = Dense(64, activation='relu')(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation='softmax')(headModel)
model = Model(inputs=baseModel.input, outputs=headModel)
model.summary()
for layer in baseModel.layers:
layer.trainable = False
learning_rate = 0.001
Epochs = 20
Batch_size = 32
print(len(train_X) // Batch_size)
optimizer = Adam(lr=learning_rate, decay=learning_rate / Epochs)
model.compile(loss='binary_crossentropy',
def buildSE_ResNet152Model(img_height, img_width, img_channl, num_classes,
num_GPU):
inputs = Input(shape=(img_height, img_width, img_channl))
x = ZeroPadding2D((3, 3))(inputs)
x = Conv2d_BN(x,
nb_filter=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='valid')
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')(x)
x = Conv_Block_3(x,
nb_filter=[64, 64, 256],
kernel_size=(3, 3),
strides=(1, 1),
with_conv_shortcut=True)
x = Conv_Block_3(x, nb_filter=[64, 64, 256], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[64, 64, 256], kernel_size=(3, 3))
x = Conv_Block_3(x,
nb_filter=[128, 128, 512],
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[128, 128, 512], kernel_size=(3, 3))
x = Conv_Block_3(x,
nb_filter=[256, 256, 1024],
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[256, 256, 1024], kernel_size=(3, 3))
x = Conv_Block_3(x,
nb_filter=[512, 512, 2048],
kernel_size=(3, 3),
strides=(2, 2),
with_conv_shortcut=True)
x = Conv_Block_3(x, nb_filter=[512, 512, 2048], kernel_size=(3, 3))
x = Conv_Block_3(x, nb_filter=[512, 512, 2048], kernel_size=(3, 3))
x = AveragePooling2D(pool_size=(7, 7))(x)
x = Flatten()(x)
outputs = Dense(num_classes, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=outputs)
model.summary()
if (num_GPU > 1):
model = multi_gpu_model(model, gpus=num_GPU)
model.compile(
loss='binary_crossentropy',
optimizer='adam', #0.001
metrics=['categorical_accuracy', 'binary_accuracy', f1_m])
return model
def Deeplabv3(weights=None, input_tensor=None, infer = False, input_shape=(512, 512, 3), classes=2, backbone='mobilenetv2', OS=16, alpha=1.):
""" Instantiates the Deeplabv3+ architecture
Optionally loads weights pre-trained
on PASCAL VOC. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
data format `(width, height, channels)`.
# Arguments
weights: one of 'pascal_voc' (pre-trained on pascal voc)
or None (random initialization)
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: shape of input image. format HxWxC
PASCAL VOC model was trained on (512,512,3) images
classes: number of desired classes. If classes != 21,
last layer is initialized randomly
backbone: backbone to use. one of {'xception','mobilenetv2'}
OS: determines input_shape/feature_extractor_output ratio. One of {8,16}.
Used only for xception backbone.
alpha: controls the width of the MobileNetV2 network. This is known as the
width multiplier in the MobileNetV2 paper.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
Used only for mobilenetv2 backbone
# Returns
A Keras model instance.
# Raises
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
ValueError: in case of invalid argument for `weights` or `backbone`
"""
if not (weights in {'pascal_voc', None}):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `pascal_voc` '
'(pre-trained on PASCAL VOC)')
# if K.backend() != 'tensorflow':
# raise RuntimeError('The Deeplabv3+ model is only available with '
# 'the TensorFlow backend.')
if not (backbone in {'xception', 'mobilenetv2'}):
raise ValueError('The `backbone` argument should be either '
'`xception` or `mobilenetv2` ')
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# batches_input = Lambda(lambda x: x/127.5 - 1)(img_input)
print(img_input)
OS = 8
first_block_filters = _make_divisible(32 * alpha, 8)
x = Conv2D(first_block_filters,
kernel_size=3,
strides=(2, 2), padding='same',
use_bias=False, name='Conv')(img_input)
x = BatchNormalization(
epsilon=1e-3, momentum=0.999, name='Conv_BN')(x)
x = Lambda(lambda x: relu(x, max_value=6.))(x)
x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1,
expansion=1, block_id=0, skip_connection=False)
x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2,
expansion=6, block_id=1, skip_connection=False)
x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1,
expansion=6, block_id=2, skip_connection=True)
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2,
expansion=6, block_id=3, skip_connection=False)
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
expansion=6, block_id=4, skip_connection=True)
x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1,
expansion=6, block_id=5, skip_connection=True)
# stride in block 6 changed from 2 -> 1, so we need to use rate = 2
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, # 1!
expansion=6, block_id=6, skip_connection=False)
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=7, skip_connection=True)
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=8, skip_connection=True)
x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=9, skip_connection=True)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=10, skip_connection=False)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=11, skip_connection=True)
x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2,
expansion=6, block_id=12, skip_connection=True)
x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=2, # 1!
expansion=6, block_id=13, skip_connection=False)
x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4,
expansion=6, block_id=14, skip_connection=True)
x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4,
expansion=6, block_id=15, skip_connection=True)
x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, rate=4,
expansion=6, block_id=16, skip_connection=False)
# end of feature extractor
# branching for Atrous Spatial Pyramid Pooling
# Image Feature branch
#out_shape = int(np.ceil(input_shape[0] / OS))
b4 = AveragePooling2D(pool_size=(int(np.ceil(input_shape[0] / OS)), int(np.ceil(input_shape[1] / OS))))(x)
b4 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='image_pooling')(b4)
b4 = BatchNormalization(name='image_pooling_BN', epsilon=1e-5)(b4)
b4 = Activation('relu')(b4)
b4 = Lambda(lambda x: tf.image.resize(x,size=(int(np.ceil(input_shape[0]/OS)), int(np.ceil(input_shape[1]/OS))), method='bilinear'))(b4)
# simple 1x1
b0 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='aspp0')(x)
b0 = BatchNormalization(name='aspp0_BN', epsilon=1e-5)(b0)
b0 = Activation('relu', name='aspp0_activation')(b0)
# there are only 2 branches in mobilenetV2. not sure why
x = Concatenate()([b4, b0])
x = Conv2D(256, (1, 1), padding='same',
use_bias=False, name='concat_projection')(x)
x = BatchNormalization(name='concat_projection_BN', epsilon=1e-5)(x)
x = Activation('relu')(x)
x = Dropout(0.1)(x)
# DeepLab v.3+ decoder
# you can use it with arbitary number of classes
if classes == 21:
last_layer_name = 'logits_semantic'
else:
last_layer_name = 'custom_logits_semantic'
x = Conv2D(classes, (1, 1), padding='same', name=last_layer_name)(x)
x = Lambda(lambda x: tf.image.resize(x,size=(input_shape[0],input_shape[1]), method='bilinear'))(x)
if infer:
x = Activation('softmax')(x)
else:
x = Reshape((input_shape[0]*input_shape[1], classes)) (x)
x = Activation('softmax')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
model = Model(inputs, x, name='deeplabv3p')
# load weights
if weights == 'pascal_voc':
if backbone == 'xception':
weights_path = tf.keras.utils.get_file('deeplabv3_xception_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH_X,
cache_subdir='models')
else:
weights_path = tf.keras.utils.get_file('deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH_MOBILE,
cache_subdir='models')
model.load_weights(weights_path, by_name=True)
return model
def ResNet50(input_shape, classes):
# making a tensor of shape input_shape
X_input = Input(input_shape)
# zero padding the tensor
X = ZeroPadding2D((3, 3))(X_input)
# stage 1
X = Conv2D(filters=64,
kernel_size=(7, 7),
strides=(2, 2),
name='conv1',
kernel_initializer='he_normal')(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2), name='max_pool')(X)
# stage 2
X = convBlock(inputTensor=X,
kernel_size=3,
filters=[64, 64, 256],
stage=2,
block='a',
strides=(1, 1))
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[64, 64, 256],
stage=2,
block='b')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[64, 64, 256],
stage=2,
block='c')
# stage 3
X = convBlock(inputTensor=X,
kernel_size=3,
filters=[128, 128, 512],
stage=3,
block='a',
strides=(2, 2))
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[128, 128, 512],
stage=3,
block='b')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[128, 128, 512],
stage=3,
block='c')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[128, 128, 512],
stage=3,
block='d')
# stage 4
X = convBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='a',
strides=(2, 2))
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='b')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='c')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='d')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='e')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[256, 256, 1024],
stage=4,
block='f')
# stage 5
X = convBlock(inputTensor=X,
kernel_size=3,
filters=[512, 512, 2048],
stage=5,
block='a',
strides=(2, 2))
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[512, 512, 2048],
stage=5,
block='b')
X = identityBlock(inputTensor=X,
kernel_size=3,
filters=[512, 512, 2048],
stage=5,
block='c')
# pooling (average)
X = AveragePooling2D((7, 7), name='avg_pool')(X)
# flatten the output layer
X = Flatten()(X)
# add a dense layer
X = Dense(128,
activation='relu',
name=f'fc_128',
kernel_initializer='he_normal')(X)
# add a dropout layer to address overfitting
X = Dropout(0.5)(X)
# creating a fully connected layer for predicting classes
X = Dense(classes,
activation='softmax',
name=f'fc_{classes}',
kernel_initializer='he_normal')(X)
# finally creating a model
model = Model(inputs=X_input, outputs=X, name='ResNet50')
# return the model
return model
