阅前须知：
为了使本文结构精简，理解简单，所以会尽量少涉及到有关数学公式，降低学习门槛，带领读者快速搭建ResNet-152经典模型并投入训练。
本文的最后也会给出相应的inference供大家直接使用
如读者在阅读时发现有错误的地方欢在评论的地方指出，共同进步
编译环境：Python3.6
TensorFlow-gpu 1.5.0
Pycharm
一、结构分析
关于ResNet的来源我就不进行赘述了，相信读者都对其或多或少有一定的了解，这个包揽各大图像识别赛事冠军的模型究竟有什么与众不同？
说起卷积模型，LeNet、Inception、Vgg都是我们在学习图像识别领域神经网络的经典模型，以上图片模型就是经典的Vgg-19与34层传统卷积网络、ResNet-34的对比。
从计算量上来讲，Vgg-19的三层全连接神经网络的计算量明显大于传统卷积网络和resnet，传统卷积网络和resnet的参数数量相同
从训练拟合度上讲，论文中分别给出了plain-18、plain-34和resnet-18、resnet-34的对比，我们不难发现plain随着层数的增加，精度并没有得到明显的提升，而resnet不仅随着层数的增加提高了训练精度，且相较同深度的plain而言精度更高
在以往的学习之中，我们知道深度网络随着层数的增加，很容易造成“退化”和“梯度消失”的问题，训练数据的过拟合。但在ResNet中，作者给出了一种解决方案：增加一个identity mapping(恒等映射，由于本文面向读者基础不同，就不加以详述，有能力的同学可以看一下ResNet作者的论文)
上图是一个残差模块的结构示意，残差块想要有效果需要有两层或两层以上的layer，同时，输入x与输出F（x）的维度也须相同
在对于高于50层深度的resnet模型中，为了进一步减少计算量且保证模型精度，作者对残差模块进行了优化，将内部两层3*3layer换成1*1 → 3*3 → 1*1,。首先采用1*1卷积进行深度降维，减少残差模块在深度上的计算量，第二层3*3layer和之前的模块功能一样，提取图像特征，第三层1*1layer用于维度还原。
那么问题又来了，既然已经经过了3*3卷积，那输出维度怎么会一样呢？作者在论文中给出了三种解决方案：
1、维度不足部分全0填充
2、输入输出维度一致时使用恒等映射，不一致时使用线性投影
3、对于所有的block均使用线性投影。
在本文中，我们对模型主要采用全0填充。
好，以上就是简单的理论入门，接下来我们开始着手用TensorFlow对理论进行代码实现
二、实现规划(ResNet-50-101-152)
我们来选取最具有代表性的152层ResNet来进行搭建，论文的作者就是用152层模型来获得Imagenet大赛冠军的。
结构定义字典
在本文中，我们的模型搭建方式是以字典的形式进行循环堆砌
结构字典
ResNet_demo = { "layer_50":[{"depth": 256,"num_class": 3},
{"depth": 512,"num_class": 4},
{"depth": 1024,"num_class": 6},
{"depth": 2048,"num_class": 3}],
"layer_101": [{"depth": 256, "num_class": 3},
{"depth": 512, "num_class": 4},
{"depth": 1024, "num_class": 23},
{"depth": 2048, "num_class": 3}],
"layer_152": [{"depth": 256, "num_class": 3},
{"depth": 512, "num_class": 8},
{"depth": 1024, "num_class": 36},
{"depth": 2048, "num_class": 3}]
子类模块规划
在ResNet网络传递的过程中，我们来探讨一些即将遇到的问题：
1.降采样过程
2.通道填充
降采样过程用于不同类瓶颈模块之间传递的过程，例如上图中粉色卷积层和蓝色卷积层之间的数据交互，蓝色卷积层中的/2就是降采样处理
降采样模块代码实现
def sampling(input_tensor, #Tensor入口
ksize = 1, #采样块大小
stride = 2): #采样步长
data = input_tensor
data = slim.max_pool2d(data,ksize,stride = stride)
return data
通道填充用于输入数据x与结果数据F（x）生成残差和时造成的通道不匹配问题
通道填充模块代码实现
def depthFilling(input_tensor, #输入
Tensor depth): #输出深度
data = input_tensor #取出输入tensor的深度
input_depth = data.get_shape().as_list()[3]
#tf.pad用与维度填充，不理解的同学可以去TensoFLow官网了解一下
data = tf.pad(data,[[0,0],
[0,0],
[0,0],
[abs(depth - input_depth)//2, abs(depth - input_depth)//2]])
return data
好的，两个子类问题已经得到解决，下面来对残差模块进行规划实现
残差模块
因为搭建方向选择layer大于等于50层，所以我们采用论文中给出的第二种残差模块（1*1+3*3+1*1）
残差模块代码实现
def bottleneck(input_tensor,output_depth):
#取出通道
redepth = input_tensor.get_shape().as_list()[3]
# 当通道不相符时，进行全零填充并降采样
if output_depth != redepth:
#全零填充
input_tensor = depthFilling(input_tensor,output_depth)
#降采样
input_tensor= sampling(input_tensor)
data = input_tensor
#降通道处理
data = slim.conv2d(inputs = data,
num_outputs = output_depth//4,
kernel_size = 1,stride = 1)
#提取特征
data = slim.conv2d(inputs = data,
num_outputs = output_depth//4,
kernel_size = 3,stride = 1)
#通道还原
data = slim.conv2d(inputs = data,
num_outputs = output_depth,
kernel_size = 1,stride = 1,
activation_fn=None,
normalizer_fn=None)
#生成残差
data = data + input_tensor
data = tf.nn.relu(data)
return data
有了残差模块，我们就可以对网络结构进行堆砌了
不过，为了精简我们的代码块，我选择把全连接层拿出来单独写成一个模块
FC代码实现
这一模块没有什么技术含量，和我们入门时的BP神经网络差不多
def cnn_to_fc(input_tensor, #Tensor入口
num_output, #输出接口数量
train = False, #是否使用dropout
regularizer = None): #正则函数
data = input_tensor #得到输出信息的维度，用于全连接层的输入
data_shape = data.get_shape().as_list()
nodes = data_shape[1] * data_shape[2] * data_shape[3]
reshaped = tf.reshape(data, [data_shape[0], nodes])
#最后全连接层
with tf.variable_scope('layer-fc'):
fc_weights = tf.get_variable("weight",
[nodes,num_output],
initializer=tf.truncated_normal_initializer(stddev=0.1))
if regularizer != None:
tf.add_to_collection('losses', regularizer(fc_weights))
fc_biases = tf.get_variable("bias", [num_output],
initializer=tf.constant_initializer(0.1))
fc = tf.nn.relu(tf.matmul(reshaped, fc_weights) + fc_biases)
if train:
fc = tf.nn.dropout(fc, 0.5)
return fc
定义传递规则
inference
#堆叠ResNet模块
def inference(input_tensor, #数据入口
demos, #模型资料（list）
num_output, #出口数量
is_train):
data = input_tensor #第一层卷积7*7,stride = 2,深度为64
data = conv2d_same(data,64,7,2,is_train,None,normalizer_fn = False)
data = slim.max_pool2d(data,3,2,scope="pool_1")
with tf.variable_scope("resnet"): #堆叠总类瓶颈模块
demo_num = 0
for demo in demos:
demo_num += 1
print("--------------------------------------------") #堆叠子类瓶颈模块
for i in range(demo["num_class"]):
print(demo_num)
if demo_num is not 4:
if i == demo["num_class"] - 1:
stride = 2
else:
stride = 1
else:
stride = 1
data = bottleneck(data,demo["depth"],stride,is_train)
print("--------------------------------------------")
data = tf.layers.batch_normalization(data,training=is_train)
data = tf.nn.relu(data) #平均池化，也可用Avg_pool函数
data = tf.reduce_mean(data, [1, 2], keep_dims=True)
print("output : ", data) #最后全连接层
data = slim.conv2d(data,num_output,1,activation_fn=None)
data_shape = data.get_shape().as_list()
nodes = data_shape[1] * data_shape[2] * data_shape[3]
data = tf.reshape(data, [-1, nodes])
return data
inference调用方式
inference(input_tensor = 数据入口
demos = ResNet_demo["layer_101"], #获取模型词典
num_output = 出口数量,
is_train = False) # BN是否被训练
参考文献：https://arxiv.org/pdf/1512.03385.pdf
http://blog.csdn.net/xxy0118/article/details/78324256
http://blog.csdn.net/mao_feng/article/details/52734438
注：本文原创，已于2018年2月2日售与今日头条头条主“昂钛客AI”
