图像分类——ResNet

**图像分类——ResNet**

图像分类是一种常见的计算机视觉任务，涉及将输入图像分配到预先定义的类别中。ResNet（残差网络）是近年来在图像分类领域取得了突破性的模型之一，它通过引入残差连接和批量归一化等创新技术，显著提高了模型的准确率。

**1. ResNet的基本结构**

ResNet的基本结构包括多个卷积块（ConvBlock），每个卷积块包含一个卷积层、一个批量归一化层和一个激活函数。这些卷积块通过残差连接相连，形成了网络的主干。

import torchimport torch.nn as nnclass ConvBlock(nn.Module):
 def __init__(self, in_channels, out_channels, kernel_size=3):
 super(ConvBlock, self).__init__()
 self.conv = nn.Conv2d(in_channels, out_channels, kernel_size)
 self.bn = nn.BatchNorm2d(out_channels)
 self.relu = nn.ReLU()

 def forward(self, x):
 x = self.conv(x)
 x = self.bn(x)
 x = self.relu(x)
 return x

class ResBlock(nn.Module):
 def __init__(self, in_channels, out_channels, kernel_size=3):
 super(ResBlock, self).__init__()
 self.conv1 = ConvBlock(in_channels, out_channels, kernel_size)
 self.conv2 = ConvBlock(out_channels, out_channels, kernel_size)

 def forward(self, x):
 residual = x x = self.conv1(x)
 x = self.conv2(x)
 x += residual # 残差连接 return x

class ResNet(nn.Module):
 def __init__(self, num_classes=10):
 super(ResNet, self).__init__()
 self.conv1 = ConvBlock(3,64)
 self.resblock1 = ResBlock(64,128)
 self.resblock2 = ResBlock(128,256)
 self.fc = nn.Linear(256, num_classes)

 def forward(self, x):
 x = self.conv1(x)
 x = self.resblock1(x)
 x = self.resblock2(x)
 x = torch.mean(x, dim=(2,3)) # Global Average Pooling x = self.fc(x)
 return x

# 加载数据train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False)

# 定义数据加载器train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)

# 训练模型model = ResNet()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(10):
 for x, y in train_loader:
 optimizer.zero_grad()
 output = model(x)
 loss = criterion(output, y)
 loss.backward()
 optimizer.step()

# 测试模型model.eval()
test_loss =0correct =0with torch.no_grad():
 for x, y in test_loader:
 output = model(x)
 test_loss += criterion(output, y).item()
 _, predicted = torch.max(output,1)
 correct += (predicted == y).sum().item()

accuracy = correct / len(test_dataset)
print('Test Loss: {:.4f}, Accuracy: {:.2f}%'.format(test_loss / len(test_loader), accuracy))