目標檢測和邊界框

%matplotlib inline from PIL import Imageimport sys sys.path.append('/home/input/') #數據集路徑 import d2lzh1981 as d2l #已封裝好的包# 展示用于目標檢測的圖 d2l.set_figsize() #已封裝好的包 img = Image.open('/home/input/img2083/img/catdog.jpg') d2l.plt.imshow(img); # 加分號只顯示圖

邊界框

# bbox是bounding box的縮寫 dog_bbox, cat_bbox = [60, 45, 378, 516], [400, 112, 655, 493] def bbox_to_rect(bbox, color): # 本函數已保存在d2lzh_pytorch中方便以后使用# 將邊界框(左上x, 左上y, 右下x, 右下y)格式轉換成matplotlib格式：# ((左上x, 左上y), 寬, 高)return d2l.plt.Rectangle(xy=(bbox[0], bbox[1]), width=bbox[2]-bbox[0], height=bbox[3]-bbox[1],fill=False, edgecolor=color, linewidth=2) fig = d2l.plt.imshow(img) fig.axes.add_patch(bbox_to_rect(dog_bbox, 'blue')) fig.axes.add_patch(bbox_to_rect(cat_bbox, 'red'));

錨框

目標檢測算法通常會在輸入圖像中采樣大量的區域，然后判斷這些區域中是否包含我們感興趣的目標，并調整區域邊緣從而更準確地預測目標的真實邊界框（ground-truth bounding box）。不同的模型使用的區域采樣方法可能不同。這里我們介紹其中的一種方法：它以每個像素為中心生成多個大小和寬高比（aspect ratio）不同的邊界框。這些邊界框被稱為錨框（anchor box）。我們將在后面基于錨框實踐目標檢測。

注: 建議想學習用PyTorch做檢測的童鞋閱讀一下倉庫a-PyTorch-Tutorial-to-Object-Detection。

先導入一下相關包。

import numpy as np import math import torch import os IMAGE_DIR = '/home/input/img2083/img/'

生成多個錨框

假設輸入圖像高為

，寬為。我們分別以圖像的每個像素為中心生成不同形狀的錨框。設大小為且寬高比為，那么錨框的寬和高將分別為和。當中心位置給定時，已知寬和高的錨框是確定的。

下面我們分別設定好一組大小

和一組寬高比。如果以每個像素為中心時使用所有的大小與寬高比的組合，輸入圖像將一共得到個錨框。雖然這些錨框可能覆蓋了所有的真實邊界框，但計算復雜度容易過高。因此，我們通常只對包含或的大小與寬高比的組合感興趣，即

也就是說，以相同像素為中心的錨框的數量為

。對于整個輸入圖像，我們將一共生成個錨框。

以上生成錨框的方法已實現在MultiBoxPrior函數中。指定輸入、一組大小和一組寬高比，該函數將返回輸入的所有錨框。

d2l.set_figsize() img = Image.open(os.path.join(IMAGE_DIR, 'catdog.jpg')) w, h = img.size print("w = %d, h = %d" % (w, h))# d2l.plt.imshow(img); # 加分號只顯示圖

輸出：w = 728, h = 561

# 本函數已保存在d2lzh_pytorch包中方便以后使用 def MultiBoxPrior(feature_map, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]):"""# 按照「9.4.1. 生成多個錨框」所講的實現, anchor表示成(xmin, ymin, xmax, ymax).https://zh.d2l.ai/chapter_computer-vision/anchor.htmlArgs:feature_map: torch tensor, Shape: [N, C, H, W].sizes: List of sizes (0~1) of generated MultiBoxPriores. ratios: List of aspect ratios (non-negative) of generated MultiBoxPriores. Returns:anchors of shape (1, num_anchors, 4). 由于batch里每個都一樣, 所以第一維為1"""pairs = [] # pair of (size, sqrt(ration))# 生成n + m -1個框for r in ratios:pairs.append([sizes[0], math.sqrt(r)])for s in sizes[1:]:pairs.append([s, math.sqrt(ratios[0])])pairs = np.array(pairs)# 生成相對于坐標中心點的框（x,y,x,y）ss1 = pairs[:, 0] * pairs[:, 1] # size * sqrt(ration)ss2 = pairs[:, 0] / pairs[:, 1] # size / sqrt(ration)base_anchors = np.stack([-ss1, -ss2, ss1, ss2], axis=1) / 2#將坐標點和anchor組合起來生成hw（n+m-1）個框輸出h, w = feature_map.shape[-2:]shifts_x = np.arange(0, w) / wshifts_y = np.arange(0, h) / hshift_x, shift_y = np.meshgrid(shifts_x, shifts_y)shift_x = shift_x.reshape(-1)shift_y = shift_y.reshape(-1)shifts = np.stack((shift_x, shift_y, shift_x, shift_y), axis=1)anchors = shifts.reshape((-1, 1, 4)) + base_anchors.reshape((1, -1, 4))return torch.tensor(anchors, dtype=torch.float32).view(1, -1, 4) X = torch.Tensor(1, 3, h, w) # 構造輸入數據 Y = MultiBoxPrior(X, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]) print(Y.shape)

輸出：torch.Size([1, 2042040, 4])

我們看到，返回錨框變量y的形狀為（1，錨框個數，4）。將錨框變量y的形狀變為（圖像高，圖像寬，以相同像素為中心的錨框個數，4）后，我們就可以通過指定像素位置來獲取所有以該像素為中心的錨框了。下面的例子里我們訪問以（250，250）為中心的第一個錨框。它有4個元素，分別是錨框左上角的

和軸坐標和右下角的和軸坐標，其中和軸的坐標值分別已除以圖像的寬和高，因此值域均為0和1之間。# 展示某個像素點的anchor boxes = Y.reshape((h, w, 5, 4)) boxes[250, 250, 0, :]# * torch.tensor([w, h, w, h], dtype=torch.float32) # 第一個size和ratio分別為0.75和1, 則寬高均為0.75 = 0.7184 + 0.0316 = 0.8206 - 0.0706

輸出：tensor([-0.0316, 0.0706, 0.7184, 0.8206])

可以驗證一下以上輸出對不對：size和ratio分別為0.75和1, 則(歸一化后的)寬高均為0.75, 所以輸出是正確的（0.75 = 0.7184 + 0.0316 = 0.8206 - 0.0706）。

為了描繪圖像中以某個像素為中心的所有錨框，我們先定義show_bboxes函數以便在圖像上畫出多個邊界框。

# 本函數已保存在dd2lzh_pytorch包中方便以后使用 def show_bboxes(axes, bboxes, labels=None, colors=None):def _make_list(obj, default_values=None):if obj is None:obj = default_valueselif not isinstance(obj, (list, tuple)):obj = [obj]return objlabels = _make_list(labels)colors = _make_list(colors, ['b', 'g', 'r', 'm', 'c'])for i, bbox in enumerate(bboxes):color = colors[i % len(colors)]rect = d2l.bbox_to_rect(bbox.detach().cpu().numpy(), color)axes.add_patch(rect)if labels and len(labels) > i:text_color = 'k' if color == 'w' else 'w'axes.text(rect.xy[0], rect.xy[1], labels[i],va='center', ha='center', fontsize=6, color=text_color,bbox=dict(facecolor=color, lw=0))

剛剛我們看到，變量boxes中

和軸的坐標值分別已除以圖像的寬和高。在繪圖時，我們需要恢復錨框的原始坐標值，并因此定義了變量bbox_scale。現在，我們可以畫出圖像中以(250, 250)為中心的所有錨框了。可以看到，大小為0.75且寬高比為1的錨框較好地覆蓋了圖像中的狗。# 展示 250 250像素點的anchor d2l.set_figsize() fig = d2l.plt.imshow(img) bbox_scale = torch.tensor([[w, h, w, h]], dtype=torch.float32) show_bboxes(fig.axes, boxes[250, 250, :, :] * bbox_scale,['s=0.75, r=1', 's=0.75, r=2', 's=0.75, r=0.5', 's=0.5, r=1', 's=0.25, r=1'])

交并比

我們剛剛提到某個錨框較好地覆蓋了圖像中的狗。如果該目標的真實邊界框已知，這里的“較好”該如何量化呢？一種直觀的方法是衡量錨框和真實邊界框之間的相似度。我們知道，Jaccard系數（Jaccard index）可以衡量兩個集合的相似度。給定集合

和，它們的Jaccard系數即二者交集大小除以二者并集大小：

實際上，我們可以把邊界框內的像素區域看成是像素的集合。如此一來，我們可以用兩個邊界框的像素集合的Jaccard系數衡量這兩個邊界框的相似度。當衡量兩個邊界框的相似度時，我們通常將Jaccard系數稱為交并比（Intersection over Union，IoU），即兩個邊界框相交面積與相并面積之比，如圖9.2所示。交并比的取值范圍在0和1之間：0表示兩個邊界框無重合像素，1表示兩個邊界框相等。

# 以下函數已保存在d2lzh_pytorch包中方便以后使用 def compute_intersection(set_1, set_2):"""計算anchor之間的交集Args:set_1: a tensor of dimensions (n1, 4), anchor表示成(xmin, ymin, xmax, ymax)set_2: a tensor of dimensions (n2, 4), anchor表示成(xmin, ymin, xmax, ymax)Returns:intersection of each of the boxes in set 1 with respect to each of the boxes in set 2, shape: (n1, n2)"""# PyTorch auto-broadcasts singleton dimensionslower_bounds = torch.max(set_1[:, :2].unsqueeze(1), set_2[:, :2].unsqueeze(0)) # (n1, n2, 2)upper_bounds = torch.min(set_1[:, 2:].unsqueeze(1), set_2[:, 2:].unsqueeze(0)) # (n1, n2, 2)intersection_dims = torch.clamp(upper_bounds - lower_bounds, min=0) # (n1, n2, 2)return intersection_dims[:, :, 0] * intersection_dims[:, :, 1] # (n1, n2)def compute_jaccard(set_1, set_2):"""計算anchor之間的Jaccard系數(IoU)Args:set_1: a tensor of dimensions (n1, 4), anchor表示成(xmin, ymin, xmax, ymax)set_2: a tensor of dimensions (n2, 4), anchor表示成(xmin, ymin, xmax, ymax)Returns:Jaccard Overlap of each of the boxes in set 1 with respect to each of the boxes in set 2, shape: (n1, n2)"""# Find intersectionsintersection = compute_intersection(set_1, set_2) # (n1, n2)# Find areas of each box in both setsareas_set_1 = (set_1[:, 2] - set_1[:, 0]) * (set_1[:, 3] - set_1[:, 1]) # (n1)areas_set_2 = (set_2[:, 2] - set_2[:, 0]) * (set_2[:, 3] - set_2[:, 1]) # (n2)# Find the union# PyTorch auto-broadcasts singleton dimensionsunion = areas_set_1.unsqueeze(1) + areas_set_2.unsqueeze(0) - intersection # (n1, n2)return intersection / union # (n1, n2)

標注訓練集的錨框

在訓練集中，我們將每個錨框視為一個訓練樣本。為了訓練目標檢測模型，我們需要為每個錨框標注兩類標簽：一是錨框所含目標的類別，簡稱類別；二是真實邊界框相對錨框的偏移量，簡稱偏移量（offset）。在目標檢測時，我們首先生成多個錨框，然后為每個錨框預測類別以及偏移量，接著根據預測的偏移量調整錨框位置從而得到預測邊界框，最后篩選需要輸出的預測邊界框。

我們知道，在目標檢測的訓練集中，每個圖像已標注了真實邊界框的位置以及所含目標的類別。在生成錨框之后，我們主要依據與錨框相似的真實邊界框的位置和類別信息為錨框標注。那么，該如何為錨框分配與其相似的真實邊界框呢？

假設圖像中錨框分別為

，真實邊界框分別為，且。定義矩陣，其中第行第列的元素為錨框與真實邊界框的交并比。 首先，我們找出矩陣中最大元素，并將該元素的行索引與列索引分別記為。我們為錨框分配真實邊界框。顯然，錨框和真實邊界框在所有的“錨框—真實邊界框”的配對中相似度最高。接下來，將矩陣中第行和第列上的所有元素丟棄。找出矩陣中剩余的最大元素，并將該元素的行索引與列索引分別記為。我們為錨框分配真實邊界框，再將矩陣中第行和第列上的所有元素丟棄。此時矩陣中已有兩行兩列的元素被丟棄。 依此類推，直到矩陣中所有列元素全部被丟棄。這個時候，我們已為個錨框各分配了一個真實邊界框。 接下來，我們只遍歷剩余的個錨框：給定其中的錨框，根據矩陣的第行找到與交并比最大的真實邊界框，且只有當該交并比大于預先設定的閾值時，才為錨框分配真實邊界框。

如圖9.3（左）所示，假設矩陣

中最大值為，我們將為錨框分配真實邊界框。然后，丟棄矩陣中第2行和第3列的所有元素，找出剩余陰影部分的最大元素，為錨框分配真實邊界框。接著如圖9.3（中）所示，丟棄矩陣中第7行和第1列的所有元素，找出剩余陰影部分的最大元素，為錨框分配真實邊界框。最后如圖9.3（右）所示，丟棄矩陣中第5行和第4列的所有元素，找出剩余陰影部分的最大元素，為錨框分配真實邊界框。之后，我們只需遍歷除去的剩余錨框，并根據閾值判斷是否為剩余錨框分配真實邊界框。

現在我們可以標注錨框的類別和偏移量了。如果一個錨框

被分配了真實邊界框，將錨框的類別設為的類別，并根據和的中心坐標的相對位置以及兩個框的相對大小為錨框標注偏移量。由于數據集中各個框的位置和大小各異，因此這些相對位置和相對大小通常需要一些特殊變換，才能使偏移量的分布更均勻從而更容易擬合。設錨框及其被分配的真實邊界框的中心坐標分別為和，和的寬分別為和，高分別為和，一個常用的技巧是將的偏移量標注為

其中常數的默認值為

。如果一個錨框沒有被分配真實邊界框，我們只需將該錨框的類別設為背景。類別為背景的錨框通常被稱為負類錨框，其余則被稱為正類錨框。

下面演示一個具體的例子。我們為讀取的圖像中的貓和狗定義真實邊界框，其中第一個元素為類別（0為狗，1為貓），剩余4個元素分別為左上角的

和軸坐標以及右下角的和軸坐標（值域在0到1之間）。這里通過左上角和右下角的坐標構造了5個需要標注的錨框，分別記為（程序中索引從0開始）。先畫出這些錨框與真實邊界框在圖像中的位置。bbox_scale = torch.tensor((w, h, w, h), dtype=torch.float32) ground_truth = torch.tensor([[0, 0.1, 0.08, 0.52, 0.92],[1, 0.55, 0.2, 0.9, 0.88]]) anchors = torch.tensor([[0, 0.1, 0.2, 0.3], [0.15, 0.2, 0.4, 0.4],[0.63, 0.05, 0.88, 0.98], [0.66, 0.45, 0.8, 0.8],[0.57, 0.3, 0.92, 0.9]])fig = d2l.plt.imshow(img) show_bboxes(fig.axes, ground_truth[:, 1:] * bbox_scale, ['dog', 'cat'], 'k') show_bboxes(fig.axes, anchors * bbox_scale, ['0', '1', '2', '3', '4']);

compute_jaccard(anchors, ground_truth[:, 1:]) # 驗證一下寫的compute_jaccard函數

輸出：tensor([[0.0536, 0.0000],
[0.1417, 0.0000],
[0.0000, 0.5657],
[0.0000, 0.2059],
[0.0000, 0.7459]])

下面實現MultiBoxTarget函數來為錨框標注類別和偏移量。該函數將背景類別設為0，并令從零開始的目標類別的整數索引自加1（1為狗，2為貓）。

# 以下函數已保存在d2lzh_pytorch包中方便以后使用 def assign_anchor(bb, anchor, jaccard_threshold=0.5):"""# 按照「9.4.1. 生成多個錨框」圖9.3所講為每個anchor分配真實的bb, anchor表示成歸一化(xmin, ymin, xmax, ymax).https://zh.d2l.ai/chapter_computer-vision/anchor.htmlArgs:bb: 真實邊界框(bounding box), shape:（nb, 4）anchor: 待分配的anchor, shape:（na, 4）jaccard_threshold: 預先設定的閾值Returns:assigned_idx: shape: (na, ), 每個anchor分配的真實bb對應的索引, 若未分配任何bb則為-1"""na = anchor.shape[0] nb = bb.shape[0]jaccard = compute_jaccard(anchor, bb).detach().cpu().numpy() # shape: (na, nb)assigned_idx = np.ones(na) * -1 # 存放標簽初始全為-1# 先為每個bb分配一個anchor(不要求滿足jaccard_threshold)jaccard_cp = jaccard.copy()for j in range(nb):i = np.argmax(jaccard_cp[:, j])assigned_idx[i] = jjaccard_cp[i, :] = float("-inf") # 賦值為負無窮, 相當于去掉這一行# 處理還未被分配的anchor, 要求滿足jaccard_thresholdfor i in range(na):if assigned_idx[i] == -1:j = np.argmax(jaccard[i, :])if jaccard[i, j] >= jaccard_threshold:assigned_idx[i] = jreturn torch.tensor(assigned_idx, dtype=torch.long)def xy_to_cxcy(xy):"""將(x_min, y_min, x_max, y_max)形式的anchor轉換成(center_x, center_y, w, h)形式的.https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Object-Detection/blob/master/utils.pyArgs:xy: bounding boxes in boundary coordinates, a tensor of size (n_boxes, 4)Returns: bounding boxes in center-size coordinates, a tensor of size (n_boxes, 4)"""return torch.cat([(xy[:, 2:] + xy[:, :2]) / 2, # c_x, c_yxy[:, 2:] - xy[:, :2]], 1) # w, hdef MultiBoxTarget(anchor, label):"""# 按照「9.4.1. 生成多個錨框」所講的實現, anchor表示成歸一化(xmin, ymin, xmax, ymax).https://zh.d2l.ai/chapter_computer-vision/anchor.htmlArgs:anchor: torch tensor, 輸入的錨框, 一般是通過MultiBoxPrior生成, shape:（1，錨框總數，4）label: 真實標簽, shape為(bn, 每張圖片最多的真實錨框數, 5)第二維中，如果給定圖片沒有這么多錨框, 可以先用-1填充空白, 最后一維中的元素為[類別標簽, 四個坐標值]Returns:列表, [bbox_offset, bbox_mask, cls_labels]bbox_offset: 每個錨框的標注偏移量，形狀為(bn，錨框總數*4)bbox_mask: 形狀同bbox_offset, 每個錨框的掩碼, 一一對應上面的偏移量, 負類錨框(背景)對應的掩碼均為0, 正類錨框的掩碼均為1cls_labels: 每個錨框的標注類別, 其中0表示為背景, 形狀為(bn，錨框總數)"""assert len(anchor.shape) == 3 and len(label.shape) == 3bn = label.shape[0]def MultiBoxTarget_one(anc, lab, eps=1e-6):"""MultiBoxTarget函數的輔助函數, 處理batch中的一個Args:anc: shape of (錨框總數, 4)lab: shape of (真實錨框數, 5), 5代表[類別標簽, 四個坐標值]eps: 一個極小值, 防止log0Returns:offset: (錨框總數*4, )bbox_mask: (錨框總數*4, ), 0代表背景, 1代表非背景cls_labels: (錨框總數, 4), 0代表背景"""an = anc.shape[0]# 變量的意義assigned_idx = assign_anchor(lab[:, 1:], anc) # (錨框總數, )print("a: ", assigned_idx.shape)print(assigned_idx)bbox_mask = ((assigned_idx >= 0).float().unsqueeze(-1)).repeat(1, 4) # (錨框總數, 4)print("b: " , bbox_mask.shape)print(bbox_mask)cls_labels = torch.zeros(an, dtype=torch.long) # 0表示背景assigned_bb = torch.zeros((an, 4), dtype=torch.float32) # 所有anchor對應的bb坐標for i in range(an):bb_idx = assigned_idx[i]if bb_idx >= 0: # 即非背景cls_labels[i] = lab[bb_idx, 0].long().item() + 1 # 注意要加一assigned_bb[i, :] = lab[bb_idx, 1:]# 如何計算偏移量center_anc = xy_to_cxcy(anc) # (center_x, center_y, w, h)center_assigned_bb = xy_to_cxcy(assigned_bb)offset_xy = 10.0 * (center_assigned_bb[:, :2] - center_anc[:, :2]) / center_anc[:, 2:]offset_wh = 5.0 * torch.log(eps + center_assigned_bb[:, 2:] / center_anc[:, 2:])offset = torch.cat([offset_xy, offset_wh], dim = 1) * bbox_mask # (錨框總數, 4)return offset.view(-1), bbox_mask.view(-1), cls_labels# 組合輸出batch_offset = []batch_mask = []batch_cls_labels = []for b in range(bn):offset, bbox_mask, cls_labels = MultiBoxTarget_one(anchor[0, :, :], label[b, :, :])batch_offset.append(offset)batch_mask.append(bbox_mask)batch_cls_labels.append(cls_labels)bbox_offset = torch.stack(batch_offset)bbox_mask = torch.stack(batch_mask)cls_labels = torch.stack(batch_cls_labels)return [bbox_offset, bbox_mask, cls_labels]

我們通過unsqueeze函數為錨框和真實邊界框添加樣本維。

labels = MultiBoxTarget(anchors.unsqueeze(dim=0),ground_truth.unsqueeze(dim=0))

輸出：a: torch.Size([5])
tensor([-1, 0, 1, -1, 1])
b: torch.Size([5, 4])
tensor([[0., 0., 0., 0.],
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[0., 0., 0., 0.],
[1., 1., 1., 1.]])

返回的結果里有3項，均為Tensor。第三項表示為錨框標注的類別。

labels[2]

輸出：tensor([[0., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 1., 1., 1., 1.]])

返回的第一項是為每個錨框標注的四個偏移量，其中負類錨框的偏移量標注為0。

labels[0]

輸出：tensor([[-0.0000e+00, -0.0000e+00, -0.0000e+00, -0.0000e+00, 1.4000e+00,
1.0000e+01, 2.5940e+00, 7.1754e+00, -1.2000e+00, 2.6882e-01,
1.6824e+00, -1.5655e+00, -0.0000e+00, -0.0000e+00, -0.0000e+00,
-0.0000e+00, -5.7143e-01, -1.0000e+00, 4.1723e-06, 6.2582e-01]])

輸出預測邊界框

在模型預測階段，我們先為圖像生成多個錨框，并為這些錨框一一預測類別和偏移量。隨后，我們根據錨框及其預測偏移量得到預測邊界框。當錨框數量較多時，同一個目標上可能會輸出較多相似的預測邊界框。為了使結果更加簡潔，我們可以移除相似的預測邊界框。常用的方法叫作非極大值抑制（non-maximum suppression，NMS）。

我們來描述一下非極大值抑制的工作原理。對于一個預測邊界框

，模型會計算各個類別的預測概率。設其中最大的預測概率為，該概率所對應的類別即的預測類別。我們也將稱為預測邊界框的置信度。在同一圖像上，我們將預測類別非背景的預測邊界框按置信度從高到低排序，得到列表。從中選取置信度最高的預測邊界框作為基準，將所有與的交并比大于某閾值的非基準預測邊界框從中移除。這里的閾值是預先設定的超參數。此時，保留了置信度最高的預測邊界框并移除了與其相似的其他預測邊界框。 接下來，從中選取置信度第二高的預測邊界框作為基準，將所有與的交并比大于某閾值的非基準預測邊界框從中移除。重復這一過程，直到中所有的預測邊界框都曾作為基準。此時中任意一對預測邊界框的交并比都小于閾值。最終，輸出列表中的所有預測邊界框。

下面來看一個具體的例子。先構造4個錨框。簡單起見，我們假設預測偏移量全是0：預測邊界框即錨框。最后，我們構造每個類別的預測概率。

anchors = torch.tensor([[0.1, 0.08, 0.52, 0.92], [0.08, 0.2, 0.56, 0.95],[0.15, 0.3, 0.62, 0.91], [0.55, 0.2, 0.9, 0.88]]) offset_preds = torch.tensor([0.0] * (4 * len(anchors))) cls_probs = torch.tensor([[0., 0., 0., 0.,], # 背景的預測概率[0.9, 0.8, 0.7, 0.1], # 狗的預測概率[0.1, 0.2, 0.3, 0.9]]) # 貓的預測概率

在圖像上打印預測邊界框和它們的置信度。

fig = d2l.plt.imshow(img) show_bboxes(fig.axes, anchors * bbox_scale,['dog=0.9', 'dog=0.8', 'dog=0.7', 'cat=0.9'])

下面我們實現MultiBoxDetection函數來執行非極大值抑制。

# 以下函數已保存在d2lzh_pytorch包中方便以后使用 from collections import namedtuple Pred_BB_Info = namedtuple("Pred_BB_Info", ["index", "class_id", "confidence", "xyxy"])def non_max_suppression(bb_info_list, nms_threshold = 0.5):"""非極大抑制處理預測的邊界框Args:bb_info_list: Pred_BB_Info的列表, 包含預測類別、置信度等信息nms_threshold: 閾值Returns:output: Pred_BB_Info的列表, 只保留過濾后的邊界框信息"""output = []# 先根據置信度從高到低排序sorted_bb_info_list = sorted(bb_info_list, key = lambda x: x.confidence, reverse=True)# 循環遍歷刪除冗余輸出while len(sorted_bb_info_list) != 0:best = sorted_bb_info_list.pop(0)output.append(best)if len(sorted_bb_info_list) == 0:breakbb_xyxy = []for bb in sorted_bb_info_list:bb_xyxy.append(bb.xyxy)iou = compute_jaccard(torch.tensor([best.xyxy]), torch.tensor(bb_xyxy))[0] # shape: (len(sorted_bb_info_list), )n = len(sorted_bb_info_list)sorted_bb_info_list = [sorted_bb_info_list[i] for i in range(n) if iou[i] <= nms_threshold]return outputdef MultiBoxDetection(cls_prob, loc_pred, anchor, nms_threshold = 0.5):"""# 按照「9.4.1. 生成多個錨框」所講的實現, anchor表示成歸一化(xmin, ymin, xmax, ymax).https://zh.d2l.ai/chapter_computer-vision/anchor.htmlArgs:cls_prob: 經過softmax后得到的各個錨框的預測概率, shape:(bn, 預測總類別數+1, 錨框個數)loc_pred: 預測的各個錨框的偏移量, shape:(bn, 錨框個數*4)anchor: MultiBoxPrior輸出的默認錨框, shape: (1, 錨框個數, 4)nms_threshold: 非極大抑制中的閾值Returns:所有錨框的信息, shape: (bn, 錨框個數, 6)每個錨框信息由[class_id, confidence, xmin, ymin, xmax, ymax]表示class_id=-1 表示背景或在非極大值抑制中被移除了"""assert len(cls_prob.shape) == 3 and len(loc_pred.shape) == 2 and len(anchor.shape) == 3bn = cls_prob.shape[0]def MultiBoxDetection_one(c_p, l_p, anc, nms_threshold = 0.5):"""MultiBoxDetection的輔助函數, 處理batch中的一個Args:c_p: (預測總類別數+1, 錨框個數)l_p: (錨框個數*4, )anc: (錨框個數, 4)nms_threshold: 非極大抑制中的閾值Return:output: (錨框個數, 6)"""pred_bb_num = c_p.shape[1]anc = (anc + l_p.view(pred_bb_num, 4)).detach().cpu().numpy() # 加上偏移量confidence, class_id = torch.max(c_p, 0)confidence = confidence.detach().cpu().numpy()class_id = class_id.detach().cpu().numpy()pred_bb_info = [Pred_BB_Info(index = i,class_id = class_id[i] - 1, # 正類label從0開始confidence = confidence[i],xyxy=[*anc[i]]) # xyxy是個列表for i in range(pred_bb_num)]# 正類的indexobj_bb_idx = [bb.index for bb in non_max_suppression(pred_bb_info, nms_threshold)]output = []for bb in pred_bb_info:output.append([(bb.class_id if bb.index in obj_bb_idx else -1.0),bb.confidence,*bb.xyxy])return torch.tensor(output) # shape: (錨框個數, 6)batch_output = []for b in range(bn):batch_output.append(MultiBoxDetection_one(cls_prob[b], loc_pred[b], anchor[0], nms_threshold))return torch.stack(batch_output)

然后我們運行MultiBoxDetection函數并設閾值為0.5。這里為輸入都增加了樣本維。我們看到，返回的結果的形狀為(批量大小, 錨框個數, 6)。其中每一行的6個元素代表同一個預測邊界框的輸出信息。第一個元素是索引從0開始計數的預測類別（0為狗，1為貓），其中-1表示背景或在非極大值抑制中被移除。第二個元素是預測邊界框的置信度。剩余的4個元素分別是預測邊界框左上角的

和軸坐標以及右下角的和軸坐標（值域在0到1之間）。output = MultiBoxDetection(cls_probs.unsqueeze(dim=0), offset_preds.unsqueeze(dim=0),anchors.unsqueeze(dim=0), nms_threshold=0.5) output

fig = d2l.plt.imshow(img) for i in output[0].detach().cpu().numpy():if i[0] == -1:continuelabel = ('dog=', 'cat=')[int(i[0])] + str(i[1])show_bboxes(fig.axes, [torch.tensor(i[2:]) * bbox_scale], label)

實踐中，我們可以在執行非極大值抑制前將置信度較低的預測邊界框移除，從而減小非極大值抑制的計算量。我們還可以篩選非極大值抑制的輸出，例如，只保留其中置信度較高的結果作為最終輸出。

多尺度目標檢測

在9.4節（錨框）中，我們在實驗中以輸入圖像的每個像素為中心生成多個錨框。這些錨框是對輸入圖像不同區域的采樣。然而，如果以圖像每個像素為中心都生成錨框，很容易生成過多錨框而造成計算量過大。舉個例子，假設輸入圖像的高和寬分別為561像素和728像素，如果以每個像素為中心生成5個不同形狀的錨框，那么一張圖像上則需要標注并預測200多萬個錨框（

）。

減少錨框個數并不難。一種簡單的方法是在輸入圖像中均勻采樣一小部分像素，并以采樣的像素為中心生成錨框。此外，在不同尺度下，我們可以生成不同數量和不同大小的錨框。值得注意的是，較小目標比較大目標在圖像上出現位置的可能性更多。舉個簡單的例子：形狀為

、和的目標在形狀為的圖像上可能出現的位置分別有4、2和1種。因此，當使用較小錨框來檢測較小目標時，我們可以采樣較多的區域；而當使用較大錨框來檢測較大目標時，我們可以采樣較少的區域。

為了演示如何多尺度生成錨框，我們先讀取一張圖像。它的高和寬分別為561像素和728像素。

d2l.set_figsize()def display_anchors(fmap_w, fmap_h, s):# 前兩維的取值不影響輸出結果(原書這里是(1, 10, fmap_w, fmap_h), 我認為錯了)fmap = torch.zeros((1, 10, fmap_h, fmap_w), dtype=torch.float32)# 平移所有錨框使均勻分布在圖片上offset_x, offset_y = 1.0/fmap_w, 1.0/fmap_hanchors = d2l.MultiBoxPrior(fmap, sizes=s, ratios=[1, 2, 0.5]) + torch.tensor([offset_x/2, offset_y/2, offset_x/2, offset_y/2])bbox_scale = torch.tensor([[w, h, w, h]], dtype=torch.float32)d2l.show_bboxes(d2l.plt.imshow(img).axes,anchors[0] * bbox_scale) display_anchors(fmap_w=4, fmap_h=2, s=[0.15])

display_anchors(fmap_w=2, fmap_h=1, s=[0.4])

display_anchors(fmap_w=1, fmap_h=1, s=[0.8])

總結

以上是生活随笔為你收集整理的mpandroidchart y轴从0开始_从零开始学Pytorch（十七）之目标检测基础的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。