resnet 和 vgg 是重要的backbone，而且许多网络结构都是以vgg 和resnet为原型进行创作，充分的理解这两个基本网络结构的代码是十分重要的，本次就详细解读一下这两个基本网络结构代码，代码来自 torchvision.models ：
1 resnet代码：
随便建立一个 .py 文件，然后：
from torchvision.models import *
m1 = resnet34()
就可以找到resnet的pytorch源码。下面先看一下resnet的层次结构图：
注意观察一下，resnet18 、34、50、101、152的是非常相似的，都是分为5个stage（stage是什么一查便知；而且通常分辨率降低同时我们会增加通道数目，因为一般认为深层的网络可以提取出更加丰富的语义信息。随着网络的加深一般我们会让分辨率降低而让通道数增加：也就是一般认为通道是携带高级语义信息的基本单位，随着网络越深，提取的语义信息越丰富，需要用来表达语义信息的单位也就越来越多，所以需要通道数目越多。）。
开始都是一个卷积接着一个maxpooling，只不过在后面的每个stage中，resnet18 、34、50、101、152的卷积层个数是不一样的。他们都是通过往上堆叠一个个的基本模块，然后使得网络达到较深的层数。
在较为浅层的resnet中（resnet1,resnet34）中使用的基本模块叫BasicBlock，它由两个 （3, 3, out_plane）的Conv2d 堆叠而成。在使用这个BasicBlock时候，只需要根据 堆叠具体参数：输入输出通道数目，堆叠几个BasicBlock，就能确定每个stage中basicblock的基本使用情况；在较为深层的resnet中（resnt50，resnet101，resnet152），既能增加模块深度，又能减少参数量，使用的是一种瓶颈结构Bottleneck，它由 (1,1, ) ，（3,3），（1,1）堆叠而成，使用方法和BasicBlock基本类似。
在2,3,4,5个stage中，resnet18的在各个stage中使用的基本模块的数目为：[2,2,2,2]；resnet34的在各个stage中的基本模块的数目为：[3,4,6,3]；resnet50的在各个stage中的基本模块的数目为：[3,4,6,3]；resnet101的在各个stage中的基本模块的数目为：[3,4,23,3]；resnet18的在各个stage中的基本模块的数目为：[3,8,36,3]；
下面以 resnet18 和 resnet 50 为代表详细解释代码：
（1）resnet 18建立（写完resnet18的建立发现根本没有必要写resnet 50了，哈哈哈哈哈。。。。。。。。）
通过调用 已经定义好的 resnet18()函数，return 一个resnet18 model实例， 建立resnet18实例：
def resnet18(pretrained=False, **kwargs):
"""Constructs a ResNet-18 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
return model
——————————————————————————————————
1）BasicBlock() 残差块 解释
resnet18() 函数调用ResNet() 类，通过输入初始化参数：BasicBlock ，[2,2,2,2]，实例化一个resnet18 model:
先看下ResNet()大类，输入哪些初始化话参数就可以实例化为 resnet18 模型：BasicBlock
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
def forward(self, x):
residual = x # 其实这里不应该叫residual，应该写为：identity mapping = x，用identity mapping代替residual
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
if self.downsample is not None:
residual = self.downsample(x)
out += residual
out = self.relu(out)
return out
下面附上 基础模块BasicBlock 也就是 残差块residual block 的图解释：
BasicBlock要解决的一个重要问题就是，identity mapping这个直连的维度 和 F(x) 输出的维度不一样无法直接相加的问题：采用一个kernel=1的conv2d卷积核融合并降低通道信息，如果H/W尺度也不一样就设计stride。下面是在ResNet()定义中 定义的一个下采样模块，在BasicBlock实例化的时候作为了输入参数。
只要 stride>1 或者 输入和输出通道数目不同 都可以断定 residul F(x)部分产生的 feature maps 相对于原来的feature maps的分辨率降低了，此时的 identity map 都要进行下采样。也就是identity map部分要和 residual 部分进行相同的尺寸变换（包括H/W 和 channel），这两部分 的输入输出通道(planes)要相同， stride（H/W）也相同。
————————————————————————————————————————
2）制作stage的函数 __make_layer() 解释
注意在resnet18()函数中，直接调用了BasicBlock类作为 实参，并没有使用BasicBlock 实例：
而是在实例化 ResNet()类的时候实例化的 BasicBlock()类（这是定义的 ResNet()类 中的成员函数_make
_layer() 的代码，下面先解释完这个十分重要的成员函数代码，然后再附上ResNet()类代码）：
_make_layer() 成员函数，是用来制作每个stage中的网络结构的函数，其的 形参 包含block, planes, blocks, stride 四个参数：
block：基本模块选择谁（前面提到过基本模块包含 BasicBlock 和 Bottleneck两个基本模块）
planes：这是每个stage中，与每个block的输出通道相关的参数（ 查看代码就知道，如果使用的是BasicBlock那么planes就等于这个block的输出通道数目，如果使用的是Bottleneck那么这个block的输出通道数目就是planes的4倍）。
_make_layer()要解决：根据不同的基本block，完成一个stage 网络结构的构建。
3) __make_layer() 中用到的重要参数 类属性expansion 和 成员变量self.inplanes
BasicBlock()（或Bottleneck()）类中的类属性expandsion，用来指定下一个BasicBlock的输入通道是多少。因为就算在stage中，第一个block结束之后，下一个block的输入通道数目已经变化了，已经不是 同一个stage 的 第一个block 的输入通道数目。self.inplanes 的重要作用：self.inplanes一共有在block中两次使用：
每个stage中（一个_make_layer()就是一个stage），第一次使用时，self.inplanes 等于上一个stage的输出通道数，后面self.inplanes都等于同一个数目，就是每个block的输出通道数目。
因为分为BasicBlock()和Bottleneck() 两个基本的block类，对应不同深度的resnet，这两种block最后的输出通道是不一样的，为了标记这两个类输出通道数目的不同，设置了一个类属性expansion。根据类属性expansion和我们指定的输出通道参数planes，可以确定对于这两种block 结束之后的输出通道数目。
———————————————————————————————————————————
4) Resnet类 代码
说完了上面的部分resnet的代码已经没有完全可以看懂了。
ResNet() 类代码：
class ResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64 # 每一个block的输入通道数目
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AvgPool2d(7, stride=1)
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def _make_layer(self, block, planes, blocks, stride=1):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(self.inplanes, planes * block.expansion,
kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(planes * block.expansion),
)
layers = []
layers.append(block(self.inplanes, planes, stride, downsample))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes))
return nn.Sequential(*layers)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
整体思路就是把每个stage保存为一个单元。
在制作每一个stage的时候，把这stage中的 每个Basicblock，按照顺序append到一个 列表layer 中，当添加完这个stage中的所有block，把这个列表放入nn.Sequential()中，就把构建好的这个stage网络模型放到了计算图中。
