昇思25天学习打卡营第17天|应用实践之SSD目标检测

根本介绍

        今天要学习的内容是计算机视觉范畴中的目标检测任务。与图像分类相比，目标检测更难，因为目标检测不但要检测出图片中的物体的类别，还要检测出该物体的位置。现主流的目标检测算法大致可分为两种，一种是基于CNN的，另一种是基于Transformer的。基于CNN的还可以细分为三种，以Faster R-CNN为代表的一阶段目标检测，以Yolo为代表的二阶段目标检测，以及Anchor-free算法。本文会先简单介绍一下SSD模型，然后在MindSpore框架下，使用COCO2017数据集训练SSD模型，并进行模型评估。
SSD模型简介

        SSD与Yolo一样，都是一阶段目标检测算法，是直接通过主干网络给出类别位置信息，不须要地区天生。此外，SSD通过卷积神经网络进行特征提取，取不同的特征层进行检测输出，所以SSD是一种多尺度的检测方法，在须要检测的特征层，直接使用一个3 ×× 3卷积，进行通道的变换。SSD的框架图如下图所示：

        SSD采用VGG16作为底子模型，然后在VGG16的底子上新增了卷积层来获得更多的特征图以用于检测。如果VGG16，也可以使用ResNet19，ResNet50等作为底子模型。SSD的网络布局如下图所示

可大致分为四个模块：VGG base Layer，Extra Feature Layer，Detection Layer、NMS

• VGG base Layer
  

        如下图所示，VGG base Layer也就是backbone layer

输入图像颠末预处理后巨细固定为300×300，起首颠末backbone，本案例中使用的是VGG16网络的前13个卷积层，然后分别将VGG16的全连接层fc6和fc7转换成3 ×× 3卷积层block6和1 ×× 1卷积层block7，进一步提取特征。 在block6中，使用了空洞数为6的空洞卷积，其padding也为6，这样做同样也是为了增加感受野的同时保持参数目与特征图尺寸的不变

• Extra Feature Layer
  

        Extra Feature Layer是在VGG16的底子增加的特征提取层，用于提取更高层的语义信息，详细布局如下：

block8-11，用于更高语义信息的提取。block8的通道数为512，而block9、block10与block11的通道数都为256。从block7到block11，这5个卷积后输出特征图的尺寸依次为19×19、10×10、5×5、3×3和1×1。为了低落参数目，使用了1×1卷积先低落通道数为该层输出通道数的一半，再利用3×3卷积进行特征提取

• Detection Layer
  

        Detection Layer负责类别和位置推测，这须要借助anchor实现。SSD模型一共有6个推测特征图，对于此中一个尺寸为m*n，通道为p的推测特征图，假设其每个像素点会产生k个anchor，每个anchor会对应c个类别和4个回归偏移量，使用(4+c)k个尺寸为3x3，通道为p的卷积核对该推测特征图进行卷积操作，得到尺寸为m*n，通道为(4+c)m*k的输出特征图，它包含了推测特征图上所产生的每个anchor的回归偏移量和各类别概率分数。

• NMS
  

        NMS即非极大抑制法，训练过程不用，只用在推理过程。其算法流程如下

SSD代码实践

数据集预备

        我们将会使用COCO2017数据集进行训练，COCO2017数据集很轻易下载，加载到内存的操作也很简单，我们将重点放在SSD模型的数据增强方法。为了使模型对于各种输入对象巨细和形状更加鲁棒，SSD算法每个训练图像通过以下选项之一随机采样：

• 使用整个原始输入图像
  
• 采样一个地区，使采样地区和原始图片最小的交并比重叠为0.1,0.3,0.5,0.7或0.9
  
• 随机采样一个地区
  

每个采样地区的巨细为原始图像巨细的[0.3,1]，长宽比在1/2和2之间。如果真实标签框中央在采样地区内，则保存两者重叠部门作为新图片的真实标注框。在上述采样步调之后，将每个采样地区巨细调整为固定巨细，并以0.5的概率程度翻转。其代码实现如下：

1. import cv2
2. import numpy as np
4. def _rand(a=0., b=1.):
5.     return np.random.rand() * (b - a) + a
7. def intersect(box_a, box_b):
8.     """Compute the intersect of two sets of boxes."""
9.     max_yx = np.minimum(box_a[:, 2:4], box_b[2:4])
10.     min_yx = np.maximum(box_a[:, :2], box_b[:2])
11.     inter = np.clip((max_yx - min_yx), a_min=0, a_max=np.inf)
12.     return inter[:, 0] * inter[:, 1]
14. def jaccard_numpy(box_a, box_b):
15.     """Compute the jaccard overlap of two sets of boxes."""
16.     inter = intersect(box_a, box_b)
17.     area_a = ((box_a[:, 2] - box_a[:, 0]) *
18.               (box_a[:, 3] - box_a[:, 1]))
19.     area_b = ((box_b[2] - box_b[0]) *
20.               (box_b[3] - box_b[1]))
21.     union = area_a + area_b - inter
22.     return inter / union
24. def random_sample_crop(image, boxes):
25.     """Crop images and boxes randomly."""
26.     height, width, _ = image.shape
27.     min_iou = np.random.choice([None, 0.1, 0.3, 0.5, 0.7, 0.9])
29.     if min_iou is None:
30.         return image, boxes
32.     for _ in range(50):
33.         image_t = image
34.         w = _rand(0.3, 1.0) * width
35.         h = _rand(0.3, 1.0) * height
36.         # aspect ratio constraint b/t .5 & 2
37.         if h / w < 0.5 or h / w > 2:
38.             continue
40.         left = _rand() * (width - w)
41.         top = _rand() * (height - h)
42.         rect = np.array([int(top), int(left), int(top + h), int(left + w)])
43.         overlap = jaccard_numpy(boxes, rect)
45.         # dropout some boxes
46.         drop_mask = overlap > 0
47.         if not drop_mask.any():
48.             continue
50.         if overlap[drop_mask].min() < min_iou and overlap[drop_mask].max() > (min_iou + 0.2):
51.             continue
53.         image_t = image_t[rect[0]:rect[2], rect[1]:rect[3], :]
54.         centers = (boxes[:, :2] + boxes[:, 2:4]) / 2.0
55.         m1 = (rect[0] < centers[:, 0]) * (rect[1] < centers[:, 1])
56.         m2 = (rect[2] > centers[:, 0]) * (rect[3] > centers[:, 1])
58.         # mask in that both m1 and m2 are true
59.         mask = m1 * m2 * drop_mask
61.         # have any valid boxes? try again if not
62.         if not mask.any():
63.             continue
65.         # take only matching gt boxes
66.         boxes_t = boxes[mask, :].copy()
67.         boxes_t[:, :2] = np.maximum(boxes_t[:, :2], rect[:2])
68.         boxes_t[:, :2] -= rect[:2]
69.         boxes_t[:, 2:4] = np.minimum(boxes_t[:, 2:4], rect[2:4])
70.         boxes_t[:, 2:4] -= rect[:2]
72.         return image_t, boxes_t
73.     return image, boxes
75. def ssd_bboxes_encode(boxes):
76.     """Labels anchors with ground truth inputs."""
78.     def jaccard_with_anchors(bbox):
79.         """Compute jaccard score a box and the anchors."""
80.         # Intersection bbox and volume.
81.         ymin = np.maximum(y1, bbox[0])
82.         xmin = np.maximum(x1, bbox[1])
83.         ymax = np.minimum(y2, bbox[2])
84.         xmax = np.minimum(x2, bbox[3])
85.         w = np.maximum(xmax - xmin, 0.)
86.         h = np.maximum(ymax - ymin, 0.)
88.         # Volumes.
89.         inter_vol = h * w
90.         union_vol = vol_anchors + (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) - inter_vol
91.         jaccard = inter_vol / union_vol
92.         return np.squeeze(jaccard)
94.     pre_scores = np.zeros((8732), dtype=np.float32)
95.     t_boxes = np.zeros((8732, 4), dtype=np.float32)
96.     t_label = np.zeros((8732), dtype=np.int64)
97.     for bbox in boxes:
98.         label = int(bbox[4])
99.         scores = jaccard_with_anchors(bbox)
100.         idx = np.argmax(scores)
101.         scores[idx] = 2.0
102.         mask = (scores > matching_threshold)
103.         mask = mask & (scores > pre_scores)
104.         pre_scores = np.maximum(pre_scores, scores * mask)
105.         t_label = mask * label + (1 - mask) * t_label
106.         for i in range(4):
107.             t_boxes[:, i] = mask * bbox[i] + (1 - mask) * t_boxes[:, i]
109.     index = np.nonzero(t_label)
111.     # Transform to tlbr.
112.     bboxes = np.zeros((8732, 4), dtype=np.float32)
113.     bboxes[:, [0, 1]] = (t_boxes[:, [0, 1]] + t_boxes[:, [2, 3]]) / 2
114.     bboxes[:, [2, 3]] = t_boxes[:, [2, 3]] - t_boxes[:, [0, 1]]
116.     # Encode features.
117.     bboxes_t = bboxes[index]
118.     default_boxes_t = default_boxes[index]
119.     bboxes_t[:, :2] = (bboxes_t[:, :2] - default_boxes_t[:, :2]) / (default_boxes_t[:, 2:] * 0.1)
120.     tmp = np.maximum(bboxes_t[:, 2:4] / default_boxes_t[:, 2:4], 0.000001)
121.     bboxes_t[:, 2:4] = np.log(tmp) / 0.2
122.     bboxes[index] = bboxes_t
124.     num_match = np.array([len(np.nonzero(t_label)[0])], dtype=np.int32)
125.     return bboxes, t_label.astype(np.int32), num_match
127. def preprocess_fn(img_id, image, box, is_training):
128.     """Preprocess function for dataset."""
129.     cv2.setNumThreads(2)
131.     def _infer_data(image, input_shape):
132.         img_h, img_w, _ = image.shape
133.         input_h, input_w = input_shape
135.         image = cv2.resize(image, (input_w, input_h))
137.         # When the channels of image is 1
138.         if len(image.shape) == 2:
139.             image = np.expand_dims(image, axis=-1)
140.             image = np.concatenate([image, image, image], axis=-1)
142.         return img_id, image, np.array((img_h, img_w), np.float32)
144.     def _data_aug(image, box, is_training, image_size=(300, 300)):
145.         ih, iw, _ = image.shape
146.         h, w = image_size
147.         if not is_training:
148.             return _infer_data(image, image_size)
149.         # Random crop
150.         box = box.astype(np.float32)
151.         image, box = random_sample_crop(image, box)
152.         ih, iw, _ = image.shape
153.         # Resize image
154.         image = cv2.resize(image, (w, h))
155.         # Flip image or not
156.         flip = _rand() < .5
157.         if flip:
158.             image = cv2.flip(image, 1, dst=None)
159.         # When the channels of image is 1
160.         if len(image.shape) == 2:
161.             image = np.expand_dims(image, axis=-1)
162.             image = np.concatenate([image, image, image], axis=-1)
163.         box[:, [0, 2]] = box[:, [0, 2]] / ih
164.         box[:, [1, 3]] = box[:, [1, 3]] / iw
165.         if flip:
166.             box[:, [1, 3]] = 1 - box[:, [3, 1]]
167.         box, label, num_match = ssd_bboxes_encode(box)
168.         return image, box, label, num_match
170.     return _data_aug(image, box, is_training, image_size=[300, 300])

复制代码

模型搭建

        借助MindSpore可以很快搭建出模型，模型代码如下：

1. class SSD300Vgg16(nn.Cell):
2.     """SSD300Vgg16 module."""
4.     def __init__(self):
5.         super(SSD300Vgg16, self).__init__()
7.         # VGG16 backbone: block1~5
8.         self.backbone = Vgg16()
10.         # SSD blocks: block6~7
11.         self.b6_1 = nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=3, padding=6, dilation=6, pad_mode='pad')
12.         self.b6_2 = nn.Dropout(p=0.5)
14.         self.b7_1 = nn.Conv2d(in_channels=1024, out_channels=1024, kernel_size=1)
15.         self.b7_2 = nn.Dropout(p=0.5)
17.         # Extra Feature Layers: block8~11
18.         self.b8_1 = nn.Conv2d(in_channels=1024, out_channels=256, kernel_size=1, padding=1, pad_mode='pad')
19.         self.b8_2 = nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=2, pad_mode='valid')
21.         self.b9_1 = nn.Conv2d(in_channels=512, out_channels=128, kernel_size=1, padding=1, pad_mode='pad')
22.         self.b9_2 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=2, pad_mode='valid')
24.         self.b10_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=1)
25.         self.b10_2 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, pad_mode='valid')
27.         self.b11_1 = nn.Conv2d(in_channels=256, out_channels=128, kernel_size=1)
28.         self.b11_2 = nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, pad_mode='valid')
30.         # boxes
31.         self.multi_box = MultiBox()
33.     def construct(self, x):
34.         # VGG16 backbone: block1~5
35.         block4, x = self.backbone(x)
37.         # SSD blocks: block6~7
38.         x = self.b6_1(x)  # 1024
39.         x = self.b6_2(x)
41.         x = self.b7_1(x)  # 1024
42.         x = self.b7_2(x)
43.         block7 = x
45.         # Extra Feature Layers: block8~11
46.         x = self.b8_1(x)  # 256
47.         x = self.b8_2(x)  # 512
48.         block8 = x
50.         x = self.b9_1(x)  # 128
51.         x = self.b9_2(x)  # 256
52.         block9 = x
54.         x = self.b10_1(x)  # 128
55.         x = self.b10_2(x)  # 256
56.         block10 = x
58.         x = self.b11_1(x)  # 128
59.         x = self.b11_2(x)  # 256
60.         block11 = x
62.         # boxes
63.         multi_feature = (block4, block7, block8, block9, block10, block11)
64.         pred_loc, pred_label = self.multi_box(multi_feature)
65.         if not self.training:
66.             pred_label = ops.sigmoid(pred_label)
67.         pred_loc = pred_loc.astype(ms.float32)
68.         pred_label = pred_label.astype(ms.float32)
69.         return pred_loc, pred_label

复制代码

模型训练

        模型训练时，使用上述所说的数据增强方式，丧失韩式是类别丧失函数和位置丧失函数的加权和，设置模型训练的epoch次数为60，然后通过create_ssd_dataset类创建了训练集和验证集。batch_size巨细为5，图像尺寸同一调整为300×300。丧失函数使用位置丧失函数和置信度丧失函数的加权和，优化器使用Momentum，并设置初始学习率为0.001。回调函数方面使用了LossMonitor和TimeMonitor来监控训练过程中每个epoch结束后，丧失值Loss的变化情况以及每个epoch、每个step的运行时间。设置每训练10个epoch保存一次模型。详细代码如下：

1. dataset = create_ssd_dataset(mindrecord_file, batch_size=5, rank=0, use_multiprocessing=True)
2. dataset_size = dataset.get_dataset_size()
4. image, get_loc, gt_label, num_matched_boxes = next(dataset.create_tuple_iterator())
6. # Network definition and initialization
7. network = SSD300Vgg16()
8. init_net_param(network)
10. # Define the learning rate
11. lr = Tensor(get_lr(global_step=0 * dataset_size,
12.                    lr_init=0.001, lr_end=0.001 * 0.05, lr_max=0.05,
13.                    warmup_epochs=2, total_epochs=60, steps_per_epoch=dataset_size))
15. # Define the optimizer
16. opt = nn.Momentum(filter(lambda x: x.requires_grad, network.get_parameters()), lr,
17.                   0.9, 0.00015, float(1024))
19. # Define the forward procedure
20. def forward_fn(x, gt_loc, gt_label, num_matched_boxes):
21.     pred_loc, pred_label = network(x)
22.     mask = ops.less(0, gt_label).astype(ms.float32)
23.     num_matched_boxes = ops.sum(num_matched_boxes.astype(ms.float32))
25.     # Positioning loss
26.     mask_loc = ops.tile(ops.expand_dims(mask, -1), (1, 1, 4))
27.     smooth_l1 = nn.SmoothL1Loss()(pred_loc, gt_loc) * mask_loc
28.     loss_loc = ops.sum(ops.sum(smooth_l1, -1), -1)
30.     # Category loss
31.     loss_cls = class_loss(pred_label, gt_label)
32.     loss_cls = ops.sum(loss_cls, (1, 2))
34.     return ops.sum((loss_cls + loss_loc) / num_matched_boxes)
36. grad_fn = ms.value_and_grad(forward_fn, None, opt.parameters, has_aux=False)
37. loss_scaler = DynamicLossScaler(1024, 2, 1000)
39. # Gradient updates
40. def train_step(x, gt_loc, gt_label, num_matched_boxes):
41.     loss, grads = grad_fn(x, gt_loc, gt_label, num_matched_boxes)
42.     opt(grads)
43.     return loss
45. print("=================== Starting Training =====================")
46. for epoch in range(60):
47.     network.set_train(True)
48.     begin_time = time.time()
49.     for step, (image, get_loc, gt_label, num_matched_boxes) in enumerate(dataset.create_tuple_iterator()):
50.         loss = train_step(image, get_loc, gt_label, num_matched_boxes)
51.     end_time = time.time()
52.     times = end_time - begin_time
53.     print(f"Epoch:[{int(epoch + 1)}/{int(60)}], "
54.           f"loss:{loss} , "
55.           f"time:{times}s ")
56. ms.save_checkpoint(network, "ssd-60_9.ckpt")
57. print("=================== Training Success =====================")

复制代码

模型评估

        训练好自然就要进行模型评估，本次使用的评估指标是目标检测范畴的经典指标Average Precision、Average Recall和mAP。评估结果如下：

可以看出：好像各个评价指标的表现都很一样平常，我个人以为有两个原因，一个是测试数据集太少了，只有9张图片好像；另一个是，SSD模型对中小物体的检测本领本来就比较弱，所以差一些。
总结

        今天所学习的SSD是有些难度的，固然我之前接触目标检测算法比较多，但还是第一接触SSD算法。不外得益于之前积聚的经验，今天的很多东西能比较快速理解。今天运行的SSD模型的结果比最新的Yolo差很多，但有其优点。此外，本人在这里只是回顾一些官方文档中的一些重要部门，SSD更详细的解说和代码解说还是要看官方文档的。
Jupyter在线运行情况

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。