2. 程式人生 > >RefineDet演算法原始碼（二）網路結構

RefineDet演算法原始碼（二）網路結構

阿新 • • 發佈：2019-01-06

關於RefineDet演算法內容可以先看看部落格：RefineDet論文筆記。

RefineDet演算法是SSD演算法的升級版本，所以大部分的程式碼也是基於SSD的開原始碼來修改的。SSD開原始碼參考連結：https://github.com/weiliu89/caffe/tree/ssd。RefineDet主要包含anchor refinement module (ARM) 、object detection module (ODM)、transfer connection block (TCB)3個部分，ARM部分可以直接用SSD程式碼，只不過將分類支路的類別數由object數量+1修改成2，類似RPN網路，目的是得到更好的初始bbox。ODM部分也可以基於SSD程式碼做修改，主要是原本採用的default box用ARM生成的bbox代替，剩下的分類和迴歸支路與SSD一樣。TCB部分則通過一些卷積層和反捲積層即可實現。

在部落格：RefineDet演算法原始碼 （一）訓練指令碼中介紹了訓練RefineDet演算法的程式碼，其中包含巨集觀上的網路結構構建，並未涉及細節內容。因此這篇部落格介紹RefineDet演算法的具體網路結構構造細節，程式碼所在路徑：~RefineDet/python/caffe/model_libs.py指令碼的CreateRefineDetHead函式。

'''
CreateRefineDetHead函式是本文關於網路結構構造的重點，這部分程式碼也是在原來SSD的CreateMultiBoxHead函式
基礎上修改得到的，可以看作是將原來SSD的CreateMultiBoxHead函式內容實現了兩遍，一遍用來實現ARM部分，
另一邊用來實現ORM部分。from_layers和from_layers2是兩個重點輸入，
分別對應論文中Figure1的ARM和OBM兩部分輸出。因此這兩遍實現除了輸入不同外，另一個不同是ARM部分
是類似RPN網路的bbox迴歸和二分類，而ORM部分是類似SSD檢測網路的bbox迴歸和object分類。
'''
 

def CreateRefineDetHead(net, data_layer="data", num_classes=[], from_layers=[], from_layers2=[], normalizations=[], use_batchnorm=True, lr_mult=1, min_sizes=[], max_sizes=[], prior_variance = [0.1],aspect_ratios=[], steps=[], img_height=0, img_width=0, share_location=True, flip=True, clip=True, offset=0.5
 
, inter_layer_depth=[], kernel_size=1, pad=0, conf_postfix='', loc_postfix='', **bn_param):
    assert num_classes, "must provide num_classes"
    assert num_classes > 0, "num_classes must be positive number"
    if normalizations:
        assert len(from_layers) == len(normalizations), "from_layers and normalizations should have same length"
    assert len(from_layers) == len(min_sizes), "from_layers and min_sizes should have same length"
    if max_sizes:
        assert len(from_layers) == len(max_sizes), "from_layers and max_sizes should have same length"
    if aspect_ratios:
        assert len(from_layers) == len(aspect_ratios), "from_layers and aspect_ratios should have same length"
    if steps:
        assert len(from_layers) == len(steps), "from_layers and steps should have same length"
    net_layers = net.keys()
    assert data_layer in net_layers, "data_layer is not in net's layers"
    if inter_layer_depth:
        assert len(from_layers) == len(inter_layer_depth), "from_layers and inter_layer_depth should have same length"

# 接下來的程式碼分為兩部分，一部分是Anchor Refinement Module（ARM），另一部分
# 是Object Detection Module（ODM），首先看看Anchor Refinement Module（ARM）部分內容。
    prefix = 'arm'
    num_classes_rpn = 2
    num = len(from_layers)
    priorbox_layers = []
    loc_layers = []
    conf_layers = []
# 這個迴圈就是作用於每個融合層，文章中預設融合層有4個。
    for i in range(0, num):
        from_layer = from_layers[i]

        # Get the normalize value.
        if normalizations:
            if normalizations[i] != -1:
                norm_name = "{}_norm".format(from_layer)
                net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalizations[i]),
                    across_spatial=False, channel_shared=False)
                from_layer = norm_name

        # Add intermediate layers.

# 這部分預設是執行的，而且inter_layer_depth=[1,1,1,1]，也就是每個融合層都接一個residual block，
# 這種在分類和迴歸支路之前再新增層的操作在很多object detection演算法中都有。
        if inter_layer_depth:
            if inter_layer_depth[i] > 0:
                inter_name = "{}_inter".format(from_layer)
                ResBody(net, from_layer, inter_name, out2a=256, out2b=256, out2c=1024, stride=1, use_branch1=True)
                # ConvBNLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, lr_mult=lr_mult,
                #       num_output=inter_layer_depth[i], kernel_size=3, pad=1, stride=1, **bn_param)
                from_layer = "res{}".format(inter_name)

        # Estimate number of priors per location given provided parameters.
        min_size = min_sizes[i]
        if type(min_size) is not list:
            min_size = [min_size]
        aspect_ratio = []
        if len(aspect_ratios) > i:
            aspect_ratio = aspect_ratios[i]
            if type(aspect_ratio) is not list:
                aspect_ratio = [aspect_ratio]
        max_size = []
        if len(max_sizes) > i:
            max_size = max_sizes[i]
            if type(max_size) is not list:
                max_size = [max_size]
            if max_size:
                assert len(max_size) == len(min_size), "max_size and min_size should have same length."
        if max_size:
            num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size)
        else:
            num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size)
        if flip:
            num_priors_per_location += len(aspect_ratio) * len(min_size)
        step = []
        if len(steps) > i:
            step = steps[i]

        # Create location prediction layer.
# 這部分程式碼是建立bbox的座標迴歸層，num_priors_per_location是feature map層的每個點生成的bbox的數量。
# share_location預設是True，所以不執行條件語句。得到的結果就會插入loc_layers列表中，
# 這樣經過4個融合層後，loc_layers就包含4個融合層的bbox座標迴歸結果。
        name = "{}_mbox_loc{}".format(from_layer, loc_postfix)
        num_loc_output = num_priors_per_location * 4
        if not share_location:
            num_loc_output *= num_classes_rpn
        ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult, num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param)
        permute_name = "{}_perm".format(name)
        net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1])
        flatten_name = "{}_flat".format(name)
        net[flatten_name] = L.Flatten(net[permute_name], axis=1)
        loc_layers.append(net[flatten_name])

        # Create confidence prediction layer.
# 這部分程式碼是建立bbox的分類層，這裡num_conf_output = num_priors_per_location * num_classes_rpn，
# 要注意的是num_classes_rpn設定為2，所以這裡是對每個bbox做二分類，也就是前景（foreground）和
# 背景（background）的二分類。因此這裡的分類支路就和RPN網路一樣，得到的結果會插入conf_layers列表中，
# 這樣經過4個融合層後，conf_layers就包含4個融合層的二分類結果了。
        name = "{}_mbox_conf{}".format(from_layer, conf_postfix)
        num_conf_output = num_priors_per_location * num_classes_rpn
        ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult,num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param)
        permute_name = "{}_perm".format(name)
        net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1])
        flatten_name = "{}_flat".format(name)
        net[flatten_name] = L.Flatten(net[permute_name], axis=1)
        conf_layers.append(net[flatten_name])

        # Create prior generation layer.
'''
這一部分程式碼是生成anchor（或者叫priorbox），這些anchor和RPN網路的anchor一樣，生成後就固定不變了，
而前面所說的bbox是指預測的框，跟這些anchor不是一回事。那麼生成這些anchor做什麼呢？
這是為了計算損失用。不管是RefineDet、SSD還是Faster RCNN，對座標的迴歸損失計算都一樣，
計算的是預測得到的offset要儘可能和（ground truth與anchor之間）的offset接近。
所以計算ground truth和anchor之間的offset的時候就需要用到這裡計算得到的輸出（anchor的座標）。
'''
        name = "{}_mbox_priorbox".format(from_layer)
        net[name] = L.PriorBox(net[from_layer], net[data_layer], min_size=min_size,
                clip=clip, variance=prior_variance, offset=offset)
        if max_size:
            net.update(name, {'max_size': max_size})
        if aspect_ratio:
            net.update(name, {'aspect_ratio': aspect_ratio, 'flip': flip})
        if step:
            net.update(name, {'step': step})
        if img_height != 0 and img_width != 0:
            if img_height == img_width:
                net.update(name, {'img_size': img_height})
            else:
                net.update(name, {'img_h': img_height, 'img_w': img_width})
        priorbox_layers.append(net[name])

    # Concatenate priorbox, loc, and conf layers.
# 接下來這部分是對不同層的輸出做融合。
    mbox_layers = []
    name = '{}{}'.format(prefix, "_loc")
    net[name] = L.Concat(*loc_layers, axis=1)
    mbox_layers.append(net[name])
    name = '{}{}'.format(prefix, "_conf")
    net[name] = L.Concat(*conf_layers, axis=1)
    mbox_layers.append(net[name])
    name = '{}{}'.format(prefix, "_priorbox")
    net[name] = L.Concat(*priorbox_layers, axis=2)
    mbox_layers.append(net[name])

# 接下來這部分是Object Detection Module（ODM），大部分和ARM相同的程式碼這裡不再重複介紹，主要介紹不同點。
    prefix = 'odm'
    num = len(from_layers2)
    loc_layers = []
    conf_layers = []
    for i in range(0, num):
        from_layer = from_layers2[i]

        # Get the normalize value.
        if normalizations:
            if normalizations[i] != -1:
                norm_name = "{}_norm".format(from_layer)
                net[norm_name] = L.Normalize(net[from_layer], scale_filler=dict(type="constant", value=normalizations[i]),
                    across_spatial=False, channel_shared=False)
                from_layer = norm_name

        # Add intermediate layers.
        if inter_layer_depth:
            if inter_layer_depth[i] > 0:
                inter_name = "{}_inter".format(from_layer)
                ResBody(net, from_layer, inter_name, out2a=256, out2b=256, out2c=1024, stride=1, use_branch1=True)
                # ConvBNLayer(net, from_layer, inter_name, use_bn=use_batchnorm, use_relu=True, lr_mult=lr_mult,
                #       num_output=inter_layer_depth[i], kernel_size=3, pad=1, stride=1, **bn_param)
                # from_layer = inter_name
                from_layer = "res{}".format(inter_name)

        # Estimate number of priors per location given provided parameters.
        min_size = min_sizes[i]
        if type(min_size) is not list:
            min_size = [min_size]
        aspect_ratio = []
        if len(aspect_ratios) > i:
            aspect_ratio = aspect_ratios[i]
            if type(aspect_ratio) is not list:
                aspect_ratio = [aspect_ratio]
        max_size = []
        if len(max_sizes) > i:
            max_size = max_sizes[i]
            if type(max_size) is not list:
                max_size = [max_size]
            if max_size:
                assert len(max_size) == len(min_size), "max_size and min_size should have same length."
        if max_size:
            num_priors_per_location = (2 + len(aspect_ratio)) * len(min_size)
        else:
            num_priors_per_location = (1 + len(aspect_ratio)) * len(min_size)
        if flip:
            num_priors_per_location += len(aspect_ratio) * len(min_size)

        # Create location prediction layer.
        name = "{}_mbox_loc{}".format(from_layer, loc_postfix)
        num_loc_output = num_priors_per_location * 4
        if not share_location:
            num_loc_output *= num_classes
        ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult,
                    num_output=num_loc_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param)
        permute_name = "{}_perm".format(name)
        net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1])
        flatten_name = "{}_flat".format(name)
        net[flatten_name] = L.Flatten(net[permute_name], axis=1)
        loc_layers.append(net[flatten_name])

        # Create confidence prediction layer.
# 這裡的num_conf_output = num_priors_per_location * num_classes，
# num_classes是所有object的數量+背景。因此這裡的分類支路就和SSD中的一樣。
        name = "{}_mbox_conf{}".format(from_layer, conf_postfix)
        num_conf_output = num_priors_per_location * num_classes
        ConvBNLayer(net, from_layer, name, use_bn=use_batchnorm, use_relu=False, lr_mult=lr_mult,
                    num_output=num_conf_output, kernel_size=kernel_size, pad=pad, stride=1, **bn_param)
        permute_name = "{}_perm".format(name)
        net[permute_name] = L.Permute(net[name], order=[0, 2, 3, 1])
        flatten_name = "{}_flat".format(name)
        net[flatten_name] = L.Flatten(net[permute_name], axis=1)
        conf_layers.append(net[flatten_name])

    # Concatenate priorbox, loc, and conf layers.
# 最後在返回列表中添加了bbox的分類輸出和迴歸輸出。
    name = '{}{}'.format(prefix, "_loc")
    net[name] = L.Concat(*loc_layers, axis=1)
    mbox_layers.append(net[name])
    name = '{}{}'.format(prefix, "_conf")
    net[name] = L.Concat(*conf_layers, axis=1)
    mbox_layers.append(net[name])

    return mbox_layers

相關推薦

RefineDet演算法原始碼（二）網路結構

關於RefineDet演算法內容可以先看看部落格：RefineDet論文筆記。 RefineDet演算法是SSD演算法的升級版本，所以大部分的程式碼也是基於SSD的開原始碼來修改的。SSD開原始碼參考連結：https://github.com/weiliu

基於深度學習的目標檢測演算法綜述（二）（截止20180821）

參考：https://zhuanlan.zhihu.com/p/40020809 基於深度學習的目標檢測演算法綜述分為三部分： 1. Two/One stage演算法改進。這部分將主要總結在two/one stage經典網路上改進的系列論文，包括Faster R-CNN、YOLO、SSD等經

資料結構和演算法緒論（二）

1、演算法概念 不同的演算法可以提高計算相同算術題的效率，那麼演算法的研究就變得有意義了。 2、演算法的特性 輸入 輸出 有窮性（執行有限的步驟） 確定性（每一個步驟僅有一個含義） 可行性 3、演算法設計要求 沒有無法錯誤、有合法輸入和輸出 4、演算法效率 度量方法： 事前分析估算方法

Zookeeper 原始碼（二）序列化元件 Jute

Zookeeper 原始碼（二）序列化元件 Jute 一、序列化元件 Jute 對於一個網路通訊，首先需要解決的就是對資料的序列化和反序列化處理，在 ZooKeeper 中，使用了Jute 這一序列化元件來進行資料的序列化和反序列化操作。同時，為了實現一個高效的網路通訊程式，良好的通訊協議設計也是至關重要

tarjan演算法入門（二）——無向圖的雙連通分量（未完成）

一.雙連通分量. 無向圖的雙連通分量分為兩種，一種是點雙連通分量，簡稱v-DCC；一種是邊雙連通分量，簡稱e-DCC. 一個v-DCC的概念即為一張沒有割點的圖，一個e-DCC的概念即為一張沒有割邊的圖. 一張極大雙連通分量子圖的是指沒有一張雙連通分量子圖完全包含這張子圖的所有點且點

逐行閱讀redux原始碼（二）combineReducers

前情提要 逐行閱讀redux原始碼（一）createStore 認識reducers 在我們開始學習原始碼之前，我們不妨先來看看何謂reducers： 如圖所見，我們可以明白， reducer 是用來對初始的狀態樹進行一些處理從而獲得一個新的狀態樹的，我們可以繼續從其使用方

資料結構與演算法筆記（二）複雜度分析

2. 複雜度分析 2.1 什麼是複雜度分析 資料結構和演算法的本質：快和省，如何讓程式碼執行得更快、更省儲存空間。 演算法複雜度分為時間複雜度和空間複雜度，從執行時間和佔用空間兩個維度來評估資料結構和演算法的效能。 複雜度描述的是演算法執行時間（或佔用空間）與資料規模的增長關

演算法訓練（二）

1.zoj-4026 首先我們需要推倒一下，每次都是從A開始拿，可以列舉幾種情況，會發現最後結束一定是在第四次抽到A的時候結束的，因為假設在第二堆結束，你在抽完4次2後第二堆才為空，你需要第五次抽到2才會回到第二堆，這時候才能結束，不符合題意，因此只有第一次就被抽的A能結束遊戲，因此結束的時

GIS演算法基礎（二）計算幾何基礎（中）

地理資料在計算機中表示大致分為兩種，向量資料和柵格資料。 要計算地理資料的空間關係，一般是向量資料之間的比較。例如：點，線，面之間的比較。 如何判斷線段之間是否相交，線段與面的包含關係。點與面的包含關係等等這些空間關係，都用到計算幾何的演算法。   空間關係的判定演算法的內

白話Spring原始碼（二）：spring原始碼分享的思路

做事先列個大綱，這樣思路清晰了才不會亂。 這次spring原始碼系列的部落格每個字我都堅持自己手敲，然後文采不好，但是真實。希望大家喜歡。 大綱： 1.spring框架的理解 2.beanfactory：怎麼建立bean的，怎麼載入xml中bean的定義的 3.AOP 4.a

基於深度學習的目標檢測演算法綜述（二）

前言 基於深度學習的目標檢測演算法綜述分為三部分： 1. Two/One stage演算法改進。這部分將主要總結在two/one stage經典網路上改進的系列論文，包括Faster R-CNN、YOLO、SSD等經典論文的升級版本。 2. 解決方案。這部分論文對物體檢

排序演算法之（二）選擇排序

原理： 每一次從待排序的資料元素中選出最小（或最大）的一個元素，存放在序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到全部待排序的資料元素排完。 選擇排序是不穩定的排序方法。 思路： n個數進行n-1次排序 每一次排

演算法訓練營（二）：堆排序

堆排序過程 建立大頂堆或者小頂堆，大頂堆（一種二叉樹型結構，子樹節點值都小於父節點的值）。這個過程的要點是：先從最後一個非葉子節點開始構建堆，因為最後一個非葉子節點才有可能需要調整，然後向前查詢的節點都有子樹，都有可能需要調整。 排序過程。建立好了大頂堆，那麼第一個節

kruskal演算法 原始碼（java）

import java.util.Collection; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.PriorityQ

讀OkHttp3原始碼（二）：CertificatePinner（鎖定證書）

okhttp3 public final class CertificatePinner extends Object 類介紹： 該類用於約束哪些證書是可信的。 鎖定證書可以防止對證書頒發機構相關的攻擊。 它還阻止通過使用者已知或未知的中間證書頒發機構建立的連線。 這個類

【精選】JAVA入門演算法題（二）

時時要有危機意識。別以為你命好運也好。 1.題目：打印出所有的 水仙花數 ，所謂 水仙花數 是指一個三位數，其各位數字立方和等於該數本身。 例如：153是一個 水仙花數 ，因為153=1的三次方＋5的三次方＋3的三次方。 題非常簡單，只要用for迴圈，取出數的個位、十位

演算法之（二）判斷一個單鏈表是否有環

思路：如果一個單鏈表中有環，用一個指標去遍歷，永遠不會結束，所以可以用兩個指標，一個指標一次走一步，另一個指標一次走兩步，如果存在環，則這兩個指標會在環內相遇，時間複雜度為O(n)。 拓展問題1：如果單鏈表有環，找出環的入口節點（環的連線點）。 這裡先證明一個

Netty 原始碼（二）NioEventLoop 之 Channel 註冊

Netty 原始碼（二）NioEventLoop 之 Channel 註冊 Netty 系列目錄(https://www.cnblogs.com/binarylei/p/10054508.html) 一、Channel 註冊到 NioEventLoop chnnel 初始化完成後就需要將其註冊到對應

MFC/Qt下呼叫caffe原始碼（二）---MFC下呼叫caffe的動態連線庫dll檔案

首先，先看下最後的效果吧。 win7 vs2013 新建一個MFC 工程 注：MFC中如何最簡便的方法將圖片顯示到對話方塊中？大家可以搜下，很多種方法，但是我採用的是最簡單的方法，即將opencv視窗繫結到MFC的PIcture control上。 在:

非阻塞同步演算法實戰（二）－BoundlessCyclicBarrier

感謝網友trytocatch的投稿 前言 相比上一 篇而言，本文不需要太多的準備知識，但技巧性更強一些。因為分析、設計的過程比較複雜繁瑣，也限於篇幅，所以，主要展示如何解決這些需求，和講解程式碼。另外，所講的內容也是後一篇實戰中需要用到的一個工具類。 需求介紹 我需要編寫一個同步工具，它需要提