CNN经典网络模型 - ResNet简介及代码实现

Shaw0xyz

1. 引言

卷积神经网络（CNN）是深度学习中广泛应用的一种神经网络结构。在众多CNN模型中，残差网络（ResNet）因其出色的性能和深度网络训练中的稳定性而备受关注。本文将介绍ResNet的基本概念，并提供一个简要的代码实现。

2. ResNet简介

2.1 残差网络的背景

深度神经网络在层数增加时，训练过程中的梯度消失和梯度爆炸问题使得网络性能难以提升。为了缓解这一问题，ResNet引入了残差块，通过残差连接（shortcut connection）使得网络更深且更易于训练。

2.2 残差块结构

ResNet的核心是残差块。一个典型的残差块包括两个卷积层和一个恒等映射（identity mapping）。其基本结构如下：

输入 → 卷积层1 → 批归一化（Batch Normalization）→ ReLU → 卷积层2 → 批归一化 → 残差连接 → ReLU → 输出

残差连接跳过了两个卷积层，将输入直接加到输出上，这样网络学习的是输入和输出之间的残差，而不是直接学习输出。

2.3 ResNet的变种

ResNet有多个变种，包括ResNet-18、ResNet-34、ResNet-50、ResNet-101等。数字表示网络层数。ResNet-50及以上的变种采用了“瓶颈结构”来减少计算量，这种结构在每个残差块中增加了一个1x1卷积层。

3. ResNet代码实现

下面我们以PyTorch为例，简要实现一个ResNet-18模型。

3.1 导入必要的库

首先，导入PyTorch及相关模块：

1. import torch
   
2. import torch.nn as nn
   
3. import torch.nn.functional as F

复制代码

3.2 定义残差块

1. class BasicBlock(nn.Module):
   
2.     def __init__(self, in_channels, out_channels, stride=1):
   
3.         super(BasicBlock, self).__init__()
   
4.         self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
   
5.         self.bn1 = nn.BatchNorm2d(out_channels)
   
6.         self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
   
7.         self.bn2 = nn.BatchNorm2d(out_channels)
   
8.         self.shortcut = nn.Sequential()
   
9.         if stride != 1 or in_channels != out_channels:
   
10.             self.shortcut = nn.Sequential(
    
11.                 nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
    
12.                 nn.BatchNorm2d(out_channels)
    
13.             )
    
14. 
    
15.     def forward(self, x):
    
16.         out = F.relu(self.bn1(self.conv1(x)))
    
17.         out = self.bn2(self.conv2(out))
    
18.         out += self.shortcut(x)
    
19.         out = F.relu(out)
    
20.         return out

复制代码

3.3 定义ResNet模型

1. class ResNet(nn.Module):
   
2.     def __init__(self, block, num_blocks, num_classes=10):
   
3.         super(ResNet, self).__init__()
   
4.         self.in_channels = 64
   
5.         self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
   
6.         self.bn1 = nn.BatchNorm2d(64)
   
7.         self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
   
8.         self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
   
9.         self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
   
10.         self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
    
11.         self.linear = nn.Linear(512, num_classes)
    
12. 
    
13.     def _make_layer(self, block, out_channels, num_blocks, stride):
    
14.         strides = [stride] + [1]*(num_blocks-1)
    
15.         layers = []
    
16.         for stride in strides:
    
17.             layers.append(block(self.in_channels, out_channels, stride))
    
18.             self.in_channels = out_channels
    
19.         return nn.Sequential(*layers)
    
20. 
    
21.     def forward(self, x):
    
22.         out = F.relu(self.bn1(self.conv1(x)))
    
23.         out = self.layer1(out)
    
24.         out = self.layer2(out)
    
25.         out = self.layer3(out)
    
26.         out = self.layer4(out)
    
27.         out = F.avg_pool2d(out, 4)
    
28.         out = out.view(out.size(0), -1)
    
29.         out = self.linear(out)
    
30.         return out
    
31. 
    
32. def ResNet18():
    
33.     return ResNet(BasicBlock, [2, 2, 2, 2])

复制代码

3.4 模型训练和测试

在定义好模型后，可以进行模型训练和测试。以下是训练和测试代码的简要示例：

1. import torch.optim as optim
   
2. from torch.utils.data import DataLoader
   
3. from torchvision import datasets, transforms
   
4. 
   
5. transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
   
6. 
   
7. train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
   
8. train_loader = DataLoader(train_dataset, batch_size=100, shuffle=True)
   
9. 
   
10. test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
    
11. test_loader = DataLoader(test_dataset, batch_size=100, shuffle=False)
    
12. 
    
13. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
14. model = ResNet18().to(device)
    
15. criterion = nn.CrossEntropyLoss()
    
16. optimizer = optim.Adam(model.parameters(), lr=0.001)
    
17. 
    
18. # Training loop
    
19. for epoch in range(10):
    
20.     model.train()
    
21.     for images, labels in train_loader:
    
22.         images, labels = images.to(device), labels.to(device)
    
23.         optimizer.zero_grad()
    
24.         outputs = model(images)
    
25.         loss = criterion(outputs, labels)
    
26.         loss.backward()
    
27.         optimizer.step()
    
28.     print(f'Epoch {epoch+1}, Loss: {loss.item()}')
    
29. 
    
30. # Testing loop
    
31. model.eval()
    
32. correct = 0
    
33. total = 0
    
34. with torch.no_grad():
    
35.     for images, labels in test_loader:
    
36.         images, labels = images.to(device), labels.to(device)
    
37.         outputs = model(images)
    
38.         _, predicted = torch.max(outputs.data, 1)
    
39.         total += labels.size(0)
    
40.         correct += (predicted == labels).sum().item()
    
41. 
    
42. print(f'Accuracy: {100 * correct / total}%')

复制代码

4. 结论

本文介绍了ResNet的基本概念、残差块的结构以及如何在PyTorch中实现ResNet-18模型。通过这一实践，读者可以深入理解ResNet的设计思想和实现方法，并应用于实际的深度学习任务中。






/ 荔枝学姐de课后专栏 /

Hi！这里是荔枝学姐~

欢迎来到我的课后专栏

自然语言学渣 NLP摆烂姐

热衷于技术写作 IT边角料

AIGC & Coding & linux ...

~互撩~ TG: @Shaw_0xyz