参考资料：《深度学习框架PyTorch：入门与实践》

注意：书籍作者表示要注意编程简洁，所以本文的网络搭建方式是可以借鉴的。

完整代码

部分讲解见注释：

from torch import nn
import torch as t
from torch.nn import functional as F

# 实现子module：Residual Block
class ResidualBlock(nn.Module):
    
    def __init__(self, inchannel, outchannel, stride=1, shortcut=None):
        super().__init__()
        self.left = nn.Sequential(
                # padding=1指的是上下左右各补一行，如果是padding=(1, 1)则是
                # 上下各补一行、左右各补一行（先高后宽）
                nn.Conv2d(inchannel, outchannel, 3, stride, 1, bias=False),
                nn.BatchNorm2d(outchannel),
                # inplace=True是指原地操作，直接修改上层传递下来的tensor，节省内存
                nn.ReLU(inplace=True),
                nn.Conv2d(outchannel, outchannel, 3, 1, 1, bias=False),
                nn.BatchNorm2d(outchannel))
        self.right = shortcut
        
    def forward(self, x):
        out = self.left(x)
        residual = x if self.right is None else self.right(x)
        out += residual
        return F.relu(out)
    
class ResNet(nn.Module):
    
    def __init__(self, num_classes=1000):
        super().__init__()
        self.pre = nn.Sequential(
                nn.Conv2d(3, 64, 7, 2, 3, bias=False),
                nn.BatchNorm2d(64),
                nn.ReLU(inplace=True),
                # kernel_size, stride, padding
                nn.MaxPool2d(3, 2, 1))
        
        self.layer1 = self._make_layer(64, 128, 3)
        self.layer2 = self._make_layer(128, 256, 4, stride=2)
        self.layer3 = self._make_layer(256, 512, 6, stride=2)
        self.layer4 = self._make_layer(512, 512, 3, stride=2)
        
        self.fc = nn.Linear(512, num_classes)
        
    def _make_layer(self, inchannel, outchannel, block_num, stride=1):
        shortcut = nn.Sequential(
                nn.Conv2d(inchannel, outchannel, 1, stride, bias=False),
                nn.BatchNorm2d(outchannel))
        
        layers = []
        # 第一个把inchannel变成outchannel
        layers.append(ResidualBlock(inchannel, outchannel, stride, shortcut))
        
        for i in range(1, block_num):
            layers.append(ResidualBlock(outchannel, outchannel))
        # list a=[1,2,3]，那么*a就是指1 2 3
        return nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.pre(x)
        
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        
        x = F.avg_pool2d(x, 7)
        # 变为[batch, ...]
        x = x.view(x.size(0), -1)
        return self.fc(x)

测试前向传播

model = ResNet()
# 模拟224×224的图片，通道为3。开头的1是batch_size
input = t.randn(1, 3, 224, 224)
o = model(input)
o.shape

输出结果：

torch.Size([1, 1000])

对应分类问题的1000个类别。