# 基于Objects as Points的尝试（二）

https://zhuanlan.zhihu.com/p/76378871

## 前言

https://github.com/xggIoU/centernet_tensorflow_wilderface_voc

## 正文

### 实验环境

```1.anaconda3、pycharm-community、python3.6、numpy1.14.3
2.tensorflow1.13.1、slim
3.cuda10.0、cudnn7.6.0
4.opencv-python4.1
5.GTX1080ti*1```

### 数据集

• wilderface人脸检测数据集，包含12876张训练集；
• pascal voc2012目标检测数据集，包含17125张训练集，分20个类别。

### 回顾

(2)yolov3_centernet+voc，我的实验中难以收敛。

### 尝试四

```def gaussian_radius(det_size, min_overlap=0.7)：
width,height  = det_size
a1 = 1
b1 = (height + width)
c1 = width * height * (1 - min_overlap) / (1 + min_overlap)
sq1 = np.sqrt(b1 ** 2 - 4 * a1 * c1)
r1 = (b1 + sq1) / 2

a2 = 4
b2 = 2 * (height + width)
c2 = (1 - min_overlap) * width * height
sq2 = np.sqrt(b2 ** 2 - 4 * a2 * c2)
r2 = (b2 + sq2) / 2

a3 = 4 * min_overlap
b3 = -2 * min_overlap * (height + width)
c3 = (min_overlap - 1) * width * height
sq3 = np.sqrt(b3 ** 2 - 4 * a3 * c3)
r3 = (b3 + sq3) / 2
return min(r1, r2, r3)
def draw_msra_gaussian(heatmap, center, sigma)：
tmp_size = sigma * 3
mu_x = int(center[0])
mu_y = int(center[1])
h, w = heatmap.shape[0], heatmap.shape[1]
ul = [int(mu_x - tmp_size), int(mu_y - tmp_size)]
br = [int(mu_x + tmp_size + 1), int(mu_y + tmp_size + 1)]
if ul[0] >= w or ul[1] >= h or br[0] < 0 or br[1] < 0:
return heatmap
size = 2 * tmp_size + 1
x = np.arange(0, size, 1, np.float32)
y = x[:, np.newaxis]
x0 = y0 = size // 2
g = np.exp(- ((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))
g_x = max(0, -ul[0]), min(br[0], w) - ul[0]
g_y = max(0, -ul[1]), min(br[1], h) - ul[1]
img_x = max(0, ul[0]), min(br[0], w)
img_y = max(0, ul[1]), min(br[1], h)
heatmap[img_y[0]:img_y[1], img_x[0]:img_x[1]] = np.maximum(
heatmap[img_y[0]:img_y[1], img_x[0]:img_x[1]],
g[g_y[0]:g_y[1], g_x[0]:g_x[1]])
return heatmap```

• (b)计算的坐标范围是整个feature map。

• (b)计算的坐标范围应该限于目标box内。

*(1)在图5.1中目标的bbox外存在非0值，而图5.2中bbox外都是0；

*(2)图5.1中heatmap不随着目标形状变化而变化，对于不同外形的目标都是一个圆形heatmap，而图5.2中的构造方式就不存在这种问题；

```def focal_loss(pred, gt):
pos_inds = tf.cast(tf.equal(gt,1.0),dtype=tf.float32)
neg_inds = 1.0-pos_inds
# neg_inds=tf.cast(tf.greater(gt,0.0),dtype=tf.float32)-pos_inds
neg_weights = tf.pow(1.0 - gt, 4.0)
loss = 0.0
pred=tf.clip_by_value(pred, 1e-6, 1.0 - 1e-6)
pos_loss = tf.log(pred) * tf.pow(1.0 - pred, 2.0) * pos_inds
neg_loss = tf.log(1.0 - pred) * tf.pow(pred, 2.0) * neg_weights * neg_inds

num_pos  = tf.reduce_sum(pos_inds)
pos_loss = tf.reduce_sum(pos_loss)
neg_loss = tf.reduce_sum(neg_loss)

if num_pos == 0.0:
loss = loss - neg_loss
else:
loss = loss - (pos_loss + neg_loss) / num_pos
return loss```

### 结果

```运行环境：
软件环境： python3.6
硬件环境： gpu：gtx1080ti*1，cpu：intel i7-8700k
model_name              avg_time(ms)    input_size   model_size(.pb)
shufflenetv2_voc        17.4            512x512      24.9MB
yolo3_centernet_voc     25.53           512x512      227.7MB```

### 总结

(1)我不能保证这个方法对所有人所有任务有效，需要结合自己的实验作结论，仅供参考。

(2)模型结构还需要完善，毕竟我功力比大佬们还差不少。

(3)想在val或者test集上取得较好的效果还更多的工作。对于误检和漏检可能是没做data augmentation，毕竟在训练集上能收敛。

(4)其实我觉得可以将centernet的检测方式应用于FPN结构，应该可行。

(5)我的cv之路仍需更多的努力，需要多动手，多实践，坚持到底，才能进步。

590 篇文章117 人订阅

0 条评论