def tiny_yolo_body(inputs, num_anchors, num_classes):
'''Create Tiny YOLO_v3 model CNN body in keras.'''
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(32, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(64, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(128, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(256, (3,3)))(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(512, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(1,1), padding='same'),
DarknetConv2D_BN_Leaky(1024, (3,3)),
DarknetConv2D_BN_Leaky(256, (1,1)))(x1)
y1 = compose(
DarknetConv2D_BN_Leaky(512, (3,3)),
DarknetConv2D(num_anchors*(num_classes+5), (1,1)))(x2)
x2 = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x2)
y2 = compose(
Concatenate(),
DarknetConv2D_BN_Leaky(256, (3,3)),
DarknetConv2D(num_anchors*(num_classes+5), (1,1)))([x2,x1])
return Model(inputs, [y1,y2])
def make_last_layers(x, num_filters, out_filters):
'''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
x = compose(
DarknetConv2D_BN_Leaky(num_filters, (1,1)),
DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
DarknetConv2D_BN_Leaky(num_filters, (1,1)),
DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
DarknetConv2D_BN_Leaky(num_filters, (1,1)))(x)
y = compose(
DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
DarknetConv2D(out_filters, (1,1)))(x)
return x, y
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
darknet = Model(inputs, darknet_body(inputs))
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[152].output])
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[92].output])
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs, [y1,y2,y3])
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
# 在第1个卷积操作DarknetConv2D_BN_Leaky中，是3个操作的组合，即：
# 1个Darknet的2维卷积Conv2D层，即DarknetConv2D；
# 1个批正则化层，即BatchNormalization()，操作对象是网络层的输入数据X；
# 1个LeakyReLU层，斜率是0.1，LeakyReLU是ReLU的变换；
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(), LeakyReLU(alpha=0.1))
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
darknet = Model(inputs, darknet_body(inputs))
# 以下语句是特征金字塔（FPN）的具体实现。
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[152].output])
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[92].output])
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs, [y1,y2,y3])
def densenet_body(img_input, num_anchors, num_classes):
x = __create_dense_net(img_input)
densenet = Model(img_input, x)
x, y1 = make_last_layers(densenet.output, 512,
num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(512, (1, 1)), UpSampling2D(2))(x)
x = Concatenate()([x, densenet.layers[308].output])
x, y2 = make_last_layers(x, 512, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
x = Concatenate()([x, densenet.layers[136].output])
x, y3 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
return Model(img_input, [y1, y2, y3])
def resblock_body(x, num_filters, num_blocks):
'''A series of resblocks starting with a downsampling Convolution2D'''
# Darknet uses left and top padding instead of 'same' mode
x = ZeroPadding2D(((1, 0), (1, 0)))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (3, 3), strides=(2, 2))(x)
for i in range(num_blocks):
y = compose(DarknetConv2D_BN_Leaky(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters, (3, 3)))(x)
x = Add()([x, y])
return x
def yolo_body_mobilenetv2_5_9(inputs, num_anchors, num_classes):
"""Create YOLO_V3_mobilenet model CNN body in Keras."""
mobilenet2 = MobileNetV2(input_tensor=inputs,weights='imagenet')
# input: 416 x 416 x 3
# out_relu : 32 13 x 13 x 1280
# block_13_expand_relu :16 26 x 26 x 576
# block_6_expand_relu :8 52 x 52 x 192
# mobilenet2.summary()
f1 = mobilenet2.get_layer('block_15_expand_relu').output
# f1 :13 x 13 x 960
# f1 = DarknetConv2D_BN_Leaky(256,(3,3))(f1)
y1 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f1)
f1 = compose(
DarknetSeparableConv2D_BN_Leaky(256, (3,3)),
UpSampling2D(2, interpolation='bilinear'))(f1)
f2 = mobilenet2.get_layer('block_13_expand_relu').output
# f2: 26 x 26 x 576
f2 = compose(
Concatenate(),
DarknetSeparableConv2D_BN_Leaky(128,(3,3))
)([f1,f2])
y2 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f2)
# f2 = compose(
# DarknetSeparableConv2D_BN_Leaky(64, (1,1)),
# UpSampling2D(2,interpolation='bilinear'))(f2)
# f3 = mobilenet2.get_layer('block_6_expand_relu').output
# f3 : 52 x 52 x 192
# f3 = compose(
# Concatenate(),
# DarknetSeparableConv2D_BN_Leaky(64,(3,3))
# )([f2,f3])
# y3 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f3)
return Model(inputs = inputs, outputs=[y1,y2])
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
darknet = Model(inputs, darknet_body(inputs))
#for detecting big objects
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
#for detecting medium objects
x = compose(
DarknetConv2D_BN_Mish(256, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[152].output])
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
#for detecting small objects
x = compose(
DarknetConv2D_BN_Mish(128, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[92].output])
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs, [y1,y2,y3])
def densenet_yolo_body(inputs, num_anchors, num_classes):
densenet = tf.keras.applications.DenseNet201(input_tensor=inputs,
include_top=False,
weights='imagenet')
x, y1 = make_last_layers(densenet.output, 512,
num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)),
tf.keras.layers.UpSampling2D(2))(x)
x = tf.keras.layers.Concatenate()(
[x, densenet.get_layer('pool4_relu').output])
x, y2 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
tf.keras.layers.UpSampling2D(2))(x)
x = tf.keras.layers.Concatenate()(
[x, densenet.get_layer('pool3_relu').output])
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return tf.keras.models.Model(inputs, [y1, y2, y3])
def yolo_body_mobilenet3s_5_15(inputs, num_anchors, num_classes):
"""Create YOLO_V3_mobilenet model CNN body in Keras."""
mobilenet = mobilenetv3.build_mobilenet_v3(inputs=inputs, num_classes=10, model_type='large', pooling_type='avg', include_top=False)
# input: 416 x 416 x 3
# out_relu : 32 13 x 13 x 1280
# block_13_expand_relu :16 26 x 26 x 576
# block_6_expand_relu :8 52 x 52 x 192
# mobilenet2.summary()
f1 = mobilenet.get_layer('conv2d1_3__hs').output
# f1 :13 x 13 x 960
# f1 = DarknetConv2D_BN_Leaky(256,(3,3))(f1)
y1 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f1)
f1 = compose(
DarknetSeparableConv2D_BN_Leaky(256, (3,3)),
UpSampling2D(2, interpolation='bilinear'))(f1)
# f2: 26 x 26 x 256
f2 = mobilenet.get_layer('block_9_expand_hs').output
# f2 = DarknetConv2D(256, (1,1))(f2)
f2 = compose(
Concatenate(),
DarknetSeparableConv2D_BN_Leaky(256,(3,3))
)([f1,f2])
y2 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f2)
# f2 = compose(
# DarknetConv2D_BN_Leaky(32, (1,1)),
# UpSampling2D(2,interpolation='bilinear'))(f2)
# f3 = mobilenet2.get_layer('block_5_add').output
# # f3 : 52 x 52 x 192
# f3 = compose(
# Concatenate(),
# DarknetConv2D_BN_Leaky(32,(3,3))
# )([f2,f3])
# y3 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f3)
return Model(inputs = inputs, outputs=[y1,y2])
def yolo_body_mobilenet3_5_14(inputs, num_anchors, num_classes):
"""Create YOLO_V3_mobilenet model CNN body in Keras."""
mobilenet = mobilenetv3.my_mobilenet(inputs=inputs)
# input: 416 x 416 x 3
# out_relu : 32 13 x 13 x 1280
# block_13_expand_relu :16 26 x 26 x 576
# block_6_expand_relu :8 52 x 52 x 192
# mobilenet2.summary()
f1 = mobilenet.get_layer('block_7_dw_hs').output
# f1 :13 x 13 x 512
# f1 = DarknetConv2D_BN_Leaky(256,(3,3))(f1)
y1 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f1)
f1 = compose(
DarknetSeparableConv2D_BN_Leaky(256, (3,3)),
UpSampling2D(2, interpolation='bilinear'))(f1)
# f2: 26 x 26 x 256
f2 = mobilenet.get_layer('block_6_expand_hs').output
f2 = DarknetConv2D(256, (1,1))(f2)
f2 = compose(
Concatenate(),
DarknetSeparableConv2D_BN_Leaky(128,(3,3))
)([f1,f2])
y2 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f2)
# f2 = compose(
# DarknetConv2D_BN_Leaky(32, (1,1)),
# UpSampling2D(2,interpolation='bilinear'))(f2)
# f3 = mobilenet2.get_layer('block_5_add').output
# # f3 : 52 x 52 x 192
# f3 = compose(
# Concatenate(),
# DarknetConv2D_BN_Leaky(32,(3,3))
# )([f2,f3])
# y3 = DarknetConv2D(num_anchors*(num_classes+5), (1,1))(f3)
return Model(inputs = inputs, outputs=[y1,y2])
def yolo_body(inputs, num_anchors, num_classes):
feat1, feat2, feat3 = renet50_body(inputs)
x = make_five_convs(feat3, 512)
x = compose(
DarknetConv2D_BN_Leaky(256, (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, feat2])
x, y1 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, feat1])
x, y2 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2])
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
print('yolo body =======')
darknet = Model(inputs, darknet_body(inputs))
x, y1 = make_last_layers(darknet.output, 512,
num_anchors * (num_classes + 5 + 3 + 3 * BIN))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
#x = Concatenate()([x,darknet.layers[152].output])
x = Concatenate()([x, darknet.layers[75].output])
x, y2 = make_last_layers(x, 256,
num_anchors * (num_classes + 5 + 3 + 3 * BIN))
x = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x)
x = Concatenate()([x, darknet.layers[57].output])
x, y3 = make_last_layers(x, 128,
num_anchors * (num_classes + 5 + 3 + 3 * BIN))
return Model(inputs, [y1, y2, y3])
def tiny_yolo_body(input_shape=(128, 1024, 1), num_anchors=6, num_classes=4):
'''Create Tiny YOLO_v3 model CNN body in keras.'''
inputs = Input(input_shape)
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(32, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(64, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(128, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(256, (3, 3)))(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(512, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(256, (1, 1)))(x1)
y1 = compose(DarknetConv2D_BN_Leaky(512, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x2)
x2 = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x2)
y2 = compose(Concatenate(), DarknetConv2D_BN_Leaky(256, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1)))([x2, x1])
y1 = Flatten()(y1)
y2 = Flatten()(y2)
y1 = Dense(4,
activation='softmax',
name='y1',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=l2(0.0001))(y1)
y2 = Dense(4,
activation='softmax',
name='y2',
kernel_initializer=glorot_uniform(seed=0),
kernel_regularizer=l2(0.0001))(y2)
model = Model(inputs, [y1, y2], name='tinymodel')
return model
def yolo_body_mobilenet(inputs, num_anchors, num_classes):
"""Create YOLO_V3_mobilenet model CNN body in Keras."""
mobilenet = MobileNet(input_tensor=inputs,weights='imagenet')
# input: 416 x 416 x 3
# conv_pw_13_relu :13 x 13 x 1024
# conv_pw_11_relu :26 x 26 x 512
# conv_pw_5_relu : 52 x 52 x 256
mobilenet.summary()
f1 = mobilenet.get_layer('conv_pw_13_relu').output
# f1 :13 x 13 x 1024
# spp
sp3 = MaxPooling2D(pool_size=(3,3),strides=1,padding='same')(f1)
sp5 = MaxPooling2D(pool_size=(5,5),strides=1,padding='same')(f1)
f1 = compose(
Concatenate(),
DarknetConv2D_BN_Leaky(256, (1,1)))([sp3,sp5,f1])
# end
x, y1 = make_last_layers(f1, 512, num_anchors * (num_classes + 5))
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)),
UpSampling2D(2))(x)
f2 = mobilenet.get_layer('conv_pw_11_relu').output
# f2: 26 x 26 x 512
x = Concatenate()([x,f2])
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x)
f3 = mobilenet.get_layer('conv_pw_5_relu').output
# f3 : 52 x 52 x 256
x = Concatenate()([x, f3])
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs = inputs, outputs=[y1,y2,y3])
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
'''封装 激活函数，批正则化，卷积层
strides 由参数 kwargs传入，默认为(1,1)，即不改变输入大小
'''
#深入理解Batch Normalization批标准化
# https://www.cnblogs.com/guoyaohua/p/8724433.html
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(), LeakyReLU(alpha=0.1))
def regression_body(inputs):
""" Create Angle Regression model By Darkent in Keras """
darknet = Model(inputs,darknet_body(inputs))
x = compose(
Flatten(),
Dropout(0.2),
Dense(256,activation='sigmoid')
)(darknet.output)
out1 = compose(
Dropout(0.2),
Dense(1)
)(x)
out2 = compose(
Dropout(0.2),
Dense(1)
)(x)
return Model(inputs,[out1,out2])
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""
Darknet Convolution2D followed by BatchNormalization and LeakyReLU
:param args:
:param kwargs:
:return:
"""
no_bias_kwargs = {"use_bias": False}
no_bias_kwargs.update(kwargs)
return compose(DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(), LeakyReLU(alpha=0.1))
def make_five_convs(x, num_filters):
'''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
x = compose(DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)))(x)
# y = compose(
# DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
# DarknetConv2D(out_filters, (1,1)))(x)
return x
def efficient_yolo_body(inputs, num_anchors, num_classes):
# efficientnet
efficientnet_modle = EfficientNetB0(input_tensor=inputs,
weights='imagenet',
include_top=False)
# input: 416 x 416 x 3
# conv_pw_13_relu :13 x 13 x 1280
# conv_pw_11_relu :26 x 26 x 672
# conv_pw_5_relu : 52 x 52 x 240
f1 = efficientnet_modle.get_layer('swish_49').output
x, y1 = make_last_layers(f1, 640, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(320, (1, 1)), UpSampling2D(2))(x)
f2 = efficientnet_modle.get_layer('swish_34').output
x = Concatenate()([x, f2])
x, y2 = make_last_layers(x, 336, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(168, (1, 1)), UpSampling2D(2))(x)
f3 = efficientnet_modle.get_layer('swish_16').output
x = Concatenate()([x, f3])
x, y3 = make_last_layers(x, 120, num_anchors * (num_classes + 5))
return Model(inputs=inputs, outputs=[y1, y2, y3])
def resblock_body(x, num_filters, num_blocks):
x = ZeroPadding2D(((1, 0), (1, 0)))(x)
x = DarkNetConv2D_BN_Leaky(num_filters, (3, 3),
strides=(2, 2))(x) # down sampling
for i in range(num_blocks):
y = compose(
DarkNetConv2D_BN_Leaky(num_filters // 2, (1, 1)), # 1 x 1 conv2d
DarkNetConv2D_BN_Leaky(num_filters, (3, 3)))(x)
x = Add()([x, y])
return x
def resblock_body(x, num_filters, num_blocks):
'''A series of resblocks starting with a downsampling Convolution2D'''
# Darknet uses left and top padding instead of 'same' mode
x = ZeroPadding2D(((1,0),(1,0)))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Leaky(num_filters//2, (1,1)),
DarknetConv2D_BN_Leaky(num_filters, (3,3)))(x)
x = Add()([x,y])
return x
def mobilenetv2_yolo_body(inputs, num_anchors, num_classes, alpha=1.0):
mobilenetv2 = tf.keras.applications.MobileNetV2(alpha=alpha,
input_tensor=inputs,
include_top=False,
weights='imagenet')
x, y1 = make_last_layers(mobilenetv2.output, 512,
num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)),
tf.keras.layers.UpSampling2D(2))(x)
x = tf.keras.layers.Concatenate()(
[x, mobilenetv2.get_layer('block_12_expand_relu').output])
x, y2 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
tf.keras.layers.UpSampling2D(2))(x)
x = tf.keras.layers.Concatenate()(
[x, mobilenetv2.get_layer('block_5_expand_relu').output])
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return tf.keras.models.Model(inputs, [y1, y2, y3])
def make_last_layers(x, num_filters, out_filters):
'''
每一个输出层最后的卷积结构，主网络是3组1*1和3*3的卷积，再连接一个1*1的卷积层
输出一个正常的目标检测结果y，还有一个引出去用作concat的特征层x
:param x:
:param num_filters:
:param out_filters: 输出层的特征图channel个数
:return:x,y 其中x是要引出去做concatenate然后输出的层，y是当前层的输出
'''
'''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
x = compose(
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)))(x)
y = compose(
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D(out_filters, (1, 1)))(x)
return x, y # x是要引出去做concatenate然后输出的层，y是当前层的输出
def resblock_body(x, num_filters, num_blocks): # total_number_of_conv = 1 + num_blocks * 2
'''A series of resblocks starting with a downsampling Convolution2D'''
# Darknet uses left and top padding instead of 'same' mode
x = ZeroPadding2D(((1, 0), (1, 0)))(x) #由于步长为2，上左各部1即可使featuremap减半，代替maxpooling
x = DarknetConv2D_BN_Leaky(num_filters, (3, 3), strides=(2, 2))(x) # featuremap减半
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Leaky(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters, (3, 3)))(x)
x = Add()([x, y])
return x
def regression_body_resnet():
input_shape = (224,224,3)
res = ResNet50(weights='imagenet',include_top=False,input_shape=input_shape)
x = compose(
Flatten(),
Dropout(0.2),
Dense(256,activation='sigmoid')
)(res.output)
out1 = compose(
Dropout(0.2),
Dense(1)
)(x)
out2 = compose(
Dropout(0.2),
Dense(1)
)(x)
return Model(res.input,[out1,out2])
def deep_attention_block(out_dim, ratio=16):
"""Create a channel-wise deep attention block
Args:
out_dim: output dimension
ratio: number of output filters
Returns: a keras tensor
"""
return compose(KL.GlobalAveragePooling2D(),
KL.Dense(out_dim // ratio, activation='relu'),
KL.Dropout(0.5), KL.Dense(out_dim, activation='sigmoid'),
KL.Dropout(0.5), KL.Reshape((1, 1, out_dim)))
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
print('Returning original YOLO-V3 architecture')
darknet = Model(inputs, darknet_body(inputs))
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[152].output])
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x)
x = Concatenate()([x,darknet.layers[92].output])
x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
return Model(inputs, [y1,y2,y3])
def tiny_yolo_infusion_body_old(inputs, num_anchors, num_classes):
'''Create Tiny YOLO_v3 model CNN body in keras, using a weak segmentation infusion layer.'''
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(32, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(64, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(128, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(256, (3,3))
)(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
DarknetConv2D_BN_Leaky(512, (3,3)),
MaxPooling2D(pool_size=(2,2), strides=(1,1), padding='same'),
DarknetConv2D_BN_Leaky(1024, (3,3))
)(x1)
x3 = DarknetConv2D_BN_Leaky(256, (1,1))(x2)
y1 = compose(
DarknetConv2D_BN_Leaky(512, (3,3)),
DarknetConv2D(num_anchors*(num_classes+5), (1,1))
)(x3)
x4 = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2)
)(x3)
y2 = compose(
Concatenate(),
DarknetConv2D_BN_Leaky(256, (3,3)),
DarknetConv2D(num_anchors*(num_classes+5), (1,1))
)([x4,x1])
#old style
y_seg = infusion_layer(x3)
return Model(inputs=inputs, outputs=[y1,y2,y_seg])
def gyolo_body(inputs, num_anchors, num_classes):
ghostnet = Model(inputs, ghost_body(inputs))
x = DarknetConv2D_BN_Leaky(512, (1, 1))(ghostnet.output)
x = ZeroPadding2D(((1, 0), (1, 0)))(x) # 由于步长为2，上左各部1即可使featuremap减半，代替maxpooling
x = DarknetConv2D_BN_Leaky(1024, (3, 3), strides=(2, 2))(x) # featuremap减半
x = DarknetConv2D_BN_Leaky(512, (1, 1))(x)
x = ZeroPadding2D(((1, 0), (1, 0)))(x) # 由于步长为2，上左各部1即可使featuremap减半，代替maxpooling
# x = DarknetConv2D_BN_Leaky(1024, (3, 3), strides=(2, 2))(x) # featuremap减半
# y = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(x)
y = compose(
DarknetConv2D_BN_Leaky(1024, (3, 3), strides=(2, 2)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x)
return Model(inputs, y)
def tiny_yolo_body(inputs, num_anchors, num_classes):
'''Create Tiny YOLO_v3 model CNN body in keras.'''
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3, 3)),
AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
#MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(32, (3, 3)),
# AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
# GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(64, (3, 3)),
# AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
# GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(128, (3, 3)),
# AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
# GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(256, (3, 3)))(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
# AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
# GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(512, (3, 3)),
# AveragePooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'),
# GlobalMaxPooling2D(dim_ordering='default'),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(256, (1, 1)))(x1)
y1 = compose(DarknetConv2D_BN_Leaky(512, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x2)
x2 = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x2)
y2 = compose(Concatenate(), DarknetConv2D_BN_Leaky(256, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1)))([x2, x1])
return Model(inputs, [y1, y2])
def tiny_yolo_body(inputs, num_anchors, num_classes):
'''
搭建yolov3的tiny_body，其中只有两个尺寸的输出，也就是13*13和26*26
然后该网络相比于darknet-53减少了重复的残差结构
:param inputs:输入层
:param num_anchors:每一个输出层的anchors个数
:param num_classes:类别个数
:return:返回一个keras定义的函数式模型
'''
'''Create Tiny YOLO_v3 model CNN body in keras.'''
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(32, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(64, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(128, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(256, (3, 3)))(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(512, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(256, (1, 1)))(x1)
y1 = compose(
DarknetConv2D_BN_Leaky(512, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x2)
x2 = compose(
DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(x2)
y2 = compose(
Concatenate(),
DarknetConv2D_BN_Leaky(256, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))([x2, x1])
return Model(inputs, [y1, y2])
def make_last_layers(x, num_filters, out_filters):
'''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
x = compose(DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)))(x)
y = compose(
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
#-----
Dropout(rate=0.2),
#-----
DarknetConv2D(out_filters, (1, 1)))(x)
"""
y=DarknetConv2D_BN_Leaky(num_filters*2, (3,3))(x),
#-----
y=Dropout(0.2)(y),
#-----
y=DarknetConv2D(out_filters, (1,1))(y)
"""
return x, y
