ResNet原理及其在TF-Slim中的實現

作者：時濁

原文鏈接：https://www.jianshu.com/p/3af06422c768

查看更多的專業文章，請移步至「人工智慧LeadAI"公眾號，查看更多的課程信息和產品信息請移步至全新打造的官網：www.leadai.org.

正文共7407個字，9張圖，預計閱讀時間19分鐘。

摘要

微軟的深度殘差網路ResNet源於2016年CVPR最佳論文---圖像識別中的深度殘差學習（Deep Residual Learning for Image Recognition）（https://www.leiphone.com/news/201606/BhcC5LV32tdot6DD.html）, 論文來源（https://link.jianshu.com/?t=https://arxiv.org/pdf/1512.03385v1.pdf）,翻譯地址（https://tower.im/users/sign_in）

這個152層ResNet架構深，除了在層數上面創紀錄，ResNet 的錯誤率也低得驚人，達到了3.6%，人類都大約在5%~10%的水平。這是目前為止最好的深度學習框架。可以看作人工神經網路領域的又一里程碑。

2016年8月31日，Google團隊宣布針對TensorFlow開源了最新發布的TF-slim資料庫，它是一個可以定義、訓練和評估模型的輕量級的軟體包，也能對圖像分類領域中幾個主要有競爭力的網路進行檢驗和定義模型。這其中，就包括了ResNet網路結構。本文將結合TF-slim庫中的ResNet模型的代碼，介紹一下ResNet網路的結構和原理。

ResNet的原理

論文中提到，近幾年的研究發現網路的深度是使網路性能更優化的一個關鍵因素，但是隨著網路深度的加深，梯度消失&爆炸問題十分明顯，網路甚至出現了退化。在論文中通過一個20層和一個56層的普通網路進行了對比，發現56層網路的性能遠低於20層網路，如圖1所示。

而在ResNet的這篇論文中，通過引入一個深度殘差學習框架，解決了這個退化問題。它不期望每一層能直接吻合一個映射，而是明確的讓這些層去吻合殘差映射。形式上看，就是用H(X)來表示最優解映射，但我們讓堆疊的非線性層去擬合另一個映射F（X）:=H(X) - X, 此時原最優解映射H（X）就可以改寫成F(X)+X，我們假設殘差映射跟原映射相比更容易被優化。極端情況下，如果一個映射是可優化的，那也會很容易將殘差推至0，把殘差推至0和把此映射逼近另一個非線性層相比要容易的多。

F(X)+X的公式可以通過在前饋網路中做一個「快捷連接」來實現（如圖2） ，快捷連接跳過一個或多個層。在我們的用例中，快捷連接簡單的執行自身映射，它們的輸出被添加到疊加層的輸出中。自身快捷連接既不會添加額外的參數也不會增加計算複雜度。整個網路依然可以用SGD+反向傳播來做端到端的訓練。

它有二層，如下表達式，其中σ代表非線性函數ReLU

然後通過一個shortcut，和第2個ReLU，獲得輸出y

而在論文的後續，又提出來深度瓶頸結構，如圖3右側.在文中是這樣描述這個結構的：接下來我們描述我們為ImageNet準備的更深的網路。因為太過漫長的訓練時間我們負擔不起，所以修改了單元塊，改為一種瓶頸設計。對於每個殘差函數F，我們使用3層來描述，而不是2層。這三層分別是1×1、3×3，和1×1的卷積層，其中1×1層負責先減少後增加（恢復）尺寸的，使3×3層具有較小的輸入/輸出尺寸瓶頸。

這個深度瓶頸結構在TF-Slim庫中的代碼實現如下所示：

def bottleneck(inputs, depth, depth_bottleneck, stride, rate=1,n outputs_collections=None, scope=None):nn with tf.variable_scope(scope, bottleneck_v1, [inputs]) as sc:n depth_in = slim.utils.last_dimension(inputs.get_shape(), min_rank=4) if depth == depth_in:n shortcut = resnet_utils.subsample(inputs, stride, shortcut) else:n shortcut = slim.conv2d(inputs, depth, [1, 1], stride=stride,n activation_fn=None, scope=shortcut)nn residual = slim.conv2d(inputs, depth_bottleneck, [1, 1], stride=1,n scope=conv1)n residual = resnet_utils.conv2d_same(residual, depth_bottleneck, 3, stride,n rate=rate, scope=conv2)n residual = slim.conv2d(residual, depth, [1, 1], stride=1,n activation_fn=None, scope=conv3)nn output = tf.nn.relu(shortcut + residual) return slim.utils.collect_named_outputs(outputs_collections,n sc.original_name_scope,n output)n

需要注意的是，在論文中提到的當輸入輸出尺寸發生增加時（圖4中的虛線的快捷連接），會考慮兩個策略：（a）快捷連接仍然使用自身映射，對於維度的增加用零來填補空缺。此策略不會引入額外的參數；（b）投影捷徑（公式2）被用來匹配尺寸（靠1×1的卷積完成）。對於這兩種選項，當快捷連接在兩個不同大小的特徵圖譜上出現時，用stride=2來處理。而在TF-Slim的代碼實現中我們可以看到採用了第二種解決方式，即通過通過1X1的卷積核卷積來達成尺寸匹配。（雖然論文中說這樣提高不多但需要更多參數所以最後沒有使用。）

同時，在代碼中對於下採樣操作(subsample)是通過1x1的池化來完成的。

ResNet的結構

所以我們可以根據一個普通的神經網路來構造一個ResNet，如圖4所示，論文中選擇的基礎網路是VGG-Net。

而它的具體網路結構如圖5的表中所示。

在TF-Slim中的代碼實現如下（以ResNet-50為例）：

def resnet_v1_50(inputs,n num_classes=None,n is_training=True,n global_pool=True,n output_stride=None,n reuse=None,n scope=resnet_v1_50):n """ResNet-50 model of [1]. See resnet_v1() for arg and return description."""n blocks = [n resnet_utils.Block( block1, bottleneck, [(256, 64, 1)] * 2 + [(256, 64, 2)]),n resnet_utils.Block( block2, bottleneck, [(512, 128, 1)] * 3 + [(512, 128, 2)]),n resnet_utils.Block( block3, bottleneck, [(1024, 256, 1)] * 5 + [(1024, 256, 2)]),n resnet_utils.Block( block4, bottleneck, [(2048, 512, 1)] * 3)n ] nreturn resnet_v1(inputs, blocks, num_classes, is_training,n global_pool=global_pool, output_stride=output_stride,n include_root_block=True, reuse=reuse, scope=scope)n

在這段代碼中，其實只是聲明了一個通過Block組合成的List，Block的聲明如下，其中的關鍵是collections.namedtuple這個函數，它把前面元組的值和後面的命名對應了起來。

class Block(collections.namedtuple(Block, [scope, unit_fn, args])): n"""nA named tuple describing a ResNet block. nIts parts are: nscope: The scope of the `Block`. nunit_fn: The ResNet unit function which takes as input a `Tensor` and nreturns another `Tensor` with the output of the ResNet unit. nargs: A list of length equal to the number of units in the `Block`. The list ncontains one (depth, depth_bottleneck, stride) tuple for each unit in the n block to serve as argument to unit_fn.n

"""

而將個元素為block的 LIst轉換為一個網路的函數，則是resnet_v1，這個函數是ResNet的核心，而不同層數的ResNet只需要改變上述函數blocks中block的個數就可以了。

class Block(collections.namedtuple(Block, [scope, unit_fn, args])): n"""nA named tuple describing a ResNet block. nIts parts are: nscope: The scope of the `Block`. n unit_fn: The ResNet unit function which takes as input a `Tensor` and nreturns another `Tensor` with the output of the ResNet unit. nargs: A list of length equal to the number of units in the `Block`. The list ncontains one (depth, depth_bottleneck, stride) tuple for each unit in the nblock to serve as argument to unit_fn.n"""ndef resnet_v1(inputs, nblocks, nnum_classes=None, nis_training=True, nglobal_pool=True, noutput_stride=None, ninclude_root_block=True, nreuse=None, nscope=None): with tf.variable_scope(scope, resnet_v1, [inputs], reuse=reuse) as sc: end_points_collection = sc.name + _end_points nwith slim.arg_scope([slim.conv2d, bottleneck, nresnet_utils.stack_blocks_dense], noutputs_collections=end_points_collection): nwith slim.arg_scope([slim.batch_norm], is_training=is_training): nnet = inputs nif include_root_block: nif output_stride is not None: nif output_stride % 4 != 0: nraise ValueError(The output_stride needs to be a multiple of 4.) noutput_stride /= 4 nnet = resnet_utils.conv2d_same(net, 64, 7, stride=2, scope=conv1) nnet = slim.max_pool2d(net, [3, 3], stride=2, scope=pool1) nnet = resnet_utils.stack_blocks_dense(net, blocks, output_stride) nif global_pool: n# Global average pooling. n net = tf.reduce_mean(net, [1, 2], name=pool5, keep_dims=True) nif num_classes is not None: nnet = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope=logits) n# Convert end_points_collection into a dictionary of end_points. nend_points = slim.utils.convert_collection_to_dict(end_points_collection) nif num_classes is not None: nend_points[predictions] = slim.softmax(net, scope=predictions) nreturn net, nend_pointsn

在這個函數中，將blocks轉換為net的語句是

net = resnet_utils.stack_blocks_dense(net, blocks, output_stride)

這個函數的具體實現如下，它通過一個循環將list中的每個block讀取出來，然後將block中相應的參數代入到前文提到的bottleneck這個函數中，這樣就生成了相應的ResNet網路結構。

def stack_blocks_dense(net, nblocks, noutput_stride=None, noutputs_collections=None): n# The current_stride variable keeps track of the effective stride of the n# activations. This allows us to invoke atrous convolution whenever applying n# the next residual unit would result in the activations having stride larger n# than the target output_stride. current_stride = 1 n# The atrous convolution rate parameter. rate = 1 for block in blocks: nwith variable_scope.variable_scope(block.scope, block, [net]) as sc: nfor i, unit in enumerate(block.args): nif output_stride is not None and current_stride > output_stride: nraise ValueError(The target output_stride cannot be reached.) nwith variable_scope.variable_scope(unit_%d % (i + 1), values=[net]): nunit_depth, unit_depth_bottleneck, unit_stride = unit n# If we have reached the target output_stride, then we need to employ n # atrous convolution with stride=1 and multiply the atrous rate by the n# current units stride for use in subsequent layers. nif output_stride is not None and current_stride == output_stride: nnet = block.unit_fn( nnet, ndepth=unit_depth, ndepth_bottleneck=unit_depth_bottleneck, nstride=1, n rate=rate) nrate *= unit_stride nelse: nnet = block.unit_fn( nnet, ndepth=unit_depth, ndepth_bottleneck=unit_depth_bottleneck, nstride=unit_stride, nrate=1) ncurrent_stride *= unit_stride nnet = utils.collect_named_outputs(outputs_collections, sc.name, net) nif output_stride is not None and current_stride != output_stride: nraise ValueError(The target output_stridencannot be reached.) nreturn netn

在這裡，代碼中提到了 atrous convolution這個結構,簡單來說，它是如圖6(b)所示的一個結構，可以起到在使用了步長為1的池化層後扔使得原結構保持相同的感受野。

參考文獻

[1]Deep Residual Learning for Image Recognition