pytorch怎么搭建resnet网络

在PyTorch中搭建ResNet（残差网络）可以按照以下步骤进行：

1. 导入必要的库： 首先，确保你已经安装了PyTorch。然后，导入所需的库和模块。

   import torch
   import torch.nn as nn
   import torch.optim as optim
   

2. 定义ResNet块： ResNet的核心是一个残差块（Residual Block），它包含两个或更多的卷积层，并且通过跳跃连接（skip connection）将输入直接加到输出中。

   class BasicBlock(nn.Module):
       expansion = 1
   
       def __init__(self, in_channels, out_channels, stride=1):
           super(BasicBlock, self).__init__()
           self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
           self.bn1 = nn.BatchNorm2d(out_channels)
           self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
           self.bn2 = nn.BatchNorm2d(out_channels)
   
           self.shortcut = nn.Sequential()
           if stride != 1 or in_channels != self.expansion * out_channels:
               self.shortcut = nn.Sequential(
                   nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size=1, stride=stride, bias=False),
                   nn.BatchNorm2d(self.expansion * out_channels)
               )
   
       def forward(self, x):
           out = nn.ReLU()(self.bn1(self.conv1(x)))
           out = self.bn2(self.conv2(out))
           out += self.shortcut(x)
           out = nn.ReLU()(out)
           return out
   

3. 定义ResNet模型： ResNet模型通常包含多个残差块，并且有一个全局平均池化层和一个全连接层。

   class ResNet(nn.Module):
       def __init__(self, block, num_blocks, num_classes=10):
           super(ResNet, self).__init__()
           self.in_channels = 64
   
           self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
           self.bn1 = nn.BatchNorm2d(64)
           self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
           self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
           self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
           self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
           self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
           self.fc = nn.Linear(512 * block.expansion, num_classes)
   
       def _make_layer(self, block, out_channels, num_blocks, stride):
           strides = [stride] + [1] * (num_blocks - 1)
           layers = []
           for stride in strides:
               layers.append(block(self.in_channels, out_channels, stride))
               self.in_channels = out_channels * block.expansion
           return nn.Sequential(*layers)
   
       def forward(self, x):
           out = nn.ReLU()(self.bn1(self.conv1(x)))
           out = self.layer1(out)
           out = self.layer2(out)
           out = self.layer3(out)
           out = self.layer4(out)
           out = self.avgpool(out)
           out = torch.flatten(out, 1)
           out = self.fc(out)
           return out
   

4. 实例化模型： 根据你的任务需求（例如，CIFAR-10分类），选择合适的块类型和数量，然后实例化模型。

   model = ResNet(BasicBlock, [2, 2, 2, 2])
   

5. 定义损失函数和优化器： 选择合适的损失函数和优化器来训练模型。

   criterion = nn.CrossEntropyLoss()
   optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
   

6. 训练模型： 将数据加载到训练集和验证集中，然后进行训练。

   for epoch in range(num_epochs):
       for i, (images, labels) in enumerate(trainloader):
           optimizer.zero_grad()
           outputs = model(images)
           loss = criterion(outputs, labels)
           loss.backward()
           optimizer.step()
   
       print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
   

7. 测试模型： 在测试集上评估模型的性能。

   correct = 0
   total = 0
   with torch.no_grad():
       for images, labels in testloader:
           outputs = model(images)
           _, predicted = torch.max(outputs.data, 1)
           total += labels.size(0)
           correct += (predicted == labels).sum().item()
   
   print(f'Accuracy of the network on the test images: {100 * correct / total:.2f}%')
   

通过以上步骤，你可以在PyTorch中搭建一个基本的ResNet网络。根据具体任务的需求，你可以调整模型的架构、块类型和数量等参数。