本文是對經典論文 SSD: Single Shot MultiBox Detector 的解析，耗時3周完成，萬字長文，可能是你能看到的最硬核的SSD教程了，如果想一遍搞懂SSD，那就耐心讀下去吧~

一句話總結SSD效果就是：比YOLO快一點且準很多，比Faster R-CNN快很多且精度差不多（僅就當時時間線而言）。可見這篇paper在目標檢測領域的重要性，話不多說，開始正文。

行文大致按照如下的流程進行：

• 首先嘗試對SSD的設計思想進行解析，帶你從大局觀上把握SSD的精髓
• 隨后盡可能全面的挖掘paper中的細節，并對照相應的pytorch版本SSD實現代碼進行介紹

一、SSD設計思想解析

結合我自己的理解，在深入論文之前，這里先來解析下SSD的設計思想。

既然帶檢測目標物體的位置、大小、形狀等情況多種多樣，那么就暴力的預設大量的不同位置、不同尺度、不同長寬比的眾多候選區域，來盡可能的cover住所有的情況。然后通過CNN端到端的一次性完成這些候選區域是否為關心的目標類別的預測，以及候選框與真實目標框之間偏差的預測，也就是對候選框進行微調，從而得到更好的目標框回歸效果。



SSD的設計中有類似Faster R-CNN中anchor的概念，同時也能夠看到YOLO的影子，可以說是對兩者的優點都有借鑒。

下面我們來更為詳細的解釋這一設計理念：

既然我們不知道待檢測的圖片中的物體大小，形狀和位置，那么我們就盡可能羅列所有的情況。我們可能需要小一些的候選區域，那我們就按8*8，或者16*16的分辨率對原圖進行初步的分割；同時我們我們也需要大一些的候選區域來檢測大的物體，那我們也需要4*4、2*2、甚至1*1這樣的分辨率。

我們可以這樣認為，在初步劃分候選區域大小后，每個劃分出的小格子負責預測其相鄰區域內出現的大小相當的物體。對于每個小格，我們可以再預設若干不同尺度以及長寬比之間的組合，來盡可能的涵蓋所有可能遇到的情況。如下圖我們可以看到，同一位置包含了長寬比1：1但尺度不同候選框，同時也包含了面積相同，但長寬比分別為1：1，2：1，1：2的候選框，從而能更好的囊括可能遇到的情況（下圖僅為作者在paper中給出的示意圖，實現細節可能會稍有差別）。

通過這樣近乎暴力的候選區域的羅列，總有一些預選框在位置、大小、形狀上大致的和圖片中物體的真實情況向對應。例如藍色和紅色的虛線表示的預選框就分別很好的對應了圖中的貓和狗。

現在我們要做的就是要讓模型學會為每一個候選框預測以下兩個信息：

• 候選框的類別（是背景，還是我們關心的目標類別，如貓、狗等）
• 目標物體的坐標（如果非背景，我們要學會預測候選框相對于真實目標框的坐標偏移量）

如何讓模型學會為所有的候選框都完成這樣的預測呢？最直接的想法，我們當然可以像R-CNN的做法一樣為每個候選區域應用一個CNN來完成類別和坐標的預測。

這樣做的一個致命問題就是速度實在堪憂，因為候選框實在太多。Ross Girshick大神已經在R-CNN -> Fast R-CNN -> Faster R-CNN 的發展歷程中給了我們的答案：

我們用來預測目標類別和坐標的輸入不必是原始圖像的rgb信息，也可以是CNN提取的更為抽象的高層特征，通過感受野的概念完成原始圖像中某塊感興趣區域與特征層feature map中相應區域的對應。這樣我們就可以通過一次前向推理，得到所有的候選區域對應的特征，在此基礎上完成類別和坐標預測，進而大幅提高速度。

YOLO也是利用卷積層提取的信息作為特征來進行最后的類別和坐標預測。

可以看到，這種思路已經成為了公認的設計思路。需要注意的是，無論是Fast R-CNN、Faster R-CNN還是YOLO，為每個候選區域提取的特征都來自同一高層特征layer對應的feature map。

而SSD的主要貢獻就是來源對于這個機制的改變，完全可以將不同的特征層的feature map利用起來。既然我們想設置不同尺度的預選框，那么我們就可以利用不同特征層感受野不同的這個特點，將小尺度的候選框分配給比較靠近輸入層的感受野小的淺層特征層來預測，將大尺度的候選框分配給遠離輸入層的感受野大的高層特征層來預測。

這樣就做到了一次推理完成了多種尺度預選框的預測，即SSD名字The Single Shot Detector (單發多框檢測器)的由來。我認為這也就是SSD的精髓所在，端到端的一階段方法保證了速度，多尺度的大量預選框保證了召回和map指標。

作者在 第一章 Introduction 中將SSD貢獻總結如下：

• 提出了SSD，一句話總結其效果就是：比YOLO快一點且準很多，比Faster R-CNN快很多且精度差不多
• SSD的核心是使用應用于特征圖上的小的卷積濾波器來預測一組預先設置好的默認bounding box的類別分數和位置坐標的偏移。
• 為了獲得高準確率，我們在不同分辨率的特征圖上進行預測，并且使用不同大小和長寬比的默認bbox。
• 這樣的設計帶來了簡單的端到端訓練和高準確率，即使在低分辨率的輸入圖像上，這進一步提升了速度和準確性的平衡問題。

到這里我們已經對SSD的設計初衷以及前向推理框架有了大致的了解，下面進入到paper中來仔細探索。

paper的內容安排：2.1小節介紹SSD框架，2.2介紹訓練方法，第三者介紹數據集相關的模型細節和實驗結果。

二、模型結構

SSD網絡的靠前的部分基于分類問題的標準網絡架構（在分類layer之前進行截斷），后面我們將其叫做 base network（基礎網絡）。本文使用VGG-16作為基礎網絡，其它優秀的backbone也是可以的。

在基礎網絡的基礎上我們加上一些輔助結構，以產生具有以下特性的檢測結果：

• Multi-scale feature maps for detection 多尺度的特征圖
• Convolutional predictors for detection 使用卷積進行檢測
• Default boxes and aspect ratios 設置默認檢測框與寬高比（類似于Faster R-CNN種anchor的設置）

其實前面關于SSD設計思想的討論中已經設計了這些概念，下面我們再對其中的一些細節進行講解。

多尺度的特征圖

在截斷的base network上添加若干卷積層，使得特征圖尺寸逐漸平滑的下降到1*1，從而最終得到多個尺度下的檢測框預測。每個尺度的特征層都使用獨立的卷積層進行預測。（Overfeat和YOLO都只在一個單一尺度的特征圖上進行預測）

SSD原版的實現輸入shape固定為300*300，使用了6個不同的尺度，分別是利用了Conv4_3、Conv7、Conv8_2、Conv9_2、Conv10_2和Conv11_ 2 這些層的feature maps作為檢測框預測的輸入特征。

其中，Conv4_3，Conv7來自VGG的base network：

其中conv7較為特殊，為了后面繼續接卷積層，作者將原版vgg中的全連接fc6，fc7替換為了卷積層conv6和conv7，同時還起到了加速的作用。

這部分比較trick，也有點炫技的成分~ 作者的原版描述如下，感興趣可以跟進下，這里就不展開了。

Similar to DeepLab-LargeFOV [17], we convert fc6 and fc7 to convolutional layers, subsample parameters from fc6 and fc7, change pool5 from 2 × 2 - s2 to 3 × 3 - s1, and use the `a trous algorithm [18] to fill the ”holes”.
[18] Holschneider, M., Kronland-Martinet, R., Morlet, J., Tchamitchian, P.: A real-time algorithm for signal analysis with the help of the wavelet transform. In: Wavelets. Springer (1990) 286–297

vgg基礎網絡部分的pytorch代碼實現如下：

# This function is derived from torchvision VGG make_layers() # https://github.com/pytorch/vision/blob/master/torchvision/models/vgg.py def vgg(cfg, i, batch_norm=False):""" 構造vgg backbonecfg: (list), 表示模型參數的列表，示例：[64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M', 512, 512, 512]i: (int), 輸入channel個數"""layers = []in_channels = ifor v in cfg:if v == 'M':layers += [nn.MaxPool2d(kernel_size=2, stride=2)]elif v == 'C':layers += [nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)] # ceil_mode 向上取整else:conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)if batch_norm:layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]else:layers += [conv2d, nn.ReLU(inplace=True)]in_channels = vpool5 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)conv6 = nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)conv7 = nn.Conv2d(1024, 1024, kernel_size=1)# 在vgg16 basenet基礎上補的pool5,conv6,conv7這三個層用來替代vgg16原本的全連接層# conv6的設置很有意思，參考paper參考文獻[18]# dilation參數的作用可以見https://github.com/vdumoulin/conv_arithmetic/blob/master/README.mdlayers += [pool5, conv6,nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]return layers

Conv8_2、Conv9_2、Conv10_2和Conv11_ 2 這4層來自在基礎網絡上額外添加的卷積層。 其代碼實現如下：

def add_extras(cfg, i, batch_norm=False):"""Extra layers added to VGG for feature scalingcfg: 配置信息，示例： [256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256],i: 輸入channel維度注：這個函數共包含了4次下采樣,這點容易產生困惑由vgg16的base模塊輸入的特征圖shape為19，四次下采樣的變化分別為19->10->5->3->1，注意觀察本函數的實現細節。四次特征圖發生變化的位置： [256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256],↑ ↑ ↑ ↑19->10 10->5 5->3 3->1"""layers = []in_channels = iflag = Falsefor k, v in enumerate(cfg):if in_channels != 'S':if v == 'S':layers += [nn.Conv2d(in_channels, cfg[k + 1],kernel_size=(1, 3)[flag], stride=2, padding=1)]else:layers += [nn.Conv2d(in_channels, v, kernel_size=(1, 3)[flag])] # 注意這里的Conv2d沒有padd,因此shape會發送變化flag = not flagin_channels = vreturn layers

通過上面的介紹和給出的代碼，不難自行驗證出 Conv4_3、Conv7、Conv8_2、Conv9_2、Conv10_2 和 Conv11_ 2 這6層卷積層的feature maps的shape分別為，38->19->10->5->3->1。

使用卷積進行檢測

對于每個用于檢測的特征層，通過卷積來進行每個位置對應的預設bbox的類別預測和坐標offset的預測。（R-CNN中使用SVM來進行分類的預測，YOLO使用全連接層作為過渡來完成預測）

這部分對應的代碼實現：

192 def multibox(vgg, extra_layers, cfg, num_classes): 193 """ 194 cfg: [4, 6, 6, 6, 4, 4], # number of boxes per feature map location 195 """ 196 loc_layers = [] 197 conf_layers = [] 198 vgg_source = [21, -2] 199 for k, v in enumerate(vgg_source): 200 loc_layers += [nn.Conv2d(vgg[v].out_channels, 201 cfg[k] * 4, kernel_size=3, padding=1)] 202 conf_layers += [nn.Conv2d(vgg[v].out_channels, 203 cfg[k] * num_classes, kernel_size=3, padding=1)] 204 for k, v in enumerate(extra_layers[1::2], 2): 205 loc_layers += [nn.Conv2d(v.out_channels, cfg[k] 206 * 4, kernel_size=3, padding=1)] 207 conf_layers += [nn.Conv2d(v.out_channels, cfg[k] 208 * num_classes, kernel_size=3, padding=1)] 209 return vgg, extra_layers, (loc_layers, conf_layers)

完整的網絡結構代碼見ssd.py，篇幅原因這里就不放了。

默認檢測框與寬高比

我們將特征圖的每個單元通過位置與若干預設的不同尺寸和長寬比的默認檢測框對應起來。對于特征圖的每一個單元，我們需要為其對應的不同尺寸和長寬比的默認檢測框預測其屬于每一個類別的概率以及位置相對于ground truth的偏移量。特別地，假設一個單元對應了k個默認檢測框，每一個檢測框我們需要預測c個類別分數以及4個位置偏移量，因此一個m*n的特征圖將會產生形狀為m*n*[(c+4)*k]的輸出。默認檢測框的設置類似Faster R-CNN中anchor boxes的設置，相比paper中作者給出的描述圖，下面的示意圖更符合代碼實現。

我們為每一個尺度下的候選框，都定義一個 min_size 和 一個 max_size，且某一尺度下候選框的 max_size 是其更大一級尺度的 min_size。

以長寬比1：1，大小為min_size的候選框為基準（如上圖較小的紅色框），又應用了與其面積相同，但長寬比不同的候選框（如上圖綠色框所示）。此外，單獨應用了一個尺寸為 $\sqrt{minsize?maxsize}$,長寬比1：1的候選框（如上圖較大紅色框所示）。

作者在2.2 training 中的 Choosing scales and aspect ratios for default boxes 一段，對 min_size 和 max_size 的設置又做了進一步的闡述。

正如上文所述，作者使用了平鋪的策略來讓多尺度策略均勻的涵蓋所有的目標物體的大小。所謂平鋪就是在設置的左右區間范圍內，讓尺度均勻地分布。這里的s_min = 0.2 指的是相對于原圖尺寸的比例，其余的信息公式表達的已經很清楚了。

為什么可以這樣設置呢？我們知道一個網絡中來自不同層的特征圖具有其特定的感受野，隨著網絡的加深感受野越來越大。使用了平鋪的策略正好可以利用這一點來為不同的特征層分配了不同的默認目標框尺寸，淺層特征層分配的尺度小，深層特征分配的尺度大，這樣分配的尺度就和其理論的感受野大致相符。

關于這塊的詳細設置，可以在 data/config.py文件中找到

# SSD300 CONFIGS voc = {'num_classes': 21,'lr_steps': (80000, 100000, 120000),'max_iter': 120000,'feature_maps': [38, 19, 10, 5, 3, 1],'min_dim': 300,'steps': [8, 16, 32, 64, 100, 300],'min_sizes': [30, 60, 111, 162, 213, 264],'max_sizes': [60, 111, 162, 213, 264, 315],'aspect_ratios': [[2], [2, 3], [2, 3], [2, 3], [2], [2]], # 寬高比，只需設置寬高比大于1的情況，相反的情況將會自動處理'variance': [0.1, 0.2],'clip': True, # 設置是否裁剪anchor越界的情況'name': 'VOC', }

代碼中的設置和paper中還是有點小區別的，SSD共有6個不同的尺度前面已經說過了，實現中第一個最小的尺度是單獨設置的，后面5個尺度是按照paper所述的方法進行的平鋪，如下表，我們自己算一下就和代碼對應上了。

min_size 比例值0.10.20.3750.550.7250.9

min_size 絕對值	30	60	111	162	213	264
max_size 絕對值	60	111	162	213	264	315

關于不同的長寬比，從代碼就可以看到，應該是考慮到大小適中的目標框出現的概率更多，作者為中間的幾種尺度額外設置了1：3和3：1長寬比的默認框。

此外，代碼中的steps 其實就是對應尺度下每一個小格的步長，例如第一個尺度為38*38，那么 steps[0] = 300 / 38 ≈ 7.89 向上取整 = 8

這一步涉及了蠻多細節，也有蠻多可調整的參數，我們不用糾結這些參數的取值，而是需要思考作者這些設計背后的用意，從而在我們的實際問題中靈活調整。作者自己也在paper中表述了，如何更好的設置這些候選框或者說anchor，本身就是一個開放問題，后續工作也會繼續研究。

我們已經扣了所有關于候選框生成的細節，下面再對照著代碼鞏固下。在 layers/functions/prior_box.py 中可以找到候選框生成部分的代碼：

class PriorBox(object):"""Compute priorbox coordinates in center-offset form for each sourcefeature map."""def __init__(self, cfg):super(PriorBox, self).__init__()self.image_size = cfg['min_dim']# number of priors for feature map location (either 4 or 6)self.num_priors = len(cfg['aspect_ratios'])self.variance = cfg['variance'] or [0.1]self.feature_maps = cfg['feature_maps']self.min_sizes = cfg['min_sizes']self.max_sizes = cfg['max_sizes']self.steps = cfg['steps']self.aspect_ratios = cfg['aspect_ratios']self.clip = cfg['clip']self.version = cfg['name']for v in self.variance:if v <= 0:raise ValueError('Variances must be greater than 0')def forward(self):mean = []for k, f in enumerate(self.feature_maps):for i, j in product(range(f), repeat=2):f_k = self.image_size / self.steps[k]# unit center x,ycx = (j + 0.5) / f_kcy = (i + 0.5) / f_k# aspect_ratio: 1# rel size: min_sizes_k = self.min_sizes[k]/self.image_sizemean += [cx, cy, s_k, s_k]# aspect_ratio: 1# rel size: sqrt(s_k * s_(k+1))s_k_prime = sqrt(s_k * (self.max_sizes[k]/self.image_size))mean += [cx, cy, s_k_prime, s_k_prime]# rest of aspect ratiosfor ar in self.aspect_ratios[k]:mean += [cx, cy, s_k*sqrt(ar), s_k/sqrt(ar)]mean += [cx, cy, s_k/sqrt(ar), s_k*sqrt(ar)]# back to torch landoutput = torch.Tensor(mean).view(-1, 4)if self.clip:output.clamp_(max=1, min=0)return output

三、訓練

回憶一下，我們已經介紹了SSD的模型結構，多尺度默認候選框的選擇和設置，前向推理的過程以及輸出所代表的含義。

下面我們介紹如何訓練SSD來讓模型正確的學會我們所期望其學會的信息：即每個候選框的類別以及相對于真實目標框ground truth的坐標偏移。達到這一目標的關鍵是需要將 ground truth 信息分配給網絡輸出的默認候選檢測框。一旦確定了這個分配，就可以端到端地應用損失函數和反向傳播。

paper作者在訓練過程種還使用了負樣本難例挖掘（hard negtive mining）和數據擴充策略（data augmentation strategies），我們也會分別介紹。

匹配策略

訓練過程中我們需要決定哪些默認的候選目標框是和真實的目標框是有匹配關系的，從而標注出每個候選目標框的期望預測結果，進而應用損失函數進行訓練。

正如下圖所示，我們很可能會認為，兩個藍色虛線框代表的候選目標框和貓的藍色真實目標框是匹配的，紅色虛線框代表的候選目標框和狗狗對應的紅色真實目標框是匹配的，而其余的黑色虛線候選框和任何真實目標都是不匹配的，無論是貓和狗。一旦建立了這樣的映射，我們就可以很方便的對模型的預測應用損失函數，對錯誤的預測進行懲罰，從而學習到正確的信息。

我們的大腦似乎很自然的就完成了這個匹配過程，那么我們如何將這個過程歸納成一個有固定模式的匹配策略呢？

首先我們要定義如何衡量單獨的一對目標框之間的匹配程度，像大多數方法一樣，SSD通過 jaccard overlap（對于矩形框來說就是IOU） 來衡量默認目標框和真實目標框之間的匹配程度。

然后我們需要計算所有真實目標框與所有候選框之間的overlap矩陣。矩陣的函數為真實目標框的個數，列數為候選框的個數，第i行第j列的元素是第i個真實目標框和第j個候選框之間的IOU。

大體上，我們找到每一列的最大值，就相當于為每一個預設候選框找到了最匹配的真實框，然后通過一個IOU閾值來判斷這是否是一個滿足要求的匹配。在此基礎上，paper作者加入了一個強制匹配機制，來確保每個真實框都能夠有預設的候選框與其匹配。這里我們不討論這樣的匹配機制的好與壞，而是先試圖把這個匹配策略的每一個環節解釋清楚。

我們拿個示例來說明可能會更加清晰，假設我們有3個真實的ground truth目標框，5個prior boxes候選框，計算得到了如下的overlap矩陣。

priorApriorBpriorCpriorDpriorE

gtA	0.8	0.1	0	0	0
gtB	0	0.5	0.7	0.9	0.1
gtC	0	0.2	0.1	0	0

匹配策略分為兩步：

第一步是先將每一個真實框和與其具有最高 jaccard overlap 的默認框進行強制匹配，這樣的操作確保了無論后面的操作如何進行，每一個真實框都至少與一個候選框完成了匹配。

代碼中通過將IOU匹配度強制賦值2來實現（因為IOU最大為1，強制也就體現在了這里），于是overlap矩陣變為：

priorApriorBpriorCpriorDpriorE

gtA	2	0.1	0	0	0
gtB	0	0.5	0.7	2	0.1
gtC	0	2	0.1	0	0

可以看到，priorB被強制匹配給了gtC，盡管預選框priorB似乎和gtB更加匹配，因為實在是沒有其它預選框和gtC匹配了。我想這個例子已經很好的解釋了作者的這個強制匹配策略。

然后第二步是將剩余的默認框和與其具有最高 jaccard overlap 的真實框進行匹配（前提是IOU大于閾值0.5），相當于進行按列求最大值。于是得到匹配結果：

priorApriorBpriorCpriorDpriorE

匹配類別	gtA	gtC	gtB	gtB	background

可以看到，SSD的匹配策略是允許多個候選框和同一個真實目標框進行匹配的，且同一個真實目標框至少匹配了一個候選框。

匹配過程實現的細節見layers/box_utils.py 中的 match 函數

目標函數

SSD的目標函數總體形式是分類損失和坐標回歸損失的加權和。

$$L(x,c,l,g)=\frac{1}{N}\left(L_{conf}(x,c)+\alpha L_{loc}(x,l,g)\right)$$

其中N是成功匹配的預設候選框的個數，α用于平衡兩種loss的權重，作者給出的取值為1。

回歸損失使用的是Smooth L1 Loss，沿用Faster R-CNN的設計，我們回歸的是預設候選框 d 的中心坐標cx，cy 以及寬高 w 和 h 相較于真實目標框 g 的偏差，公式如下：

$$L_{loc}(x,l,g)=\sum _{i\in Pos}^N\sum _{m\in \{cx,cy,w,h\}}{x}_{ij}^k{\mathrm{smooth}}_{L1}\left(l_i^m?{\hat{g}}_j^m\right)$$

$${\hat{g}}_j^{cx}=\left(g_j^{cx}?d_i^{cx}\right)/d_i^w{\hat{g}}_j^{cy}=\left(g_j^{cy}?d_i^{cy}\right)/d_i^h$$

$${\hat{g}}_j^w=\log \left(\frac{g_j^w}{d_i^w}\right){\hat{g}}_j^h=\log \left(\frac{g_j^h}{d_i^h}\right)$$

其中$x_{ij}^k$是一個標識符，$x_{ij}^k=1$代表第i個預設候選框和第j個類別為k的真實目標框是匹配的，這個符號想表達的就是只計算匹配的候選框的回歸損失，不匹配的預測的多么離譜也不關心。

并且我們注意到，這個偏差的預測，預測的是編碼后的偏差。中心坐標cx，cy 以及寬高 w 和 h 分別使用了不同的編碼方法，但目的和達到的效果都是類似的，那就是歸一化，幫助模型更好的收斂。

而smooth L1的計算方法如下:

$${\mathrm{smooth}}_{L_1}(x)=\{\begin{array}{ll}0.5x^2& \text{?if?}|x|<1\\ |x|?0.5& \text{?otherwise?}\end{array}$$

分類損失的部分就是預測出的多類別置信度c的softmax損失

$$L_{\text{conf}}(x,c)=?\sum _{i\in Pos}^N{x}_{ij}^p\log \left({\hat{c}}_i^p\right)?\sum _{i\in Neg}\log \left({\hat{c}}_i^0\right)\text{?where?}{\hat{c}}_i^p=\frac{\exp \left(c_i^p\right)}{{\sum }_p\exp \left(c_i^p\right)}$$

負樣本難例挖掘

由于默認候選框的數量眾多并且在完成匹配操作后，其中絕大多數會屬于負樣本，這就帶來了用于計算分類loss的正負樣本的極度不平衡問題。因此作者使用了難例挖掘，只從負樣本中選出loss最大的那些默認目標框作為負樣本，其余不參與loss計算，paper中正負樣
本比設置為1：3。

數據增強

論文中關于數據增強的描述有兩段，分別是2.2 training的末尾部分，以及3.6 Data Augmentation for Small Object Accuracy。

2.2 training 中關于數據增強的描述如下：

這部分介紹了SSD訓練過程使用的數據增強策略，核心就是通過一定概率進行的隨機采樣來加強模型對于輸入物體尺寸的魯棒性。在隨機采樣之后，不同shape的patch都會被縮放到固定的尺寸，也就是300*300，隨后以0.5的概率進行隨機的水平翻轉，并且加上一些類似paper中文獻[14]介紹的光學相關的扭曲和變換(photo-metric distortions)。

由于上面的介紹的數據增強方法一定程度是將圖片進行了“放大”，因此作者在 3.6 Data Augmentation for Small Object Accuracy 小節補充了關于如何通過數據增強來增加小目標檢測準確性的描述。

如上圖所示，作者使用將原圖貼到一張更大的隨機尺寸的背景圖中的方法，來達到“zoom out”的效果，并且證明了有2%-3%mAP的提升，尤其是對小目標檢測的效果。

我們將兩段關于數據增強的描述進行梳理，得到最終的數據增強方案，大致流程如下：

• 一定概率將原圖貼到一張更大的背景圖中（起到zoom out 作用）
• 隨機采樣一個patch（起到zoom in作用）
• 通過resize將不同shape的圖像塊fix到固定尺寸300*300
• 50%概率進行隨機水平翻轉
• 光線相關的扭曲變換

實現的時候可能在順序和一些細節上進行靈活調整，定義數據增強整體流程的代碼如下：

class SSDAugmentation(object):def __init__(self, size=300, mean=(104, 117, 123)):self.mean = meanself.size = sizeself.augment = Compose([ConvertFromInts(),ToAbsoluteCoords(), # 將取值0-1的相對坐標變絕對坐標(為了方便后面的變換)PhotometricDistort(), # 光線相關的扭曲變換,參考文獻[14]Expand(self.mean), # zoom out 操作RandomSampleCrop(), # RandomSample a patchRandomMirror(), # 50%概率進行隨機水平翻轉ToPercentCoords(), # 將絕對坐標變換回取值0-1的相對坐標Resize(self.size), # 通過resize將不同shape的圖像塊fix到固定尺寸300*300SubtractMeans(self.mean) # 按channel維度減去數據集均值])def __call__(self, img, boxes, labels):return self.augment(img, boxes, labels)

其中Compose函數的定義如下，

class Compose(object):"""Composes several augmentations together.Args:transforms (List[Transform]): list of transforms to compose.Example:>>> augmentations.Compose([>>> transforms.CenterCrop(10),>>> transforms.ToTensor(),>>> ])"""def __init__(self, transforms):self.transforms = transformsdef __call__(self, img, boxes=None, labels=None):for t in self.transforms:img, boxes, labels = t(img, boxes, labels)return img, boxes, labels

下面我們拆解著來看下論文和源碼：

PhotometricDistort()

applying some photo-metric distortions similar to those described in [14].

應用類似參考文獻[14]的光線相關的扭曲變換

14.Howard, A.G.: Some improvements on deep convolutional neural network based image classification. arXiv preprint arXiv:1312.5402 (2013)

class PhotometricDistort(object):def __init__(self):self.pd = [RandomContrast(),ConvertColor(transform='HSV'),RandomSaturation(),RandomHue(),ConvertColor(current='HSV', transform='BGR'),RandomContrast()]self.rand_brightness = RandomBrightness()self.rand_light_noise = RandomLightingNoise()def __call__(self, image, boxes, labels):im = image.copy()im, boxes, labels = self.rand_brightness(im, boxes, labels)if random.randint(2):distort = Compose(self.pd[:-1])else:distort = Compose(self.pd[1:])im, boxes, labels = distort(im, boxes, labels)return self.rand_light_noise(im, boxes, labels)

Expand(self.mean)
隨機貼圖從而起到zoom out的效果

To implement a ”zoom out” operation that creates more small training examples, we first randomly place an image on a canvas of 16× of the original image size filled with mean values before we do any random crop operation.

class Expand(object):def __init__(self, mean):self.mean = meandef __call__(self, image, boxes, labels):if random.randint(2): # 一半的概率不進行操作return image, boxes, labelsheight, width, depth = image.shaperatio = random.uniform(1, 4)left = random.uniform(0, width*ratio - width)top = random.uniform(0, height*ratio - height)expand_image = np.zeros((int(height*ratio), int(width*ratio), depth),dtype=image.dtype)expand_image[:, :, :] = self.meanexpand_image[int(top):int(top + height),int(left):int(left + width)] = imageimage = expand_imageboxes = boxes.copy()boxes[:, :2] += (int(left), int(top))boxes[:, 2:] += (int(left), int(top))return image, boxes, labels

RandomSampleCrop()
隨機采樣一個patch

each training image is randomly sampled by one of the following options:
– Use the entire original input image.
– Sample a patch so that the minimum jaccard overlap with the objects is 0.1, 0.3,
0.5, 0.7, or 0.9.
– Randomly sample a patch.
The size of each sampled patch is [0.1, 1] of the original image size, and the aspect ratio is between 0.5 and 2.
We keep the overlapped part of the ground truth box if the center of it is in the sampled patch.

class RandomSampleCrop(object):"""CropArguments:img (Image): the image being input during trainingboxes (Tensor): the original bounding boxes in pt formlabels (Tensor): the class labels for each bboxmode (float tuple): the min and max jaccard overlapsReturn:(img, boxes, classes)img (Image): the cropped imageboxes (Tensor): the adjusted bounding boxes in pt formlabels (Tensor): the class labels for each bbox"""def __init__(self):self.sample_options = (# using entire original input imageNone,# sample a patch s.t. MIN jaccard w/ obj in .1,.3,.4,.7,.9(0.1, None),(0.3, None),(0.7, None),(0.9, None),# randomly sample a patch(None, None),)def __call__(self, image, boxes=None, labels=None):height, width, _ = image.shapewhile True:# randomly choose a modemode = random.choice(self.sample_options)if mode is None:return image, boxes, labelsmin_iou, max_iou = modeif min_iou is None:min_iou = float('-inf')if max_iou is None:max_iou = float('inf')# max trails (50)for _ in range(50):current_image = imagew = random.uniform(0.3 * width, width)h = random.uniform(0.3 * height, height)# aspect ratio constraint b/t .5 & 2if h / w < 0.5 or h / w > 2:continueleft = random.uniform(width - w)top = random.uniform(height - h)# convert to integer rect x1,y1,x2,y2rect = np.array([int(left), int(top), int(left+w), int(top+h)])# calculate IoU (jaccard overlap) b/t the cropped and gt boxesoverlap = jaccard_numpy(boxes, rect)# is min and max overlap constraint satisfied? if not try againif overlap.min() < min_iou and max_iou < overlap.max():continue# cut the crop from the imagecurrent_image = current_image[rect[1]:rect[3], rect[0]:rect[2], :]# keep overlap with gt box IF center in sampled patchcenters = (boxes[:, :2] + boxes[:, 2:]) / 2.0# mask in all gt boxes that above and to the left of centersm1 = (rect[0] < centers[:, 0]) * (rect[1] < centers[:, 1])# mask in all gt boxes that under and to the right of centersm2 = (rect[2] > centers[:, 0]) * (rect[3] > centers[:, 1])# mask in that both m1 and m2 are truemask = m1 * m2# have any valid boxes? try again if notif not mask.any():continue# take only matching gt boxescurrent_boxes = boxes[mask, :].copy()# take only matching gt labelscurrent_labels = labels[mask]# should we use the box left and top corner or the crop'scurrent_boxes[:, :2] = np.maximum(current_boxes[:, :2], rect[:2])# adjust to crop (by substracting crop's left,top)current_boxes[:, :2] -= rect[:2]current_boxes[:, 2:] = np.minimum(current_boxes[:, 2:], rect[2:])# adjust to crop (by substracting crop's left,top)current_boxes[:, 2:] -= rect[:2]return current_image, current_boxes, current_labels

RandomMirror()
50%概率進行隨機水平翻轉

class RandomMirror(object):def __call__(self, image, boxes, classes):_, width, _ = image.shapeif random.randint(2):image = image[:, ::-1]boxes = boxes.copy()boxes[:, 0::2] = width - boxes[:, 2::-2]return image, boxes, classes

Resize(self.size)
通過resize將不同shape的圖像塊fix到固定尺寸

class Resize(object):def __init__(self, size=300):self.size = sizedef __call__(self, image, boxes=None, labels=None):image = cv2.resize(image, (self.size,self.size))return image, boxes, labels

-------------------------------------分割線-------------------------------------------

呼~ 終于肝完了，希望對各位有所幫助

注： 為了保證內容的準確性，我幾乎只參考了paper和源碼。但個人水平畢竟有限，如有錯誤，歡迎指出。
注： 本文中的部分配圖非原創，來自以下文章或博客：
https://zhuanlan.zhihu.com/p/113635317
https://zh.d2l.ai/chapter_computer-vision/multiscale-object-detection.html
https://blog.csdn.net/xunan003/article/details/79186162

總結

以上是生活随笔為你收集整理的SSD之硬的不能再硬的硬核解析的全部內容，希望文章能夠幫你解決所遇到的問題。

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