2. 程式人生 > >深度學習--Inception-ResNet-v1網路結構

深度學習--Inception-ResNet-v1網路結構

阿新 • • 發佈：2019-02-17

　　Inception V4的網路結構如下： 　　
這裡寫圖片描述
　　從圖中可以看出，輸入部分與V1到V3的輸入部分有較大的差別，這樣設計的目的為了：使用並行結構、不對稱卷積核結構，可以在保證資訊損失足夠小的情況下，降低計算量。結構中1*1的卷積核也用來降維，並且也增加了非線性。
　　Inception-ResNet-v2與Inception-ResNet-v1的結構類似，除了stem部分。Inception-ResNet-v2的stem與V4的結構類似，Inception-ResNet-v2的輸出chnnel要高。Reduction-A相同，Inception-ResNet-A、Inception-ResNet-B、Inception-ResNet-C和Reduction-B的結構與v1的類似，只不過輸出的channel數量更多。
　　這裡寫圖片描述


　　Inception-ResNet-v1的總體網路結構如下所示：
Inception-ResNet-v1
Inception-ResNet-v1的Stem與V3的結構是一致的。
　　接下來主要說一下Inception-ResNet-v1的網路結構及程式碼的實現部分。

Stem結構

Stem結構
　　stem結構與V3的Stem結構類似。
對應的程式碼為

with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d],stride=1, padding='SAME'):

    # 149 x 149 x 32
    net = slim.conv2d(inputs, 32
 
, 3, stride=2, padding='VALID', scope='Conv2d_1a_3x3')
    end_points['Conv2d_1a_3x3'] = net
    # 147 x 147 x 32
    net = slim.conv2d(net, 32, 3, padding='VALID',
scope='Conv2d_2a_3x3')
    end_points['Conv2d_2a_3x3'] = net
    # 147 x 147 x 64
    net = slim.conv2d(net, 64, 3, scope='Conv2d_2b_3x3'
 
)
end_points['Conv2d_2b_3x3'] = net
    # 73 x 73 x 64
    net = slim.max_pool2d(net, 3, stride=2, padding='VALID', scope='MaxPool_3a_3x3')
    end_points['MaxPool_3a_3x3'] = net
    # 73 x 73 x 80
    net = slim.conv2d(net, 80, 1, padding='VALID',
scope='Conv2d_3b_1x1')
    end_points['Conv2d_3b_1x1'] = net
    # 71 x 71 x 192
    net = slim.conv2d(net, 192, 3, padding='VALID',
scope='Conv2d_4a_3x3')
    end_points['Conv2d_4a_3x3'] = net
    # 35 x 35 x 256
    net = slim.conv2d(net, 256, 3, stride=2, padding='VALID',
scope='Conv2d_4b_3x3')
   end_points['Conv2d_4b_3x3'] = net

Inception-resnet-A模組

　　Inception-resnet-A模組是要重複5次的，網路結構為：
Inception-resnet-A
　　對應的程式碼表示為：

# Inception-Renset-A
def block35(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
    """Builds the 35x35 resnet block."""
    with tf.variable_scope(scope, 'Block35', [net], reuse=reuse):
        with tf.variable_scope('Branch_0'):
            # 35 × 35 × 32
            tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1')
        with tf.variable_scope('Branch_1'):
            # 35 × 35 × 32
            tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
            # 35 × 35 × 32
            tower_conv1_1 = slim.conv2d(tower_conv1_0, 32, 3, scope='Conv2d_0b_3x3')
        with tf.variable_scope('Branch_2'):
            # 35 × 35 × 32
            tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
            # 35 × 35 × 32
            tower_conv2_1 = slim.conv2d(tower_conv2_0, 32, 3, scope='Conv2d_0b_3x3')
            # 35 × 35 × 32
            tower_conv2_2 = slim.conv2d(tower_conv2_1, 32, 3, scope='Conv2d_0c_3x3')
        # 35 × 35 × 96
        mixed = tf.concat([tower_conv, tower_conv1_1, tower_conv2_2], 3)
        # 35 × 35 × 256
        up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,activation_fn=None, scope='Conv2d_1x1')
        # 使用殘差網路scale = 0.17
        net += scale * up
        if activation_fn:
            net = activation_fn(net)
    return net

# 5 x Inception-resnet-A
net = slim.repeat(net, 5, block35, scale=0.17)
end_points['Mixed_5a'] = net

Reduction-A結構

　　Reduction-A中含有4個引數k、l、 m、 n，它們對應的值分別為：192, 192, 256, 384，在該層網路結構，輸入為35×35×256，輸出為17×17×896.
Reduction-A

def reduction_a(net, k, l, m, n):
    # 192, 192, 256, 384
    with tf.variable_scope('Branch_0'):
        # 17×17×384
        tower_conv = slim.conv2d(net, n, 3, stride=2, padding='VALID',
                                 scope='Conv2d_1a_3x3')
    with tf.variable_scope('Branch_1'):
        # 35×35×192
        tower_conv1_0 = slim.conv2d(net, k, 1, scope='Conv2d_0a_1x1')
        # 35×35×192
        tower_conv1_1 = slim.conv2d(tower_conv1_0, l, 3,
                                    scope='Conv2d_0b_3x3')
        # 17×17×256
        tower_conv1_2 = slim.conv2d(tower_conv1_1, m, 3,
                                    stride=2, padding='VALID',
                                    scope='Conv2d_1a_3x3')
    with tf.variable_scope('Branch_2'):
        # 17×17×256
        tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID',
                                     scope='MaxPool_1a_3x3')
    # 17×17×896
    net = tf.concat([tower_conv, tower_conv1_2, tower_pool], 3)
    return net

# Reduction-A
with tf.variable_scope('Mixed_6a'):
    net = reduction_a(net, 192, 192, 256, 384)
    end_points['Mixed_6a'] = net

Inception-Resnet-B

　　Inception-Resnet-B模組是要重複10次，輸入為17×17×896，輸出為17×17×896，網路結構為：
Inception-Resnet-B

# Inception-Renset-B
def block17(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
    """Builds the 17x17 resnet block."""
    with tf.variable_scope(scope, 'Block17', [net], reuse=reuse):
        with tf.variable_scope('Branch_0'):
            # 17*17*128
            tower_conv = slim.conv2d(net, 128, 1, scope='Conv2d_1x1')
        with tf.variable_scope('Branch_1'):
            # 17*17*128
            tower_conv1_0 = slim.conv2d(net, 128, 1, scope='Conv2d_0a_1x1')
            # 17*17*128
            tower_conv1_1 = slim.conv2d(tower_conv1_0, 128, [1, 7],
                                        scope='Conv2d_0b_1x7')
            # 17*17*128
            tower_conv1_2 = slim.conv2d(tower_conv1_1, 128, [7, 1],
                                        scope='Conv2d_0c_7x1')
        # 17*17*256
        mixed = tf.concat([tower_conv, tower_conv1_2], 3)
        # 17*17*896
        up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,activation_fn=None, scope='Conv2d_1x1')
        net += scale * up
        if activation_fn:
            net = activation_fn(net)
    return net

# 10 x Inception-Resnet-B
net = slim.repeat(net, 10, block17, scale=0.10)
end_points['Mixed_6b'] = net

Reduction-B

　　Reduction-B的輸入為17*17*896，輸出為8*8*1792。網路結構為：
Reduction-B
對應的程式碼為：

def reduction_b(net):
    with tf.variable_scope('Branch_0'):
        # 17*17*256
        tower_conv = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
        # 8*8*384
        tower_conv_1 = slim.conv2d(tower_conv, 384, 3, stride=2,
                                   padding='VALID', scope='Conv2d_1a_3x3')
    with tf.variable_scope('Branch_1'):
        # 17*17*256
        tower_conv1 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
        # 8*8*256
        tower_conv1_1 = slim.conv2d(tower_conv1, 256, 3, stride=2,
                                    padding='VALID', scope='Conv2d_1a_3x3')
    with tf.variable_scope('Branch_2'):
        # 17*17*256
        tower_conv2 = slim.conv2d(net, 256, 1, scope='Conv2d_0a_1x1')
        # 17*17*256
        tower_conv2_1 = slim.conv2d(tower_conv2, 256, 3,
                                    scope='Conv2d_0b_3x3')
        # 8*8*256
        tower_conv2_2 = slim.conv2d(tower_conv2_1, 256, 3, stride=2,
                                    padding='VALID', scope='Conv2d_1a_3x3')
    with tf.variable_scope('Branch_3'):
        # 8*8*896
        tower_pool = slim.max_pool2d(net, 3, stride=2, padding='VALID',
                                     scope='MaxPool_1a_3x3')
    # 8*8*1792
    net = tf.concat([tower_conv_1, tower_conv1_1,
                        tower_conv2_2, tower_pool], 3)
    return net
# Reduction-B
with tf.variable_scope('Mixed_7a'):
     net = reduction_b(net)
end_points['Mixed_7a'] = net

Inception-Resnet-C結構

　　Inception-Resnet-C結構重複5次。它輸入為8*8*1792，輸出為8*8*1792。對應的結構為：
Inception-Resnet-C
　　對應的程式碼為：

# Inception-Resnet-C
def block8(net, scale=1.0, activation_fn=tf.nn.relu, scope=None, reuse=None):
    """Builds the 8x8 resnet block."""
    with tf.variable_scope(scope, 'Block8', [net], reuse=reuse):
        with tf.variable_scope('Branch_0'):
            # 8*8*192
            tower_conv = slim.conv2d(net, 192, 1, scope='Conv2d_1x1')
        with tf.variable_scope('Branch_1'):
            # 8*8*192
            tower_conv1_0 = slim.conv2d(net, 192, 1, scope='Conv2d_0a_1x1')
            # 8*8*192
            tower_conv1_1 = slim.conv2d(tower_conv1_0, 192, [1, 3],
                                        scope='Conv2d_0b_1x3')
            # 8*8*192
            tower_conv1_2 = slim.conv2d(tower_conv1_1, 192, [3, 1],
                                        scope='Conv2d_0c_3x1')
        # 8*8*384
        mixed = tf.concat([tower_conv, tower_conv1_2], 3)
        # 8*8*1792
        up = slim.conv2d(mixed, net.get_shape()[3], 1, normalizer_fn=None,activation_fn=None, scope='Conv2d_1x1')
        # scale=0.20
        net += scale * up
        if activation_fn:
            net = activation_fn(net)
    return net
# 5 x Inception-Resnet-C
net = slim.repeat(net, 5, block8, scale=0.20)
end_points['Mixed_8a'] = net

　　但是在facenet中，接下來又是一層Inception-Resnet-C，但是它沒有重複，並且沒有啟用函式。輸入與輸出大小相同。

net = block8(net, activation_fn=None)
end_points['Mixed_8b'] = net

結果輸出

　　結果輸出包含Average Pooling和Dropout (keep 0.8)及Softmax三層，這裡我們以facenet中為例：具體的程式碼如下：

with tf.variable_scope('Logits'):
     end_points['PrePool'] = net
     #pylint: disable=no-member
     # Average Pooling層，輸出為8×8×1792
     net = slim.avg_pool2d(net, net.get_shape()[1:3], padding='VALID',scope='AvgPool_1a_8x8')
     #扁平除了batch_size維度的其它維度。使輸出變為：[batch_size, ...]
     net = slim.flatten(net)
     #dropout層
     net = slim.dropout(net, dropout_keep_prob, is_training=is_training,scope='Dropout')
     end_points['PreLogitsFlatten'] = net
     # 全連結層。輸出為batch_size×128
     net = slim.fully_connected(net, bottleneck_layer_size, activation_fn=None,scope='Bottleneck', reuse=False)

　　至此，inception_resnet_v1網路結構就結束了，但facenet的程式碼分析未完，待續～～～～

相關推薦

深度學習--Inception-ResNet-v1網路結構

　　Inception V4的網路結構如下： 　　 　　從圖中可以看出，輸入部分與V1到V3的輸入部分有較大的差別，這樣設計的目的為了：使用並行結構、不對稱卷積核結構，可以在保證資訊損失足夠小的情況下，降低計算量。結構中1*1的卷積核也用來降維，並且也增

Inception-ResNet-v1網路結構

Inception V4的網路結構如下： 　　 　　從圖中可以看出，輸入部分與V1到V3的輸入部分有較大的差別，這樣設計的目的為了：使用並行結構、不對稱卷積核結構，可以在保證資訊損失足夠小的情況下，降低計算量。結構中1*1的卷積核也用來降維，並且也增加了非線性。 　　Incept

系統學習深度學習（二十一）--GoogLeNetV4與Inception-ResNet V1,V2

[v4] Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning，top5 error 3.08% 上面那篇論文，主要貢獻如下： 1、在Inception v3

【深度學習】ResNet解讀及程式碼實現

簡介 ResNet是何凱明大神在2015年提出的一種網路結構，獲得了ILSVRC-2015分類任務的第一名，同時在ImageNet detection，ImageNet localization，COCO detection和COCO segmentation等任務中均獲得了第一名，在當

深度學習，影象分類，從vgg到inception,到resnet

最近工作在做一件事情，就是把遊戲影象進行場景分類，相比於自然影象來說，遊戲影象種類較少，因此分類任務比較簡單，但是由於追求工程上的高精度和高效率，所以閱讀了vgg，inception，resnet等相關論文，並且都試了一下效果，算是對深度學習影象分類有了一個系統

(深度學習)比較新的網路模型：Inception-v3 ， ResNet， Inception-v4， Dual-Path-Net ， Dense-net ， SEnet ， Wide ResNet

1. Inception-v3 （Dec，2015） 2. ResNet（Dec，2015） 3. nception-v4（Aug，2016） 4. Dual-Path-Net （Aug，2017） 5. Dense-net（Aug，2017） 6. SEn

基於深度學習的病毒檢測技術無需沙箱環境，直接將樣本文件轉換為二維圖片，進而應用改造後的卷積神經網絡 Inception V4 進行訓練和檢測

進制 思科 開發 主題 需求 做的 病毒 無法 大於 話題 3: 基於深度學習的二進制惡意樣本檢測 分享主題：全球正在經歷一場由科技驅動的數字化轉型，傳統技術已經不能適應病毒數量飛速增長的發展態勢。而基於沙箱的檢測方案無法滿足 APT 攻擊的檢測需求，也受到多種反沙箱技術的

深度學習——卷積神經網絡 的經典網絡（LeNet-5、AlexNet、ZFNet、VGG-16、GoogLeNet、ResNet）

足夠 論文 ogl 相關性 spa 原因 線性 pad fan 一、CNN卷積神經網絡的經典網絡綜述 下面圖片參照博客：http://blog.csdn.net/cyh_24/article/details/51440344 二、LeNet-5網絡

一文讀懂AI網路結構：LeNet-5 AlexNet VGG Inception ResNet MobileNet

1 引言 當前深度學習十分火熱，深度學習網路模型對於降低錯誤率的重要作用不言而喻。深度學習應用場景主要分為三類：物體識別與分類，物體檢測，自然語言處理。在物體識別與分類領域，隨著AlexNet在2012年一炮走紅，深度學習重新燃起了一片熱情。從Lenet5第一次使用卷積開始，經歷了AlexNet

機器學習與深度學習系列連載： 第二部分 深度學習（十二）卷積神經網路 3 經典的模型（LeNet-5，AlexNet ，VGGNet，GoogLeNet，ResNet）

卷積神經網路 3 經典的模型 經典的卷積神經網路模型是我們學習CNN的利器，不光是學習原理、架構、而且經典模型的超引數、引數，都是我們做遷移學習最好的源材料之一。 1. LeNet-5 [LeCun et al., 1998] 我們還是從CNN之父，LeCun大神在98年提出的模

基於深度學習和遷移學習的遙感影象場景分類實踐（AlexNet、ResNet）

卷積神經網路（CNN）在影象處理方面有很多出色的表現，在ImageNet上有很多成功的模型都是基於CNN的。AlexNet是具有歷史意義的一個網路，2012年提出來當年獲得了當年的ImageNet LSVRC比賽的冠軍，此後ImageNet LSVRC的冠軍都是都是用CNN做的，並且層

[深度學習]Object detection物體檢測之YOLO v1(6)

目錄 與以往rcnn，SPPNet，fast rcnn，faster rcnn的不同 YOLO的特點 YOLO的流程 YOLO的網路結構圖 YOLO的loss function YOLO的侷限 YOLO的實驗結果 論文全稱：《You Only Look Once:

【深度學習】GoogLeNet系列解讀 —— Inception v4

目錄 GoogLeNet系列解讀 Inception v1 Inception v2 Inception v3 Inception v4 簡介 在介紹Inception v4之前，首先說明一下Inception v4沒有使用殘差學習的思想。大部分小夥伴對Inc

【深度學習】GoogLeNet系列解讀 —— Inception v3

目錄 GoogLeNet系列解讀 Inception v1 Inception v2 Inception v3 Inception v4 Inception v3 Inception v3整體上採用了Inception v2的網路結構，並在優化演算法、正則化等

【深度學習】GoogLeNet系列解讀 —— Inception v2

目錄 GoogLeNet系列解讀 Inception v1 Inception v2 Inception v3 Inception v4 簡介 GoogLeNet憑藉其優秀的表現，得到了很多研究人員的學習和使用，因此Google又對其進行了改進，產生了Goog

《TensorFlow：實戰Google深度學習框架》——6.2 卷積神經網路簡介（卷積神經網路的基本網路結構及其與全連線神經網路的差異）

下圖為全連線神經網路與卷積神經網路的結構對比圖： 由上圖來分析兩者的差異：                  全連線神經網路與卷積網路相同點   &nb

經典深度學習CNN- LeNet、AlexNet、GoogLeNet、VGG、ResNet

參考了： https://www.cnblogs.com/52machinelearning/p/5821591.html https://blog.csdn.net/qq_24695385/article/details/80368618   LeNet    

深度學習與計算機視覺(PB-12)-ResNet

系列學習： 深度學習與計算機視覺(PB-13)—ImageNet資料集準備 深度學習與計算機視覺(PB-12)—ResNet 深度學習與計算機視覺(PB-11)—GoogLeNet 深度學習與計算機視覺(PB-10)—Kaggle之貓狗比賽 深度學習與計算

[深度學習]Semantic Segmentation語義分割之Deeplab v1(5)

論文全稱：《SEMANTIC IMAGE SEGMENTATION WITH DEEP CONVOLUTIONAL NETS AND FULLY CONNECTED CRFS》 論文地址：https://arxiv.org/pdf/1412.7062.pdf 得益於影象空間轉換的不變性，DC

深度學習 --- 深度殘差網路（ResNet）變體介紹

先說明，本文不是本人所寫，是本人翻譯得來，目的是系統整理一下，供以後深入研究時引用，如有侵權請聯絡本人刪除。 ResNet變體 寬剩餘網路（WRN）：從“寬度”入手做提升： Wide Residual Network（WRN）由Sergey Zagoruyko和Nikos Komod