Reference material ：《 Deep learning framework PyTorch： Introduction and practice 》

Be careful ： The author of the book said that we should pay attention to the simplicity of programming , Therefore, the network construction method of this paper can be used for reference .

Complete code

See notes for some explanations ：

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

#  Implementer module：Residual Block
class ResidualBlock(nn.Module):
    
    def __init__(self, inchannel, outchannel, stride=1, shortcut=None):
        super().__init__()
        self.left = nn.Sequential(
                # padding=1 It refers to filling a line up, down, left and right , If it is padding=(1, 1) It is 
                #  Fill in a line from top to bottom 、 Fill in a line on the left and right （ First high then wide ）
                nn.Conv2d(inchannel, outchannel, 3, stride, 1, bias=False),
                nn.BatchNorm2d(outchannel),
                # inplace=True It refers to in-situ operation , Directly modify the... Passed down from the upper layer tensor, Save memory 
                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 = []
        #  The first one to put inchannel become 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], that *a Is refers to 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)
        #  Turn into [batch, ...]
        x = x.view(x.size(0), -1)
        return self.fc(x)

Test forward propagation

model = ResNet()
#  simulation 224×224 Pictures of the , Passageway is 3. At the beginning 1 yes batch_size
input = t.randn(1, 3, 224, 224)
o = model(input)
o.shape

Output results ：

torch.Size([1, 1000])

Corresponding classification problem 1000 Categories .