Writing ResNet from Scratch in PyTorch

为了结束我在PyTorch中从头开始构建经典卷积神经网络的系列，我们将构建ResNet，这是计算机视觉领域的一个重大突破，它解决了如果网络太深，网络性能会下降的问题。它还引入了 "剩余连接 "的概念（后面会详细介绍）。我们可以在我的个人资料上访问该系列的前几篇文章，即LeNet5、AlexNet和VGG。

我们将首先研究ResNet的架构和背后的直觉。然后我们将把它与VGG进行比较，并研究它是如何解决VGG的一些问题的。然后，和以前一样，我们将加载我们的数据集CIFAR10，并对其进行预处理，使其准备好进行建模。然后，我们将首先实现ResNet的基本构件（我们将称之为ResidualBlock），并使用它来构建我们的网络。然后，这个网络将在预处理过的数据上进行训练，最后，我们将看到训练过的模型在未见过的数据（测试集）上表现如何。

资源网络

VGG的一个缺点是，它不能像想要的那样深入，因为它开始失去泛化能力（即，它开始过度拟合）。这是因为随着神经网络的深入，损失函数的梯度开始缩减为零，因此权重不会被更新。这个问题被称为梯度消失问题。ResNet通过使用跳过连接基本上解决了这个问题。

Writing ResNet from Scratch in PyTorch

一个残差块。资料来源：ResNet论文。ResNet论文

在上图中，我们可以看到，除了正常的连接，还有一个直接连接，跳过了模型中的一些层（跳过连接）。通过跳过连接，输出从h（x）=f（wx+b） 变为h（x）=f（x）+x。 这些跳过连接有帮助，因为它们允许梯度流经另一条捷径。下面是34层ResNet的结构。

Writing ResNet from Scratch in PyTorch

资料来源。ResNet论文

数据加载

数据集

在本文中，我们将使用著名的CIFAR-10数据集，它已经成为计算机视觉初学者最常用的数据集之一。该数据集是8000万张微小图像数据集的一个标记子集。它们是由Alex Krizhevsky、Vinod Nair和Geoffrey Hinton收集的。CIFAR-10数据集由10类60000张32x32的彩色图像组成，每类有6000张图像。有50000张训练图像和10000张测试图像。

该数据集被分为五个训练批和一个测试批，每个批有10000张图像。测试批包含从每个类中随机选择的1000张图像。训练批包含其余的随机顺序的图像，但有些训练批可能包含一个类别的图像多于另一个。在它们之间，训练批次恰好包含了每个类别的5000张图像。这些类别是完全相互排斥的。汽车和卡车之间没有重叠。"汽车 "包括轿车、SUV和类似的东西。"卡车 "只包括大卡车。也不包括皮卡。

下面是数据集中的类别，以及每个类别的10张随机图片。

Writing ResNet from Scratch in PyTorch

来源：www.cs.toronto.edu/%7Ekriz/cif…

导入库

我们将从导入我们要使用的库开始。除此之外，我们将确保Notebook使用GPU来训练模型，如果它是可用的。

import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from torch.utils.data.sampler import SubsetRandomSampler


# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

导入库

加载数据集

现在我们继续加载我们的数据集。为此，我们将使用torchvision 库，它不仅提供了对数百个计算机视觉数据集的快速访问，而且还提供了简单而直观的方法来预处理/转换它们，以便为建模做好准备。

我们首先定义我们的data_loader 函数，根据参数返回训练或测试数据。
在深度学习项目中，规范化我们的数据总是一个好的做法，因为它使训练更快，更容易收敛。为此，我们用数据集中每个通道（红、绿、蓝）的平均值和标准偏差定义变量normalize 。这些可以手动计算，但也可以在网上获得。这被用于transform ，在这里我们调整数据的大小，将其转换为张量，然后将其归一化。
我们利用数据加载器。数据加载器允许我们分批迭代数据，数据是在迭代的同时加载的，而不是一下子就开始进入我们的RAM。如果我们要处理大约一百万张图片的大数据集，这就非常有帮助。
根据test 参数，我们要么加载train（如果是test=False ）分割，要么加载test （如果是test=True ）分割。在训练的情况下，数据集被随机分为训练集和验证集（0.9：0.1）。

def data_loader(data_dir,
                batch_size,
                random_seed=42,
                valid_size=0.1,
                shuffle=True,
                test=False):
  
    normalize = transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2023, 0.1994, 0.2010],
    )

    # define transforms
    transform = transforms.Compose([
            transforms.Resize((224,224)),
            transforms.ToTensor(),
            normalize,
    ])

    if test:
        dataset = datasets.CIFAR10(
          root=data_dir, train=False,
          download=True, transform=transform,
        )

        data_loader = torch.utils.data.DataLoader(
            dataset, batch_size=batch_size, shuffle=shuffle
        )

        return data_loader

    # load the dataset
    train_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    valid_dataset = datasets.CIFAR10(
        root=data_dir, train=True,
        download=True, transform=transform,
    )

    num_train = len(train_dataset)
    indices = list(range(num_train))
    split = int(np.floor(valid_size * num_train))

    if shuffle:
        np.random.seed(42)
        np.random.shuffle(indices)

    train_idx, valid_idx = indices[split:], indices[:split]
    train_sampler = SubsetRandomSampler(train_idx)
    valid_sampler = SubsetRandomSampler(valid_idx)

    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=batch_size, sampler=train_sampler)
 
    valid_loader = torch.utils.data.DataLoader(
        valid_dataset, batch_size=batch_size, sampler=valid_sampler)

    return (train_loader, valid_loader)


# CIFAR10 dataset 
train_loader, valid_loader = data_loader(data_dir='./data',
                                         batch_size=64)

test_loader = data_loader(data_dir='./data',
                              batch_size=64,
                              test=True)

加载数据集

把这个项目带入生活

在梯度上运行

从零开始的ResNet

模型如何在PyTorch中工作

在开始构建残差块和ResNet之前，我们首先要研究并了解PyTorch中是如何定义神经网络的。

nn.Module PyTorch提供了一个用于创建自定义模型的模板，以及一些有助于训练的必要功能。这就是为什么每个自定义模型都倾向于继承自nn.Module
然后，每个自定义模型内部都有两个主要的函数。首先是初始化函数，__init__ ，在这里我们定义了我们将使用的各种层，其次是forward 函数，它定义了上述层在给定的输入上的执行顺序。

PyTorch中的图层

现在来看看PyTorch中对我们有用的不同类型的层。

nn.Conv2d:这些是卷积层，它接受输入和输出通道的数量作为参数，同时也接受滤波器的内核大小。如果我们想应用这些参数，它还接受任何跨度或填充。
nn.BatchNorm2d:这将对卷积层的输出进行批量标准化处理。
nn.ReLU:这是一种激活函数，适用于网络中的各种输出。
nn.MaxPool2d:这是将最大池化应用到给定核大小的输出上。
nn.Dropout:这是用给定的概率对输出应用dropout。
nn.Linear:这基本上是一个全连接层
nn.Sequential:这在技术上不是一种层的类型，但它有助于结合属于同一步骤的不同操作。

剩余块

在开始使用网络之前，我们需要建立一个ResidualBlock，我们可以在整个网络中重复使用。该块（如架构所示）包含一个跳过连接，它是一个可选的参数(downsample )。注意，在forward ，这直接应用于输入，x ，而不是输出，out 。

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride = 1, downsample = None):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Sequential(
                        nn.Conv2d(in_channels, out_channels, kernel_size = 3, stride = stride, padding = 1),
                        nn.BatchNorm2d(out_channels),
                        nn.ReLU())
        self.conv2 = nn.Sequential(
                        nn.Conv2d(out_channels, out_channels, kernel_size = 3, stride = 1, padding = 1),
                        nn.BatchNorm2d(out_channels))
        self.downsample = downsample
        self.relu = nn.ReLU()
        self.out_channels = out_channels
        
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.conv2(out)
        if self.downsample:
            residual = self.downsample(x)
        out += residual
        out = self.relu(out)
        return out

ResidualBlock

ResNet

现在，我们已经创建了ResidualBlock，我们可以建立我们的ResNet。

注意，架构中有三个块，分别包含3、3、6和3层。为了制作这个块，我们创建了一个辅助函数_make_layer 。该函数将各层与残差块一起逐一添加。在这些块之后，我们添加平均池和最后的线性层。

class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes = 10):
        super(ResNet, self).__init__()
        self.inplanes = 64
        self.conv1 = nn.Sequential(
                        nn.Conv2d(3, 64, kernel_size = 7, stride = 2, padding = 3),
                        nn.BatchNorm2d(64),
                        nn.ReLU())
        self.maxpool = nn.MaxPool2d(kernel_size = 3, stride = 2, padding = 1)
        self.layer0 = self._make_layer(block, 64, layers[0], stride = 1)
        self.layer1 = self._make_layer(block, 128, layers[1], stride = 2)
        self.layer2 = self._make_layer(block, 256, layers[2], stride = 2)
        self.layer3 = self._make_layer(block, 512, layers[3], stride = 2)
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512, num_classes)
        
    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        if stride != 1 or self.inplanes != planes:
            
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes, kernel_size=1, stride=stride),
                nn.BatchNorm2d(planes),
            )
        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes
        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.maxpool(x)
        x = self.layer0(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)

        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x

ResNet34

设置超参数

我们总是建议在我们的模型中尝试不同的超参数值，但在这里我们将只使用一个设置。无论如何，我们建议每个人都尝试不同的参数，看看哪个参数效果最好。超参数包括定义epochs的数量、批次大小、学习率、损失函数以及优化器。由于我们正在构建34层的ResNet变体，我们也需要传递适当的层数。

num_classes = 10
num_epochs = 20
batch_size = 16
learning_rate = 0.01

model = ResNet(ResidualBlock, [3, 4, 6, 3]).to(device)

# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay = 0.001, momentum = 0.9)  

# Train the model
total_step = len(train_loader)

设置超参数

训练

现在，我们的模型已经准备好进行训练了，但首先我们需要知道PyTorch中的模型训练是如何进行的。

我们首先使用我们的train_loader ，为每个epoch分批加载图像，同时使用我们之前定义的device 变量将数据移动到GPU上
然后，模型被用来预测标签，model(images) ，然后我们使用上面定义的损失函数计算预测和地面实况之间的损失。criterion(outputs, labels)
现在是学习部分，我们使用损失反推法，loss.backward() ，并更新权重，optimizer.step() 。在每次更新之前，需要做的一件事是使用optimizer.zero_grad() ，将梯度设置为零，因为否则梯度会被累积（PyTorch的默认行为）。
最后，在每个历时之后，我们在验证集上测试我们的模型，但是，由于我们在评估时不需要梯度，我们可以使用with torch.no_grad() 关闭它，以使评估更快。

import gc
total_step = len(train_loader)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        # Move tensors to the configured device
        images = images.to(device)
        labels = labels.to(device)
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        del images, labels, outputs
        torch.cuda.empty_cache()
        gc.collect()

    print ('Epoch [{}/{}], Loss: {:.4f}' 
                   .format(epoch+1, num_epochs, loss.item()))
            
    # Validation
    with torch.no_grad():
        correct = 0
        total = 0
        for images, labels in valid_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            del images, labels, outputs
    
        print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))

训练和验证

分析代码的输出，我们可以看到模型正在学习，因为损失在减少，而验证集上的准确度随着每个epoch而增加。但是我们可能会注意到，它在最后是波动的，这可能意味着模型是过拟合的，或者batch_size 。我们将不得不进行测试以找出问题所在。

Writing ResNet from Scratch in PyTorch

训练损失

测试

对于测试，我们使用与验证完全相同的代码，但使用test_loader 。

with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        del images, labels, outputs

    print('Accuracy of the network on the {} test images: {} %'.format(10000, 100 * correct / total))

测试

使用上述代码并对模型进行10个epochs的训练，我们能够在测试集上达到82.87%的准确率。

Writing ResNet from Scratch in PyTorch

测试准确率

总结

现在让我们来总结一下我们在这篇文章中所做的事情。

我们从了解架构和ResNet的工作原理开始
接下来，我们使用 "CIFAR10 "数据集加载并进行预处理。torchvision
然后，我们了解了PyTorch中的自定义模型定义是如何工作的，以及PyTorch中可用的不同类型的层。torch
我们通过建立一个ResidualBlock从头开始建立我们的ResNet。
最后，我们在CIFAR10数据集上训练并测试了我们的模型，该模型在测试数据集上表现良好，准确率达到75%。

未来的工作

通过这篇文章，我们得到了一个很好的介绍和实践学习，但如果我们将其扩展到其他挑战中，我们可以学到更多。

尝试使用不同的数据集。其中一个数据集是CIFAR100，它是ImageNet数据集的一个子集，也就是8000万张小图片数据集。
实验不同的超参数，看看它们对模型的最佳组合。
最后，尝试从数据集中添加或删除层，看看它们对模型能力的影响。更好的是，尝试建立这个模型的ResNet-51版本。

今天就为你的机器学习工作流程增加速度和简单性吧

开始联系销售

在PyTorch中从零开始编写ResNet

资源网络

数据加载

数据集

导入库

加载数据集

从零开始的ResNet

模型如何在PyTorch中工作

PyTorch中的图层

剩余块

ResNet

设置超参数

训练

测试

总结

未来的工作