DL note 06：目標檢測/圖像分類，風格遷移

目標檢測基礎

邊界框

# 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'));

錨框（Anchor）

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

注: 學習用PyTorch做檢測可以先閱讀一下倉庫a-PyTorch-Tutorial-to-Object-Detection。

生成多錨框

假設輸入圖像高爲 $h$，寬爲$w$。我們分別以圖像的每個像素爲中心生成不同形狀的錨框。設大小爲$s\in (0,1]$且寬高比爲$r > 0$，那麼錨框的寬和高將分別爲$ws\sqrt{r}$和$hs/\sqrt{r}$。當中心位置給定時，已知寬和高的錨框是確定的。

下面我們分別設定好一組大小$s_1,\ldots,s_n$和一組寬高比$r_1,\ldots,r_m$。如果以每個像素爲中心時使用所有的大小與寬高比的組合，輸入圖像將一共得到$whnm$個錨框。雖然這些錨框可能覆蓋了所有的真實邊界框，但計算複雜度容易過高。因此，我們通常只對包含$s_1$或$r_1$的大小與寬高比的組合感興趣，即

$(s_1, r_1), (s_1, r_2), \ldots, (s_1, r_m), (s_2, r_1), (s_3, r_1), \ldots, (s_n, r_1).$

也就是說，以相同像素爲中心的錨框的數量爲$n+m-1$。對於整個輸入圖像，我們將一共生成$wh(n+m-1)$個錨框。

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

def MultiBoxPrior(feature_map, sizes=[0.75, 0.5, 0.25], ratios=[1, 2, 0.5]):
    """
    # 按照「生成多個錨框」所講的實現, anchor表示成(xmin, ymin, xmax, ymax).
    Args:
        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) / w
    shifts_y = np.arange(0, h) / h
    shift_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)

我們看到，返回錨框變量y的形狀爲（1，錨框個數，4）。將錨框變量y的形狀變爲（圖像高，圖像寬，以相同像素爲中心的錨框個數，4）後，我們就可以通過指定像素位置來獲取所有以該像素爲中心的錨框了。下面的例子裏我們訪問以（250，250）爲中心的第一個錨框。它有4個元素，分別是錨框左上角的$x$和$y$軸座標和右下角的$x$和$y$軸座標，其中$x$和$y$軸的座標值分別已除以圖像的寬和高，因此值域均爲0和1之間。

def show_bboxes(axes, bboxes, labels=None, colors=None):
    def _make_list(obj, default_values=None):
        if obj is None:
            obj = default_values
        elif not isinstance(obj, (list, tuple)):
            obj = [obj]
        return obj

    labels = _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))

交併比

我們剛剛提到某個錨框較好地覆蓋了圖像中的狗。如果該目標的真實邊界框已知，這裏的“較好”該如何量化呢？一種直觀的方法是衡量錨框和真實邊界框之間的相似度。我們知道，Jaccard係數（Jaccard index）可以衡量兩個集合的相似度。給定集合$\mathcal{A}$和$\mathcal{B}$，它們的Jaccard係數即二者交集大小除以二者並集大小：

$J(\mathcal{A},\mathcal{B}) = \frac{\left|\mathcal{A} \cap \mathcal{B}\right|}{\left| \mathcal{A} \cup \mathcal{B}\right|}.$

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

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 dimensions
    lower_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 intersections
    intersection = compute_intersection(set_1, set_2)  # (n1, n2)

    # Find areas of each box in both sets
    areas_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 dimensions
    union = areas_set_1.unsqueeze(1) + areas_set_2.unsqueeze(0) - intersection  # (n1, n2)

    return intersection / union  # (n1, n2)

標註訓練集的錨框

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

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

假設圖像中錨框分別爲$A_1, A_2, \ldots, A_{n_a}$，真實邊界框分別爲$B_1, B_2, \ldots, B_{n_b}$，且$n_a \geq n_b$。定義矩陣$\boldsymbol{X} \in \mathbb{R}^{n_a \times n_b}$，其中第$i$行第$j$列的元素$x_{ij}$爲錨框$A_i$與真實邊界框$B_j$的交併比。
首先，我們找出矩陣$\boldsymbol{X}$中最大元素，並將該元素的行索引與列索引分別記爲$i_1,j_1$。我們爲錨框$A_{i_1}$分配真實邊界框$B_{j_1}$。顯然，錨框$A_{i_1}$和真實邊界框$B_{j_1}$在所有的“錨框—真實邊界框”的配對中相似度最高。接下來，將矩陣$\boldsymbol{X}$中第$i_1$行和第$j_1$列上的所有元素丟棄。找出矩陣$\boldsymbol{X}$中剩餘的最大元素，並將該元素的行索引與列索引分別記爲$i_2,j_2$。我們爲錨框$A_{i_2}$分配真實邊界框$B_{j_2}$，再將矩陣$\boldsymbol{X}$中第$i_2$行和第$j_2$列上的所有元素丟棄。此時矩陣$\boldsymbol{X}$中已有兩行兩列的元素被丟棄。
依此類推，直到矩陣$\boldsymbol{X}$中所有$n_b$列元素全部被丟棄。這個時候，我們已爲$n_b$個錨框各分配了一個真實邊界框。
接下來，我們只遍歷剩餘的$n_a - n_b$個錨框：給定其中的錨框$A_i$，根據矩陣$\boldsymbol{X}$的第$i$行找到與$A_i$交併比最大的真實邊界框$B_j$，且只有當該交併比大於預先設定的閾值時，才爲錨框$A_i$分配真實邊界框$B_j$。

如圖9.3（左）所示，假設矩陣$\boldsymbol{X}$中最大值爲$x_{23}$，我們將爲錨框$A_2$分配真實邊界框$B_3$。然後，丟棄矩陣中第2行和第3列的所有元素，找出剩餘陰影部分的最大元素$x_{71}$，爲錨框$A_7$分配真實邊界框$B_1$。接着如圖9.3（中）所示，丟棄矩陣中第7行和第1列的所有元素，找出剩餘陰影部分的最大元素$x_{54}$，爲錨框$A_5$分配真實邊界框$B_4$。最後如圖9.3（右）所示，丟棄矩陣中第5行和第4列的所有元素，找出剩餘陰影部分的最大元素$x_{92}$，爲錨框$A_9$分配真實邊界框$B_2$。之後，我們只需遍歷除去$A_2, A_5, A_7, A_9$的剩餘錨框，並根據閾值判斷是否爲剩餘錨框分配真實邊界框。

現在我們可以標註錨框的類別和偏移量了。如果一個錨框$A$被分配了真實邊界框$B$，將錨框$A$的類別設爲$B$的類別，並根據$B$和$A$的中心座標的相對位置以及兩個框的相對大小爲錨框$A$標註偏移量。由於數據集中各個框的位置和大小各異，因此這些相對位置和相對大小通常需要一些特殊變換，才能使偏移量的分佈更均勻從而更容易擬合。設錨框$A$及其被分配的真實邊界框$B$的中心座標分別爲$(x_a, y_a)$和$(x_b, y_b)$，$A$和$B$的寬分別爲$w_a$和$w_b$，高分別爲$h_a$和$h_b$，一個常用的技巧是將$A$的偏移量標註爲

$\left( \frac{ \frac{x_b - x_a}{w_a} - \mu_x }{\sigma_x}, \frac{ \frac{y_b - y_a}{h_a} - \mu_y }{\sigma_y}, \frac{ \log \frac{w_b}{w_a} - \mu_w }{\sigma_w}, \frac{ \log \frac{h_b}{h_a} - \mu_h }{\sigma_h}\right),$

其中常數的默認值爲$\mu_x = \mu_y = \mu_w = \mu_h = 0, \sigma_x=\sigma_y=0.1, \sigma_w=\sigma_h=0.2$。如果一個錨框沒有被分配真實邊界框，我們只需將該錨框的類別設爲背景。類別爲背景的錨框通常被稱爲負類錨框，其餘則被稱爲正類錨框。

下面演示一個具體的例子。我們爲讀取的圖像中的貓和狗定義真實邊界框，其中第一個元素爲類別（0爲狗，1爲貓），剩餘4個元素分別爲左上角的$x$和$y$軸座標以及右下角的$x$和$y$軸座標（值域在0到1之間）。這裏通過左上角和右下角的座標構造了5個需要標註的錨框，分別記爲$A_0, \ldots, A_4$（程序中索引從0開始）。先畫出這些錨框與真實邊界框在圖像中的位置。

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

def assign_anchor(bb, anchor, jaccard_threshold=0.5):
    """
    # 爲每個anchor分配真實的bb, anchor表示成歸一化(xmin, ymin, xmax, ymax).
    
    Args:
        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] = j
        jaccard_cp[i, :] = float("-inf") # 賦值爲負無窮, 相當於去掉這一行
     
    # 處理還未被分配的anchor, 要求滿足jaccard_threshold
    for i in range(na):
        if assigned_idx[i] == -1:
            j = np.argmax(jaccard[i, :])
            if jaccard[i, j] >= jaccard_threshold:
                assigned_idx[i] = j
                
    return 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.py
    Args:
        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_y
                      xy[:, 2:] - xy[:, :2]], 1)  # w, h

def MultiBoxTarget(anchor, label):
    """
    #  anchor表示成歸一化(xmin, ymin, xmax, ymax).
   
    Args:
        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, 正類錨框的掩碼均爲1
        cls_labels: 每個錨框的標註類別, 其中0表示爲背景, 形狀爲(bn，錨框總數)
    """
    assert len(anchor.shape) == 3 and len(label.shape) == 3
    bn = label.shape[0]
    
    def MultiBoxTarget_one(anc, lab, eps=1e-6):
        """
        MultiBoxTarget函數的輔助函數, 處理batch中的一個
        Args:
            anc: shape of (錨框總數, 4)
            lab: shape of (真實錨框數, 5), 5代表[類別標籤, 四個座標值]
            eps: 一個極小值, 防止log0
        Returns:
            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]

我們根據錨框與真實邊界框在圖像中的位置來分析這些標註的類別。首先，在所有的“錨框—真實邊界框”的配對中，錨框$A_4$與貓的真實邊界框的交併比最大，因此錨框$A_4$的類別標註爲貓。不考慮錨框$A_4$或貓的真實邊界框，在剩餘的“錨框—真實邊界框”的配對中，最大交併比的配對爲錨框$A_1$和狗的真實邊界框，因此錨框$A_1$的類別標註爲狗。接下來遍歷未標註的剩餘3個錨框：與錨框$A_0$交併比最大的真實邊界框的類別爲狗，但交併比小於閾值（默認爲0.5），因此類別標註爲背景；與錨框$A_2$交併比最大的真實邊界框的類別爲貓，且交併比大於閾值，因此類別標註爲貓；與錨框$A_3$交併比最大的真實邊界框的類別爲貓，但交併比小於閾值，因此類別標註爲背景。

返回值的第二項爲掩碼（mask）變量，形狀爲(批量大小, 錨框個數的四倍)。掩碼變量中的元素與每個錨框的4個偏移量一一對應。
由於我們不關心對背景的檢測，有關負類的偏移量不應影響目標函數。通過按元素乘法，掩碼變量中的0可以在計算目標函數之前過濾掉負類的偏移量。

輸出預測邊界框

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

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

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

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

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:
            break

        bb_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 output

def MultiBoxDetection(cls_prob, loc_pred, anchor, nms_threshold = 0.5):
    """
    #  anchor表示成歸一化(xmin, ymin, xmax, ymax).
    
    Args:
        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) == 3
    bn = 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)]
        
        # 正類的index
        obj_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個元素分別是預測邊界框左上角的$x$和$y$軸座標以及右下角的$x$和$y$軸座標（值域在0到1之間）。最後輸出的結果是：

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

小結

• 以每個像素爲中心，生成多個大小和寬高比不同的錨框。
• 交併比是兩個邊界框相交面積與相併面積之比。
• 在訓練集中，爲每個錨框標註兩類標籤：一是錨框所含目標的類別；二是真實邊界框相對錨框的偏移量。
• 預測時，可以使用非極大值抑制來移除相似的預測邊界框，從而令結果簡潔。

多尺度目標檢測

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

減少錨框個數並不難。一種簡單的方法是在輸入圖像中均勻採樣一小部分像素，並以採樣的像素爲中心生成錨框。此外，在不同尺度下，我們可以生成不同數量和不同大小的錨框。值得注意的是，較小目標比較大目標在圖像上出現位置的可能性更多。舉個簡單的例子：形狀爲$1 \times 1$、$1 \times 2$和$2 \times 2$的目標在形狀爲$2 \times 2$的圖像上可能出現的位置分別有4、2和1種。因此，當使用較小錨框來檢測較小目標時，我們可以採樣較多的區域；而當使用較大錨框來檢測較大目標時，我們可以採樣較少的區域。

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

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])

圖像分類

CIFAR-10圖像分類

獲取和組織數據集

比賽數據分爲訓練集和測試集。訓練集包含 50,000 圖片。測試集包含 300,000 圖片。兩個數據集中的圖像格式均爲PNG，高度和寬度均爲32像素，並具有三個顏色通道（RGB）。圖像涵蓋10個類別：飛機，汽車，鳥類，貓，鹿，狗，青蛙，馬，船和卡車。 爲了更容易上手，我們提供了上述數據集的小樣本。“ train_tiny.zip”包含 80 訓練樣本，而“ test_tiny.zip”包含100個測試樣本。它們的未壓縮文件夾名稱分別是“ train_tiny”和“ test_tiny”。

圖像增強

使用torchvision.transforms中的Resize，RandomHorizontalFlip，RandomCrop等進行增強，transforms.ToTensor()轉換成$[0,1]$範圍的數據。transforms.Normalize進行數據的歸一化。

選擇模型

ResNet-18網絡結構：ResNet全名Residual Network殘差網絡。Kaiming He 的《Deep Residual Learning for Image Recognition》獲得了CVPR最佳論文。他提出的深度殘差網絡在2015年可以說是洗刷了圖像方面的各大比賽，以絕對優勢取得了多個比賽的冠軍。而且它在保證網絡精度的前提下，將網絡的深度達到了152層，後來又進一步加到1000的深度。

ImageNet圖像分類

設置隨機種子，增加實驗可復現性

random.seed(0)
torch.manual_seed(0)
torch.cuda.manual_seed(0)

整理數據集

我們可以從比賽網址上下載數據集，其目錄結構爲：

| Dog Breed Identification
    | train
    |   | 000bec180eb18c7604dcecc8fe0dba07.jpg
    |   | 00a338a92e4e7bf543340dc849230e75.jpg
    |   | ...
    | test
    |   | 00a3edd22dc7859c487a64777fc8d093.jpg
    |   | 00a6892e5c7f92c1f465e213fd904582.jpg
    |   | ...
    | labels.csv
    | sample_submission.csv

train和test目錄下分別是訓練集和測試集的圖像，訓練集包含10,222張圖像，測試集包含10,357張圖像，圖像格式都是JPEG，每張圖像的文件名是一個唯一的id。labels.csv包含訓練集圖像的標籤，文件包含10,222行，每行包含兩列，第一列是圖像id，第二列是狗的類別。狗的類別一共有120種。

我們希望對數據進行整理，方便後續的讀取，我們的主要目標是：

從訓練集中劃分出驗證數據集，用於調整超參數。劃分之後，數據集應該包含4個部分：劃分後的訓練集、劃分後的驗證集、完整訓練集、完整測試集
對於4個部分，建立4個文件夾：train, valid, train_valid, test。在上述文件夾中，對每個類別都建立一個文件夾，在其中存放屬於該類別的圖像。前三個部分的標籤已知，所以各有120個子文件夾，而測試集的標籤未知，所以僅建立一個名爲unknown的子文件夾，存放所有測試數據。

定義模型

這個比賽的數據屬於ImageNet數據集的子集，我們使用微調的方法，選用在ImageNet完整數據集上預訓練的模型來抽取圖像特徵，以作爲自定義小規模輸出網絡的輸入。

此處我們使用與訓練的ResNet-34模型，直接複用預訓練模型在輸出層的輸入，即抽取的特徵，然後我們重新定義輸出層，本次我們僅對重定義的輸出層的參數進行訓練，而對於用於抽取特徵的部分，我們保留預訓練模型的參數。

圖像風格遷移

樣式遷移

如果你是一位攝影愛好者，也許接觸過濾鏡。它能改變照片的顏色樣式，從而使風景照更加銳利或者令人像更加美白。但一個濾鏡通常只能改變照片的某個方面。如果要照片達到理想中的樣式，經常需要嘗試大量不同的組合，其複雜程度不亞於模型調參。

在本節中，我們將介紹如何使用卷積神經網絡自動將某圖像中的樣式應用在另一圖像之上，即樣式遷移（style transfer）。這裏我們需要兩張輸入圖像，一張是內容圖像，另一張是樣式圖像，我們將使用神經網絡修改內容圖像使其在樣式上接近樣式圖像。圖9.12中的內容圖像爲本書作者在西雅圖郊區的雷尼爾山國家公園（Mount Rainier National Park）拍攝的風景照，而樣式圖像則是一副主題爲秋天橡樹的油畫。最終輸出的合成圖像在保留了內容圖像中物體主體形狀的情況下應用了樣式圖像的油畫筆觸，同時也讓整體顏色更加鮮豔。

方法

用一個例子來闡述基於卷積神經網絡的樣式遷移方法。首先，我們初始化合成圖像，例如將其初始化成內容圖像。該合成圖像是樣式遷移過程中唯一需要更新的變量，即樣式遷移所需迭代的模型參數。然後，我們選擇一個預訓練的卷積神經網絡來抽取圖像的特徵，其中的模型參數在訓練中無須更新。深度卷積神經網絡憑藉多個層逐級抽取圖像的特徵。我們可以選擇其中某些層的輸出作爲內容特徵或樣式特徵。以圖9.13爲例，這裏選取的預訓練的神經網絡含有3個卷積層，其中第二層輸出圖像的內容特徵，而第一層和第三層的輸出被作爲圖像的樣式特徵。接下來，我們通過正向傳播（實線箭頭方向）計算樣式遷移的損失函數，並通過反向傳播（虛線箭頭方向）迭代模型參數，即不斷更新合成圖像。樣式遷移常用的損失函數由3部分組成：內容損失（content loss）使合成圖像與內容圖像在內容特徵上接近，樣式損失（style loss）令合成圖像與樣式圖像在樣式特徵上接近，而總變差損失（total variation loss）則有助於減少合成圖像中的噪點。最後，當模型訓練結束時，我們輸出樣式遷移的模型參數，即得到最終的合成圖像。

預處理和後處理圖像

下面定義圖像的預處理函數和後處理函數。預處理函數preprocess對輸入圖像在RGB三個通道分別做標準化，並將結果變換成卷積神經網絡接受的輸入格式。後處理函數postprocess則將輸出圖像中的像素值還原回標準化之前的值。由於圖像打印函數要求每個像素的浮點數值在0到1之間，我們使用clamp函數對小於0和大於1的值分別取0和1。

rgb_mean = np.array([0.485, 0.456, 0.406])
rgb_std = np.array([0.229, 0.224, 0.225])

def preprocess(PIL_img, image_shape):
    process = torchvision.transforms.Compose([
        torchvision.transforms.Resize(image_shape),
        torchvision.transforms.ToTensor(),
        torchvision.transforms.Normalize(mean=rgb_mean, std=rgb_std)])

    return process(PIL_img).unsqueeze(dim = 0) # (batch_size, 3, H, W)

def postprocess(img_tensor):
    inv_normalize = torchvision.transforms.Normalize(
        mean= -rgb_mean / rgb_std,
        std= 1/rgb_std)
    to_PIL_image = torchvision.transforms.ToPILImage()
    return to_PIL_image(inv_normalize(img_tensor[0].cpu()).clamp(0, 1))

抽取特徵

我們使用基於ImageNet數據集預訓練的VGG-19模型來抽取圖像特徵 。爲了抽取圖像的內容特徵和樣式特徵，我們可以選擇VGG網絡中某些層的輸出。一般來說，越靠近輸入層的輸出越容易抽取圖像的細節信息，反之則越容易抽取圖像的全局信息。爲了避免合成圖像過多保留內容圖像的細節，我們選擇VGG較靠近輸出的層，也稱內容層，來輸出圖像的內容特徵。我們還從VGG中選擇不同層的輸出來匹配局部和全局的樣式，這些層也叫樣式層。在“使用重複元素的網絡（VGG）”一節中我們曾介紹過，VGG網絡使用了5個卷積塊。實驗中，我們選擇第四卷積塊的最後一個卷積層作爲內容層，以及每個卷積塊的第一個卷積層作爲樣式層。這些層的索引可以通過打印pretrained_net實例來獲取。

style_layers, content_layers = [0, 5, 10, 19, 28], [25]

在抽取特徵時，我們只需要用到VGG從輸入層到最靠近輸出層的內容層或樣式層之間的所有層。下面構建一個新的網絡net，它只保留需要用到的VGG的所有層。我們將使用net來抽取特徵。
給定輸入X，如果簡單調用前向計算net(X)，只能獲得最後一層的輸出。由於我們還需要中間層的輸出，因此這裏我們逐層計算，並保留內容層和樣式層的輸出。

def extract_features(X, content_layers, style_layers):
    contents = []
    styles = []
    for i in range(len(net)):
        X = net[i](X)
        if i in style_layers:
            styles.append(X)
        if i in content_layers:
            contents.append(X)
    return contents, styles

下面定義兩個函數，其中get_contents函數對內容圖像抽取內容特徵，而get_styles函數則對樣式圖像抽取樣式特徵。因爲在訓練時無須改變預訓練的VGG的模型參數，所以我們可以在訓練開始之前就提取出內容圖像的內容特徵，以及樣式圖像的樣式特徵。由於合成圖像是樣式遷移所需迭代的模型參數，我們只能在訓練過程中通過調用extract_features函數來抽取合成圖像的內容特徵和樣式特徵。

def get_contents(image_shape, device):
    content_X = preprocess(content_img, image_shape).to(device)
    contents_Y, _ = extract_features(content_X, content_layers, style_layers)
    return content_X, contents_Y

def get_styles(image_shape, device):
    style_X = preprocess(style_img, image_shape).to(device)
    _, styles_Y = extract_features(style_X, content_layers, style_layers)
    return style_X, styles_Y

定義損失函數

下面我們來描述樣式遷移的損失函數。它由內容損失、樣式損失和總變差損失3部分組成。

內容損失

與線性迴歸中的損失函數類似，內容損失通過平方誤差函數衡量合成圖像與內容圖像在內容特徵上的差異。平方誤差函數的兩個輸入均爲extract_features函數計算所得到的內容層的輸出。

def content_loss(Y_hat, Y):
    return F.mse_loss(Y_hat, Y)

樣式損失

樣式損失也一樣通過平方誤差函數衡量合成圖像與樣式圖像在樣式上的差異。爲了表達樣式層輸出的樣式，我們先通過extract_features函數計算樣式層的輸出。假設該輸出的樣本數爲1，通道數爲$c$，高和寬分別爲$h$和$w$，我們可以把輸出變換成$c$行$hw$列的矩陣$\boldsymbol{X}$。矩陣$\boldsymbol{X}$可以看作是由$c$個長度爲$hw$的向量$x_1,x_2,\dots,x_c$組成的。其中$\boldsymbol{x}_i$向量代表了通道$i$上的樣式特徵。這些向量的格拉姆矩陣（Gram matrix）$\boldsymbol{X}\boldsymbol{X}^{T} \in \mathbb{R}^{c \times c}$中$i$行$j$列的元素$x_{ij}$即向量$\boldsymbol{x}_i$與$\boldsymbol{x}_j$的內積，它表達了通道$i$和通道$j$上樣式特徵的相關性。我們用這樣的格拉姆矩陣表達樣式層輸出的樣式。需要注意的是，當$hw$的值較大時，格拉姆矩陣中的元素容易出現較大的值。此外，格拉姆矩陣的高和寬皆爲通道數$c$。爲了讓樣式損失不受這些值的大小影響，下面定義的gram函數將格拉姆矩陣除以了矩陣中元素的個數，即$chw$。

def gram(X):
    num_channels, n = X.shape[1], X.shape[2] * X.shape[3]
    X = X.view(num_channels, n)
    return torch.matmul(X, X.t()) / (num_channels * n)

自然地，樣式損失的平方誤差函數的兩個格拉姆矩陣輸入分別基於合成圖像與樣式圖像的樣式層輸出。這裏假設基於樣式圖像的格拉姆矩陣gram_Y已經預先計算好了。

def style_loss(Y_hat, gram_Y):
    return F.mse_loss(gram(Y_hat), gram_Y)

總變差損失

有時候，我們學到的合成圖像裏面有大量高頻噪點，即有特別亮或者特別暗的顆粒像素。一種常用的降噪方法是總變差降噪（total variation denoising）。假設$x_{i,j}$表示座標$(i,j)$爲的像素值，降低總變差損失
$\sum_{i,j} \left|x_{i,j} - x_{i+1,j}\right| + \left|x_{i,j} - x_{i,j+1}\right|$
能夠儘可能使鄰近的像素值相似。

def tv_loss(Y_hat):
    return 0.5 * (F.l1_loss(Y_hat[:, :, 1:, :], Y_hat[:, :, :-1, :]) + 
                  F.l1_loss(Y_hat[:, :, :, 1:], Y_hat[:, :, :, :-1]))

損失函數

樣式遷移的損失函數即內容損失、樣式損失和總變差損失的加權和。通過調節這些權值超參數，我們可以權衡合成圖像在保留內容、遷移樣式以及降噪三方面的相對重要性。

content_weight, style_weight, tv_weight = 1, 1e3, 10

def compute_loss(X, contents_Y_hat, styles_Y_hat, contents_Y, styles_Y_gram):
    # 分別計算內容損失、樣式損失和總變差損失
    contents_l = [content_loss(Y_hat, Y) * content_weight for Y_hat, Y in zip(
        contents_Y_hat, contents_Y)]
    styles_l = [style_loss(Y_hat, Y) * style_weight for Y_hat, Y in zip(
        styles_Y_hat, styles_Y_gram)]
    tv_l = tv_loss(X) * tv_weight
    # 對所有損失求和
    l = sum(styles_l) + sum(contents_l) + tv_l
    return contents_l, styles_l, tv_l, l

創建和初始化合成圖像

在樣式遷移中，合成圖像是唯一需要更新的變量。因此，我們可以定義一個簡單的模型GeneratedImage，並將合成圖像視爲模型參數。模型的前向計算只需返回模型參數即可。

class GeneratedImage(torch.nn.Module):
    def __init__(self, img_shape):
        super(GeneratedImage, self).__init__()
        self.weight = torch.nn.Parameter(torch.rand(*img_shape))

    def forward(self):
        return self.weight
# 初始化函數並預先計算各個樣式層的gram矩陣
def get_inits(X, device, lr, styles_Y):
    gen_img = GeneratedImage(X.shape).to(device)
    gen_img.weight.data = X.data
    optimizer = torch.optim.Adam(gen_img.parameters(), lr=lr)
    styles_Y_gram = [gram(Y) for Y in styles_Y]
    return gen_img(), styles_Y_gram, optimizer

訓練結果

• 樣式遷移常用的損失函數由3部分組成：內容損失使合成圖像與內容圖像在內容特徵上接近，樣式損失令合成圖像與樣式圖像在樣式特徵上接近，而總變差損失則有助於減少合成圖像中的噪點。
• 可以通過預訓練的卷積神經網絡來抽取圖像的特徵，並通過最小化損失函數來不斷更新合成圖像。
• 用格拉姆矩陣表達樣式層輸出的樣式。