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))