1. 紅外小目標檢測

紅外小目標檢測的目標比較小，目標極其容易和其他物體混淆，有一定的挑戰性。

另外，這本質上也是一個小目標領域的問題，很多適用于小目標的創新點也會被借鑒進來。

 

此外，該數據集還有一個特點，就是分背景，雖然同樣是檢測紅外小目標，區別是背景的不同，我們對數據集進行了統計以及通過人工翻看的方式總結了其特點，如下表所示：

通過以上結果，可以看出背景的不同對結果影響還是蠻大的，最后一列也給出了針對性的建議，打算后續實施。

2. 實驗過程

首先，我們使用的是U版的yolov3: https://github.com/ultralytics/yolov3，那時候YOLOv4/5、PPYOLO還都沒出，當時出了一個《從零開始學習YOLOv3》就是做項目的時候寫的電子書，其中的在YOLOv3中添加注意力機制那篇很受歡迎（可以水很多文章出來，畢業要緊:）

我們項目的代碼以及修改情況可以查看：https://github.com/GiantPandaCV/yolov3-point

將數據集轉成VOC格式的數據集，之前文章有詳細講述如何轉化為標準的VOC數據集，以及如何將VOC格式數據集轉化為U版的講解。當時接觸到幾個項目，都需要用YOLOv3，由于每次都需要轉化，大概分別調用4、5個腳本吧，感覺很累，所以當時花了一段時間構建了一個一鍵從VOC轉U版YOLOv3格式的腳本庫: https://github.com/pprp/voc2007_for_yolo_torch。

到此時為止，我們項目就已經可以運行了，然后就是很多細節調整了。

2.1 修改Anchor

紅外小目標的Anchor和COCO等數據集的Anchor是差距很大的，為了更好更快速的收斂，采用了BBuf總結的一套專門計算Anchor的腳本：

#coding=utf-8
import xml.etree.ElementTree as ET
import numpy as np

 
def iou(box, clusters):
    """
    計算一個ground truth邊界盒和k個先驗框(Anchor)的交并比(IOU)值。
    參數box: 元組或者數據，代表ground truth的長寬。
    參數clusters: 形如(k,2)的numpy數組，其中k是聚類Anchor框的個數
    返回：ground truth和每個Anchor框的交并比。
    """
    x = np.minimum(clusters[:, 0], box[0])
    y = np.minimum(clusters[:, 1], box[1])
    if np.count_nonzero(x == 0) > 0 or np.count_nonzero(y == 0) > 0:
        raise ValueError("Box has no area")
    intersection = x * y
    box_area = box[0] * box[1]
    cluster_area = clusters[:, 0] * clusters[:, 1]
    iou_ = intersection / (box_area + cluster_area - intersection)
    return iou_


def avg_iou(boxes, clusters):
    """
    計算一個ground truth和k個Anchor的交并比的均值。
    """
    return np.mean([np.max(iou(boxes[i], clusters)) for i in range(boxes.shape[0])])

def kmeans(boxes, k, dist=np.median):
    """
    利用IOU值進行K-means聚類
    參數boxes: 形狀為(r, 2)的ground truth框，其中r是ground truth的個數
    參數k: Anchor的個數
    參數dist: 距離函數
    返回值：形狀為(k, 2)的k個Anchor框
    """
    # 即是上面提到的r
    rows = boxes.shape[0]
    # 距離數組，計算每個ground truth和k個Anchor的距離
    distances = np.empty((rows, k))
    # 上一次每個ground truth"距離"最近的Anchor索引
    last_clusters = np.zeros((rows,))
    # 設置隨機數種子
    np.random.seed()

    # 初始化聚類中心，k個簇，從r個ground truth隨機選k個
    clusters = boxes[np.random.choice(rows, k, replace=False)]
    # 開始聚類
    while True:
        # 計算每個ground truth和k個Anchor的距離，用1-IOU(box,anchor)來計算
        for row in range(rows):
            distances[row] = 1 - iou(boxes[row], clusters)
        # 對每個ground truth，選取距離最小的那個Anchor，并存下索引
        nearest_clusters = np.argmin(distances, axis=1)
        # 如果當前每個ground truth"距離"最近的Anchor索引和上一次一樣，聚類結束
        if (last_clusters == nearest_clusters).all():
            break
        # 更新簇中心為簇里面所有的ground truth框的均值
        for cluster in range(k):
            clusters[cluster] = dist(boxes[nearest_clusters == cluster], axis=0)
        # 更新每個ground truth"距離"最近的Anchor索引
        last_clusters = nearest_clusters

    return clusters

# 加載自己的數據集，只需要所有labelimg標注出來的xml文件即可
def load_dataset(path):
    dataset = []
    for xml_file in glob.glob("{}/*xml".format(path)):
        tree = ET.parse(xml_file)
        # 圖片高度
        height = int(tree.findtext("./size/height"))
        # 圖片寬度
        width = int(tree.findtext("./size/width"))
        
        for obj in tree.iter("object"):
            # 偏移量
            xmin = int(obj.findtext("bndbox/xmin")) / width
            ymin = int(obj.findtext("bndbox/ymin")) / height
            xmax = int(obj.findtext("bndbox/xmax")) / width
            ymax = int(obj.findtext("bndbox/ymax")) / height
            xmin = np.float64(xmin)
            ymin = np.float64(ymin)
            xmax = np.float64(xmax)
            ymax = np.float64(ymax)
            if xmax == xmin or ymax == ymin:
                print(xml_file)
            # 將Anchor的長寬放入dateset，運行kmeans獲得Anchor
            dataset.append([xmax - xmin, ymax - ymin])
    return np.array(dataset)
 
if __name__ == '__main__':
    
    ANNOTATIONS_PATH = "F:\Annotations" #xml文件所在文件夾
    CLUSTERS = 9 #聚類數量，anchor數量
    INPUTDIM = 416 #輸入網絡大小
 
    data = load_dataset(ANNOTATIONS_PATH)
    out = kmeans(data, k=CLUSTERS)
    print('Boxes:')
    print(np.array(out)*INPUTDIM)    
    print("Accuracy: {:.2f}%".format(avg_iou(data, out) * 100))       
    final_anchors = np.around(out[:, 0] / out[:, 1], decimals=2).tolist()
    print("Before Sort Ratios:\n {}".format(final_anchors))
    print("After Sort Ratios:\n {}".format(sorted(final_anchors)))

通過瀏覽腳本就可以知道，Anchor和圖片的輸入分辨率有沒有關系 這個問題了，當時這個問題有很多群友都在問。通過kmeans函數得到的結果實際上是歸一化到0-1之間的，然后Anchor的輸出是在此基礎上乘以輸入分辨率的大小。所以個人認為Anchor和圖片的輸入分辨率是有關系的。

此外，U版也提供了Anchor計算，如下：

def kmean_anchors(path='./2007_train.txt', n=5, img_size=(416, 416)):
    # from utils.utils import *; _ = kmean_anchors()
    # Produces a list of target kmeans suitable for use in *.cfg files
    from utils.datasets import LoadImagesAndLabels
    thr = 0.20  # IoU threshold

    def print_results(thr, wh, k):
        k = k[np.argsort(k.prod(1))]  # sort small to large
        iou = wh_iou(torch.Tensor(wh), torch.Tensor(k))
        max_iou, min_iou = iou.max(1)[0], iou.min(1)[0]
        bpr, aat = (max_iou > thr).float().mean(), (
            iou > thr).float().mean() * n  # best possible recall, anch > thr
        print('%.2f iou_thr: %.3f best possible recall, %.2f anchors > thr' %
              (thr, bpr, aat))
        print(
            'kmeans anchors (n=%g, img_size=%s, IoU=%.3f/%.3f/%.3f-min/mean/best): '
            % (n, img_size, min_iou.mean(), iou.mean(), max_iou.mean()),
            end='')
        for i, x in enumerate(k):
            print('%i,%i' % (round(x[0]), round(x[1])),
                  end=',  ' if i < len(k) - 1 else '\n')  # use in *.cfg
        return k

    def fitness(thr, wh, k):  # mutation fitness
        iou = wh_iou(wh, torch.Tensor(k)).max(1)[0]  # max iou
        bpr = (iou > thr).float().mean()  # best possible recall
        return iou.mean() * bpr  # product

    # Get label wh
    wh = []
    dataset = LoadImagesAndLabels(path,
                                  augment=True,
                                  rect=True,
                                  cache_labels=True)
    nr = 1 if img_size[0] == img_size[1] else 10  # number augmentation repetitions
    for s, l in zip(dataset.shapes, dataset.labels):
        wh.append(l[:, 3:5] *
                  (s / s.max()))  # image normalized to letterbox normalized wh
    wh = np.concatenate(wh, 0).repeat(nr, axis=0)  # augment 10x
    wh *= np.random.uniform(img_size[0], img_size[1],
                            size=(wh.shape[0],
                                  1))  # normalized to pixels (multi-scale)

    # Darknet yolov3.cfg anchors
    use_darknet = False
    if use_darknet:
        k = np.array([[10, 13], [16, 30], [33, 23], [30, 61], [62, 45],
                      [59, 119], [116, 90], [156, 198], [373, 326]])
    else:
        # Kmeans calculation
        from scipy.cluster.vq import kmeans
        print('Running kmeans for %g anchors on %g points...' % (n, len(wh)))
        s = wh.std(0)  # sigmas for whitening
        k, dist = kmeans(wh / s, n, iter=30)  # points, mean distance
        k *= s
    k = print_results(thr, wh, k)
    # Evolve
    wh = torch.Tensor(wh)
    f, ng = fitness(thr, wh, k), 2000  # fitness, generations
    for _ in tqdm(range(ng), desc='Evolving anchors'):
        kg = (
            k.copy() *
            (1 + np.random.random() * np.random.randn(*k.shape) * 0.30)).clip(
                min=2.0)
        fg = fitness(thr, wh, kg)
        if fg > f:
            f, k = fg, kg.copy()
            print_results(thr, wh, k)
    k = print_results(thr, wh, k)

    return k

這個和超參數搜索那篇采用的方法類似，也是一種類似遺傳算法的方法，通過一代一代的篩選找到合適的Anchor。以上兩種方法筆者并沒有對比，有興趣可以試試這兩種方法，對比看看。

Anchor這方面設置了三個不同的數量進行聚類：

3 anchor:

13, 18, 16, 22, 19, 25

6 anchor:

12,17, 14,17, 15,19, 15,21, 13,20, 19,24

9 anchor:

10,16, 12,17, 13,20, 13,22, 15,18, 15,20, 15,23, 18,23, 21,26

2.2 構建Baseline

由于數據集是單類的，并且相對VOC等數據集來看，比較單一，所以不打算使用Darknet53這樣的深度神經網絡，采用的Baseline是YOLOv3-tiny模型，在使用原始Anchor的情況下，該模型可以在驗證集上達到mAP@0.5=93.2%，在測試集上達到mAP@0.5=0.869的結果。

那接下來換Anchor，用上一節得到的新Anchor替換掉原來的Anchor，該改掉的模型為yolov3-tiny-6a:

可以看到幾乎所有的指標都提升了，這說明Anchor先驗的引入是很有必要的。

2.3 數據集部分改進

上邊已經分析過了，背景對目標檢測的結果還是有一定影響的，所以我們先后使用了幾種方法進行改進。

第一個：過采樣

通過統計不同背景的圖像的數量，比如以sea為背景的圖像只有17張，而最多的cloudless_sky為背景的圖像有1300+張，這就產生了嚴重的不平衡性。顯然cloudless_sky為背景的很簡單，sea為背景的難度更大，這樣由于數據不平衡的原因，訓練得到的模型很可能也會在cloudless_sky這類圖片上效果很好，在其他背景下效果一般。

所以首先要采用過采樣的方法，這里的過采樣可能和別的地方的不太一樣，這里指的是將某些背景數量小的圖片通過復制的方式擴充。

:( 可惜實驗結果不支持想法，一起分析一下。ps:os代表over sample

然后進行分背景測試，結果如下：

均衡后的分背景測試

從分背景結果來看，確實sea訓練數據很少的結果很好，mAP提高了2個點，但是complex_cloud等mAP有所下降。總結一下就是對于訓練集中數據很少的背景類mAP有提升，但是其他本身數量就很多的背景mAP略微下降或者保持。

第二個：在圖片中任意位置復制小目標

修改后的版本地址：https://github.com/pprp/SimpleCVReproduction/tree/master/SmallObjectAugmentation

具體實現思路就是，先將所有小目標摳出來備用。然后在圖像上復制這些小目標，要求兩兩之間重合率不能達到一個閾值并且復制的位置不能超出圖像邊界。

效果如下：（這個是示意圖，比較夸張，復制的個數比較多

 

這種做法來自當時比較新的論文《Augmentation for small object detection》,文中最好的結果是復制了1-2次。實際我們項目中也試過1次、2次、3次到多次的結果，都不盡如人意，結果太差就沒有記錄下來。。（話說論文中展示的效果最佳組合是原圖+增強后的圖，并且最好的結果也就提高了1個百分點）╮(╯﹏╰）╭

2.4 修改Backbone

修改Backbone經常被群友問到這樣一件事，修改骨干網絡以后無法加載預訓練權重了，怎么辦？

有以下幾個辦法：

• 干脆不加載，從頭訓練，簡單問題（比如紅外小目標）從頭收斂效果也不次于有預訓練權重的。

• 不想改代碼的話，可以選擇修改Backbone之后、YOLO Head之前的部分（比如SPP的位置屬于這種情況）

• 能力比較強的，可以改一下模型加載部分代碼，跳過你新加入的模塊，這樣也能加載（筆者沒試過，別找我）。

修改Backbone我們也從幾個方向入的手，分為注意力模塊、即插即用模塊、修改FPN、修改激活函數、用成熟的網絡替換backbone和SPP系列。

1. 注意力模塊

這個項目中使用的注意力模塊，大部分都在公號上寫過代碼解析，感興趣的可以翻看一下。筆者前一段時間公布了一個電子書《卷積神經網絡中的即插即用模塊》也是因為這個項目中總結了很多注意力模塊，所以開始整理得到的結果。具體模塊還在繼續更新：https://github.com/pprp/SimpleCVReproduction

當時實驗的模塊有：SE、CBAM等，由于當時Baseline有點高，效果并不十分理想。（注意力模塊插進來不可能按照預期一下就提高多少百分點，需要多調參才有可能超過原來的百分點）根據群友反饋，SE直接插入成功率比較高。筆者在一個目標檢測比賽中見到有一個大佬是在YOLOv3的FPN的三個分支上各加了一個CBAM，最終超過Cascade R-CNN等模型奪得冠軍。

2. 即插即用模塊

注意力模塊也屬于即插即用模塊，這部分就說的是非注意力模塊的部分如 FFM、ASPP、PPM、Dilated Conv、SPP、FRB、CorNerPool、DwConv、ACNet等，效果還可以，但是沒有超過當前最好的結果。

3. 修改FPN

FPN這方面花了老久時間，參考了好多版本才搞出了一個dt-6a-bifpn(dt代表dim target紅外目標；6a代表6個anchor)，令人失望的是，這個BiFPN效果并不好，測試集上效果更差了。可能是因為實現的cfg有問題，歡迎反饋。

大家都知道通過改cfg的方式改網絡結構是一件很痛苦的事情，推薦一個可視化工具：

https://lutzroeder.github.io/netron/

除此以外，為了方便查找行數，筆者寫了一個簡單腳本用于查找行數（獻丑了

import os
import shutil
cfg_path = "./cfg/yolov3-dwconv-cbam.cfg"
save_path = "./cfg/preprocess_cfg/"
new_save_name = os.path.join(save_path,os.path.basename(cfg_path))

f = open(cfg_path, 'r')
lines = f.readlines()

# 去除以#開頭的，屬于注釋部分的內容
# lines = [x for x in lines if x and not x.startswith('#')]
# lines = [x.rstrip().lstrip() for x in lines]

lines_nums = []
layers_nums = []

layer_cnt = -1

for num, line in enumerate(lines):
    if line.startswith('['):
        layer_cnt += 1
        layers_nums.append(layer_cnt)
        lines_nums.append(num+layer_cnt)
        print(line)
        # s = s.join("")
    # s = s.join(line)
for i,num in enumerate(layers_nums):
    print(lines_nums[i], num)
    lines.insert(lines_nums[i]-1, '# layer-%d\n' % (num-1))
fo = open(new_save_name, 'w')
fo.write(''.join(lines))
fo.close()
f.close()

我們也嘗試了只用一個、兩個和三個YOLO Head的情況，結果是3>2>1，但是用3個和2個效果幾乎一樣，差異不大小數點后3位的差異，所以還是選用兩個YOLO Head。

4. 修改激活函數

YOLO默認使用的激活函數是leaky relu,激活函數方面使用了mish。效果并沒有提升，所以無疾而終了。

5. 用成熟的網絡替換backbone

這里使用了ResNet10(第三方實現)、DenseNet、BBuf修改的DenseNet、ENet、VOVNet(自己改的)、csresnext50-panet(當時AB版darknet提供的)、PRN(作用不大)等網絡結構。

當前最強的網絡是dense-v3-tiny-spp，也就是BBuf修改的Backbone+原汁原味的SPP組合的結構完虐了其他模型，在測試集上達到了mAP@0.5=0.932、F1=0.951的結果。

6. SPP系列

這個得好好說說，我們三人調研了好多論文、參考了好多trick，大部分都無效，其中從來不會讓人失望的模塊就是SPP。我們對SPP進行了深入研究，在《卷積神經網絡中的各種池化操作》中提到過。

SPP是在SPPNet中提出的，SPPNet提出比較早，在RCNN之后提出的，用于解決重復卷積計算和固定輸出的兩個問題，具體方法如下圖所示：

 

在feature map上通過selective search獲得窗口，然后將這些區域輸入到CNN中，然后進行分類。

實際上SPP就是多個空間池化的組合，對不同輸出尺度采用不同的劃窗大小和步長以確保輸出尺度相同，同時能夠融合金字塔提取出的多種尺度特征，能夠提取更豐富的語義信息。常用于多尺度訓練和目標檢測中的RPN網絡。

在YOLOv3中有一個網絡結構叫yolov3-spp.cfg, 這個網絡往往能達到比yolov3.cfg本身更高的準確率，具體cfg如下：

### SPP ###
[maxpool]
stride=1
size=5

[route]
layers=-2

[maxpool]
stride=1
size=9

[route]
layers=-4

[maxpool]
stride=1
size=13

[route]
layers=-1,-3,-5,-6

### End SPP ###

這里的SPP相當于是原來的SPPNet的變體，通過使用多個kernel size的maxpool，最終將所有feature map進行concate，得到新的特征組合。

 

再來看一下官方提供的yolov3和yolov3-spp在COCO數據集上的對比：

 

可以看到，在幾乎不增加FLOPS的情況下，YOLOv3-SPP要比YOLOv3-608mAP高接近3個百分點。

分析一下SPP有效的原因：

1. 從感受野角度來講，之前計算感受野的時候可以明顯發現，maxpool的操作對感受野的影響非常大，其中主要取決于kernel size大小。在SPP中，使用了kernel size非常大的maxpool會極大提高模型的感受野，筆者沒有詳細計算過darknet53這個backbone的感受野，在COCO上有效很可能是因為backbone的感受野還不夠大。
2. 第二個角度是從Attention的角度考慮，這一點啟發自CSDN@小楞，他在文章中這樣講：

出現檢測效果提升的原因：通過spp模塊實現局部特征和全局特征（所以空間金字塔池化結構的最大的池化核要盡可能的接近等于需要池化的featherMap的大小）的featherMap級別的融合，豐富最終特征圖的表達能力，從而提高MAP。

Attention機制很多都是為了解決遠距離依賴問題，通過使用kernel size接近特征圖的size可以以比較小的計算代價解決這個問題。另外就是如果使用了SPP模塊，就沒有必要在SPP后繼續使用其他空間注意力模塊比如SK block，因為他們作用相似，可能會有一定冗余。

在本實驗中，確實也得到了一個很重要的結論，那就是：

SPP是有效的，其中size的設置應該接近這一層的feature map的大小

口說無憑，看一下實驗結果：

SPP系列實驗

當前的feature map大小就是13x13，實驗結果表示，直接使用13x13的效果和SPP的幾乎一樣，運算量還減少了。

2.5 修改Loss

loss方面嘗試了focal loss，但是經過調整alpha和beta兩個參數，不管用默認的還是自己慢慢調參，網絡都無法收斂，所以當時給作者提了一個issue: https://github.com/ultralytics/yolov3/issues/811

glenn-jocher說效果不好就別用:(

 

BBuf也研究了好長時間，發現focal loss在Darknet中可以用，但是效果也一般般。最終focal loss也是無疾而終。此外還試著調整了ignore thresh，來配合focal loss，實驗結果如下（在AB版Darknet下完成實驗）：

3. 經驗性總結

在這個實驗過程中，和BBuf討論有了很多啟發，也進行了總結，在這里公開出來，（可能部分結論不夠嚴謹，沒有經過嚴格對比實驗，感興趣的話可以做一下對比實驗）。

• SPP層是有效的，Size設置接近feature map的時候效果更好。
• YOLOv3、YOLOv3-SPP、YOLOv3-tiny三者在檢測同一個物體的情況下，YOLOv3-tiny給的該物體的置信度相比其他兩個模型低。（其實也可以形象化理解，YOLOv3-tiny的腦容量比較小，所以唯唯諾諾不敢確定）
• 個人感覺Concate的方法要比Add的方法更柔和，對小目標效果更好。本實驗結果上是DenseNet作為Backbone的時候效果是最佳的。
• 多尺度訓練問題，這個文中沒提。多尺度訓練對于尺度分布比較廣泛的問題效果明顯，比如VOC這類數據集。但是對于尺度單一的數據集反而有反作用，比如紅外小目標數據集目標尺度比較統一，都很小。
• Anchor對模型影響比較大，Anchor先驗不合理會導致更多的失配，從而降低Recall。
• 當時跟群友討論的時候就提到一個想法，對于小目標來說，淺層的信息更加有用，那么進行FPN的時候，不應該單純將兩者進行Add或者Concate，而是應該以一定的比例完成，比如對于小目標來說，引入更多的淺層信息，讓淺層網絡權重增大；大目標則相反。后邊通過閱讀發現，這個想法被ASFF實現了，而且想法比較完善。
• PyTorch中的Upsample層是不可復現的。
• 有卡可以嘗試一下超參數進化方法。

以上是整個實驗過程的一部分，后邊階段我們還遇到了很多困難，想將項目往輕量化的方向進行，由于種種原因，最終沒有繼續下去，在這個過程中，總結一下教訓，實驗說明和備份要做好，修改的數據集、訓練得到的權重、當時的改動點要做好備份。現在回看之前的實驗記錄和cfg文件都有點想不起來某些模型的改動點在哪里了，還是整理的不夠詳細，實驗記錄太亂。