def creat_model(self):
#測試使用類似ResNet架構
input_layer = Input(shape = [400, 400, self.channels, ], name = "Input_layer")
#第一區多用較大的stride降維
block_0_con2d_layer = layers.Conv2D(self.start_nodes, 3, 2, name = "block_0_con2d_layer")(input_layer)
block_0_bn_layer = layers.BatchNormalization(name = "block_0_bn_layer")(block_0_con2d_layer)
block_0_act_layer = layers.PReLU(name = "block_0_act_layer")(block_0_bn_layer)
block_0_maxpool_layer = layers.MaxPool2D(name = "block_0_maxpool_layer")(block_0_act_layer)
#第二區由數個block組成
#通常會在每個block開頭先降解析度並增加維度
block_1_reduce_image_size = self.reduce_image_size(block_0_maxpool_layer, 1)
block_1_main_con2d_net = self.con2d_net_block(block_1_reduce_image_size, 1, 2)
block_2_reduce_image_size = self.reduce_image_size(block_1_main_con2d_net, 2)
block_2_main_con2d_net = self.con2d_net_block(block_2_reduce_image_size, 2, 2)
block_3_reduce_image_size = self.reduce_image_size(block_2_main_con2d_net, 3)
block_3_main_con2d_net = self.con2d_net_block(block_3_reduce_image_size, 3, 3)
block_4_reduce_image_size = self.reduce_image_size(block_3_main_con2d_net, 4)
block_4_main_con2d_net = self.con2d_net_block(block_4_reduce_image_size, 4, 5)
block_5_reduce_image_size = self.reduce_image_size(block_4_main_con2d_net, 5)
block_5_main_con2d_net = self.con2d_net_block(block_5_reduce_image_size, 5, 2)
#最後以一個avg_pool降維並連接到輸出
avg_pool_layer = layers.AvgPool2D(4, 1)(block_5_main_con2d_net)
flatten_layer = layers.Flatten()(avg_pool_layer)
output_layer = layers.Dense(self.number_of_class, activation = 'softmax')(flatten_layer)
self.model = Model(input_layer, output_layer)
def inception_v1(inputs):
"""Inception
1.discard dense layer that has too many params
2.dense layer can overfit
3.network in network: Use conv_1X1 to reduce params and use conv_3X3, conv_5X5 to make
[receptive field rich]. Make feature rich.
"""
x = layers.Conv2D(64, 7, 2, padding='same', activation='relu')(inputs)
x = layers.MaxPool2D(3, 2, padding='same')(x)
x = layers.Conv2D(64, 1, padding='same', activation='relu')(x)
x = layers.Conv2D(192, 3, padding='same', activation='relu')(x)
x = layers.MaxPool2D(3, 2, padding='same')(x)
x1 = inception_block(x, 64, 96, 128, 16, 32, 32)
x2 = inception_block(x1, 128, 128, 192, 32, 96, 64)
x3 = layers.MaxPool2D(3, strides=2, padding='same')(x2)
x4 = inception_block(x3, 192, 96, 208, 16, 48, 64)
x5 = inception_block(x4, 160, 112, 224, 24, 64, 64)
x6 = inception_block(x5, 128, 128, 256, 24, 64, 64)
x7 = inception_block(x6, 112, 144, 288, 32, 64, 64)
x8 = inception_block(x7, 256, 160, 320, 32, 128, 128)
x9 = layers.MaxPool2D(3, 2, padding='same')(x8)
x10 = inception_block(x9, 256, 160, 320, 32, 128, 128)
x11 = inception_block(x10, 384, 192, 384, 48, 128, 128)
x12 = layers.AvgPool2D(7, strides=1)(x11)
x13 = layers.Dropout(rate=0.4)(x12)
x14 = layers.Dense(1000, activation='softmax')(x13)
return x14
def call(self, x):
# Define the forward pass
# input: instead of wxhx1 use wx1xh
# output: instead of 3x3x1xhxwx3 get 3x1xfxtx1xc
L = x.shape[1]
C = x.shape[2]
# inputs = tf.reshape(x, [-1, L, 1, C]) # [N, L, 1, C]
inputs = tf.reshape(x, [-1, L, 3, C]) # [N, L, 1, C]
res0_1 = self.conv1(inputs)
# through block1
res1_1 = self.bn1_2(self.conv3(self.activ1_1(self.bn1_1(self.conv2(res0_1)))))
res1_1_1 = self.activ1_1_1(self.bn1_1_1(self.conv4(res0_1)))
res1_2 = l.concatenate([res1_1, res1_1_1])
res1_3 = self.activ1_2(res1_2)
# through block 2
res2_1 = self.bn2_2(self.conv6(self.activ2_1(self.bn2_1(self.conv5(res1_3)))))
res2_1_1 = self.activ2_1_1(self.bn2_1_1(self.conv7(res1_2)))
res2_2 = l.concatenate([res2_1, res2_1_1])
res2_3 = self.activ2_2(res2_2)
# through block 3
res3_1 = self.bn3_2(self.conv9(self.activ3_1(self.bn3_1(self.conv8(res2_3)))))
res3_1_1 = self.activ3_1_1(self.bn3_1_1(self.conv10(res2_3)))
res3_2 = l.concatenate([res3_1, res3_1_1])
res3_3 = self.activ3_2(res3_2)
self.avg_pool = l.AvgPool2D(pool_size=res3_3.shape[1:3], strides=1) # Average Pooling
res = self.avg_pool(res3_3)
return self.out_block(res)
def __init__(self, num_classes, **kwargs):
super(InceptionAux, self).__init__(**kwargs)
self.averagePool = layers.AvgPool2D(pool_size=5, strides=3) #平均池化
self.conv = layers.Conv2D(128, kernel_size=1, activation='relu')
self.fc1 = layers.Dense(1024, activation='relu')
self.fc2 = layers.Dense(num_classes)
self.softmax = layers.Softmax()
def __init__(self):
self.cnn1 = layers.Conv2D(
filters=6,
kernel_size=5,
activation='sigmoid',
)
self.avgpool1 = layers.AvgPool2D(pool_size=2, strides=2)
self.cnn2 = layers.Conv2D(filters=16,
kernel_size=5,
activation='sigmoid')
self.avgpool2 = layers.AvgPool2D(pool_size=2, strides=2)
self.flat = layers.Flatten()
self.dense1 = layers.Dense(120, activation='sigmoid')
self.dense2 = layers.Dense(84, activation='sigmoid')
self.dense3 = layers.Dense(10, activation='sigmoid')
def ResNet_20():
inputs = tf.keras.Input(shape=(256, 256, 3), name="img")
x = inputs
x = layers.Conv2D(64, 7)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.MaxPool2D()(x)
for _ in range(3):
x = ResBlock(num_feature_in=64, num_feature_out=64)(x)
x = ResBlock(num_feature_in=64, num_feature_out=128, strides=(2, 2))(x)
for _ in range(2):
x = ResBlock(num_feature_in=128, num_feature_out=128)(x)
x = ResBlock(num_feature_in=128, num_feature_out=256, strides=(2, 2))(x)
for _ in range(2):
x = ResBlock(num_feature_in=256, num_feature_out=256)(x)
x = ResBlock(num_feature_in=256, num_feature_out=512, strides=(2, 2))(x)
for _ in range(2):
x = ResBlock(num_feature_in=512, num_feature_out=512)(x)
x = layers.AvgPool2D()(x)
x = layers.Flatten()(x)
outputs = layers.Dense(10, activation="softmax")(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs, name="ResNet_20")
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss="categorical_crossentropy",
metrics=["acc"])
return model
def GoogleNet(im_height=224, im_width=224, class_num=1000, aux_logits=False):
# tensorflow 中的tensor通道排序是NHWC
input_image = layers.Input(shape=(im_height, im_width, 3), dtype="float32")
# (None, 224,224, 3)
x = layers.Conv2D(64,
kernel_size=7,
strides=2,
padding="SAME",
activation="relu",
name="conv2d_1")(input_image)
# (None, 112,112,64)
x = layers.MaxPool2D(pool_size=3,
strides=2,
padding="SAME",
name="maxpool_1")(x)
# (None, 56,56, 64)
x = layers.Conv2D(64, kernel_size=1, activation="relu", name="conv2d_2")(x)
# (None, 28, 28,192)
x = Inception(64, 96, 128, 16, 32, 32, name="inception_3a")(x)
# (None, 28, 28,256)
x = Inception(128, 128, 192, 32, 96, 64, name="inception_3b")(x)
# (None, 28, 28, 480)
x = layers.MaxPool2D(pool_size=3,
strides=2,
padding="SAME",
name="maxpool_3")(x)
# (None, 14,14,480)
x = Inception(192, 96, 208, 16, 48, 64, name="inception_4a")(x)
if aux_logits:
aux1 = InceptionAux(class_num, name="aux_1")(x)
# (None, 14,14,512)
x = Inception(160, 112, 224, 24, 64, 64, name="inception_4b")(x)
# (None, 14,14,512)
x = Inception(128, 128, 256, 24, 64, 64, name="inception_4c")(x)
# (None, 14,14,512)
x = Inception(112, 144, 288, 32, 64, 64, name="inception_4d")(x)
if aux_logits:
aux2 = InceptionAux(class_num, name="aux_2")(x)
# (None,14,14,528)
x = Inception(256, 160, 320, 32, 128, 128, name="inception_5a")(x)
# (None, 7, 7, 832)
x = Inception(384, 192, 384, 48, 128, 128, name="inception_5b")(x)
# (None,7,7,1024)
x = layers.AvgPool2D(pool_size=7, strides=1, name="avgpool_1")(x)
# (None, 1,1,1024)
x = layers.Flatten(name="output_flatten")(x)
# (None,1024)
x = layers.Dropout(rate=0.4, name="output_dropout")(x)
x = layers.Dense(class_num, name='output_dense')(x)
# (None, class_num)
aux3 = layers.Softmax(name="aux_3")(x) #aux3 is main classicer
if aux_logits:
model = models.Model(inputs=input_image, outputs=[aux1, aux2, aux3])
else:
model = models.Model(inputs=input_image, outputs=aux3)
return model
def __init__(self, num_classes, **kwargs):
super(InceptionAux, self).__init__(**kwargs)
self.averagePool = layers.AvgPool2D(pool_size=5, strides=3)
self.conv = layers.Conv2D(128, kernel_size=1, use_bias=False, name="conv/conv")
self.bn1 = layers.BatchNormalization(momentum=0.9, epsilon=1e-5, name="conv/bn")
self.rule1 = layers.ReLU()
self.fc1 = layers.Dense(1024, activation="relu", name="fc1")
self.fc2 = layers.Dense(num_classes, name="fc2")
self.softmax = layers.Softmax()
def build(self, input_shape):
filters = self._filters or input_shape[-1]
conv_name = f'{self.scope_name}/conv'
norm_cls = get_norm(self._norm)
norm_name = f'{self.scope_name}/{self._norm}'
act_name = f'{self.scope_name}/{self._activation}'
act_cls = get_activation(self._activation, return_cls=True)
pool_name = f'{self.scope_name}/{self._pool_type}'
self._layers = []
if self._conv is not None:
self._layers += [
self._conv(filters,
self._filter_size,
strides=1,
padding='same',
name=conv_name,
**self._kwargs),
norm_cls(**self._norm_kwargs, name=norm_name),
act_cls(name=act_name, **self._act_kwargs),
]
if self._pool_type == 'max':
self._layers += [
layers.MaxPool2D(self._filter_size,
strides=self._strides,
padding='same',
name=pool_name)
]
elif self._pool_type == 'avg':
self._layers += [
layers.AvgPool2D(self._filter_size,
strides=self._strides,
padding='same',
name=pool_name)
]
elif self._pool_type == 'maxblur':
self._layers += [
layers.MaxPool2D(self._filter_size,
strides=1,
padding='same',
name=f'{self.scope_name}/max'),
blurpool(self._filter_size,
strides=self._strides,
pad_mode=self._pad_mode,
name=f'{self.scope_name}/blur')
]
elif self._pool_type == 'blur':
self._layers += [
blurpool(self._filter_size,
strides=self._strides,
pad_mode=self._pad_mode,
name=pool_name)
]
else:
raise ValueError(f'Unkonwn pool type: {self._pool_type}')
def __init__(self,numclass = 10,expansion = 4):
super(Resnet, self).__init__()
self.expansion = expansion
self.conv1 = Conv1(64)
self.layer1 = self.make_layer(channel=64,block=3,stride=1)
self.layer2 = self.make_layer(128,8,stride=2)
self.layer3 = self.make_layer(256,36,stride=2)
self.layer4 = self.make_layer(512,3,stride=2)
self.avgpool = layers.AvgPool2D(7,strides=1)
self.fc = layers.Dense(numclass)
self.fal = layers.Flatten()
def Squeeze(_in, out_channels, se_ratio=12):
# First pool
avg_pool = layers.AvgPool2D(1)(_in)
# Next, fully connected sequential layers
x = layers.Conv2D(out_channels // se_ratio, kernel_size=1, padding='valid')(avg_pool)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.Conv2D(out_channels, kernel_size=1, padding='valid', activation='sigmoid')(x)
return layers.multiply([_in, x])
def inception_module_A(x,
filters_b1,
filters_b2_1,
filters_b2_2,
filters_b3_1,
filters_b3_2,
filters_b3_3,
filters_b4,
name="Inception"):
branch1 = layers.Conv2D(filters_b1,
1,
activation="relu",
name=name + "_branch_1_1x1")(x)
branch2 = layers.Conv2D(filters_b2_1,
1,
activation="relu",
name=name + "_branch_2_1x1")(x)
branch2 = layers.Conv2D(filters_b2_2,
3,
padding="same",
activation="relu",
name=name + "_branch_2_3x3")(branch2)
branch3 = layers.Conv2D(filters_b3_1,
1,
activation="relu",
name=name + "_branch_3_1x1")(x)
branch3 = layers.Conv2D(filters_b3_2,
3,
padding="same",
activation="relu",
name=name + "_branch_3_3x3_1")(branch3)
branch3 = layers.Conv2D(filters_b3_3,
3,
padding="same",
activation="relu",
name=name + "_branch_3_3x3_2")(branch3)
branch4 = layers.AvgPool2D(pool_size=3,
strides=1,
padding="same",
name=name + "_branch_4_pool")(x)
branch4 = layers.Conv2D(filters_b4,
1,
activation="relu",
name=name + "_branch_4_1x1")(branch4)
x = layers.Concatenate(name=name +
"_Mixed")([branch1, branch2, branch3, branch4])
return x
def LeNet(num_classes, input_shape=(32, 32, 3)):
model = models.Sequential()
model.add(
layers.Conv2D(6,
input_shape=input_shape,
kernel_size=5,
activation='tanh'))
model.add(layers.AvgPool2D(pool_size=(2, 2), strides=2))
model.add(layers.Conv2D(16, activation='tanh', kernel_size=5))
model.add(layers.AvgPool2D(pool_size=(2, 2), strides=2))
model.add(layers.Flatten())
model.add(layers.Dense(
120,
activation='tanh',
))
model.add(layers.Dense(84, activation='tanh'))
model.add(layers.Dense(num_classes, activation='softmax'))
return model
def __init__(self): super().__init__() self.model = tf.keras.Sequential() self.model.add(make_conv(32, 3)) self.model.add(Layers.MaxPool2D(padding='same')) self.model.add(InceptionBlock(20, 8, 20, 6, 12, 12)) self.model.add(InceptionBlock(20, 8, 20, 6, 12, 12)) self.model.add(Layers.MaxPool2D(padding='same')) self.model.add(InceptionBlock(36, 12, 36, 10, 28, 28)) self.model.add(InceptionBlock(36, 12, 36, 10, 28, 28)) self.model.add(InceptionBlock(36, 12, 36, 10, 28, 28)) self.model.add(Layers.AvgPool2D(padding='same')) self.model.add(Layers.Flatten()) self.model.add(Layers.Dropout(0.5)) self.model.add(Layers.Dense(10, activation='softmax'))
def pool_layer(self, layer_metadata):
if layer_metadata["pool_type"] == "avg":
return layers.AvgPool2D(pool_size=layer_metadata["pool_size"],
strides=layer_metadata["strides"],
padding=layer_metadata["padding"],
data_format=self.data_format)
elif layer_metadata["pool_type"] == "max":
return layers.MaxPool2D(pool_size=layer_metadata["pool_size"],
strides=layer_metadata["strides"],
padding=layer_metadata["padding"],
data_format=self.data_format)
else:
raise ValueError(
"Invalid pooling layer type for {}, should be one of (avg, max)"
.format(layer_metadata))
def call(self, inputs):
# Input = [X^H, X^L]
high_input, low_input = inputs
assert len(inputs) == 2
# High -> High conv
high_to_high = layers.Conv2DTranspose(
self.high_channels,
self.kernel_size,
strides=self.strides,
padding=self.padding,
data_format="channels_last",
kernel_regularizer=self.kernel_regularizer)(high_input)
# High -> Low conv
high_to_low = layers.AvgPool2D((2, 2), strides=(2, 2))(high_input)
high_to_low = layers.Conv2DTranspose(
self.low_channels,
self.kernel_size,
strides=self.strides,
padding=self.padding,
data_format="channels_last",
kernel_regularizer=self.kernel_regularizer)(high_to_low)
# Low -> High conv
low_to_high = layers.Conv2DTranspose(
self.high_channels,
self.kernel_size,
strides=self.strides,
padding=self.padding,
data_format="channels_last",
kernel_regularizer=self.kernel_regularizer)(low_input)
low_to_high = layers.UpSampling2D(
(2, 2), data_format='channels_last', interpolation='nearest')(
low_to_high) # Nearest Neighbor Upsampling
# low_to_high = K.repeat_elements(low_to_high, 2, axis=2)
# Low -> Low conv
low_to_low = layers.Conv2DTranspose(
self.low_channels,
self.kernel_size,
strides=self.strides,
padding=self.padding,
data_format="channels_last",
kernel_regularizer=self.kernel_regularizer)(low_input)
# Cross Add
high_add = high_to_high + low_to_high
low_add = high_to_low + low_to_low
return [high_add, low_add]
def _inception_output(input, num_classes):
x = layers.AvgPool2D(pool_size=(5, 5), strides=1, padding='valid')(input)
x = layers.Conv2D(128,
activation='relu',
kernel_size=1,
strides=1,
padding='same')(x)
x = tf.keras.layers.Flatten()(x)
x = layers.Dense(1024,
activation='relu',
kernel_size=1,
strides=1,
padding='same')(x)
x = layers.Dropout(0.7)(x)
out = layers.Dense(num_classes, activation='softmax')(x)
return out
def _make_layers(self):
m = tf.keras.Sequential()
for s in self.child_states:
if s[0]==2:
m.add(layers.MaxPool2D(pool_size=s[1],
strides=s[2],
padding='same'))
elif s[0]==1:
m.add(layers.Conv2D(filters=s[3],
kernel_size=s[1],
strides=s[2],
padding='same'))
m.add(layers.ReLU())
else:
pass
m.add(layers.AvgPool2D(pool_size=1, strides=1, padding='same'))
m.add(layers.Flatten())
return m
def GoogLeNet(im_height=224, im_width=224, class_num=1000, aux_logits=False):
# 输入224*224的3通道彩色图片
input_image = layers.Input(shape=(im_height, im_width, 3), dtype="float32")
x = layers.Conv2D(64, kernel_size=7, strides=2, padding="SAME", activation="relu", name="conv2d_1")(input_image)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_1")(x)
x = layers.Conv2D(64, kernel_size=1, activation="relu", name="conv2d_2")(x)
x = layers.Conv2D(192, kernel_size=3, padding="SAME", activation="relu", name="conv2d_3")(x)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_2")(x)
# Inception模块
x = Inception(64, 96, 128, 16, 32, 32, name="inception_3a")(x)
x = Inception(128, 128, 192, 32, 96, 64, name="inception_3b")(x)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_3")(x)
# Inception模块
x = Inception(192, 96, 208, 16, 48, 64, name="inception_4a")(x)
# 判断是否使用辅助分类器1。训练时使用，测试时去掉。
if aux_logits:
aux1 = InceptionAux(class_num, name="aux_1")(x)
# Inception模块
x = Inception(160, 112, 224, 24, 64, 64, name="inception_4b")(x)
x = Inception(128, 128, 256, 24, 64, 64, name="inception_4c")(x)
x = Inception(112, 144, 288, 32, 64, 64, name="inception_4d")(x)
# 判断是否使用辅助分类器2。训练时使用，测试时去掉。
if aux_logits:
aux2 = InceptionAux(class_num, name="aux_2")(x)
# Inception模块
x = Inception(256, 160, 320, 32, 128, 128, name="inception_4e")(x)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_4")(x)
# Inception模块
x = Inception(256, 160, 320, 32, 128, 128, name="inception_5a")(x)
x = Inception(384, 192, 384, 48, 128, 128, name="inception_5b")(x)
# 平均池化层
x = layers.AvgPool2D(pool_size=7, strides=1, name="avgpool_1")(x)
# 拉直
x = layers.Flatten(name="output_flatten")(x)
x = layers.Dropout(rate=0.4, name="output_dropout")(x)
x = layers.Dense(class_num, name="output_dense")(x)
aux3 = layers.Softmax(name="aux_3")(x)
# 判断是否使用辅助分类器
if aux_logits:
model = models.Model(inputs=input_image, outputs=[aux1, aux2, aux3])
else:
model = models.Model(inputs=input_image, outputs=aux3)
return model
def __init__(self,
out_features,
norm=False,
kernel_size=4,
pool=False,
sn=False):
super(DownBlock2d, self).__init__()
self.conv = layers.Conv2D(out_features,
kernel_size=kernel_size,
padding='SAME')
if sn:
self.conv = addons_layers.SpectralNormalization(self.conv)
if norm:
self.norm = addons_layers.InstanceNormalization()
else:
self.norm = None
self.pool = pool
if self.pool:
self.avg_pool = layers.AvgPool2D(pool_size=(2, 2))
def AOI_model():
inputs_image = tf.keras.Input(shape=(512, 512, 1), name='input_image')
x = inputs_image
x = layers.Conv2D(32, 3, strides=(2,2))(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.MaxPool2D()(x)
x = layers.Conv2D(64, 3, strides=(2,2))(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.MaxPool2D()(x)
for _ in range(2):
x = ResBlockBottleneck(64, 64, 256)(x)
x = ResBlockBottleneck(64, 64, 256, strides=(2,2))(x)
for _ in range(3):
x = ResBlockBottleneck(128, 128, 512)(x)
x = ResBlockBottleneck(128, 128, 512, strides=(2,2))(x)
for _ in range(5):
x = ResBlockBottleneck(256, 256, 1024)(x)
x = ResBlockBottleneck(256, 256, 1024, strides=(2,2))(x)
for _ in range(2):
x = ResBlockBottleneck(512, 512, 2048)(x)
x = ResBlockBottleneck(512, 512, 2048, strides=(2,2))(x)
x = layers.AvgPool2D()(x)
x = layers.Flatten()(x)
x = layers.Dense(100, activation='relu')(x)
x = layers.Dense(6, activation='softmax')(x)
model = tf.keras.Model(inputs=inputs_image, outputs=x)
model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(), metrics=['acc'])
return model
def _make_layer(
self,
block,
layer,
in_channels,
out_channels,
reduce_spatial_size,
):
m_layers = [block(in_channels, out_channels)]
for i in range(1, layer):
m_layers.append(block(out_channels, out_channels))
if reduce_spatial_size:
m_layers.append(
tf.keras.Sequential([
Conv1x1TF(out_channels, out_channels),
layers.AvgPool2D(2, strides=2)
])
)
return tf.keras.Sequential(m_layers)
padding=padding)
def upsample_simple(filters, kernel_size, strides, padding):
return layers.UpSampling2D(strides)
if UPSAMPLE_MODE == 'DECONV':
upsample = upsample_conv
else:
upsample = upsample_simple
input_img = layers.Input(t_x.shape[1:], name='RGB_Input')
pp_in_layer = input_img
if NET_SCALING is not None:
pp_in_layer = layers.AvgPool2D(NET_SCALING)(pp_in_layer)
pp_in_layer = layers.GaussianNoise(GAUSSIAN_NOISE)(pp_in_layer)
pp_in_layer = layers.BatchNormalization()(pp_in_layer)
c1 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(pp_in_layer)
c1 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(c1)
p1 = layers.MaxPooling2D((2, 2))(c1)
def inception(num_classes, input_shape, output_layes, maxpool_layers, depth=1):
# if is isinstance(output_layes, (list,set,tuple)):
# output_layes = set(output_layes)
# else:
# raise("Enter a valid output_layers")
#if depth < len(maxpool_layers) or depth< len(output_layes):
# raise("Enter a valid depth")
inputs = tf.keras.Input(shape=input_shape, name='img')
x = layers.Conv2D(64,
activation='relu',
kernel_size=7,
strides=2,
padding='same')(inputs)
x = layers.MaxPool2D(pool_size=(3, 3), strides=2, padding='same')(x)
x = layers.Conv2D(192,
activation='relu',
kernel_size=1,
strides=1,
padding='same')(x)
x = layers.Conv2D(256,
activation='relu',
kernel_size=3,
strides=1,
padding='same')(x)
x = layers.MaxPool2D(pool_size=(3, 3), strides=2, padding='same')(x)
x = _inception_block(x, num_filters=512, activation='relu')
x = _inception_block(x, num_filters=512, activation='relu')
x = layers.MaxPool2D(pool_size=(3, 3), strides=2, padding='same')(x)
x = _inception_block(x, num_filters=512, activation='relu')
out1 = _inception_output(x, num_classes)
x = _inception_block(x, num_filters=512, activation='relu')
x = _inception_block(x, num_filters=512, activation='relu')
x = _inception_block(x, num_filters=512, activation='relu')
out2 = _inception_output(x, num_classes)
x = _inception_block(x, num_filters=512, activation='relu')
x = layers.MaxPool2D(pool_size=(3, 3), strides=2, padding='same')(x)
x = _inception_block(x, num_filters=512, activation='relu')
x = _inception_block(x, num_filters=512, activation='relu')
x = layers.AvgPool2D(pool_size=(7, 7), strides=1, padding='valid')(x)
x = tf.keras.layers.Flatten()(x)
x = layers.Dense(256,
activation='relu',
kernel_size=1,
strides=1,
padding='same')(x)
out3 = layers.Dense(num_classes, activation='softmax')(x)
model = tf.keras.Model(inputs=inputs,
outputs=[out1, out2, out3],
name='inception')
return model
def __init__(self, out_dim, f=0.25):
super(TCResNet8, self).__init__()
# constants
FIRST_CONV_KERNEL = [3, 1]
ANYOTHER_CONV_KERNEL = [9, 1]
SHORTCUT_CONV_KERNEL = [1, 1]
L2_REGULIZER_VAL = 1e-4
DROP_PROBABILITY = 0.5
# begin
self.conv1 = l.Conv2D(int(16 * f), FIRST_CONV_KERNEL, strides=1, padding='same',
use_bias=False)
# for block1:
self.conv2 = l.Conv2D(filters=int(24 * f), kernel_size=ANYOTHER_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn1_1 = l.BatchNormalization(scale=True, trainable=True)
self.activ1_1 = l.Activation('relu')
self.conv3 = l.Conv2D(int(24 * f), ANYOTHER_CONV_KERNEL, strides=1, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn1_2 = l.BatchNormalization(scale=True, trainable=True)
self.conv4 = l.Conv2D(int(24 * f), SHORTCUT_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn1_1_1 = l.BatchNormalization(scale=True, trainable=True)
self.activ1_1_1 = l.Activation('relu')
self.activ1_2 = l.Activation('relu')
# for block2:
self.conv5 = l.Conv2D(int(32 * f), ANYOTHER_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn2_1 = l.BatchNormalization(scale=True, trainable=True)
self.activ2_1 = l.Activation('relu')
self.conv6 = l.Conv2D(int(32 * f), ANYOTHER_CONV_KERNEL, strides=1, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn2_2 = l.BatchNormalization(scale=True, trainable=True)
self.conv7 = l.Conv2D(int(32 * f), SHORTCUT_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn2_1_1 = l.BatchNormalization()
self.activ2_1_1 = l.Activation('relu')
self.activ2_2 = l.Activation('relu')
# for block3:
self.conv8 = l.Conv2D(int(48 * f), ANYOTHER_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn3_1 = l.BatchNormalization(scale=True, trainable=True)
self.activ3_1 = l.Activation('relu')
self.conv9 = l.Conv2D(int(48 * f), ANYOTHER_CONV_KERNEL, strides=1, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn3_2 = l.BatchNormalization(scale=True, trainable=True)
self.conv10 = l.Conv2D(int(48 * f), SHORTCUT_CONV_KERNEL, strides=2, padding='same',
use_bias=False, kernel_initializer="he_normal",
kernel_regularizer=reg.l2(L2_REGULIZER_VAL))
self.bn3_1_1 = l.BatchNormalization()
self.activ3_1_1 = l.Activation('relu')
self.activ3_2 = l.Activation('relu')
# avg pooling 2D
self.avg_pool = l.AvgPool2D(strides=1)
self.out_block = tf.keras.Sequential([
l.Flatten(),
l.Activation('relu'),
l.Dropout(DROP_PROBABILITY),
l.Dense(int(46 * f)),
l.Activation('softmax'),
l.Dense(out_dim)]
)
def InceptionV1(im_height=224, im_width=224, class_num=1000, aux_logits=False):
# tensorflow中的tensor通道排序是NHWC
input_image = layers.Input(shape=(im_height, im_width, 3), dtype="float32")
# (None, 224, 224, 3)
x = layers.Conv2D(64, kernel_size=7, strides=2, padding="SAME", use_bias=False, name="conv1/conv")(input_image)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5, name="conv1/bn")(x)
x = layers.ReLU()(x)
# (None, 112, 112, 64)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_1")(x)
# (None, 56, 56, 64)
x = layers.Conv2D(64, kernel_size=1, use_bias=False, name="conv2/conv")(x)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5, name="conv2/bn")(x)
x = layers.ReLU()(x)
# (None, 56, 56, 64)
x = layers.Conv2D(192, kernel_size=3, padding="SAME", use_bias=False, name="conv3/conv")(x)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5, name="conv3/bn")(x)
x = layers.ReLU()(x)
# (None, 56, 56, 192)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_2")(x)
# (None, 28, 28, 192)
x = Inception(64, 96, 128, 16, 32, 32, name="inception3a")(x)
# (None, 28, 28, 256)
x = Inception(128, 128, 192, 32, 96, 64, name="inception3b")(x)
# (None, 28, 28, 480)
x = layers.MaxPool2D(pool_size=3, strides=2, padding="SAME", name="maxpool_3")(x)
# (None, 14, 14, 480)
x = Inception(192, 96, 208, 16, 48, 64, name="inception4a")(x)
if aux_logits:
aux1 = InceptionAux(class_num, name="aux1")(x)
# (None, 14, 14, 512)
x = Inception(160, 112, 224, 24, 64, 64, name="inception4b")(x)
# (None, 14, 14, 512)
x = Inception(128, 128, 256, 24, 64, 64, name="inception4c")(x)
# (None, 14, 14, 512)
x = Inception(112, 144, 288, 32, 64, 64, name="inception4d")(x)
if aux_logits:
aux2 = InceptionAux(class_num, name="aux2")(x)
# (None, 14, 14, 528)
x = Inception(256, 160, 320, 32, 128, 128, name="inception4e")(x)
# (None, 14, 14, 532)
x = layers.MaxPool2D(pool_size=2, strides=2, padding="SAME", name="maxpool_4")(x)
# (None, 7, 7, 832)
x = Inception(256, 160, 320, 32, 128, 128, name="inception5a")(x)
# (None, 7, 7, 832)
x = Inception(384, 192, 384, 48, 128, 128, name="inception5b")(x)
# (None, 7, 7, 1024)
x = layers.AvgPool2D(pool_size=7, strides=1, name="avgpool_1")(x)
# (None, 1, 1, 1024)
x = layers.Flatten(name="output_flatten")(x)
# (None, 1024)
x = layers.Dropout(rate=0.4, name="output_dropout")(x)
x = layers.Dense(class_num, name="fc")(x)
# (None, class_num)
aux3 = layers.Softmax()(x)
if aux_logits:
model = models.Model(inputs=input_image, outputs=[aux1, aux2, aux3])
else:
model = models.Model(inputs=input_image, outputs=aux3)
return model
def GoogLeNet(img_height=224, img_width=224, class_num=1000, aux_logits=False):
"""
GoogLeNet网络
:param img_height:
:param img_width:
:param class_num:
:param aux_logits:
:return:
"""
input_image = layers.Input(shape=(img_height, img_width, 3),
dtype='float32')
# (None, 224, 224, 3)
x = layers.Conv2D(64,
kernel_size=7,
strides=2,
padding='same',
use_bias=False,
name='conv1/conv')(input_image)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5,
name='conv1/bn')(x)
x = layers.ReLU()(x)
# (None, 112, 112, 64)
x = layers.MaxPool2D(pool_size=3,
strides=2,
padding='same',
name='maxpool_1')(x)
# (None, 56, 56, 64)
x = layers.Conv2D(64, kernel_size=1, use_bias=False, name='conv2/conv')(x)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5,
name='conv2/bn')(x)
x = layers.ReLU()(x)
# (None, 56, 56, 64)
x = layers.Conv2D(192,
kernel_size=3,
padding='same',
use_bias=False,
name='conv3/conv')(x)
x = layers.BatchNormalization(momentum=0.9, epsilon=1e-5,
name='conv3/bn')(x)
x = layers.ReLU()(x)
# (None, 56, 56, 192)
x = layers.MaxPool2D(pool_size=3,
strides=2,
padding='same',
name='maxpool_2')(x)
# (None, 28, 28, 192)
x = Inception(64, 96, 128, 16, 32, 32, name='inception3a')(x)
# (None, 28, 28, 256)
x = Inception(128, 128, 192, 32, 96, 64, name='inception3b')(x)
# (None, 28, 28, 480)
x = layers.MaxPool2D(pool_size=3,
strides=2,
padding='same',
name='maxpool_3')(x)
# (None, 14, 14, 480)
x = Inception(192, 96, 208, 16, 48, 64, name='inception4a')(x)
if aux_logits:
aux1 = InceptionAux(class_num, name='aux1')(x)
# (None, 14, 14, 512)
x = Inception(160, 112, 224, 24, 64, 64, name='inception4b')(x)
# (None, 14, 14, 512)
x = Inception(128, 128, 256, 24, 64, 64, name='inception4c')(x)
# (None, 14, 14, 512)
x = Inception(112, 144, 288, 32, 64, 64, name='inception4d')(x)
if aux_logits:
aux2 = InceptionAux(class_num, name='aux2')(x)
# (None, 14, 14, 528)
x = Inception(256, 160, 320, 32, 128, 128, name='inception4e')(x)
# (None, 14, 14, 832)
x = layers.MaxPool2D(pool_size=2,
strides=2,
padding='same',
name='maxpool_4')(x)
# (None, 7, 7, 832)
x = Inception(256, 160, 320, 32, 128, 128, name='inception5a')(x)
# (None, 7, 7, 832)
x = Inception(384, 192, 384, 48, 128, 128, name='inception5b')(x)
# (None, 7, 7, 1024)
x = layers.AvgPool2D(pool_size=7, strides=1, name='avgpool_1')(x)
# (None, 1, 1, 1024)
x = layers.Flatten(name='output_flatten')(x)
# (None, 1024)
x = layers.Dropout(rate=0.4, name='output_dropout')(x)
x = layers.Dense(class_num, name='fc')(x)
# (None, num_class)
aux3 = layers.Softmax()(x)
if aux_logits:
model = models.Model(inputs=input_image, outputs=[aux1, aux2, aux3])
else:
model = models.Model(inputs=input_image, outputs=aux3)
return model
def Model_PSP(pre_trained_model, num_classes=35):
last_pretrained_layer = pre_trained_model.get_layer('conv3_block4_out')
last_output = last_pretrained_layer.output
last_output = layers.Conv2D(filters=128,
kernel_size=(1, 1),
name='Compress_out')(last_output)
#Define the params for the pooling module
#This has to be 1/4 times the input channel depth
INPUT_CHANNEL_DEPTH = 128
INPUT_DIM = 32
TARGET_CHANNEL_DEPTH = INPUT_CHANNEL_DEPTH / 4
Y_KERNEL_DIM = (INPUT_DIM // 2, INPUT_DIM // 2)
B_KERNEL_DIM = (INPUT_DIM // 4, INPUT_DIM // 4)
G_KERNEL_DIM = (INPUT_DIM // 8, INPUT_DIM // 8)
#Now we define the pyramidal pooling architecture
base = last_output
#Define the GAP with 1*1 block size for 1x1 bin
red_blk = layers.GlobalAvgPool2D(name='red_block_pooling')(base)
red_blk = layers.Reshape((1, 1, INPUT_CHANNEL_DEPTH))(red_blk)
red_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='red_1x1_conv')(red_blk)
red_blk = layers.UpSampling2D(size=(256, 256),
interpolation='bilinear',
name='red_upsample')(red_blk)
#Define the average pooling for the yellow block for 2x2 bin
y_blk = layers.AvgPool2D(pool_size=Y_KERNEL_DIM,
name='yellow_blk_pooling')(base)
y_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='yellow_1x1_conv')(y_blk)
y_blk = layers.UpSampling2D(size=(128, 128),
interpolation='bilinear',
name='yellow_upsample')(y_blk)
#Define the average pooling for the blue block for 4x4 bin
blue_blk = layers.AvgPool2D(pool_size=B_KERNEL_DIM,
name='blue_blk_pooling')(base)
blue_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='blue_1x1_conv')(blue_blk)
blue_blk = layers.UpSampling2D(size=(64, 64),
interpolation='bilinear',
name='blue_upsample')(blue_blk)
#Define the average pooling for the green block for 8x8 bins
green_blk = layers.AvgPool2D(pool_size=G_KERNEL_DIM,
name='green_blk_pooling')(base)
green_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='green_1x1_conv')(green_blk)
green_blk = layers.UpSampling2D(size=(32, 32),
interpolation='bilinear',
name='green_upsample')(green_blk)
#Now we upsample the base and check all output shapes to ensure that they match
base = layers.UpSampling2D(size=(256 // INPUT_DIM, 256 // INPUT_DIM),
interpolation='bilinear',
name='base_upsample')(base)
print(base.get_shape)
print(red_blk.get_shape)
print(y_blk.get_shape)
print(blue_blk.get_shape)
print(green_blk.get_shape)
#Generate the final output and check shape
PPM = tf.keras.layers.concatenate(
[base, green_blk, blue_blk, y_blk, red_blk])
print(PPM.get_shape)
#Now we define the final convolutional block
output = layers.Conv2D(filters=num_classes,
kernel_size=(3, 3),
padding='same',
name='final_3x3_conv_blk',
activation='softmax')(PPM)
return output
def build_generator():
input = tf.keras.Input(shape=(L_node, W_node,
Time_steps)) # (None, 256, 256, 5)
l1 = input # (None, 256, 256, 5)
l2_1 = layers.Conv2D(64, 1, 1, 'same',
activation='relu')(l1) # (None, 256, 256, 64)
l2_1 = layers.BatchNormalization()(l2_1)
l2_2 = layers.Conv2D(48, 1, 1, 'same',
activation='relu')(l1) # (None, 256, 256, 48)
l2_2 = layers.BatchNormalization()(l2_2)
l2_2 = layers.Conv2D(64, 3, 1, 'same',
activation='relu')(l2_2) # (None, 256, 256, 64)
l2_2 = layers.BatchNormalization()(l2_2)
l2_3 = layers.Conv2D(48, 1, 1, 'same',
activation='relu')(l1) # (None, 256, 256, 48)
l2_3 = layers.BatchNormalization()(l2_3)
l2_3 = layers.Conv2D(64, 5, 1, 'same',
activation='relu')(l2_3) # (None, 256, 256, 64)
l2_3 = layers.BatchNormalization()(l2_3)
l2_4 = layers.AvgPool2D(3, 1, 'same')(l1)
l2_4 = layers.Conv2D(64, 1, 1, 'same',
activation='relu')(l2_4) # (None, 256, 256, 64)
l2_4 = layers.BatchNormalization()(l2_4)
l2 = layers.concatenate([l2_1, l2_2, l2_3, l2_4],
3) # (None, 256, 256, 256)
l3 = layers.Conv2D(64, 3, 1, 'same',
activation='relu')(l2) # (None, 256, 256, 64)
l4_1 = layers.Conv2D(128, 3, 2, 'same')(l3) # (None, 128, 128, 128)
l4_1 = layers.BatchNormalization()(l4_1)
l4_1 = layers.LeakyReLU(0.2)(l4_1)
l5_1 = layers.Conv2D(256, 3, 2, 'same')(l4_1) # (None, 64, 64, 256)
l5_1 = layers.BatchNormalization()(l5_1)
l5_1 = layers.LeakyReLU(0.2)(l5_1)
l6_1 = layers.Conv2D(512, 3, 2, 'same')(l5_1) # (None, 32, 32, 512)
l6_1 = layers.BatchNormalization()(l6_1)
l6_1 = layers.LeakyReLU(0.2)(l6_1)
l7_1 = layers.Conv2D(512, 3, 2, 'same')(l6_1) # (None, 16, 16, 512)
l7_1 = layers.BatchNormalization()(l7_1)
l7_1 = layers.LeakyReLU(0.2)(l7_1)
l8_1 = layers.Conv2DTranspose(512, 3, 2,
'same')(l7_1) # (None, 32, 32, 512)
l8_1 = layers.BatchNormalization()(l8_1)
l8_1 = layers.Dropout(0.3)(l8_1)
l8_1 = layers.Activation('relu')(l8_1)
l9_1 = layers.Conv2DTranspose(256, 3, 2,
'same')(l8_1) # (None, 64, 64, 256)
l9_1 = layers.BatchNormalization()(l9_1)
l9_1 = layers.Dropout(0.3)(l9_1)
l9_1 = layers.Activation('relu')(l9_1)
l10_1 = layers.Conv2DTranspose(128, 3, 2,
'same')(l9_1) # (None, 128, 128, 128)
l10_1 = layers.BatchNormalization()(l10_1)
l10_1 = layers.Dropout(0.3)(l10_1)
l10_1 = layers.Activation('relu')(l10_1)
l11_1 = layers.Conv2DTranspose(64, 3, 2,
'same')(l10_1) # (None, 256, 256, 64)
l11_1 = layers.BatchNormalization()(l11_1)
l11_1 = layers.Dropout(0.3)(l11_1)
l11_1 = layers.Activation('tanh')(l11_1)
# l4_2 = layers.Conv2D(32, 3, 2, 'same')(l3) # (None, 128, 128, 32)
l5_2 = layers.Conv2D(5, 3, 2, 'same')(l3) # (None, 256, 256, 5)
l5_2_1 = tf.reshape(l5_2[:, :, :, 0],
shape=(-1, 1, LSTM_layer, LSTM_layer, 1))
l5_2_2 = tf.reshape(l5_2[:, :, :, 1],
shape=(-1, 1, LSTM_layer, LSTM_layer, 1))
l5_2_3 = tf.reshape(l5_2[:, :, :, 2],
shape=(-1, 1, LSTM_layer, LSTM_layer, 1))
l5_2_4 = tf.reshape(l5_2[:, :, :, 3],
shape=(-1, 1, LSTM_layer, LSTM_layer, 1))
l5_2_5 = tf.reshape(l5_2[:, :, :, 4],
shape=(-1, 1, LSTM_layer, LSTM_layer, 1))
l5_2 = layers.concatenate([l5_2_1, l5_2_2, l5_2_3, l5_2_4, l5_2_5],
1) # (None, 5, 256, 256, 1)
l6_2 = layers.ConvLSTM2D(5, 3, 1, 'same', return_sequences=True)(
l5_2) # (None, 5, 256, 256, 10)
l7_2 = layers.ConvLSTM2D(10, 3, 1, 'same', return_sequences=True)(
l6_2) # (None, 5, 256, 256, 20)
# l8_2 = layers.ConvLSTM2D(10, 3, 1, 'same', return_sequences=True)(l7_2) # (None, 5, 256, 256, 20)
l9_2 = layers.ConvLSTM2D(5, 3, 1, 'same', return_sequences=False)(
l7_2) # (None, 256, 256, 10)
# l10_2 = layers.Conv2DTranspose(32, 3, 2, 'same')(l9_2) # (None, 128, 128, 32)
# l10_2 = layers.BatchNormalization()(l10_2)
# l10_2 = layers.Dropout(0.3)(l10_2)
# l10_2 = layers.Activation('relu')(l10_2)
l11_2 = layers.Conv2DTranspose(64, 3, 2,
'same')(l9_2) # (None, 256, 256, 64)
l11_2 = layers.BatchNormalization()(l11_2)
l11_2 = layers.Dropout(0.3)(l11_2)
l11_2 = layers.Activation('relu')(l11_2)
# l11_2 = layers.Conv2D(64, 5, 1, 'same', activation='relu')(l9_2)
l12 = layers.add([l11_1, l11_2]) # (None, 256, 256, 64)
l13 = layers.Conv2D(1, 3, 1, 'same',
activation='tanh')(l12) # (None, 256, 256, 1)
Model = tf.keras.Model(input, l13, name='generator')
return Model
kernel_size=(3, 3),
strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Dropout(0.5))
model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Dropout(0.5))
model.add(layers.AvgPool2D())
model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Dropout(0.5))
model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Dropout(0.5))
model.add(layers.MaxPool2D())
# Group - 2
model.add(layers.Conv2D(filters=128, kernel_size=(3, 3), strides=1))
model.add(layers.BatchNormalization())
model.add(layers.ReLU())
model.add(layers.Dropout(0.5))
model.add(layers.Conv2D(filters=128, kernel_size=(3, 3), strides=1))
