def res_block(inputs, filters, prune_factor):
shortcut = inputs
net = conv2d(inputs, np.floor(filters * prune_factor), 1)
net = conv2d(net, np.floor(filters * 2 * prune_factor), 3)
net = net + shortcut
return net
def res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters // 2, 1)
net = conv2d(net, filters * 2 // 2, 3)
net = net + shortcut
return net
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_initializer=tf.contrib.layers.
variance_scaling_initializer(dtype=tf.float32)
# weights_regularizer=slim.l2_regularizer(self.weight_decay)
):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(
inter1,
route_2.get_shape().as_list()
if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(
inter2,
route_1.get_shape().as_list()
if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3, (3 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return [feature_map_3]
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1)):
with tf.variable_scope('darknet19_body'):
route_1, _, route_2, _ = darknet19_body(inputs)
with tf.variable_scope('yolov3_tiny_head'):
inter1, net = yolo_tiny_block(route_2, 256)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 128, 1, strides=1)
inter1 = upsample_layer(inter1,
route_1.get_shape().as_list())
concat1 = tf.concat([inter1, route_1], axis=3)
net = conv2d(concat1, 256, 3, strides=1)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
return feature_map_1, feature_map_2
def res_block(inputs, filters, prune_factor, prune_cnt):
true_filters_1 = filters
true_filters_2 = filters * 2
for i in range(prune_cnt):
true_filters_1 = np.floor(true_filters_1 * prune_factor)
# true_filters_2 = np.floor(true_filters_2 * prune_factor)
shortcut = inputs
net = conv2d(inputs, true_filters_1, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope([slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.relu6(x)):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
downsample_1 = conv2d(route_1, 128, 3, strides=2)
concat1 = tf.concat([downsample_1, route_2], axis=3)
downsample_2 = conv2d(concat1, 128, 3, strides=2)
concat2 = tf.concat([downsample_2, route_3], axis=3)
out_1 = conv2d(concat2, 128, 3, strides=2)
out_2 = conv2d(out_1, 128, 3, strides=1)
out_3 = conv2d(out_2, 128, 3, strides=1)
out_4 = tf.layers.flatten(out_3)
out_5 = tf.layers.dense(
out_4,
128,
activation=lambda x: tf.nn.relu6(x),
kernel_initializer=tf.contrib.layers.
xavier_initializer(),
bias_initializer=tf.zeros_initializer(),
use_bias=True)
logits_output = tf.layers.dense(
out_5,
self.class_num,
kernel_initializer=tf.contrib.layers.
xavier_initializer(),
bias_initializer=tf.zeros_initializer(),
use_bias=False)
return logits_output, out_5
def forward_head(self, route_1, route_2, route_3, is_training=False):
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_regularizer=slim.l2_regularizer(self.weight_decay)):
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(net, 3 * (5 + self.class_num), 1,
stride=1, normalizer_fn=None,
activation_fn=None, biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1, name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1, route_2.get_shape().as_list() if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(net, 3 * (5 + self.class_num), 1,
stride=1, normalizer_fn=None,
activation_fn=None, biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2, name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2, route_1.get_shape().as_list() if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(feature_map_3, 3 * (5 + self.class_num), 1,
stride=1, normalizer_fn=None,
activation_fn=None, biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3, name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def parse_include_res_darknet53_body(inputs):
def res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters // 2, 1)
net = conv2d(net, filters * 2 // 2, 3)
net = net + shortcut
return net
def darknet_last_res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
# first two conv2d layers
net = conv2d(inputs, 32 // 2, 3, strides=1)
net = conv2d(net, 64 // 2, 3, strides=2)
# res_block * 1
net = res_block(net, 32)
net = conv2d(net, 128 // 2, 3, strides=2)
# res_block * 2
for i in range(2):
net = res_block(net, 64)
net = conv2d(net, 256 // 2, 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 128)
route_1 = net
net = conv2d(net, 512 // 2, 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 256)
route_2 = net
net = conv2d(net, 1024 // 2, 3, strides=2)
# res_block * 4
for i in range(4):
net = res_block(net, 512)
net = darknet_last_res_block(net, 512)
net = conv2d(net, 1024, 1)
route_3 = net
return route_1, route_2, route_3
def parse_include_res_darknet53_body_prune_factor(inputs, prune_factor):
import numpy as np
def res_block(inputs, filters, prune_factor):
shortcut = inputs
net = conv2d(inputs, np.floor(filters * prune_factor), 1)
net = conv2d(net, np.floor(filters * 2 * prune_factor), 3)
net = net + shortcut
return net
def darknet_last_res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
# first two conv2d layers
net = conv2d(inputs, np.floor(32 * prune_factor), 3, strides=1)
net = conv2d(net, np.floor(64 * prune_factor), 3, strides=2)
# res_block * 1
net = res_block(net, 32, prune_factor)
net = conv2d(net, np.floor(128 * prune_factor), 3, strides=2)
# res_block * 2
for i in range(2):
net = res_block(net, 64, prune_factor)
net = conv2d(net, np.floor(256 * prune_factor), 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 128, prune_factor)
# net = res_block(net, 128, prune_factor=1)
route_1 = net
net = conv2d(net, np.floor(512 * prune_factor), 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 256, prune_factor)
# net = res_block(net, 256, prune_factor=1)
route_2 = net
net = conv2d(net, np.floor(1024 * prune_factor), 3, strides=2)
# res_block * 4
for i in range(4):
net = res_block(net, 512, prune_factor)
# net = darknet_last_res_block(net, 512)
# net = conv2d(net, 1024, 1)
route_3 = net
return route_1, route_2, route_3
def parse_include_res_darknet53_body_prune_factor(inputs,
prune_factor,
prune_cnt=1):
import numpy as np
def res_block(inputs, filters, prune_factor, prune_cnt):
true_filters_1 = filters
true_filters_2 = filters * 2
for i in range(prune_cnt):
true_filters_1 = np.floor(true_filters_1 * prune_factor)
# true_filters_2 = np.floor(true_filters_2 * prune_factor)
shortcut = inputs
net = conv2d(inputs, true_filters_1, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
# first two conv2d layers
true_filters_conv0 = 32
for i in range(prune_cnt):
true_filters_conv0 = np.floor(true_filters_conv0 * prune_factor)
net = conv2d(inputs, true_filters_conv0, 3, strides=1)
net = conv2d(net, 64, 3, strides=2)
# res_block * 1
net = res_block(net, 32, prune_factor, prune_cnt=prune_cnt)
net = conv2d(net, 128, 3, strides=2)
# res_block * 2
for i in range(2):
net = res_block(net, 64, prune_factor, prune_cnt=prune_cnt)
net = conv2d(net, 256, 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 128, prune_factor, prune_cnt=prune_cnt)
route_1 = net
net = conv2d(net, 512, 3, strides=2)
# res_block * 8
for i in range(8):
net = res_block(net, 256, prune_factor, prune_cnt=prune_cnt)
route_2 = net
net = conv2d(net, 1024, 3, strides=2)
# res_block * 4
for i in range(4):
net = res_block(net, 512, prune_factor, prune_cnt=prune_cnt)
route_3 = net
return route_1, route_2, route_3
def darknet53_body_shortcut(inputs, shortcut_list):
def res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters * 1, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
# first two conv2d layers
net = conv2d(inputs, 32, 3, strides=1)
net = conv2d(net, 64, 3, strides=2)
# res_block * 1
for i in range(shortcut_list[0]):
net = res_block(net, 32)
net = conv2d(net, 128, 3, strides=2)
# res_block * 2
for i in range(shortcut_list[1]):
net = res_block(net, 64)
net = conv2d(net, 256, 3, strides=2)
# res_block * 8
for i in range(shortcut_list[2]):
net = res_block(net, 128)
route_1 = net
net = conv2d(net, 512, 3, strides=2)
# res_block * 8
for i in range(shortcut_list[3]):
net = res_block(net, 256)
route_2 = net
net = conv2d(net, 1024, 3, strides=2)
# res_block * 4
for i in range(shortcut_list[4]):
net = res_block(net, 512)
# net = darknet_last_res_block(net, 512)
# net = conv2d(net, 1024, 1)
route_3 = net
return route_1, route_2, route_3
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope([slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_regularizer=slim.l2_regularizer(self.weight_decay)), \
slim.arg_scope([slim.max_pool2d], kernel_size=2, stride=2, padding="SAME"):
with tf.variable_scope("body"):
net = conv2d(inputs, 16)
net = slim.max_pool2d(net)
net = conv2d(net, 32)
net = slim.max_pool2d(net)
net = conv2d(net, 64)
net = slim.max_pool2d(net)
net = conv2d(net, 128)
net = slim.max_pool2d(net)
net = conv2d(net, 256)
route1 = net
with tf.variable_scope("head"):
net = slim.max_pool2d(net)
net = conv2d(net, 512)
net = slim.max_pool2d(net, stride=1)
net = conv2d(net, 1024)
net = conv2d(net, 256, kernel_size=1)
route2 = net
net = conv2d(net, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
route2 = conv2d(route2, 128, kernel_size=1)
route2 = upsample_layer(
route2,
route1.get_shape().as_list()
if self.use_static_shape else tf.shape(route1))
net = tf.concat([route1, route2], axis=-1)
net = conv2d(net, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
return feature_map_1, feature_map_2
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=False):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1)):
with tf.variable_scope('darknet53_body'):
# 三个输出值就是3 different scales.
# route_1:52*52*256, route_2=26*26*512, route_3=13*13*1024
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
'''实现first scale layer的predict'''
# 输出inter1是用于下一层的upsampled feature。 8*8*512*1024
inter1, net = yolo_block(route_3, 512)
# 针对输入416*416的图，输出值是13*13*255. a 3-d tensor encoding bounding box, objectness, and class predictions.
# 单个1*1的卷积将维度降到预测channel。
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
# 这一步的目的好像是在使用GPU时在不同设备间传递变量的值
# refer: https://blog.csdn.net/qq_23981335/article/details/81361748
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
'''实现second scale layer的predict'''
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1,
route_2.get_shape().as_list())
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
'''实现third scale layer的predict'''
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2,
route_1.get_shape().as_list())
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def darknet_last_res_block(inputs, filters):
shortcut = inputs
net = conv2d(inputs, filters, 1)
net = conv2d(net, filters * 2, 3)
net = net + shortcut
return net
def forward_include_res_with_prune_factor(self,
inputs,
prune_factor,
is_training=False,
reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_regularizer=slim.l2_regularizer(
self.weight_decay)):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = parse_include_res_darknet53_body_prune_factor(
inputs, prune_factor)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1, tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2, tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
# =============================================================================
# batch_norm_params = {
# 'decay': self.batch_norm_decay,
# 'epsilon': 1e-05,
# 'scale': True,
# 'is_training': is_training,
# 'fused': None, # Use fused batch norm if possible.
# }
# =============================================================================
batch_norm_params = {
'decay': 0.9997,
'epsilon': 0.001,
'updates_collections': tf.GraphKeys.UPDATE_OPS,
'fused': None, # Use fused batch norm if possible.
'scale': False,
'is_training': is_training
}
# =============================================================================
# with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
# with slim.arg_scope([slim.conv2d],
# normalizer_fn=slim.batch_norm,
# normalizer_params=batch_norm_params,
# biases_initializer=None,
# activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
# weights_regularizer=slim.l2_regularizer(self.weight_decay)):
# =============================================================================
with slim.arg_scope([slim.conv2d],
weights_regularizer=slim.l2_regularizer(0.00004),
biases_regularizer=slim.l2_regularizer(0.00004),
activation_fn=tf.nn.relu,
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params) as scope:
with tf.variable_scope('InceptionResnetV2', [inputs],
reuse=reuse) as scope:
route_1, route_2, route_3 = inception_resnet_v2_base(
inputs, scope=scope)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(
inter1,
route_2.get_shape().as_list()
if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(
inter2,
route_1.get_shape().as_list()
if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
#设置卷积和BN时的一些参数，因为前面的utils.layer_utils里面的conv2d用的slim.conv2d，所以这里设置默认参数可以生效
with slim.arg_scope([slim.conv2d, slim.batch_norm],
reuse=reuse): #允许复用
#用了BN，还带上了leaky——relu和L3正则化
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_regularizer=slim.l2_regularizer(
self.weight_decay)):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
#feature map 1 就是y1的输出，13*13*255
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
#inter1跟route2一样的shape
#axis = 3，在channel方向做concat
inter1 = upsample_layer(
inter1,
route_2.get_shape().as_list()
if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
#feature map 2是26*26*255，相当于y2
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
#inter2跟route1一样的shape
inter2 = upsample_layer(
inter2,
route_1.get_shape().as_list()
if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
#feature map 2是52*52*255，相当于y3
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'is_training': is_training,
'center': True,
'scale': True,
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'updates_collections': tf.GraphKeys.UPDATE_OPS
#'fused': None, # Use fused batch norm if possible.
}
# hyperparams to use
activation_fn = tf.nn.relu6
normalizer_fn = tf.contrib.slim.batch_norm
normalizer_params = {
'is_training': True,
'center': True,
'scale': True,
'decay': 0.9997,
'epsilon': 0.001,
'updates_collections': tf.GraphKeys.UPDATE_OPS
}
weights_initializer = tf.truncated_normal_initializer(stddev=0.09)
weights_regularizer = tf.contrib.layers.l2_regularizer(0.00004)
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope([slim.conv2d],
activation_fn=activation_fn,
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params,
weights_initializer=weights_initializer,
weights_regularizer=weights_regularizer,
):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(net,
3 * (5 + self.class_num),
1,
stride=1,
activation_fn=activation_fn,
normalizer_fn=normalizer_fn,
normalizer_params=normalizer_params,
weights_initializer=weights_initializer,
weights_regularizer=weights_regularizer,
scope='feature_map_00')
feature_map_1 = tf.identity(feature_map_1, name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1, route_2.get_shape().as_list() if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(net, 3 * (5 + self.class_num), 1,
stride=1, normalizer_fn=None,
activation_fn=activation_fn, biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2, name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2, route_1.get_shape().as_list() if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(feature_map_3, 3 * (5 + self.class_num), 1,
stride=1, normalizer_fn=None,
activation_fn=None, biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3, name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]图像大小为 【高，宽】
# it will be used later
#inputs[m,height,weight,3],img_size[height,weight]
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
#归一化参数
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
#设置卷积、批次归一化默认参数
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1)):
with tf.variable_scope('darknet53_body'):
#darknet53网络框架
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
#顶层特征图13*13*
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(
inter1,
route_2.get_shape().as_list()
if self.use_static_shape else tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(
inter2,
route_1.get_shape().as_list()
if self.use_static_shape else tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
"""
得到的feature_map就是映射到原图像的网格的尺寸
:param inputs:
:param is_training:
:param reuse:
:return:
"""
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3] #[416,416]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1)):
#参数是x 函数里面的内容是 ：后面
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
# (-1, 52, 52, 256) (-1, 26, 26, 512) (-1, 13, 13, 1024)
with tf.variable_scope('yolov3_head'):
#返回(-1, 13, 13, 512) (-1, 13, 13, 1024)
#里面做了5个 和6个DBL inter1 5个DBL的输出 net 是6个
inter1, net = yolo_block(route_3, 512)
#-------------------------------------------------------------------------------------
#第一个尺度预测的输出，这里要把normalizer_fn，activation_fn设置为None
#输入(-1, 13, 13, 1024) 输出 (-1，13，13，255) 3 * (5 + self.class_num)=255
#3 * (5 + self.class_num)的意思是 一个像素点预测三个框，一个框有5个值 需要预测几个类别
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
#-------------------------------------------------------------------------------------
#第二个尺度的预测输出代码
#inter1输入 (-1, 13, 13, 512)==>256
inter1 = conv2d(inter1, 256, 1)
#将route_3那条路线输出的图片进行 上采样 使与 route_2尺寸相同 深度不变
inter1 = upsample_layer(inter1,
route_2.get_shape().as_list())
#route_2 = (-1, 26, 26, 512) (-1, 26, 26, 256) ==> (-1, 26, 26, 768)
concat1 = tf.concat([inter1, route_2], axis=3)
# 里面做了5个 和6个DBL inter2 5个DBL的输出 net 是6个
inter2, net = yolo_block(concat1, 256)
#-------------------------------------------------------------------------------------
#第二个尺度预测的输出，这里要把normalizer_fn，activation_fn设置为None
#输出(-1, 26, 26, 255)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
#-------------------------------------------------------------------------------------
#第三个尺度
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2,
route_1.get_shape().as_list())
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
#输出尺寸(-1, 52, 52, 256)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
#-------------------------------------------------------------------------------------
return feature_map_1, feature_map_2, feature_map_3
def forward(self, inputs, is_training=False, reuse=False):
self.img_size = tf.shape(inputs)[1:3] # input大小:[1,416,416,3]
# 设置 batch norm 参数
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope([slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: leaky_relu(x, 0.1)):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1,
route_2.get_shape().as_list())
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2,
route_1.get_shape().as_list())
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
def forward_get_result(self, inputs, is_training=False, reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope(
[slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.leaky_relu(x, alpha=0.1),
weights_regularizer=slim.l2_regularizer(
self.weight_decay)):
with tf.variable_scope('darknet53_body'):
route_1, route_2, route_3 = darknet53_body(inputs)
with tf.variable_scope('yolov3_head'):
inter1, net = yolo_block_spp(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1, tf.shape(route_2))
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block_spp(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2, tf.shape(route_1))
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block_spp(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
'''
predict layer and nms
'''
boxes, scores, labels = self.post_process(
(feature_map_1, feature_map_2, feature_map_3))
# pred_boxes, pred_confs, pred_probs = self.predict((feature_map_1, feature_map_2, feature_map_3))
# pred_scores = pred_confs * pred_probs
# boxes, scores, labels = gpu_nms(pred_boxes, pred_scores, self.class_num, max_boxes=30,
# score_thresh=0.4, nms_thresh=0.5)
boxes = tf.identity(boxes, name='detect_bbox')
scores = tf.identity(scores, name="detect_scores")
labels = tf.identity(labels, name="detect_labels")
return boxes, scores, labels
def forward(self,
inputs,
is_training=False,
train_with_gray=True,
reuse=False):
# the input img_size, form: [height, weight]
# it will be used later
self.img_size = tf.shape(inputs)[1:3]
# set batch norm params
batch_norm_params = {
'decay': self.batch_norm_decay,
'epsilon': 1e-05,
'scale': True,
'is_training': is_training,
'fused': None, # Use fused batch norm if possible.
}
with slim.arg_scope([slim.conv2d, slim.batch_norm], reuse=reuse):
with slim.arg_scope([slim.conv2d],
normalizer_fn=slim.batch_norm,
normalizer_params=batch_norm_params,
biases_initializer=None,
activation_fn=lambda x: tf.nn.relu6(x)):
with tf.variable_scope('darknet53_body'):
# 转为灰度图
if train_with_gray:
inputs = inputs * self.rgb_factor
inputs = tf.reduce_sum(inputs, axis=-1)
inputs = tf.expand_dims(inputs, -1)
inputs = tf.tile(inputs, [1, 1, 1, 3])
if self.backbone_name == "darknet53":
routes = darknet53_body(
inputs, self.train_with_two_feature_map)
elif self.backbone_name == "darknet53_prun":
routes = darknet53_body_prun(
inputs, self.train_with_two_feature_map)
elif self.backbone_name == "mobilenetv2":
routes = mobilenetv2(inputs,
self.train_with_two_feature_map,
is_training)
elif self.backbone_name == "mobilenetv3":
routes = mobilenetv3(inputs,
self.train_with_two_feature_map,
is_training)
elif self.backbone_name == "mobilenetv3_add_zoom_factor":
routes = mobilenetv3_add_zoom_factor(
inputs, self.train_with_two_feature_map,
is_training)
else:
print(
"backbone name is not right, it is mast in [darknet53, darknet53_prun, mobilenetv2, mobilenetv3, mobilenetv3_add_zoom_factor]"
)
sys.exit()
with tf.variable_scope('yolov3_head'):
if not self.train_with_two_feature_map:
route_1, route_2, route_3 = routes
inter1, net = yolo_block(route_3, 512)
feature_map_1 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_1 = tf.identity(feature_map_1,
name='feature_map_1')
inter1 = conv2d(inter1, 256, 1)
inter1 = upsample_layer(inter1,
route_2.get_shape().as_list())
#
# inter1 = slim.conv2d(inter1, inter1.get_shape().as_list()[3], 3,
# stride=1, biases_initializer=tf.zeros_initializer())
concat1 = tf.concat([inter1, route_2], axis=3)
inter2, net = yolo_block(concat1, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2,
route_1.get_shape().as_list())
# inter2 = slim.conv2d(inter2, inter2.get_shape().as_list()[3], 3,
# stride=1, biases_initializer=tf.zeros_initializer())
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_1, feature_map_2, feature_map_3
else:
route_1, route_2 = routes
inter2, net = yolo_block(route_2, 256)
feature_map_2 = slim.conv2d(
net,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_2 = tf.identity(feature_map_2,
name='feature_map_2')
inter2 = conv2d(inter2, 128, 1)
inter2 = upsample_layer(inter2,
route_1.get_shape().as_list())
# inter2 = slim.conv2d(inter2, inter2.get_shape().as_list()[3], 3,
# stride=1, biases_initializer=tf.zeros_initializer())
concat2 = tf.concat([inter2, route_1], axis=3)
_, feature_map_3 = yolo_block(concat2, 128)
feature_map_3 = slim.conv2d(
feature_map_3,
3 * (5 + self.class_num),
1,
stride=1,
normalizer_fn=None,
activation_fn=None,
biases_initializer=tf.zeros_initializer())
feature_map_3 = tf.identity(feature_map_3,
name='feature_map_3')
return feature_map_2, feature_map_3
