High-level Semantic Feature Detection A New Perspective for Pedestrian Detection

Posted on Edited on In Views:
CVPR-19 High-level Semantic Feature Detection A New Perspective for Pedestrian Detection

Paper Link

Code

简介

CSP: Center and Scale Prediction

CVPR19_CSP_pipeline
20190529_CVPR19_CSP_architecture
20190529_CVPR19_CSP_annotations

方法

实验

20190529_CVPR19_CSP_points
20190529_CVPR19_CSP_scale
20190529_CVPR19_CSP_downsampling_factors
20190529_CVPR19_CSP_multi_scale
20190529_CVPR19_CSP_Caltech_new
20190529_CVPR19_CSP_CityPersons

代码

准备ground truth

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def calc_gt_center(C, img_data,r=2, down=4,scale='h',offset=True):
	def gaussian(kernel):
		sigma = ((kernel-1) * 0.5 - 1) * 0.3 + 0.8
		s = 2*(sigma**2)
		dx = np.exp(-np.square(np.arange(kernel) - int(kernel / 2)) / s)
		return np.reshape(dx,(-1,1))
	gts = np.copy(img_data['bboxes'])
	igs = np.copy(img_data['ignoreareas'])
	scale_map = np.zeros((int(C.size_train[0]/down), int(C.size_train[1]/down), 2))
	if scale=='hw':
		scale_map = np.zeros((int(C.size_train[0] / down), int(C.size_train[1] / down), 3))
	if offset:
		offset_map = np.zeros((int(C.size_train[0] / down), int(C.size_train[1] / down), 3))
	seman_map = np.zeros((int(C.size_train[0]/down), int(C.size_train[1]/down), 3))
	seman_map[:,:,1] = 1
	if len(igs) > 0:
		igs = igs/down
		for ind in range(len(igs)):
			x1,y1,x2,y2 = int(igs[ind,0]), int(igs[ind,1]), int(np.ceil(igs[ind,2])), int(np.ceil(igs[ind,3]))
			seman_map[y1:y2, x1:x2,1] = 0  # 被忽视的区域在第１个通道上置０
	if len(gts)>0:
		gts = gts/down
		for ind in range(len(gts)):
			# x1, y1, x2, y2 = int(round(gts[ind, 0])), int(round(gts[ind, 1])), int(round(gts[ind, 2])), int(round(gts[ind, 3]))
			x1, y1, x2, y2 = int(np.ceil(gts[ind, 0])), int(np.ceil(gts[ind, 1])), int(gts[ind, 2]), int(gts[ind, 3])
			c_x, c_y = int((gts[ind, 0] + gts[ind, 2]) / 2), int((gts[ind, 1] + gts[ind, 3]) / 2)
			dx = gaussian(x2-x1)
			dy = gaussian(y2-y1)
			gau_map = np.multiply(dy, np.transpose(dx))
			seman_map[y1:y2, x1:x2,0] = np.maximum(seman_map[y1:y2, x1:x2,0], gau_map)  # 在第０个通道上置高斯值
			seman_map[y1:y2, x1:x2,1] = 1  # 前景在第１个通道上置１
			seman_map[c_y, c_x, 2] = 1  # 在第２个通道上目标中心位置１

			if scale == 'h':
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 0] = np.log(gts[ind, 3] - gts[ind, 1])
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 1] = 1
			elif scale=='w':
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 0] = np.log(gts[ind, 2] - gts[ind, 0])
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 1] = 1
			elif scale=='hw':
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 0] = np.log(gts[ind, 3] - gts[ind, 1])
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 1] = np.log(gts[ind, 2] - gts[ind, 0])
				scale_map[c_y-r:c_y+r+1, c_x-r:c_x+r+1, 2] = 1
			if offset:
				offset_map[c_y, c_x, 0] = (gts[ind, 1] + gts[ind, 3]) / 2 - c_y - 0.5
				offset_map[c_y, c_x, 1] = (gts[ind, 0] + gts[ind, 2]) / 2 - c_x - 0.5
				offset_map[c_y, c_x, 2] = 1

	if offset:
		return seman_map,scale_map,offset_map
	else:
		return seman_map, scale_map

seman_map有三个位面，第一个是高斯值mask，第二个是学习权重，第三个是目标中心点的位置。

20190529_CVPR19_CSP_seman_map0
20190529_CVPR19_CSP_seman_map2
20190529_CVPR19_CSP_scale_map0

网络结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def nn_p3p4p5(img_input=None, offset=True, num_scale=1, trainable=False):
    bn_axis = 3
    x = ZeroPadding2D((3, 3))(img_input)
    x = Convolution2D(64, (7, 7), strides=(2, 2), name='conv1', trainable=False)(x)
    x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
    x = Activation('relu')(x)
    x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
    x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1), trainable=False)
    x = identity_block(x, 3, [64, 64, 256], stage=2, block='b', trainable=False)
    stage2 = identity_block(x, 3, [64, 64, 256], stage=2, block='c', trainable=False)
    # print('stage2: ', stage2._keras_shape[1:])
    x = conv_block(stage2, 3, [128, 128, 512], stage=3, block='a', trainable=trainable)
    x = identity_block(x, 3, [128, 128, 512], stage=3, block='b', trainable=trainable)
    x = identity_block(x, 3, [128, 128, 512], stage=3, block='c', trainable=trainable)
    stage3 = identity_block(x, 3, [128, 128, 512], stage=3, block='d', trainable=trainable)
    # print('stage3: ', stage3._keras_shape[1:])
    x = conv_block(stage3, 3, [256, 256, 1024], stage=4, block='a', trainable=trainable)
    x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b', trainable=trainable)
    x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c', trainable=trainable)
    x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d', trainable=trainable)
    x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e', trainable=trainable)
    stage4 = identity_block(x, 3, [256, 256, 1024], stage=4, block='f', trainable=trainable)
    # print('stage4: ', stage4._keras_shape[1:])
    x = conv_block(stage4, 3, [512, 512, 2048], stage=5, block='a', strides=(1, 1), dila=(2, 2),
                   trainable=trainable)
    x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b', dila=(2, 2), trainable=trainable)
    stage5 = identity_block(x, 3, [512, 512, 2048], stage=5, block='c', dila=(2, 2), trainable=trainable)
    # print('stage5: ', stage5._keras_shape[1:])

    P3_up = Deconvolution2D(256, kernel_size=4, strides=2, padding='same',
                            kernel_initializer='glorot_normal', name='P3up', trainable=trainable)(stage3)
    # print('P3_up: ', P3_up._keras_shape[1:])
    P4_up = Deconvolution2D(256, kernel_size=4, strides=4, padding='same',
                            kernel_initializer='glorot_normal', name='P4up', trainable=trainable)(stage4)
    # print('P4_up: ', P4_up._keras_shape[1:])
    P5_up = Deconvolution2D(256, kernel_size=4, strides=4, padding='same',
                            kernel_initializer='glorot_normal', name='P5up', trainable=trainable)(stage5)
    # print('P5_up: ', P5_up._keras_shape[1:])

    P3_up = L2Normalization(gamma_init=10, name='P3norm')(P3_up)
    P4_up = L2Normalization(gamma_init=10, name='P4norm')(P4_up)
    P5_up = L2Normalization(gamma_init=10, name='P5norm')(P5_up)
    conc = Concatenate(axis=-1)([P3_up, P4_up, P5_up])

    feat = Convolution2D(256, (3, 3), padding='same', kernel_initializer='glorot_normal', name='feat',
                         trainable=trainable)(conc)
    feat = BatchNormalization(axis=bn_axis, name='bn_feat')(feat)
    feat = Activation('relu')(feat)

    x_class = Convolution2D(1, (1, 1), activation='sigmoid',
                            kernel_initializer='glorot_normal',
                            bias_initializer=prior_probability_onecls(probability=0.01),
                            name='center_cls', trainable=trainable)(feat)
    x_regr = Convolution2D(num_scale, (1, 1), activation='linear', kernel_initializer='glorot_normal',
                           name='height_regr', trainable=trainable)(feat)

    if offset:
        x_offset = Convolution2D(2, (1, 1), activation='linear', kernel_initializer='glorot_normal',
                                 name='offset_regr', trainable=trainable)(feat)
        return [x_class, x_regr, x_offset]
    else:
        return [x_class, x_regr]

Loss

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def cls_center(y_true, y_pred):

	classification_loss = K.binary_crossentropy(y_pred[:, :, :, 0], y_true[:, :, :, 2])
	# firstly we compute the focal weight
	positives = y_true[:, :, :, 2]
	negatives = y_true[:, :, :, 1]-y_true[:, :, :, 2]
	foreground_weight = positives * (1.0 - y_pred[:, :, :, 0]) ** 2.0
	background_weight = negatives * ((1.0 - y_true[:, :, :, 0])**4.0)*(y_pred[:, :, :, 0] ** 2.0)

	focal_weight = foreground_weight + background_weight

	assigned_boxes = tf.reduce_sum(y_true[:, :, :, 2])
	class_loss = 0.01*tf.reduce_sum(focal_weight*classification_loss) / tf.maximum(1.0, assigned_boxes)
 assigned_boxes)

	return class_loss