基于Paddle复现残差连接网络ResNet

import timeimport paddleimport paddle.nn as nnimport paddle.nn.functional as F 
from paddle.vision.transforms import Compose, Resizefrom PIL import Imageimport matplotlib.pyplot as pltfrom collections import OrderedDictimport copyimport numpy as npimport paddle.fluid as fluidfrom paddle.vision import transforms as transformsfrom paddle.vision.datasets import Cifar10from paddle.vision.transforms import Normalizefrom time import strftimefrom time import gmtime

#定义残差块class ResidualBlock(nn.Layer):
    def __init__(self, inchannel, outchannel, stride):
        super(ResidualBlock, self).__init__()

        self.left = nn.Sequential(
            nn.Conv2D(inchannel, outchannel, kernel_size=3, stride=stride, padding=1, bias_attr=False),
            nn.BatchNorm2D(outchannel),
            nn.ReLU(),
            nn.Conv2D(outchannel, outchannel, kernel_size=3, stride=1, padding=1, bias_attr=False),
            nn.BatchNorm2D(outchannel)
        )

        self.shortcut = nn.Sequential()        if stride != 1 or inchannel != outchannel:            # 使x的变化一致 使用与F相同的outchannel与stride
            self.shortcut = nn.Sequential(
                nn.Conv2D(inchannel, outchannel, kernel_size=1, stride=stride, bias_attr=False),
                nn.BatchNorm2D(outchannel)
            )    def forward(self, x):
        out = self.left(x)        # 这里是直接加上去了，DenseNet是累起来的，相当于扩充了通道数
        out += self.shortcut(x)
        out = F.relu(out)        return out

#resnet主体class ResNet(nn.Layer):
    def __init__(self, ResidualBlock, num_classes=10):
        super(ResNet, self).__init__()
        self.inchannel = 64
        self.conv1 = nn.Sequential(
            nn.Conv2D(3, 64, kernel_size=3, stride=1, padding=1, bias_attr=False),
            nn.BatchNorm2D(64),
            nn.ReLU(),
        )        # 把函数传了进去
        self.layer1 = self.make_layer(ResidualBlock, 64,  2, stride=1)
        self.layer2 = self.make_layer(ResidualBlock, 128, 2, stride=2)
        self.layer3 = self.make_layer(ResidualBlock, 256, 2, stride=2)
        self.layer4 = self.make_layer(ResidualBlock, 512, 2, stride=2)
        self.fc = nn.Linear(512, num_classes) 
    def make_layer(self, block, channels, num_blocks, stride):
        # 堆叠的层数与num_blocks有关
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []        for stride in strides:
            layers.append(block(self.inchannel, channels, stride))            # 储存上次输出的通道数，以便一次输入回去
            self.inchannel = channels        return nn.Sequential(*layers)    # 假设输入3*32*32 这样训练的快点哈哈
    # 如果不用32*32，可以在开头几个conv中缩小尺寸
    def forward(self, x):
        # 3*32*32
        out = self.conv1(x)        # 64*32*32
        out = self.layer1(out)        # 64*32*32
        out = self.layer2(out)        # 128*16*16
        out = self.layer3(out)        # 256*8*8
        out = self.layer4(out)        # 512*4*4
        out = F.avg_pool2d(out,4)        # 512*1*1
        out = paddle.reshape(out,[out.shape[0], -1])        # x 1*1*512=512
        out = self.fc(out)        return out#定义resnet18def ResNet18():
    return ResNet(ResidualBlock)

transform_train = Compose([
    transforms.RandomHorizontalFlip(prob=0.5),
    transforms.RandomVerticalFlip(prob=0.5),
    transforms.ColorJitter(brightness=0.5),
    transforms.ColorJitter(contrast=0.5),
    transforms.ColorJitter(saturation=0.5),
    transforms.ColorJitter(hue=0.3),
    transforms.Resize([32, 32]),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

transform_test = Compose([
    transforms.Resize([32, 32]),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

LR = 0.001EPOCHES = 100BATCHSIZE = 150trainset=Cifar10(data_file=None, mode='train', transform=transform_train, download=True)
testset=Cifar10(data_file=None, mode='test', transform=transform_test, download=True)

trainloader = paddle.io.DataLoader(trainset, batch_size=BATCHSIZE, shuffle=True, num_workers=2)
testloader = paddle.io.DataLoader(testset, batch_size=BATCHSIZE, shuffle=False, num_workers=2)

resnet18 = ResNet18()
optimizer = paddle.optimizer.Adam(learning_rate=LR,parameters=resnet18.parameters())
loss_function = nn.CrossEntropyLoss()

for ep in range(EPOCHES):
    train_correct = 0
    train_sum=0
    epoch_used_time=0
    epoch_ave_time=0
    time_start=time.time()    for i,(img, label) in enumerate(trainloader):

        optimizer.clear_grad()
        resnet18.train()
        out = resnet18(img)

        prediction = paddle.argmax(out, 1)
        pre_num = prediction.cpu().numpy()
        train_correct += (pre_num == label.cpu().numpy()).sum()
        train_sum+=BATCHSIZE

        loss = loss_function(out, label)
        loss.backward()
        optimizer.step()

        epoch_used_time+=(time.time()-time_start)
        time_start=time.time()        
        # 加了个比较简陋的计时方式，显示训练剩余时间，以便估计摸鱼时间
        used_t=strftime("%H:%M:%S", gmtime(epoch_used_time))
        total_t=strftime("%H:%M:%S", gmtime((epoch_used_time/(i+1))*len(trainloader)))        print(f"\rEpoch：{str(ep)} Iter {train_sum}/{len(trainloader)*BATCHSIZE} Train ACC： {(train_correct/train_sum):.5}\
    Used_Time：{used_t} / Total_Time：{total_t}",end="")    
    print('')

    vote_correct = 0
    test_sum=0
    for img, label in testloader:
        resnet18.eval()
        out = resnet18(img)
        prediction = paddle.argmax(out, 1)
        pre_num = prediction.cpu().numpy()
        vote_correct += (pre_num == label.cpu().numpy()).sum()
        test_sum+=BATCHSIZE    
        print(f"\rEpoch：{str(ep)} Iter {test_sum}/{len(testloader)*BATCHSIZE} Test ACC： {(vote_correct/test_sum):.5}",end="")    print('')