def resnet(input_data, num_layer):
if num_layer == 18:
restnet = ResNet18()
if num_layer == 34:
restnet = ResNet34()
if num_layer == 50:
restnet = ResNet50()
if num_layer == 101:
restnet = ResNet101()
if num_layer == 152:
restnet = ResNet152()
output_resnet = restnet.call(input_data, training=True)
route_1 = common.convolutional(output_resnet, (3, 3, 2048, 256), downsample=False)
for _ in range(8):
route_1 = common.residual_block(route_1, 256, 128, 256)
route_2 = common.convolutional(output_resnet, (3, 3, 2048, 512), downsample=True)
for _ in range(8):
route_2 = common.residual_block(route_2, 512, 256, 512)
route_3 = common.convolutional(route_2, (3, 3, 512, 1024), downsample=True)
for _ in range(4):
route_3 = common.residual_block(route_3, 1024, 512, 1024)
return route_1, route_2, route_3
def YOLOv4_more_tiny(input_layer, NUM_CLASS):
route_1, conv = backbone.cspdarknet53_tiny(input_layer)
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.convolutional(conv, (3, 3, 256, 512))
conv_mbbox = common.convolutional(conv, (1, 1, 512, 3 * (NUM_CLASS + 5)), activate=False, bn=False) #256
return [conv_mbbox]
def darknet19(input_data, trainable):
with tf.variable_scope('darknet'):
input_data = common.convolutional(input_data, filters_shape=(3, 3, 3, 16), trainable=self.trainable,name='conv0')
input_data = common.max_pooling_2d(input_data,ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], data_format=self.data_format,name='max1')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 16, 32), trainable=self.trainable,name='conv2')
input_data = common.max_pooling_2d(input_data, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],data_format=self.data_format,name='max3')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 32, 64), trainable=self.trainable,name='conv4')
input_data = common.max_pooling_2d(input_data, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],data_format=self.data_format,name='max5')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 64, 128), trainable=self.trainable,name='conv6')
input_data = common.max_pooling_2d(input_data, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],data_format=self.data_format,name='max7')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 128, 256), trainable=self.trainable,name='conv8')
route_8_layer = input_data
input_data = common.max_pooling_2d(input_data, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],data_format=self.data_format,name='max9')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 256, 512), trainable=self.trainable,name='conv10')
input_data = common.max_pooling_2d(input_data, ksize=[1, 2, 2, 1], strides=[1, 1, 1, 1],data_format=self.data_format,name='max11')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 512, 1024), trainable=self.trainable,name='conv12')
input_data = common.convolutional(input_data, filters_shape=(1, 1, 1024, 256), trainable=self.trainable,name='conv13')
route_13_layer = input_data
return route_8_layer, route_13_layer, input_data
def __build_nework(self, input_data):
route_8_layer, route_13_layer, input_data = backbone.darknet19(
input_data, self.trainable)
with tf.variable_scope('yolo1'):
conv_lobj_branch = common.convolutional(input_data,
(3, 3, 256, 512),
self.trainable,
name='conv_lobj_branch')
conv_lbbox = common.convolutional(
conv_lobj_branch, (1, 1, 512, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_lbbox',
activate=False,
bn=False)
with tf.variable_scope('route_1'):
input_data = route_13_layer
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 256, 128),
trainable=self.trainable,
name='conv18')
input_data = common.upsample(input_data,
method=self.upsample_method,
name='upsample19')
with tf.variable_scope('route_2'):
input_data = tf.concat([input_data, route_8_layer],
axis=-1,
name='route20')
with tf.variable_scope('yolo2'):
conv_mobj_branch = common.convolutional(input_data,
filters_shape=(1, 1, 384,
256),
trainable=self.trainable,
name='conv21')
conv_mbbox = common.convolutional(
conv_mobj_branch,
filters_shape=(1, 1, 256, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv22',
activate=False,
bn=False)
return conv_lbbox, conv_mbbox
def conv_wrapper(input_data):
with tf.variable_scope(scope_name):
input_data = common.convolutional(input_data, filters_shape,
trainable, use_gn, name,
precision, downsample, activate,
norm, weight_centering)
return {"input_data": input_data}
def head_3_wrapper(conv_sobj_branch):
conv_sbbox = common.convolutional(
conv_sobj_branch, (1, 1, 256, 3 * (self.num_class + 5)),
trainable=self.trainable,
use_gn=self.upsample_gn,
name="conv_sbbox",
activate=False,
norm=False,
weight_centering=self.use_centering,
precision=self.precision)
return {"conv_sbbox": conv_sbbox}
def darknet53(input_data, trainable):
with tf.variable_scope('darknet'):
input_data = common.convolutional(input_data, filters_shape=(3, 3, 3, 12), trainable=trainable, name='conv0')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 12, 24),
trainable=trainable, name='conv1', downsample=True)
#print(input_data.shape)
input_data=common.PEP(input_data,24,24,7,name='PEP0',stride=1)
input_data=common.EP(input_data,24,70,name='EP0',stride=2)
input_data=common.PEP(input_data,70,70,25,name='PEP1',stride=1)
input_data=common.PEP(input_data,70,70,24,name='PEP2',stride=1)
input_data=common.EP(input_data,70,150,name='EP1',stride=2)
input_data=common.PEP(input_data,150,150,56,name='PEP3',stride=1)
input_data = common.convolutional(input_data, filters_shape=(1, 1, 150, 150), trainable=trainable, name='conv2')
input_data=common.FCA(input_data,150,8)
input_data=common.PEP(input_data,150,150,73,name='PEP4',stride=1)
input_data=common.PEP(input_data,150,150,71,name='PEP5',stride=1)
input_data=common.PEP(input_data,150,150,75,name='PEP6',stride=1)
route_1=input_data
input_data=common.EP(input_data,150,325,name='EP2',stride=2)
input_data=common.PEP(input_data,325,325,132,name='PEP7',stride=1)
input_data=common.PEP(input_data,325,325,124,name='PEP8',stride=1)
input_data=common.PEP(input_data,325,325,141,name='PEP9',stride=1)
input_data=common.PEP(input_data,325,325,140,name='PEP10',stride=1)
input_data=common.PEP(input_data,325,325,137,name='PEP11',stride=1)
input_data=common.PEP(input_data,325,325,135,name='PEP12',stride=1)
input_data=common.PEP(input_data,325,325,133,name='PEP13',stride=1)
input_data=common.PEP(input_data,325,325,140,name='PEP14',stride=1)
route_2=input_data
input_data=common.EP(input_data,325,545,name='EP3',stride=2)
input_data=common.PEP(input_data,545,545,276,name='PEP15',stride=1)
input_data = common.convolutional(input_data, filters_shape=(1, 1, 545, 230), trainable=trainable, name='conv3')
input_data=common.EP(input_data,230,489,name='EP4',stride=1)
input_data=common.PEP(input_data,489,469,213,name='PEP16',stride=1)
input_data = common.convolutional(input_data, filters_shape=(1, 1, 469, 189), trainable=trainable, name='conv4')
return route_1, route_2, input_data
def darknet53(input_data):
'''
input_data是3通道的
output_data是1024通道的
'''
x = common.convolutional(input_data, (3, 3, 3, 32))
x = common.convolutional(x, (3, 3, 32, 64), downsample='True')
for i in range(1):
x = common.residual_block(x, 64, 32, 64)
x = common.convolutional(x, (3, 3, 64, 128), downsample='True')
for i in range(2):
x = common.residual_block(x, 128, 64, 128)
x = common.convolutional(x, (3, 3, 128, 256), downsample='True')
for i in range(8):
x = common.residual_block(x, 256, 128, 256)
route_1 = x
x = common.convolutional(x, (3, 3, 256, 512), downsample='True')
for i in range(8):
x = common.residual_block(x, 512, 256, 512)
route_2 = x
output_data = common.convolutional(x, (3, 3, 512, 1024), downsample='True')
return route_1, route_2, output_data
def darknet53(input_data):
input_data = common.convolutional(input_data, (3, 3, 3, 32))
input_data = common.convolutional(input_data, (3, 3, 32, 64),
downsample=True)
for i in range(1):
input_data = common.residual_block(input_data, 64, 32, 64)
input_data = common.convolutional(input_data, (3, 3, 64, 128),
downsample=True)
for i in range(2):
input_data = common.residual_block(input_data, 128, 64, 128)
input_data = common.convolutional(input_data, (3, 3, 128, 256),
downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 256, 128, 256)
route_1 = input_data
input_data = common.convolutional(input_data, (3, 3, 256, 512),
downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 512, 256, 512)
route_2 = input_data
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
downsample=True)
for i in range(4):
input_data = common.residual_block(input_data, 1024, 512, 1024)
return route_1, route_2, input_data
def residual_layer1_wrapper(input_data):
with tf.variable_scope(scope_name):
with tf.variable_scope(name):
short_cut = input_data
input_data = common.convolutional(input_data,
filters_shape=(1, 1,
input_channel,
filter_num1),
trainable=trainable,
use_gn=use_gn,
name='conv1',
precision=precision)
return {'short_cut': short_cut, 'input_data': input_data}
def PPNet(input_image, num_csp_blocks=1, num_dense_blocks=2, growth_rate=4,fc_activation='leaky', conv_activation='leaky', init_num_fms=32, final_num_fms=64, fc_dropout=0.5, conv_dropout=0.5, use_downsample=True):
#Warm-up convolution: (H x W x 1 -> H x W x init_num_fms)
conv = common.convolutional(input_image, (3,3,input_image.shape[-1],init_num_fms))
#pass through multiple csp blocks:
# H X W X init_num_fms -> H/(2^num_csp_blocks) x W/(2^num_csp_blocks) x (init_num_fm + num_csp_blocks*num_denseblocks*growth_rate)
for i in range(num_csp_blocks):
#Pass through a csp blocks: H x W x num_fm -> H x W x (num_fm + num_dense*growth_rate)
num_fm = conv.shape[-1]
conv = common.csp_block(conv, num_fm, growth_rate, num_dense_blocks, conv_activation, conv_dropout)
#Downsampling: H x W -> H//2 x W//2
num_fm = conv.shape[-1]
conv = common.convolutional(conv, (3,3, num_fm, num_fm), use_downsample)
#Final convolution to reduce number of feature maps > H x W x final_num_fms
conv = common.convolutional(conv, (1,1,conv.shape[-1], final_num_fms))
image_output = keras.layers.Flatten()(conv)
#Fully connected for regression
net_output = common.fully_connected(image_output, units=16, activate_type=fc_activation, dropout=fc_dropout)
net_output = common.fully_connected(net_output, units=3, activate=False)
return net_output
def MobilenetV2(input_data, trainable):
with tf.variable_scope('MobilenetV2'):
conv = common.convolutional(name='Conv', input_data=input_data, filters_shape=(3, 3, 3, 32),
trainable=trainable, downsample=True, activate=True, bn=True)
conv = common.inverted_residual(name='expanded_conv', input_data=conv, input_c=32, output_c=16,
trainable=trainable, t=1)
conv = common.inverted_residual(name='expanded_conv_1', input_data=conv, input_c=16, output_c=24, downsample=True,
trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_2', input_data=conv, input_c=24, output_c=24, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_3', input_data=conv, input_c=24, output_c=32, downsample=True,
trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_4', input_data=conv, input_c=32, output_c=32, trainable=trainable)
feature_map_s = common.inverted_residual(name='expanded_conv_5', input_data=conv, input_c=32, output_c=32,
trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_6', input_data=feature_map_s, input_c=32, output_c=64,
downsample=True, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_7', input_data=conv, input_c=64, output_c=64, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_8', input_data=conv, input_c=64, output_c=64, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_9', input_data=conv, input_c=64, output_c=64, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_10', input_data=conv, input_c=64, output_c=96, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_11', input_data=conv, input_c=96, output_c=96, trainable=trainable)
feature_map_m = common.inverted_residual(name='expanded_conv_12', input_data=conv, input_c=96, output_c=96,
trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_13', input_data=feature_map_m, input_c=96, output_c=160,
downsample=True, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_14', input_data=conv, input_c=160, output_c=160, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_15', input_data=conv, input_c=160, output_c=160, trainable=trainable)
conv = common.inverted_residual(name='expanded_conv_16', input_data=conv, input_c=160, output_c=320, trainable=trainable)
feature_map_l = common.convolutional(name='Conv_1', input_data=conv, filters_shape=(1, 1, 320, 1280),
trainable=trainable, downsample=False, activate=True, bn=True)
return feature_map_s, feature_map_m, feature_map_l
def residual_layer2_wrapper(short_cut, input_data):
with tf.variable_scope(scope_name):
with tf.variable_scope(name):
input_data = common.convolutional(input_data,
filters_shape=(3, 3,
filter_num1,
filter_num2),
trainable=trainable,
use_gn=use_gn,
name='conv2',
precision=precision)
input_data = input_data + short_cut
# "short_cut" won't be used in the following functions
# set short_cut to None means this value will be removed from stage function's output
return {'short_cut': None, 'input_data': input_data}
def darknet53(input_data, trainable):
with tf.variable_scope('darknet'):
#filters_shape=(3, 3, 3, 32),前2个3代表卷积核大小，第三个3代表输入图像的通道数数，此处为RGB，32是输出的通道数
input_data = common.convolutional(input_data, filters_shape=(3, 3, 3, 32), trainable=trainable, name='conv0')
#conv0 416*416*3 ---- 416*416*32
input_data = common.convolutional(input_data, filters_shape=(3, 3, 32, 64),
trainable=trainable, name='conv1', downsample=True)
# conv1 416*416*32 ---- 208*208*64
for i in range(1):
input_data = common.residual_block(input_data, 64, 32, 64, trainable=trainable, name='residual%d' %(i+0))
#residual 0 208*208*64---208*208*64
input_data = common.convolutional(input_data, filters_shape=(3, 3, 64, 128),
trainable=trainable, name='conv4', downsample=True)
# conv4 208*208*64---104*104*128
for i in range(2):
input_data = common.residual_block(input_data, 128, 64, 128, trainable=trainable, name='residual%d' %(i+1))
# residual 1 104*104*128---104*104*128
# residual 2 104*104*128---104*104*128
route_1 = input_data #4倍下采样的输出，104*104*128
input_data = common.convolutional(input_data, filters_shape=(3, 3, 128, 256),
trainable=trainable, name='conv9', downsample=True)
# conv9 104*104*128---52*52*256
for i in range(8):
input_data = common.residual_block(input_data, 256, 128, 256, trainable=trainable, name='residual%d' %(i+3))
# residual 3 52*52*256---52*52*128
# residual 4 52*52*128---52*52*256
# residual 5 52*52*256---52*52*128
# residual 6 52*52*128---52*52*256
# residual 7 52*52*256---52*52*128
# residual 8 52*52*128---52*52*256
# residual 9 52*52*256---52*52*128
# residual 10 52*52*128---52*52*256
route_2 = input_data #用作后面的concat操作，是8倍下采样的输出52*52*256
input_data = common.convolutional(input_data, filters_shape=(3, 3, 256, 512),
trainable=trainable, name='conv26', downsample=True)
# conv26 52*52*256---26*26*512
for i in range(8):
input_data = common.residual_block(input_data, 512, 256, 512, trainable=trainable, name='residual%d' %(i+11))
# residual 11 26*26*512---26*26*256
# residual 12 26*26*256---26*26*512
# residual 13 26*26*512---26*26*256
# residual 14 26*26*256---26*26*512
# residual 15 26*26*512---26*26*256
# residual 16 26*26*256---26*26*512
# residual 17 26*26*512---26*26*256
# residual 18 26*26*256---26*26*512
route_3 = input_data #16倍下采样的输出26*26*512
input_data = common.convolutional(input_data, filters_shape=(3, 3, 512, 1024),
trainable=trainable, name='conv43', downsample=True)
# conv43 26*26*512---13*13*1024
for i in range(4):
input_data = common.residual_block(input_data, 1024, 512, 1024, trainable=trainable, name='residual%d' %(i+19))
# residual 19 13*13*1024---13*13*512
# residual 20 13*13*512---13*13*1024
return route_1, route_2, route_3, input_data
def darknet53(input_data, trainable):
with tf.variable_scope('darknet'):
output_data = common.convolutional(input_data, filter_shape=(3,3,32,32),
trainable=trainable, name='conv1')
output_data = common.convolutional(output_data, filter_shape=(3,3,32,64),
trainable=trainable, downsample=True, name='conv2')
for i in range(1):
output_data = common.residual_block(output_data, 64, 32, 64,
trainable=trainable, name='residual%d'%(i+1))
output_data = common.convolutional(output_data, filter_shape=(3,3,64,128),
trainable=trainable, downsample=True, name='conv5')
for i in range(2):
output_data = common.residual_block(output_data, 128, 64, 128,
trainable=trainable, name='residual%d'%(i+2))
output_data = common.convolutional(output_data, filter_shape=(3,3,128,256),
trainable=trainable, downsample=True, name='conv10')
for i in range(8):
output_data = common.residual_block(output_data, 256, 128, 256,
trainable=trainable, name='residual%d'%(i+4))
route_1 = output_data
output_data = common.convolutional(output_data, filter_shape=(3,3,256,512),
trainable=trainable, downsample=True, name='conv27')
for i in range(8):
output_data = common.residual_block(output_data, 512, 256, 512,
trainable=trainable, name='residual%d'%(i+12))
route_2=output_data
output_data = common.convolutional(output_data, filter_shape=(3,3,512,1024),
trainable=trainable, downsample=True, name='conv44')
for i in range(4):
output_data = common.residual_block(output_data, 1024, 512, 1024,
trainable=trainable, name='residual%d'%(i+20))
return route_1, route_2, output_data
def darknet53_tiny(input_data):
input_data = common.convolutional(input_data, (3, 3, 3, 16))
input_data = tf.keras.layers.MaxPool2D(2, 2, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 16, 32))
input_data = tf.keras.layers.MaxPool2D(2, 2, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 32, 64))
input_data = tf.keras.layers.MaxPool2D(2, 2, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 64, 128))
input_data = tf.keras.layers.MaxPool2D(2, 2, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 128, 256))
route_1 = input_data
input_data = tf.keras.layers.MaxPool2D(2, 2, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 256, 512))
input_data = tf.keras.layers.MaxPool2D(2, 1, 'same')(input_data)
input_data = common.convolutional(input_data, (3, 3, 512, 1024))
return route_1, input_data
def YOLOv3_tiny(input_layer, NUM_CLASS):
route_1, conv = backbone.darknet53_tiny(input_layer)
conv = common.convolutional(conv, (1, 1, 1024, 256))
conv_lobj_branch = common.convolutional(conv, (3, 3, 256, 512))
conv_lbbox = common.convolutional(conv_lobj_branch, (1, 1, 512, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = common.convolutional(conv, (1, 1, 256, 128))
conv = common.upsample(conv)
conv = tf.concat([conv, route_1], axis=-1)
conv_mobj_branch = common.convolutional(conv, (3, 3, 128, 256))
conv_mbbox = common.convolutional(conv_mobj_branch, (1, 1, 256, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
return [conv_mbbox, conv_lbbox]
def YOLOv4_custom(input_layer, NUM_CLASS):
x = tf.keras.layers.Conv2D(32, 3, strides=2, padding='SAME')(input_layer)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.LeakyReLU(alpha=0.1)(x)
conv = common.convolutional(x, (3, 3, 32, 64), downsample=True)
conv = common.convolutional(conv, (3, 3, 64, 64))
route_1 = common.route_group(conv, 2, 1)
conv = common.convolutional(conv, (3,3,32,32))
conv = common.convolutional(conv, (3,3,32,32))
route_1 = tf.concat([conv, route_1], axis=-1)
conv = common.convolutional(conv, (3,3, 64,64))
conv = tf.concat([conv, route_1], axis=-1)
conv = common.convolutional(conv, (3,3,64,64))
def darknet53(input_data, trainable):
with tf.variable_scope('darknet'):
input_data = common.convolutional(input_data, filters_shape=(3, 3, 3, 32), trainable=trainable, name='conv0')
input_data = common.convolutional(input_data, filters_shape=(3, 3, 32, 64),
trainable=trainable, name='conv1', downsample=True)
for i in range(1):
input_data = common.residual_block(input_data, 64, 32, 64, trainable=trainable, name='residual%d' % (i + 0))
input_data = common.convolutional(input_data, filters_shape=(3, 3, 64, 128),
trainable=trainable, name='conv4', downsample=True)
for i in range(2):
input_data = common.residual_block(input_data, 128, 64, 128, trainable=trainable,
name='residual%d' % (i + 1))
input_data = common.convolutional(input_data, filters_shape=(3, 3, 128, 256),
trainable=trainable, name='conv9', downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 256, 128, 256, trainable=trainable,
name='residual%d' % (i + 3))
route_1 = input_data
input_data = common.convolutional(input_data, filters_shape=(3, 3, 256, 512),
trainable=trainable, name='conv26', downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 512, 256, 512, trainable=trainable,
name='residual%d' % (i + 11))
route_2 = input_data
input_data = common.convolutional(input_data, filters_shape=(3, 3, 512, 1024),
trainable=trainable, name='conv43', downsample=True)
for i in range(4):
input_data = common.residual_block(input_data, 1024, 512, 1024, trainable=trainable,
name='residual%d' % (i + 19))
return route_1, route_2, input_data
def plugmodel():
sbbox = tf.keras.layers.Input(shape=(52, 52, 768))
mbbox = tf.keras.layers.Input(shape=(26, 26, 1536))
lbbox = tf.keras.layers.Input(shape=(13, 13, 3072))
conv_spose = common.convolutional(sbbox, (1, 1, 256, 256))
conv_spose = common.convolutional(conv_spose, (1, 1, 256, 3 * (NUM_POSES)),
activate=False,
bn=False)
conv_mpose = common.convolutional(mbbox, (1, 1, 512, 512))
conv_mpose = common.convolutional(conv_mpose, (1, 1, 512, 3 * (NUM_POSES)),
activate=False,
bn=False)
conv_lpose = common.convolutional(lbbox, (1, 1, 255, 1024))
conv_lpose = common.convolutional(conv_lpose, (1, 1, 1024, 3 * NUM_POSES),
activate=False,
bn=False)
return Model(inputs=[sbbox, mbbox, lbbox],
outputs=[conv_spose, conv_mpose, conv_lpose])
def darknet53(input_data):
'''
If downsample=True, the feature map size will be decreased by a factor of 2.
'''
input_data = common.convolutional(input_data, (3, 3, 3, 32))
input_data = common.convolutional(input_data, (3, 3, 32, 64),
downsample=True)
for i in range(1):
input_data = common.residual_block(input_data, 64, 32, 64)
input_data = common.convolutional(input_data, (3, 3, 64, 128),
downsample=True)
for i in range(2):
input_data = common.residual_block(input_data, 128, 64, 128)
input_data = common.convolutional(input_data, (3, 3, 128, 256),
downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 256, 128, 256)
route_1 = input_data
input_data = common.convolutional(input_data, (3, 3, 256, 512),
downsample=True)
for i in range(8):
input_data = common.residual_block(input_data, 512, 256, 512)
route_2 = input_data
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
downsample=True)
for i in range(4):
input_data = common.residual_block(input_data, 1024, 512, 1024)
return route_1, route_2, input_data
def darknet53(input_data):
"""
build backbone according to the paper
"""
input_data = common.convolutional(input_data, filters_shape=(3, 3, 3, 32))
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 32, 64),
downsample=True)
for _ in range(1):
input_data = common.residual_block(input_data, 32, 64)
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 64, 128),
downsample=True)
for _ in range(2):
input_data = common.residual_block(input_data, 64, 128)
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 128, 256),
downsample=True)
for _ in range(8):
input_data = common.residual_block(input_data, 128, 256)
route1 = input_data
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 256, 512),
downsample=True)
for _ in range(8):
input_data = common.residual_block(input_data, 256, 512)
route2 = input_data
input_data = common.convolutional(input_data,
filters_shape=(3, 3, 512, 1024),
downsample=True)
for _ in range(4):
input_data = common.residual_block(input_data, 512, 1024)
return route1, route2, input_data
def darknet53(input_data):
#conv2d Filters=32 Size=3x3 Strike=1
input_data = common.convolutional(input_data, (3, 3, 3, 32)) # 256
#conv2d Filters=64 Size=3x3 Strike=2
input_data = common.convolutional(input_data, (3, 3, 32, 64), downsample=True) # 128
# The first block residual
for _ in range(1):
input_data = common.residual_block(input_data, 64, 32, 64)
input_data = common.convolutional(input_data, (3, 3, 64, 128), downsample=True) # 64
for _ in range(2):
input_data = common.residual_block(input_data, 128, 64, 128)
input_data = common.convolutional(input_data, (3, 3, 128, 256), downsample=True) # 32
for _ in range(8):
input_data = common.residual_block(input_data, 256, 128, 256)
route_1 = input_data # 256
input_data = common.convolutional(input_data, (3, 3, 256, 512), downsample=True) # 16
for _ in range(8):
input_data = common.residual_block(input_data, 512, 256, 512)
route_2 = input_data #512
input_data = common.convolutional(input_data, (3, 3, 512, 1024), downsample=True) # 8
for _ in range(4):
input_data = common.residual_block(input_data, 1024, 512, 1024)
print('route_1: ', route_1.shape)
print('route_2: ', route_2.shape)
print('input_data: ', input_data.shape)
return route_1, route_2, input_data # 52 | 26 | 13
def YOLOv4(input_layer, NUM_CLASS):
route_1, route_2, conv = backbone.cspdarknet53(input_layer)
route = conv
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.upsample(conv)
route_2 = common.convolutional(route_2, (1, 1, 512, 256))
conv = tf.concat([route_2, conv], axis=-1)
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = common.convolutional(conv, (1, 1, 256, 128))
conv = common.upsample(conv)
route_1 = common.convolutional(route_1, (1, 1, 256, 128))
conv = tf.concat([route_1, conv], axis=-1)
conv = common.convolutional(conv, (1, 1, 256, 128))
conv = common.convolutional(conv, (3, 3, 128, 256))
conv = common.convolutional(conv, (1, 1, 256, 128))
conv = common.convolutional(conv, (3, 3, 128, 256))
conv = common.convolutional(conv, (1, 1, 256, 128))
route_1 = conv
conv = common.convolutional(conv, (3, 3, 128, 256))
conv_sbbox = common.convolutional(conv, (1, 1, 256, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = common.convolutional(route_1, (3, 3, 128, 256), downsample=True)
conv = tf.concat([conv, route_2], axis=-1)
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
route_2 = conv
conv = common.convolutional(conv, (3, 3, 256, 512))
conv_mbbox = common.convolutional(conv, (1, 1, 512, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = common.convolutional(route_2, (3, 3, 256, 512), downsample=True)
conv = tf.concat([conv, route], axis=-1)
conv = common.convolutional(conv, (1, 1, 1024, 512))
conv = common.convolutional(conv, (3, 3, 512, 1024))
conv = common.convolutional(conv, (1, 1, 1024, 512))
conv = common.convolutional(conv, (3, 3, 512, 1024))
conv = common.convolutional(conv, (1, 1, 1024, 512))
conv = common.convolutional(conv, (3, 3, 512, 1024))
conv_lbbox = common.convolutional(conv, (1, 1, 1024, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
return [conv_sbbox, conv_mbbox, conv_lbbox]
def YOLOv3(for_annother_use=False):
input_layer = tf.keras.layers.Input(shape=[416,416,3])
route_1, route_2, conv = backbone.darknet53(input_layer)
conv = common.convolutional(conv, (1, 1, 1024, 512))
sconv1 = conv = common.convolutional(conv, (3, 3, 512, 1024))
conv = common.convolutional(conv, (1, 1, 1024, 512))
sconv2 = conv = common.convolutional(conv, (3, 3, 512, 1024))
conv = common.convolutional(conv, (1, 1, 1024, 512))
sconv3 = conv_lobj_branch = common.convolutional(conv, (3, 3, 512, 1024))
conv_lbbox = common.convolutional(conv_lobj_branch, (1, 1, 1024, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = common.convolutional(conv, (1, 1, 512, 256))
conv = common.upsample(conv)
conv = tf.concat([conv, route_2], axis=-1)
conv = common.convolutional(conv, (1, 1, 768, 256))
mconv1 = conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
mconv2 = conv = common.convolutional(conv, (3, 3, 256, 512))
conv = common.convolutional(conv, (1, 1, 512, 256))
mconv3 = conv_mobj_branch = common.convolutional(conv, (3, 3, 256, 512))
conv_mbbox = common.convolutional(conv_mobj_branch, (1, 1, 512, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
conv = common.convolutional(conv, (1, 1, 256, 128))
conv = common.upsample(conv)
conv = tf.concat([conv, route_1], axis=-1)
conv = common.convolutional(conv, (1, 1, 384, 128))
lconv1 = conv = common.convolutional(conv, (3, 3, 128, 256))
conv = common.convolutional(conv, (1, 1, 256, 128))
lconv2 = conv = common.convolutional(conv, (3, 3, 128, 256))
conv = common.convolutional(conv, (1, 1, 256, 128))
lconv3 = conv_sobj_branch = common.convolutional(conv, (3, 3, 128, 256))
conv_sbbox = common.convolutional(conv_sobj_branch, (1, 1, 256, 3 * (NUM_CLASS + 5)), activate=False, bn=False)
if for_annother_use:
convs_sbbox = tf.concat([lconv1, lconv2, lconv3], axis=-1, name="lfeature")
convs_mbbox = tf.concat([mconv1, mconv2, mconv3], axis=-1, name="mfeature")
convs_lbbox = tf.concat([sconv1, sconv2, sconv3], axis=-1, name="sfeature")
yolo = Model(input_layer,[conv_sbbox, conv_mbbox, conv_lbbox, convs_sbbox,convs_mbbox,convs_lbbox])
# 52,26,13 52,26,13
yolo.load_weights(filepath=tf.keras.utils.get_file('yolo3.h5',''))
yolo.trainable = False
else:
# classic YOLOV3 model trained for coco datasets
yolo = Model(input_layer, [conv_sbbox, conv_mbbox, conv_lbbox])
yolo.load_weights(filepath=tf.keras.utils.get_file('yolo3.h5',''))
yolo.trainable =False
return yolo
def __build_nework(self, input_data):
# mobilenet v1 backbone
# input_data = tf.layers.conv2d(input_data,
# filters=32,
# kernel_size=(3, 3),
# strides=(2,2),
# padding = 'same',
# activation = tf.nn.relu,
# name = 'conv1'
# )
# input_data = tf.layers.batch_normalization(input_data, beta_initializer=tf.zeros_initializer(),
# gamma_initializer=tf.ones_initializer(),
# moving_mean_initializer=tf.zeros_initializer(),
# moving_variance_initializer=tf.ones_initializer(), training=self.trainable,
# name='bn')
'''
input_data = common.convolutional(input_data, (3, 3, 3, 32), self.trainable, 'conv0')
input_data = self.separable_conv_block(input=input_data, dw_filter=(3,3,32,1),output_channel=64,
strides=(1,1,1,1), name="spearable_1")
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 64, 1), output_channel=128,
strides=(1, 2, 2, 1), name="spearable_2")
input_data = self.separable_conv_block(input=input_data, dw_filter=(3,3,128,1),output_channel=128,
strides=(1,1,1,1), name="spearable_3")
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 128, 1), output_channel=256,
strides=(1, 2, 2, 1), name="spearable_4")
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 256, 1), output_channel=256,
strides=(1, 1, 1, 1), name="spearable_5")
with tf.variable_scope("spearable_6"):
dw_weight = tf.get_variable(name='dw_filter', dtype=tf.float32, trainable=True,
shape=(3, 3, 256, 1), initializer=tf.random_normal_initializer(stddev=0.01))
input_data = tf.nn.depthwise_conv2d(input=input_data, filter=dw_weight, strides=(1, 2, 2, 1), padding="SAME", name='Conv/dw')
input_data = tf.layers.batch_normalization(input_data, beta_initializer=tf.zeros_initializer(),
gamma_initializer=tf.ones_initializer(),
moving_mean_initializer=tf.zeros_initializer(),
moving_variance_initializer=tf.ones_initializer(), training=self.trainable,
name='dw/bn')
route = tf.nn.leaky_relu(input_data,0.1)
weight = tf.get_variable(name='weight', dtype=tf.float32, trainable=True,
shape=(1, 1, 256, 512), initializer=tf.random_normal_initializer(stddev=0.01))
input_data = tf.nn.conv2d(input=route, filter=weight, strides=[1, 1, 1, 1], padding="SAME",name="conv/s1")
input_data = tf.layers.batch_normalization(input_data, beta_initializer=tf.zeros_initializer(),
gamma_initializer=tf.ones_initializer(),
moving_mean_initializer=tf.zeros_initializer(),
moving_variance_initializer=tf.ones_initializer(),
training=self.trainable,
name='pt/bn')
input_data = tf.nn.leaky_relu(input_data,0.1)
for i in range(5):
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 512, 1), output_channel=512,
strides=(1, 1, 1, 1), name="spearable_%d" % (i+ 7))
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 512, 1), output_channel=1024,
strides=(1, 2, 2, 1), name="spearable_12")
input_data = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 1024, 1), output_channel=1024,
strides=(1, 1, 1, 1), name="spearable_13")
'''
# mobilenet backbone end
# yolo tiny backbone
input_data = common.convolutional(input_data, (3, 3, 3, 16),
self.trainable, 'conv0')
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 16, 32),
self.trainable, 'conv1')
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 32, 64),
self.trainable, 'conv2')
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 64, 128),
self.trainable, 'conv3')
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 128, 256),
self.trainable, 'conv4')
route = input_data
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 256, 512),
self.trainable, 'conv5')
input_data = tf.nn.max_pool(input_data,
ksize=[1, 2, 2, 1],
strides=[1, 1, 1, 1],
padding='SAME')
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
self.trainable, 'conv6')
# end
# yolo detect layer
input_data = common.convolutional(input_data, (1, 1, 1024, 256),
self.trainable, 'conv7')
conv_lobj_branch = common.convolutional(input_data, (3, 3, 256, 512),
self.trainable,
'conv_lobj_branch')
conv_lbbox = common.convolutional(
conv_lobj_branch, (1, 1, 512, 3 * (self.num_class + 5)),
self.trainable,
'conv_lbbox',
activate=False,
bn=False)
input_data = common.convolutional(input_data, (1, 1, 256, 128),
self.trainable, 'conv8')
input_data = common.upsample(input_data,
name='upsample0',
method=self.upsample_method)
with tf.variable_scope('route_1'):
input_data = tf.concat([input_data, route], axis=-1)
conv_mobj_branch = common.convolutional(input_data, (3, 3, 384, 256),
self.trainable,
'conv_mobj_branch')
conv_mbbox = common.convolutional(
conv_mobj_branch, (1, 1, 256, 3 * (self.num_class + 5)),
self.trainable,
'conv_mbbox',
activate=False,
bn=False)
# yolo detect layer end
# yolo detect layer DSC
'''
input_data = self.separable_conv_block(input=input_data, dw_filter=(1, 1, 1024, 1),output_channel=256,
strides=(1,1,1,1), name="conv7")
conv_lobj_branch = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 256, 1),output_channel=512,
strides=(1,1,1,1), name="conv_lobj_branch")
conv_lbbox = self.separable_conv_block(input=conv_lobj_branch, dw_filter=(1, 1, 512, 1),output_channel=3 * (self.num_class + 5),
strides=(1,1,1,1), name="conv_lbbox")
input_data = self.separable_conv_block(input=input_data, dw_filter=(1, 1, 256, 1),output_channel=128,
strides=(1,1,1,1), name="conv8")
input_data = common.upsample(input_data, name='upsample0', method=self.upsample_method)
with tf.variable_scope('route_1'):
input_data = tf.concat([input_data, route], axis=-1)
conv_mobj_branch = self.separable_conv_block(input=input_data, dw_filter=(3, 3, 384, 1),output_channel=256,
strides=(1,1,1,1), name="conv_mobj_branch")
conv_mbbox = self.separable_conv_block(input=conv_mobj_branch, dw_filter=(1, 1, 256, 1),output_channel=3 * (self.num_class + 5),
strides=(1,1,1,1), name="conv_mbbox")
'''
return conv_lbbox, conv_mbbox
def cspdarknet53(input_data):
print(
'[INFO][core.backbone.cspdarknet53] Initializing cspdarknet53 backbone-architecture '
)
input_data = common.convolutional(input_data, (3, 3, 3, 32),
activate_type="mish")
input_data = common.convolutional(input_data, (3, 3, 32, 64),
downsample=True,
activate_type="mish")
route = input_data
route = common.convolutional(route, (1, 1, 64, 64), activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 64, 64),
activate_type="mish")
for i in range(1):
input_data = common.residual_block(input_data,
64,
32,
64,
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 64, 64),
activate_type="mish")
input_data = tf.concat([input_data, route], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 128, 64),
activate_type="mish")
input_data = common.convolutional(input_data, (3, 3, 64, 128),
downsample=True,
activate_type="mish")
route = input_data
route = common.convolutional(route, (1, 1, 128, 64), activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 128, 64),
activate_type="mish")
for i in range(2):
input_data = common.residual_block(input_data,
64,
64,
64,
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 64, 64),
activate_type="mish")
input_data = tf.concat([input_data, route], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 128, 128),
activate_type="mish")
input_data = common.convolutional(input_data, (3, 3, 128, 256),
downsample=True,
activate_type="mish")
route = input_data
route = common.convolutional(route, (1, 1, 256, 128), activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 256, 128),
activate_type="mish")
for i in range(8):
input_data = common.residual_block(input_data,
128,
128,
128,
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 128, 128),
activate_type="mish")
input_data = tf.concat([input_data, route], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 256, 256),
activate_type="mish")
route_1 = input_data
input_data = common.convolutional(input_data, (3, 3, 256, 512),
downsample=True,
activate_type="mish")
route = input_data
route = common.convolutional(route, (1, 1, 512, 256), activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 512, 256),
activate_type="mish")
for i in range(8):
input_data = common.residual_block(input_data,
256,
256,
256,
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 256, 256),
activate_type="mish")
input_data = tf.concat([input_data, route], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 512, 512),
activate_type="mish")
route_2 = input_data
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
downsample=True,
activate_type="mish")
route = input_data
route = common.convolutional(route, (1, 1, 1024, 512),
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 1024, 512),
activate_type="mish")
for i in range(4):
input_data = common.residual_block(input_data,
512,
512,
512,
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 512, 512),
activate_type="mish")
input_data = tf.concat([input_data, route], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 1024, 1024),
activate_type="mish")
input_data = common.convolutional(input_data, (1, 1, 1024, 512))
input_data = common.convolutional(input_data, (3, 3, 512, 1024))
input_data = common.convolutional(input_data, (1, 1, 1024, 512))
input_data = tf.concat([
tf.nn.max_pool(input_data, ksize=13, padding='SAME', strides=1),
tf.nn.max_pool(input_data, ksize=9, padding='SAME', strides=1),
tf.nn.max_pool(input_data, ksize=5, padding='SAME', strides=1),
input_data
],
axis=-1)
input_data = common.convolutional(input_data, (1, 1, 2048, 512))
input_data = common.convolutional(input_data, (3, 3, 512, 1024))
input_data = common.convolutional(input_data, (1, 1, 1024, 512))
print(
'[INFO][core.backbone.cspdarknet53] cspdarknet53 backbone-architecture initialized'
)
return route_1, route_2, input_data
def __build_nework(self, input_data):
route_1, route_2, input_data = backbone.darknet53(
input_data, self.trainable)
conv_lobj_branch = common.EP(input_data,
189,
462,
name='EP5',
stride=1)
conv_lbbox = common.convolutional(
conv_lobj_branch, (1, 1, 462, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_lbbox',
activate=False,
bn=False)
input_data = common.convolutional(input_data, (1, 1, 189, 105),
self.trainable, 'conv5')
input_data = common.upsample(input_data,
name='upsample0',
method=self.upsample_method)
input_data = tf.concat([input_data, route_2], axis=-1)
input_data = common.PEP(input_data,
430,
325,
113,
name='PEP17',
stride=1)
input_data = common.PEP(input_data,
325,
207,
99,
name='PEP18',
stride=1)
input_data = common.convolutional(input_data, (1, 1, 207, 98),
self.trainable, 'conv6')
conv_mobj_branch = common.EP(input_data, 98, 183, name='EP6', stride=1)
conv_mbbox = common.convolutional(
conv_mobj_branch, (1, 1, 183, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_mbbox',
activate=False,
bn=False)
input_data = common.convolutional(input_data, (1, 1, 98, 47),
self.trainable, 'conv7')
input_data = common.upsample(input_data,
name='upsample1',
method=self.upsample_method)
input_data = tf.concat([input_data, route_1], axis=-1)
input_data = common.PEP(input_data,
197,
122,
58,
name='PEP19',
stride=1)
input_data = common.PEP(input_data,
122,
87,
52,
name='PEP20',
stride=1)
conv_sobj_branch = common.PEP(input_data,
87,
93,
47,
name='PEP21',
stride=1)
conv_sbbox = common.convolutional(conv_sobj_branch,
(1, 1, 93, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_sbbox',
activate=False,
bn=False)
return conv_lbbox, conv_mbbox, conv_sbbox
def darknet53(input_data):
"""
build the darknet 53
:param input_data: [416,416,3]
:return: 3 feature maps [52,52,256], [26,26,512], [13,13,1024]
"""
input_data = common.convolutional(
input_data, (3, 3, 3, 32),
conv_trainable=False) # 32 filters [3,3,3], output [416,416,32]
input_data = common.convolutional(
input_data, (3, 3, 32, 64), downsample=True,
conv_trainable=False) # 64 filters [3,3,3], output [208, 208, 64]
for i in range(1):
input_data = common.residual_block(input_data,
64,
32,
64,
conv_trainable=False)
input_data = common.convolutional(input_data, (3, 3, 64, 128),
downsample=True,
conv_trainable=False)
for i in range(2):
input_data = common.residual_block(input_data,
128,
64,
128,
conv_trainable=False)
input_data = common.convolutional(input_data, (3, 3, 128, 256),
downsample=True,
conv_trainable=False)
for i in range(8):
input_data = common.residual_block(input_data,
256,
128,
256,
conv_trainable=False)
route_1 = input_data
input_data = common.convolutional(input_data, (3, 3, 256, 512),
downsample=True,
conv_trainable=False)
for i in range(8):
input_data = common.residual_block(input_data,
512,
256,
512,
conv_trainable=False)
route_2 = input_data
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
downsample=True,
conv_trainable=False)
for i in range(4):
input_data = common.residual_block(input_data,
1024,
512,
1024,
conv_trainable=False)
return route_1, route_2, input_data # [52,52,256], [26,26,512], [13,13,1024]
def __build_nework(self, input_data):
route_1, route_2, input_data = backbone.darknet53(
input_data, self.trainable)
input_data = common.convolutional(input_data, (1, 1, 1024, 512),
self.trainable, 'conv52')
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
self.trainable, 'conv53')
input_data = common.convolutional(input_data, (1, 1, 1024, 512),
self.trainable, 'conv54')
input_data = common.convolutional(input_data, (3, 3, 512, 1024),
self.trainable, 'conv55')
input_data = common.convolutional(input_data, (1, 1, 1024, 512),
self.trainable, 'conv56')
conv_lobj_branch = common.convolutional(input_data, (3, 3, 512, 1024),
self.trainable,
name='conv_lobj_branch')
conv_lbbox = common.convolutional(
conv_lobj_branch, (1, 1, 1024, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_lbbox',
activate=False,
bn=False)
input_data = common.convolutional(input_data, (1, 1, 512, 256),
self.trainable, 'conv57')
input_data = common.upsample(input_data,
name='upsample0',
method=self.upsample_method)
with tf.variable_scope('route_1'):
input_data = tf.concat([input_data, route_2], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 768, 256),
self.trainable, 'conv58')
input_data = common.convolutional(input_data, (3, 3, 256, 512),
self.trainable, 'conv59')
input_data = common.convolutional(input_data, (1, 1, 512, 256),
self.trainable, 'conv60')
input_data = common.convolutional(input_data, (3, 3, 256, 512),
self.trainable, 'conv61')
input_data = common.convolutional(input_data, (1, 1, 512, 256),
self.trainable, 'conv62')
conv_mobj_branch = common.convolutional(input_data, (3, 3, 256, 512),
self.trainable,
name='conv_mobj_branch')
conv_mbbox = common.convolutional(
conv_mobj_branch, (1, 1, 512, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_mbbox',
activate=False,
bn=False)
input_data = common.convolutional(input_data, (1, 1, 256, 128),
self.trainable, 'conv63')
input_data = common.upsample(input_data,
name='upsample1',
method=self.upsample_method)
with tf.variable_scope('route_2'):
input_data = tf.concat([input_data, route_1], axis=-1)
input_data = common.convolutional(input_data, (1, 1, 384, 128),
self.trainable, 'conv64')
input_data = common.convolutional(input_data, (3, 3, 128, 256),
self.trainable, 'conv65')
input_data = common.convolutional(input_data, (1, 1, 256, 128),
self.trainable, 'conv66')
input_data = common.convolutional(input_data, (3, 3, 128, 256),
self.trainable, 'conv67')
input_data = common.convolutional(input_data, (1, 1, 256, 128),
self.trainable, 'conv68')
conv_sobj_branch = common.convolutional(input_data, (3, 3, 128, 256),
self.trainable,
name='conv_sobj_branch')
conv_sbbox = common.convolutional(
conv_sobj_branch, (1, 1, 256, 3 * (self.num_class + 5)),
trainable=self.trainable,
name='conv_sbbox',
activate=False,
bn=False)
return conv_lbbox, conv_mbbox, conv_sbbox
