def mobilenetv2_yolo_body(inputs, num_anchors, num_classes):
#net, endpoint = inception_v2.inception_v2(inputs)
mobilenet = MobileNetV2(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
f1 = mobilenet.get_layer('out_relu').output
# f1 :13 x 13 x 1024
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('block_13_expand_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('block_6_expand_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 yolo_body(inputs, num_anchors, num_classes, phi=0):
# 生成darknet53的主干模型
feats, filters_outs = Efficient[phi](inputs=inputs)
feat1 = feats[2]
feat2 = feats[4]
feat3 = feats[6]
efficientnet = Model(inputs, feat3)
# 第一个特征层
# y1=(batch_size,13,13,3,85)
x, y1 = make_last_layers(efficientnet.output, int(filters_outs[2]),
num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(int(filters_outs[1]), (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, feat2])
# 第二个特征层
# y2=(batch_size,26,26,3,85)
x, y2 = make_last_layers(x, int(filters_outs[1]),
num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(int(filters_outs[0]), (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, feat1])
# 第三个特征层
# y3=(batch_size,52,52,3,85)
x, y3 = make_last_layers(x, int(filters_outs[0]),
num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
feat1, feat2, feat3 = darknet_body(inputs)
# y1=(batch_size,13,13,3,85)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(feat3)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
maxpool1 = MaxPooling2D(pool_size=(13, 13), strides=(1, 1),
padding='same')(P5)
maxpool2 = MaxPooling2D(pool_size=(9, 9), strides=(1, 1),
padding='same')(P5)
maxpool3 = MaxPooling2D(pool_size=(5, 5), strides=(1, 1),
padding='same')(P5)
P5 = Concatenate()([maxpool1, maxpool2, maxpool3, P5])
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
P5_upsample = compose(DarknetConv2D_BN_Leaky(256, (1, 1)),
UpSampling2D(2))(P5)
P4 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
P4 = Concatenate()([P4, P5_upsample])
P4 = make_five_convs(P4, 256)
P4_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(P4)
P3 = DarknetConv2D_BN_Leaky(128, (1, 1))(feat1)
P3 = Concatenate()([P3, P4_upsample])
P3 = make_five_convs(P3, 128)
P3_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P3)
P3_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P3_output)
# 26,26 output
P3_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P3)
P3_downsample = DarknetConv2D_BN_Leaky(256, (3, 3),
strides=(2, 2))(P3_downsample)
P4 = Concatenate()([P3_downsample, P4])
P4 = make_five_convs(P4, 256)
P4_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P4)
P4_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P4_output)
# 13,13 output
P4_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P4)
P4_downsample = DarknetConv2D_BN_Leaky(512, (3, 3),
strides=(2, 2))(P4_downsample)
P5 = Concatenate()([P4_downsample, P5])
P5 = make_five_convs(P5, 512)
P5_output = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P5_output)
return Model(inputs, [P5_output, P4_output, P3_output])
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
# 获得三个特征层 分别是
# 52,52,256
# 26,26,512
# 13,13,1024
feat1, feat2, feat3 = darknet_body(inputs)
darknet = Model(inputs, feat3)
# 第一个特征层 25 种类数
# y1=(batch_size,13,13,3,85)
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, feat2])
# 第二个特征层
# y2=(batch_size,26,26,3,85)
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, feat1])
# 第三个特征层
# y3=(batch_size,52,52,3,85)
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
# Darknet53
feat1, feat2, feat3 = darknet_body(inputs)
darknet = Model(inputs, feat3)
# fist stage's outputs
# y1 = (batch_size, 13, 13 , 3, 85)
x, y1 = make_last_layers(darknet.output, 512,
num_anchors * (num_classes + 5))
# feature fusion
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
x = Concatenate()([x, feat2])
# second stage's outputs
# y2 = (batch_size, 26, 26, 3, 85)
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, feat1])
# third stage's outputs
# y3 = (batch_size, 52, 52, 3, 85)
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
#net, endpoint = inception_v2.inception_v2(inputs)
densenet = DenseNet121(
input_tensor=inputs,
weights='imagenet') #include top can be added but will not change much
# input: 416 x 416 x 3
# conv_pw_13_relu :13 x 13 x 1024
# conv_pw_11_relu :26 x 26 x 1024
# conv_pw_5_relu : 52 x 52 x 512
f1 = densenet.get_layer('relu').output
# f1 :13 x 13 x 1024
x, y1 = make_last_layers(f1, 512, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
f2 = densenet.get_layer('pool4_relu').output
# f2: 26 x 26 x 1024 // 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 = densenet.get_layer('pool3_relu').output
# f3 : 52 x 52 x 512 // 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 yolo_body(inputs, num_anchors, num_classes):
#net, endpoint = inception_v2.inception_v2(inputs)
squeezenet = squeezenet_body(input_tensor=inputs)
# input: 416 x 416 x 3
# contatenate_10 :12 x 12 x 640
# contatenate_6 :25 x 25 x 384
# contatenate_4 : 51 x 51 x 256
f1 = squeezenet.get_layer('concatenate_10').output
# f1 :13 x 13 x 1024
x, y1 = make_last_layers(f1, 512, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
f2 = squeezenet.get_layer('concatenate_6').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 = squeezenet.get_layer('concatenate_4').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 yolo_body(inputs, num_anchors, num_classes):
#net, endpoint = inception_v2.inception_v2(inputs)
mobilenet = MobileNet(input_tensor=inputs,
weights='imagenet',
include_top=False)
# 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
f1 = mobilenet.get_layer('conv_pw_13_relu').output
# f1 :13 x 13 x 1024
x, y1 = make_last_layers(f1, 256, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(128, (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, 128, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(64, (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, 64, num_anchors*(num_classes+5))
y3 = compose(DarknetConv2D_BN_Leaky(64 * 2, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x)
return Model(inputs=inputs, outputs=[y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
feat1, feat2, feat3 = darknet_body(inputs) #darknet53获得的特征层
#52*52*256,26*26*512,13*13*1024
darknet = Model(inputs, feat3)
# 第一个特征层
# y1=(batch_size,13,13,3,25)
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, feat2]) #与第二特征层输出结合
# 第二个特征层
# y2=(batch_size,26,26,3,25)
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, feat1])
# 第三个特征层
# y3=(batch_size,52,52,3,25)
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2, y3])
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 vgg16(inputs):
stage1 = compose(
VGGnetConv2D_BN_Relu(64, (3, 3)),
VGGnetConv2D_BN_Relu(64, (3, 3)),
MaxPooling2D(),
VGGnetConv2D_BN_Relu(128, (3, 3)),
VGGnetConv2D_BN_Relu(128, (3, 3)),
MaxPooling2D(),
VGGnetConv2D_BN_Relu(256, (3, 3)),
VGGnetConv2D_BN_Relu(256, (3, 3)),
VGGnetConv2D_BN_Relu(256, (3, 3)),
MaxPooling2D(),
VGGnetConv2D_BN_Relu(512, (3, 3)),
VGGnetConv2D_BN_Relu(512, (3, 3)),
VGGnetConv2D_BN_Relu(512, (3, 3)),
)(inputs)
stage2 = compose(MaxPooling2D(), VGGnetConv2D_BN_Relu(512, (3, 3)),
VGGnetConv2D_BN_Relu(512, (3, 3)),
VGGnetConv2D_BN_Relu(512, (3, 3)))(stage1)
stage3 = MaxPooling2D()(stage2)
stage3 = compose(DarknetConv2D_BN_Leaky(512, (1, 1)),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(512, (1, 1)),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(512, (1, 1)),
DarknetConv2D_BN_Leaky(1024, (3, 3)))(stage3)
return [stage3, stage2, stage1]
def yolo_body(inputs, num_anchors, num_classes):
#net, endpoint = inception_v2.inception_v2(inputs)
darknet = Model(inputs, darknet_ref_body(inputs))
# input: 416 x 416 x 3
# leaky_re_lu_7 :13 x 13 x 1024
# leaky_re_lu_5 :26 x 26 x 512
# leaky_re_lu_4 : 52 x 52 x 256
f1 = darknet.get_layer('leaky_re_lu_7').output
# f1 :13 x 13 x 1024
x, y1 = make_last_layers(f1, 256, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x)
f2 = darknet.get_layer('leaky_re_lu_5').output
# f2: 26 x 26 x 512
x = Concatenate()([x, f2])
x, y2 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(64, (1, 1)), UpSampling2D(2))(x)
f3 = darknet.get_layer('leaky_re_lu_4').output
# f3 : 52 x 52 x 256
x = Concatenate()([x, f3])
x, y3 = make_last_layers(x, 64, num_anchors * (num_classes + 5))
return Model(inputs=inputs, outputs=[y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
feat1, feat2, feat3 = darknet_body(inputs)
darknet = Model(inputs, feat3)
# 第一个特征层
x, y1 = make_last_layers(darknet.output, 512,
num_anchors * (num_classes + 5))
# 得到y1 = 【batch_size,13,13,255】
x = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x)
# 得到x=【batch_size,26,26,256】，feat2 = 【batch_size,26,26,512】
x = Concatenate()([x, feat2])
# 得到x = 【batch_size,26,26,768】
# 第二个特征层
# y2=(batch_size,26,26,3,75)
x, y2 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
# 得到y2 =【batch_size,26,26,255】，x = 【batch_size,26,26,256】
x = compose(
DarknetConv2D_BN_Leaky(128, (1, 1)), # 得到x =【batch_size,26,26,128】
UpSampling2D(2))(x)
# 得到x =【batch_size,52,52,128】，feat1 = 【batch_size,52,52,256】
x = Concatenate()([x, feat1])
# 得到x =【batch_size,52,52,384】
# 第三个特征层
# y3=(batch_size,52,52,3,85)
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
# 得到y2 =【batch_size,52,52,255】，x = 【batch_size,52,52,128】
return Model(inputs, [y1, y2, y3])
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
feat1, feat2, feat3 = darknet_body(inputs)
# feat3进行三次卷积进入SPP结构
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(feat3)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
# 使用了SPP结构，即不同尺度的最大池化后堆叠。
maxpool1 = MaxPooling2D(pool_size=(13, 13), strides=(1, 1), padding='same')(P5)
maxpool2 = MaxPooling2D(pool_size=(9, 9), strides=(1, 1), padding='same')(P5)
maxpool3 = MaxPooling2D(pool_size=(5, 5), strides=(1, 1), padding='same')(P5)
P5 = Concatenate()([maxpool1, maxpool2, maxpool3, P5])
#SPP聚合后的三次卷积
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
P5 = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5 = DarknetConv2D_BN_Leaky(512, (1, 1))(P5)
#卷积+上采样
P5_upsample = compose(DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(P5)
P4 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
P4 = Concatenate()([P4, P5_upsample])
P4 = make_five_convs(P4, 256)
P4_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(P4)
P3 = DarknetConv2D_BN_Leaky(128, (1, 1))(feat1)
P3 = Concatenate()([P3, P4_upsample])
P3 = make_five_convs(P3, 128)
P3_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P3)
# num_anchors = 3
# num_classes+1+4(1是先验框是不是包含物体，4是先验框的参数)
P3_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(P3_output)
# 38x38 output
P3_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P3)
P3_downsample = DarknetConv2D_BN_Leaky(256, (3, 3), strides=(2, 2))(P3_downsample)
P4 = Concatenate()([P3_downsample, P4])
P4 = make_five_convs(P4, 256)
P4_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P4)
P4_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(P4_output)
# 19x19 output
P4_downsample = ZeroPadding2D(((1, 0), (1, 0)))(P4)
P4_downsample = DarknetConv2D_BN_Leaky(512, (3, 3), strides=(2, 2))(P4_downsample)
P5 = Concatenate()([P4_downsample, P5])
P5 = make_five_convs(P5, 512)
P5_output = DarknetConv2D_BN_Leaky(1024, (3, 3))(P5)
P5_output = DarknetConv2D(num_anchors * (num_classes + 5), (1, 1))(P5_output)
return Model(inputs, [P5_output, P4_output, P3_output])
def pmake_last_layers(x, num_filters, out_filters):
x = compose(pDarknetConv2D_BN_Leaky(num_filters, (1, 1)),
pDarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
pDarknetConv2D_BN_Leaky(num_filters, (1, 1)),
pDarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
pDarknetConv2D_BN_Leaky(num_filters, (1, 1)))(x)
y = compose(pDarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
pDarknetConv2D(out_filters, (1, 1)))(x)
return x, y
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 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 resblock_body(x, num_filters, num_blocks, all_narrow=True):
#----------------------------------------------------------------#
# 利用ZeroPadding2D和一个步长为2x2的卷积块进行高和宽的压缩
#----------------------------------------------------------------#
preconv1 = ZeroPadding2D(((1, 0), (1, 0)))(x)
preconv1 = DarknetConv2D_BN_Mish(num_filters, (3, 3), strides=2)(preconv1)
#--------------------------------------------------------------------#
# 然后建立一个大的残差边shortconv、这个大残差边绕过了很多的残差结构
#--------------------------------------------------------------------#
shortconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
#----------------------------------------------------------------#
# 主干部分会对num_blocks进行循环，循环内部是残差结构。
#----------------------------------------------------------------#
mainconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Mish(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters,
(3, 3)))(mainconv)
mainconv = Add()([mainconv, y])
postconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(mainconv)
#----------------------------------------------------------------#
# 将大残差边再堆叠回来
#----------------------------------------------------------------#
route = Concatenate()([postconv, shortconv])
# 最后对通道数进行整合
return DarknetConv2D_BN_Mish(num_filters, (1, 1))(route)
def resblock_body(x, num_filters, num_blocks, all_narrow=True):
# Perform length and width compression
preconv1 = ZeroPadding2D(((1, 0), (1, 0)))(x)
preconv1 = DarknetConv2D_BN_Mish(num_filters, (3, 3),
strides=(2, 2))(preconv1)
shortconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# Convolution of the backbone
mainconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# 1x1 convolution->3x3convolution Extract features
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Mish(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters,
(3, 3)))(mainconv)
mainconv = Add()([mainconv, y])
# Stacking with residual edge after 1x1 convolution
postconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(mainconv)
route = Concatenate()([postconv, shortconv])
# the number of channels is integrated
return DarknetConv2D_BN_Mish(num_filters, (1, 1))(route)
def yolo_body(inputs, num_anchors, num_classes):
# 生成darknet53的主干模型
# 首先我们会获取到两个有效特征层
# feat1 26x26x256
# feat2 13x13x512
feat1, feat2 = darknet_body(inputs)
# 13x13x512 -> 13x13x256
P5 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
P5_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P5)
P5_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P5_output)
# Conv+UpSampling2D 13x13x256 -> 26x26x128
P5_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(P5)
# 26x26x(128+256) 26x26x384
P4 = Concatenate()([feat1, P5_upsample])
P4_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P4)
P4_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P4_output)
return Model(inputs, [P5_output, P4_output])
def yolo_body(inputs, num_anchors, num_classes):
#---------------------------------------------------#
# 生成CSPdarknet53_tiny的主干模型
# feat1的shape为26,26,256
# feat2的shape为13,13,512
#---------------------------------------------------#
feat1, feat2 = darknet_body(inputs)
# 13,13,512 -> 13,13,256
P5 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
# 13,13,256 -> 13,13,512 -> 13,13,255
P5_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P5)
P5_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P5_output)
# 13,13,256 -> 13,13,128 -> 26,26,128
P5_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(P5)
# 26,26,256 + 26,26,128 -> 26,26,384
P4 = Concatenate()([P5_upsample, feat1])
# 26,26,384 -> 26,26,256 -> 26,26,255
P4_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P4)
P4_output = DarknetConv2D(num_anchors * (num_classes + 5),
(1, 1))(P4_output)
return Model(inputs, [P5_output, P4_output])
def resblock_body(x, num_filters, num_blocks, all_narrow=True):
# Compression of length and width
preconv1 = ZeroPadding2D(((1, 0), (1, 0)))(x)
preconv1 = DarknetConv2D_BN_Mish(num_filters, (3, 3),
strides=(2, 2))(preconv1)
# It makes a big residual edge
shortconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# The convolution of the trunk
mainconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# 1x1 convolution integrates the number of channels - > Feature extraction using 3x3 convolution and residual structure
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Mish(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters,
(3, 3)))(mainconv)
mainconv = Add()([mainconv, y])
# 1x1 convolved with the residual edge
postconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(mainconv)
route = Concatenate()([postconv, shortconv])
# Finally, the number of channels is integrated
return DarknetConv2D_BN_Mish(num_filters, (1, 1))(route)
def DarknetConv2D_BN_Leaky(*args, **kwargs):
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
def DarknetConv2D_BN_Mish(*args, **kwargs):
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
Mish())
def DarknetConv2D_BN_Leaky(*args, **kwargs):
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
Activation(relu6))
def yolo_body(input_shape, anchors_mask, num_classes, phi=0):
inputs = Input(input_shape)
#---------------------------------------------------#
# 生成CSPdarknet53_tiny的主干模型
# feat1的shape为26,26,256
# feat2的shape为13,13,512
#---------------------------------------------------#
feat1, feat2 = darknet_body(inputs)
if phi >= 1 and phi <= 4:
feat1 = attention[phi - 1](feat1, name='feat1')
feat2 = attention[phi - 1](feat2, name='feat2')
# 13,13,512 -> 13,13,256
P5 = DarknetConv2D_BN_Leaky(256, (1, 1))(feat2)
# 13,13,256 -> 13,13,512 -> 13,13,255
P5_output = DarknetConv2D_BN_Leaky(512, (3, 3))(P5)
P5_output = DarknetConv2D(
len(anchors_mask[0]) * (num_classes + 5), (1, 1))(P5_output)
# 13,13,256 -> 13,13,128 -> 26,26,128
P5_upsample = compose(DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(P5)
if phi >= 1 and phi <= 4:
P5_upsample = attention[phi - 1](P5_upsample, name='P5_upsample')
# 26,26,256 + 26,26,128 -> 26,26,384
P4 = Concatenate()([P5_upsample, feat1])
# 26,26,384 -> 26,26,256 -> 26,26,255
P4_output = DarknetConv2D_BN_Leaky(256, (3, 3))(P4)
P4_output = DarknetConv2D(
len(anchors_mask[1]) * (num_classes + 5), (1, 1))(P4_output)
return Model(inputs, [P5_output, P4_output])
def resblock_body(x, num_filters, num_blocks, all_narrow=True):
# 进行长和宽的压缩
preconv1 = ZeroPadding2D(((1, 0), (1, 0)))(x)
preconv1 = DarknetConv2D_BN_Mish(num_filters, (3, 3),
strides=(2, 2))(preconv1)
# 生成一个大的残差边
shortconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# 主干部分的卷积
mainconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(preconv1)
# 1x1卷积对通道数进行整合->3x3卷积提取特征，使用残差结构
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Mish(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters,
(3, 3)))(mainconv)
mainconv = Add()([mainconv, y])
# 1x1卷积后和残差边堆叠
postconv = DarknetConv2D_BN_Mish(
num_filters // 2 if all_narrow else num_filters, (1, 1))(mainconv)
route = Concatenate()([postconv, shortconv])
# 最后对通道数进行整合
return DarknetConv2D_BN_Mish(num_filters, (1, 1))(route)
def yolo_body(inputs, num_anchors, num_classes):
#---------------------------------------------------#
# 生成darknet53的主干模型
# 获得三个有效特征层，他们的shape分别是：
# 13,13,256
# 26,26,512
# 13,13,1024
#---------------------------------------------------#
feat1,feat2,feat3 = darknet_body(inputs)
darknet = Model(inputs, feat3)
#---------------------------------------------------#
# 第一个特征层
# y1=(batch_size,13,13,3,85)
#---------------------------------------------------#
# 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512
x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
# 13,13,512 -> 13,13,256 -> 26,26,256
x = compose(
DarknetConv2D_BN_Leaky(256, (1,1)),
UpSampling2D(2))(x)
# 26,26,256 + 26,26,512 -> 26,26,768
x = Concatenate()([x,feat2])
#---------------------------------------------------#
# 第二个特征层
# y2=(batch_size,26,26,3,85)
#---------------------------------------------------#
# 26,26,768 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
# 26,26,256 -> 26,26,128 -> 52,52,128
x = compose(
DarknetConv2D_BN_Leaky(128, (1,1)),
UpSampling2D(2))(x)
# 52,52,128 + 52,52,256 -> 52,52,384
x = Concatenate()([x,feat1])
#---------------------------------------------------#
# 第三个特征层
# y3=(batch_size,52,52,3,85)
#---------------------------------------------------#
# 52,52,384 -> 52,52,128 -> 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128
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."""
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
def Conv2D_BN_Leaky(*args, **kwargs):
leaky = 0.1
try:
leaky = kwargs["leaky"]
del kwargs["leaky"]
except:
pass
return compose(Conv2D(*args, **kwargs), BatchNormalization(),
LeakyReLU(alpha=leaky))
