SSD实现

一、模子

        此模子紧张由底子网络构成，厥后是几个多尺度特性块。根本网络用于从输入图像中提取特性，因此它可以使用深度卷积神经网络。
        单发多框检测选用了在分类层之前截断的VGG，如今也常用ResNet更换；可以筹划底子网络，使它输出的高和宽较大，使基于该特性图天生的锚框数目较多，可以用来检测尺寸较小的目的。 接下来的每个多尺度特性块将上一层提供的特性图的高和宽缩小（如减半），并使特性图中每个单位在输入图像上的感受野变得更广阔。
1、种别推测层

2. %matplotlib inline
3. import torch
4. import torchvision
5. from torch import nn
6. from torch.nn import functional as F
7. from d2l import torch as d2l
10. def cls_predictor(num_inputs, num_anchors, num_classes):
11.     #类别+1是因为加上了背景类别
12.     return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1),
13.                      kernel_size=3, padding=1)

复制代码

2、界限框推测层

2. def bbox_predictor(num_inputs, num_anchors):
3.     #边界框预测四个偏移，四条边
4.     return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

复制代码

3、连结多尺度的推测
        单发多框检测使用多尺度特性图来天生锚框并推测其种别和偏移量。 在差别的尺度下，特性图的形状或以同一单位为中心的锚框的数目大概会有所差别。 因此，差别尺度下推测输出的形状大概会有所差别。

2. def forward(x, block):
3.     return block(x)

复制代码

        为了将这两个推测输出链接起来以进步盘算服从，我们将把这些张量转换为更同等的格式。

2. def flatten_pred(pred):
3.     #将通道维移到最后一维，是为了做展平时候同一个像素的框所判断的类是集中在一起的
4.     return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)
6. def concat_preds(preds):
7.     return torch.cat([flatten_pred(p) for p in preds], dim=1)

复制代码

4、高和宽减半块

2. def down_sample_blk(in_channels, out_channels):
3.     blk = []
4.     for _ in range(2):
5.         blk.append(nn.Conv2d(in_channels, out_channels,
6.                              kernel_size=3, padding=1))
7.         blk.append(nn.BatchNorm2d(out_channels))
8.         blk.append(nn.ReLU())
9.         in_channels = out_channels
10.     blk.append(nn.MaxPool2d(2))
11.     return nn.Sequential(*blk)

复制代码

5、根本网络块

2. def base_net():
3.     blk = []
4.     num_filters = [3, 16, 32, 64]
5.     for i in range(len(num_filters) - 1):
6.         blk.append(down_sample_blk(num_filters[i], num_filters[i+1]))
7.     return nn.Sequential(*blk)
9. forward(torch.zeros((2, 3, 256, 256)), base_net()).shape

复制代码

6、完备的模子

2. def get_blk(i):
3.     if i == 0:
4.         blk = base_net()
5.     elif i == 1:
6.         blk = down_sample_blk(64, 128)
7.     elif i == 4:
8.         blk = nn.AdaptiveMaxPool2d((1,1))
9.     else:
10.         blk = down_sample_blk(128, 128)
11.     return blk

复制代码

2. def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
3.     Y = blk(X)
4.     anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)
5.     cls_preds = cls_predictor(Y)
6.     bbox_preds = bbox_predictor(Y)
7.     return (Y, anchors, cls_preds, bbox_preds)

复制代码

2. sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
3.          [0.88, 0.961]]
4. ratios = [[1, 2, 0.5]] * 5
5. num_anchors = len(sizes[0]) + len(ratios[0]) - 1

复制代码

2. class TinySSD(nn.Module):
3.     def __init__(self, num_classes, **kwargs):
4.         super(TinySSD, self).__init__(**kwargs)
5.         self.num_classes = num_classes
6.         idx_to_in_channels = [64, 128, 128, 128, 128]
7.         for i in range(5):
8.             # 即赋值语句self.blk_i=get_blk(i)
9.             setattr(self, f'blk_{i}', get_blk(i))
10.             setattr(self, f'cls_{i}', cls_predictor(idx_to_in_channels[i],
11.                                                     num_anchors, num_classes))
12.             setattr(self, f'bbox_{i}', bbox_predictor(idx_to_in_channels[i],
13.                                                       num_anchors))
15.     def forward(self, X):
16.         anchors, cls_preds, bbox_preds = [None] * 5, [None] * 5, [None] * 5
17.         for i in range(5):
18.             # getattr(self,'blk_%d'%i)即访问self.blk_i
19.             X, anchors[i], cls_preds[i], bbox_preds[i] = blk_forward(
20.                 X, getattr(self, f'blk_{i}'), sizes[i], ratios[i],
21.                 getattr(self, f'cls_{i}'), getattr(self, f'bbox_{i}'))
22.         anchors = torch.cat(anchors, dim=1)
23.         cls_preds = concat_preds(cls_preds)
24.         cls_preds = cls_preds.reshape(
25.             cls_preds.shape[0], -1, self.num_classes + 1)
26.         bbox_preds = concat_preds(bbox_preds)
27.         return anchors, cls_preds, bbox_preds

复制代码

2. net = TinySSD(num_classes=1)
3. X = torch.zeros((32, 3, 256, 256))
4. anchors, cls_preds, bbox_preds = net(X)
6. print('output anchors:', anchors.shape)
7. print('output class preds:', cls_preds.shape)
8. print('output bbox preds:', bbox_preds.shape)

复制代码

二、练习模子
1、界说丧失函数和评价函数
         第一种有关锚框种别的丧失，可以简单地复用之前图像分类题目里不绝使用的交织熵丧失函数来盘算； 第二种有关正类锚框偏移量的丧失：推测偏移量是一个回归题目

2. cls_loss = nn.CrossEntropyLoss(reduction='none')
3. #因为L2是平方，可能会特别大，我们就用绝对值的L1
4. bbox_loss = nn.L1Loss(reduction='none')
6. def calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels, bbox_masks):
7.     batch_size, num_classes = cls_preds.shape[0], cls_preds.shape[2]
8.     cls = cls_loss(cls_preds.reshape(-1, num_classes),
9.                    cls_labels.reshape(-1)).reshape(batch_size, -1).mean(dim=1)
10.     bbox = bbox_loss(bbox_preds * bbox_masks,
11.                      bbox_labels * bbox_masks).mean(dim=1)
12.     return cls + bbox

复制代码

2. def cls_eval(cls_preds, cls_labels):
3.     # 由于类别预测结果放在最后一维，argmax需要指定最后一维。
4.     return float((cls_preds.argmax(dim=-1).type(
5.         cls_labels.dtype) == cls_labels).sum())
7. def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
8.     return float((torch.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())

复制代码

2、练习模子

2. num_epochs, timer = 20, d2l.Timer()
3. animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
4.                         legend=['class error', 'bbox mae'])
5. net = net.to(device)
6. for epoch in range(num_epochs):
7.     # 训练精确度的和，训练精确度的和中的示例数
8.     # 绝对误差的和，绝对误差的和中的示例数
9.     metric = d2l.Accumulator(4)
10.     net.train()
11.     for features, target in train_iter:
12.         timer.start()
13.         trainer.zero_grad()
14.         X, Y = features.to(device), target.to(device)
15.         # 生成多尺度的锚框，为每个锚框预测类别和偏移量
16.         anchors, cls_preds, bbox_preds = net(X)
17.         # 为每个锚框标注类别和偏移量
18.         bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)
19.         # 根据类别和偏移量的预测和标注值计算损失函数
20.         l = calc_loss(cls_preds, cls_labels, bbox_preds, bbox_labels,
21.                       bbox_masks)
22.         l.mean().backward()
23.         trainer.step()
24.         metric.add(cls_eval(cls_preds, cls_labels), cls_labels.numel(),
25.                    bbox_eval(bbox_preds, bbox_labels, bbox_masks),
26.                    bbox_labels.numel())
27.     cls_err, bbox_mae = 1 - metric[0] / metric[1], metric[2] / metric[3]
28.     animator.add(epoch + 1, (cls_err, bbox_mae))
29. print(f'class err {cls_err:.2e}, bbox mae {bbox_mae:.2e}')
30. print(f'{len(train_iter.dataset) / timer.stop():.1f} examples/sec on '
31.       f'{str(device)}')

复制代码

三、推测目的

2. #根据锚框及其预测偏移量得到预测边界框，通过非极大值抑制来移除相似的预测边界框
3. def predict(X):
4.     net.eval()
5.     anchors, cls_preds, bbox_preds = net(X.to(device))
6.     cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1)
7.     output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)
8.     #筛选有效结果
9.     idx = [i for i, row in enumerate(output[0]) if row[0] != -1]
10.     return output[0, idx]
12. output = predict(X)

复制代码

2. #筛选所有置信度不低于0.9的边界框
3. def display(img, output, threshold):
4.     d2l.set_figsize((5, 5))
5.     fig = d2l.plt.imshow(img)
6.     for row in output:
7.         score = float(row[1])
8.         if score < threshold:
9.             continue
10.         h, w = img.shape[0:2]
11.         bbox = [row[2:6] * torch.tensor((w, h, w, h), device=row.device)]
12.         d2l.show_bboxes(fig.axes, bbox, '%.2f' % score, 'w')
14. display(img, output.cpu(), threshold=0.9)

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金