Resnet50学习

1.残差块

2.模块图

代码详解

import torch
from torch import nn

class Bottleneck(nn.Module):
    def __init__(self, in_channels,filters,stride=1):
        super(Bottleneck, self).__init__()
        self.stride = stride
        self.in_channels = in_channels
        F1, F2, F3 = filters
        self.out_channels = F3

        self.block = nn.Sequential(
            nn.Conv2d(in_channels, F1, 1, stride=stride, padding=0, bias=False),
            nn.BatchNorm2d(F1),
            nn.ReLU(inplace=True),
            # padding *2+1 = kernel_size大小
            nn.Conv2d(F1, F2, 3, stride=1, padding=1, bias=False),
            nn.BatchNorm2d(F2),
            nn.ReLU(inplace=True),
            nn.Conv2d(F2, F3, 1, stride=1, padding=0,bias =False),
            nn.BatchNorm2d(F3)
        )
        self.downsample = nn.Sequential(
            nn.Conv2d(in_channnels=in_channnels, out_channels=F3,
                      kernel_size=1,stride=stride, bias=False ),
            nn.BatchNorm2d(F3))
        self.relu = nn.ReLU(inplace=True)
    def forwad(self, x):
        identity = x
        out = self.block(x)
        if self.stride !=1 or self.in_channels != self.out_channels:
            identity =self.downsample(x)
        out += identity
        out = self.relu(out)
        return out
class Resnet50(nn.Module):
    def __init__(self, n_class):
        super(Resnet50, self).__init__()
        self.stage1 = nn.Sequential(
            nn.Conv2d(3, 64, stride=2, padding=3, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.MaxPool2d (3, 2, padding=1),
        )
        self.stage2 = nn.Sequential(
            Bottleneck(64,[64,64,256], stride=1),
            Bottleneck(256,[64,64,256]),
            Bottleneck(256, [64,64,256])
        )
        self.stage3 = nn.Sequential(
            Bottleneck(256, [128,128,512], stride=2), # 用stride=2是因为图像大小改变了,stride变大下采样操作
            Bottleneck(512,[128,128,512]), # stride默认为1不用进行下采样 操作
            Bottleneck(512,[128,128,512]),
            Bottleneck(512,[128,128,512])
        )
        self.stage4 = nn.Sequential(
            Bottleneck(512, [258, 258, 1024], stride=2),
            Bottleneck(1024, [258, 258, 1024]),
            Bottleneck(1024, [258, 258, 1024]),
            Bottleneck(1024, [258, 258, 1024]),
            Bottleneck(1024, [258, 258, 1024]),
            Bottleneck(1024, [258, 258, 1024])
        )
        self.stage5 = nn.Sequential(
            Bottleneck(1024, [512,512,2028], stride=2),
            Bottleneck(2048, [512, 512, 2048]),
            Bottleneck(2048, [512, 512, 2048])
        )
        self.avgpool = nn.AdaptiveAvgPool2d((1,1)) #最后的输出变成一个1×1的大小，同时通道变成上层的2048个通道
        self.fc = nn.Sequential(
            nn.Linear(2048, n_class)
        )
    def forward(self, x):
        out = self.stage1(x)
        print(out.shape)
        out = self.stage2(out)
        print(out.shape)
        out = self.stage3(out)
        print(out.shape)
        out = self.stage4(out)
        print(out.shape)
        out = self.stage5(out)
        print(out.shape)
        out = self.avgpool(out)  #torch.size([1, 2048,1,1])
        print(out.shape)
        print(out.size(0))
        out = out.view(out.size(0), 2048)  #展平变成一个1x1048
        out = self.fc(out)
        return out
if __name__ == '__main__':
    model = Resnet50(1000)  #实例化类
    # 设置x
    x = torch.randn(1,3, 224,224)
    y = model(x)
    print(y.shape)