RESNET

当ResNet第一次被引入时，它是革命性的，它证明了当时深度神经网络的一个巨大问题的新解决方案:梯度问消失题。神经网络虽然是通用的函数逼近器，但在一定阈值下增加层数会使训练速度变慢，使准确度趋于饱和。

这是由于梯度从最后一层到最早的一层的反向传播——将0到1之间的数字相乘多次，使其变得越来越小:因此，当到达较早的一层时，梯度开始“消失”。这意味着早期的层不仅训练速度较慢，而且更容易出错。这是一个巨大的问题，因为最早的层是整个网络的构建块——它们负责识别基本的、核心的特征!

为了缓解这个问题，ResNet采用了identity shortcut connections，它本质上跳过一个或多个层的训练 - 创建一个残差块。

然后，作者提出了一个“优化”的残差块，添加了一个称为bottleneck的扩展。它会降低前两个CONV层的维数（在最后一个CONV层中学习的filters 的1/4），然后在最后一个CONV层中再次增加。这里有两个堆叠在一起的残差模块。

最后，He等人发表了关于残差模块的第二篇论文，称为Identity Mappings in Deep Residual Networks，它提供了更好的残差块版本：pre-activation residual model。这允许梯度通过shortcut connections传播到任何较早的层而不受阻碍。

我们不是从卷积（权重）开始，而是从一系列（BN => RELU => CONV）* N层（假设正在使用bottleneck ）开始。然后，残差模块输出被馈送到网络中的下一个残差模块的加法运算 （因为残差模块堆叠在彼此之上）。

（a）原始bottleneck 残差模块。（e）完整的预激活残差模块。称为预激活，因为BN和ReLU层出现在卷积之前。

整体网络架构看起来像这样，我们的模型将与之类似。

让我们开始用Python编写实际的网络。这个具体的实现受到He等人Caffe发行版和Wei Wu的mxnet实现的启发。

我们将把它写成一个类（ResNet），以便我们稍后在训练深度学习模型时调用它。

# import the necessary packages
from keras.layers.normalization import BatchNormalization
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import AveragePooling2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.convolutional import ZeroPadding2D
from keras.layers.core import Activation
from keras.layers.core import Dense
from keras.layers import Flatten
from keras.layers import Input
from keras.models import Model
from keras.layers import add
from keras.regularizers import l2
from keras import backend as K
class ResNet:
	@staticmethod
	def residual_module(data, K, stride, chanDim, red=False, 
		reg=0.0001, bnEps=2e-5, bnMom=0.9):

我们从标准的CNN导入开始，然后开始构建我们的residual_module函数。看看参数：

• data：输入到残差模块
• K：最后一个CONV层将学习的filters数量（前两个CONV层将学习K / 4的filters）
• stride：控制卷积的步幅（将帮助我们减少空间维度而不使用最大池）
• chanDim：定义将执行批归一化的轴
• red（即减少）将控制我们是否减少空间维度(True)或不(False)，因为不是所有残差模块都将减少空间体积的维度
• reg：对残差模块中的所有CONV层应用正则化强度
• bnEps：控制?负责在归一化输入时避免“除以零”错误
• bnMom：控制移动平均线的momentum

现在让我们看看函数的其余部分。Python代码如下：

	# the shortcut branch of the ResNet module should be
	# initialize as the input (identity) data
 	shortcut = data
 
 	# the first block of the ResNet module are the 1x1 CONVs
 	bn1 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(data)
 	act1 = Activation("relu")(bn1)
	conv1 = Conv2D(int(K * 0.25), (1, 1), use_bias=False, 
		kernel_regularizer=l2(reg))(act1)

首先，我们初始化 (identity) shortcut (connection)，它实际上只是对输入数据的引用。在残差模块的末尾，我们只需将shortcut 添加到我们的预激活/bottleneck 分支（第3行）的输出中。

在第6-9行，ResNet模块的第一个块遵循BN ==> RELU ==> CONV ==>pattern。CONV层通过K / 4 filters使用1x1卷积。请注意，CONV层的偏差项已关闭，因为偏差已经在下面的BN层中，因此不需要第二个偏差项。

	# the second block of the ResNet module are the 3x3 CONVs
	bn2 = BatchNormalization(axis=chanDim, epsilon=bnEps, momentum=bnMom)(conv1)
	act2 = Activation("relu")(bn2)
	conv2 = Conv2D(int(K * 0.25), (3, 3), strides=stride, padding="same", use_bias=False, 
		kernel_regularizer=l2(reg)(act2)

第二个CONV层学习3 x 3的K / 4 filters。

	# the third block of the ResNet module is another set of 1x1 CONVs
	bn3 = BatchNormalization(axis=chanDim, epsilon=bnEps,momentum=bnMom)(conv2)
	act3 = Activation("relu")(bn3)
	conv3 = Conv2D(K, (1, 1), use_bias=False, kernel_regularizer=l2(reg))(act3)

最后一个块将再次增加维度，应用尺寸为1 x 1的K filters。

为避免应用最大池化，我们需要检查是否需要减少空间维度。

	# if we are to reduce the spatial size, apply a CONV layer to the shortcut
	if red:
	 shortcut = Conv2D(K, (1, 1), strides=stride, use_bias=False, 
	 		kernel_regularizer=l2(reg))(act1)
	# add together the shortcut and the final CONV
	x = add([conv3, shortcut])
	# return the addition as the output of the ResNet module
	return x

如果我们被命令减小空间尺寸，则stride > 1的卷积层将应用于shortcut（第2-4行）。

最后，我们将shortcut和最终CONV层相加，创建输出到我们的ResNet模块（第7行）。我们终于有了“构建模块”来开始构建我们的深度残差网络。

让我们开始构建构建方法。

	@staticmethod
	def build(width, height, depth, classes, stages, filters, 
	 reg=0.0001, bnEps=2e-5, bnMom=0.9):

看一下参数stages和filters （两个都是列表）。在我们的架构中（如上所示），我们将N个残差模块堆叠在一起（N =stage value）。同一stage 中的每个残差模块学习相同数量的filters。在每个stage 学习其各自的filters之后，接着是降维。我们重复这个过程，直到我们准备应用平均池化层和softmax分类器。

Stages 和Filters

例如，让我们设置stages=（3,4,6）和filters =（64,128,256,512）。第一个filter （64）应用于唯一的CONV层，而不是残差模块的一部分 - 网络中的第一个CONV层。然后，三个（stages= 3）残差模块堆叠在彼此之上 - 每个模块将学习128个filters。空间维度将减少，然后我们将四个（stage = 4）残差模块堆叠在一起 - 每个模拟256个filters。最后，我们再次减少空间维度，继续将六个（stage = 6）残差模块堆叠在一起，每个模块学习512个过滤器。

ResNet架构。带圆圈的数字是filter值，而括号显示stage 。注意每个stage 后如何降低维数。

让我们回到构建构建方法。

	# initialize the input shape to be "channels last" and the
	# channels dimension itself
	inputShape = (height, width, depth)
	chanDim = -1
	# if we are using "channels first", update the input shape
	# and channels dimension
	if K.image_data_format() == "channels_first":
		inputShape = (depth, height, width)
		chanDim = 1

根据我们是使用“channel last”还是“channel first”排序（第3-4行）初始化inputShape和chanDim。

		# set the input and apply BN
		inputs = Input(shape=inputShape)
		x = BatchNormalization(axis=chanDim, epsilon=bnEps,
			momentum=bnMom)(inputs)
		# apply CONV => BN => ACT => POOL to reduce spatial size
		x = Conv2D(filters[0], (5, 5), use_bias=False,
			padding="same", kernel_regularizer=l2(reg))(x)
		x = BatchNormalization(axis=chanDim, epsilon=bnEps,
			momentum=bnMom)(x)
		x = Activation("relu")(x)
		x = ZeroPadding2D((1, 1))(x)
		x = MaxPooling2D((3, 3), strides=(2, 2))(x)

如上所述，ResNet使用BN作为第一层作为输入归一化的附加级别（第2-4行）。然后，我们应用CONV =>，BN => ACT => POOL来减小空间大小（第7-13行）。现在，让我们开始将残差层堆叠在一起。

	# loop over the number of stages
	for i in range(0, len(stages)):
		# initialize the stride, then apply a residual module
		# used to reduce the spatial size of the input volume
		stride = (1, 1) if i == 0 else (2, 2)
		x = ResNet.residual_module(x, filters[i + 1], stride,
				chanDim, red=True, bnEps=bnEps, bnMom=bnMom)
		# loop over the number of layers in the stage
		for j in range(0, stages[i] - 1):
			# apply a ResNet module
			x = ResNet.residual_module(x, filters[i + 1],
				(1, 1), chanDim, bnEps=bnEps, bnMom=bnMom)

为了在不使用池化层的情况下减小体积大小，我们可以改变卷积的步幅。stage中的第一个条目将具有（1,1）的步幅 - 表示没有下采样。然后，在此之后的每个stage，我们将应用具有（2,2）步幅的残差模块，这将减小体积大小。这在第5行显示。

然后，我们在第10-13行循环遍历当前stage的层数（将堆叠在彼此之上的残差模块的数量）。我们使用[i + 1]作为filters的索引，因为已经使用了第一个filter。一旦我们将stage[i]残差模块堆叠在彼此之上，我们将返回到第6-7行，在那里我们减小体积的空间维度并重复该过程。

为避免dense的全连接层，我们将应用平均池化而不是将卷大小减小到1 x 1 x classes：

	# apply BN => ACT => POOL
	x = BatchNormalization(axis=chanDim, epsilon=bnEps,
			momentum=bnMom)(x)
	x = Activation("relu")(x)
	x = AveragePooling2D((8, 8))(x)

最后，我们将为我们要学习的类的总数创建一个dense层，然后应用softmax激活来生成我们的最终输出概率！

	# softmax classifier
	x = Flatten()(x)
	x = Dense(classes, kernel_regularizer=l2(reg))(x)
	x = Activation("softmax")(x)
	
	# create the model
	model = Model(inputs, x, name="resnet")
	
	# return the constructed network architecture
	return model

现在我们已经完全构建了ResNet模型！您可以调用此类在深度学习项目中实现ResNet体系结构。