Single Shot Multibox Detection (SSD)实战（下）
Single Shot Multibox Detection (SSD)实战（下）
2. Training
将逐步解释如何训练SSD模型进行目标检测。
2.1. Data Reading and Initialization
创建的Pikachu数据集。
batch_size = 32
train_iter, _ = d2l.load_data_pikachu(batch_size)
Pikachu数据集中有1个类别。在定义模块之后，我们需要初始化模型参数并定义优化算法。
ctx, net = d2l.try_gpu(), TinySSD(num_classes=1)
net.initialize(init=init.Xavier(), ctx=ctx)
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': 0.2, 'wd': 5e-4})
2.2. Defining Loss and Evaluation Functions
目标检测有两种损失。一是锚箱类损失。为此，我们可以简单地重用我们在图像分类中使用的交叉熵损失函数。第二个损失是正锚箱偏移损失。偏移量预测是一个规范化问题。但是，在这里，我们没有使用前面介绍的平方损失。相反，我们使用L1范数损失，即预测值与地面真实值之差的绝对值。mask变量bbox_masks从损失计算中删除负锚定框和填充锚定框。最后，我们加入锚箱类别和补偿损失，以找到模型的最终损失函数。
cls_loss = gluon.loss.SoftmaxCrossEntropyLoss()
bbox_loss = gluon.loss.L1Loss()
def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
cls = cls_loss(cls_preds, cls_labels)
bbox = bbox_loss(bbox_preds * bbox_masks, bbox_labels * bbox_masks)
return cls + bbox
我们可以用准确率来评价分类结果。当我们使用L1范数损失，我们将使用平均绝对误差来评估包围盒预测结果。
def cls_eval(cls_preds, cls_labels):
# Because the category prediction results are placed in the final
# dimension, argmax must specify this dimension
return float((cls_preds.argmax(axis=-1) == cls_labels).sum())
def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
return float((np.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())
2.3. Training the Model
在模型训练过程中，我们必须在模型的正向计算过程中生成多尺度锚盒（anchors），并预测每个锚盒的类别（cls_preds）和偏移量（bbox_preds）。然后，我们根据标签信息Y标记每个锚定框的类别（cls_labels）和偏移量（bbox_labels）。最后，我们使用预测和标记的类别和偏移量值计算损失函数。为了简化代码，这里不计算训练数据集。
num_epochs, timer = 20, d2l.Timer()
animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
legend=['class error', 'bbox mae'])
for epoch in range(num_epochs):
# accuracy_sum, mae_sum, num_examples, num_labels
metric = d2l.Accumulator(4)
train_iter.reset() # Read data from the start.
for batch in train_iter:
timer.start()
X = batch.data[0].as_in_ctx(ctx)
Y = batch.label[0].as_in_ctx(ctx)
with autograd.record():
# Generate multiscale anchor boxes and predict the category and
# offset of each
anchors, cls_preds, bbox_preds = net(X)
# Label the category and offset of each anchor box
bbox_labels, bbox_masks, cls_labels = npx.multibox_target(
anchors, Y, cls_preds.transpose(0, 2, 1))
# Calculate the loss function using the predicted and labeled
# category and offset values
l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
bbox_masks)
l.backward()
trainer.step(batch_size)
metric.add(cls_eval(cls_preds, cls_labels), cls_labels.size,
bbox_eval(bbox_preds, bbox_labels, bbox_masks),
bbox_labels.size)
cls_err, bbox_mae = 1-metric[0]/metric[1], metric[2]/metric[3]
animator.add(epoch+1, (cls_err, bbox_mae))
print('class err %.2e, bbox mae %.2e' % (cls_err, bbox_mae))
print('%.1f examples/sec on %s' % (train_iter.num_image/timer.stop(), ctx))
class err 2.35e-03, bbox mae 2.68e-03
4315.5 examples/sec on gpu(0)
3. Prediction
在预测阶段，我们要检测图像中所有感兴趣的对象。下面，我们读取测试图像并转换其大小。然后，我们将其转换为卷积层所需的四维格式。
img = image.imread('../img/pikachu.jpg')
feature = image.imresize(img, 256, 256).astype('float32')
X = np.expand_dims(feature.transpose(2, 0, 1), axis=0)
利用MultiBoxDetection函数，我们根据锚定框及其预测的偏移量来预测边界框。然后，我们使用非最大值抑制来移除类似的边界框。
def predict(X):
anchors, cls_preds, bbox_preds = net(X.as_in_ctx(ctx))
cls_probs = npx.softmax(cls_preds).transpose(0, 2, 1)
output = npx.multibox_detection(cls_probs, bbox_preds, anchors)
idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
return output[0, idx]
output = predict(X)
最后，我们取置信度至少为0.3的所有边界框，并将它们显示为最终输出。
def display(img, output, threshold):
d2l.set_figsize((5, 5))
fig = d2l.plt.imshow(img.asnumpy())
for row in output:
score = float(row[1])
if score < threshold:
continue
h, w = img.shape[0:2]
bbox = [row[2:6] * np.array((w, h, w, h), ctx=row.ctx)]
d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
display(img, output, threshold=0.3)
4. Loss Function
由于空间的限制，我们在本实验中忽略了SSD模型的一些实现细节。您能否在以下方面进一步改进该模型？
For the predicted offsets, replace L1L1 norm loss with L1L1 regularization loss. This loss function uses a square function around zero for greater smoothness. This is the regularized area controlled by the hyperparameter σσ:
When σσ is large, this loss is similar to the L1L1 norm loss. When the value is small, the loss function is smoother.
sigmas = [10, 1, 0.5]
lines = ['-', '--', '-.']
x = np.arange(-2, 2, 0.1)
d2l.set_figsize()
for l, s in zip(lines, sigmas):
y = npx.smooth_l1(x, scalar=s)
d2l.plt.plot(x.asnumpy(), y.asnumpy(), l, label='sigma=%.1f' % s)
d2l.plt.legend
def focal_loss(gamma, x):
return -(1 - x) ** gamma * np.log(x)
x = np.arange(0.01, 1, 0.01)
for l, gamma in zip(lines, [0, 1, 5]):
y = d2l.plt.plot(x.asnumpy(), focal_loss(gamma, x).asnumpy(), l,
label='gamma=%.1f' % gamma)
d2l.plt.legend();
Training and Prediction
When an object is relatively large compared to the image, the model normally adopts a larger input image size.
This generally produces a large number of negative anchor boxes when labeling anchor box categories. We can sample the negative anchor boxes to better balance the data categories. To do this, we can set the MultiBoxTarget function’s negative_mining_ratio parameter.
Assign hyper-parameters with different weights to the anchor box category loss and positive anchor box offset loss in the loss function.
Refer to the SSD paper. What methods can be used to evaluate the precision of object detection models?
5. Summary
- SSD is a multiscale object detection model. This model generates different numbers of anchor boxes of different sizes based on the base network block and each multiscale feature block and predicts the categories and offsets of the anchor boxes to detect objects of different sizes.
- During SSD model training, the loss function is calculated using the predicted and labeled category and offset values.
