好的，下面我将对上面的代码逐段进行讲解。
首先，我们引入了PyTorch需要的库：
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
```
其中，`torch`是PyTorch的核心库，提供了张量操作和自动微分功能；`nn`是PyTorch的神经网络库，提供了各种神经网络层和损失函数；`optim`是PyTorch的优化器库，提供了各种优化算法；`datasets`和`transforms`是PyTorch的数据处理库，提供了各种数据集和数据预处理方法。
接下来，我们定义了CNN模型：
```python
class ConvNet(nn.Module):
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.pool1 = nn.MaxPool2d(2)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.pool2 = nn.MaxPool2d(2)
self.conv3 = nn.Conv2d(32, 64, 3, padding=1)
self.pool3 = nn.MaxPool2d(2)
self.fc1 = nn.Linear(64 * 4 * 4, 256)
self.fc2 = nn.Linear(256, 10)
def forward(self, x):
x = self.pool1(torch.relu(self.conv1(x)))
x = self.pool2(torch.relu(self.conv2(x)))
x = self.pool3(torch.relu(self.conv3(x)))
x = x.view(-1, 64 * 4 * 4)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
```
这个模型包含三个卷积层和两个全连接层。在`__init__`方法中，我们定义了各个层的参数，如输入通道数、输出通道数、卷积核大小、填充等。在`forward`方法中，我们定义了模型的前向传播过程，即各层的输入输出关系。其中，`relu`是激活函数，`MaxPool2d`是池化层，`Linear`是全连接层，`view`是将多维张量转换成一维张量的方法。
然后，我们加载了CIFAR-10数据集：
```python
train_dataset = datasets.CIFAR10(root='data/', train=True, transform=transforms.ToTensor(), download=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True)
test_dataset = datasets.CIFAR10(root='data/', train=False, transform=transforms.ToTensor(), download=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
```
这里使用了`datasets.CIFAR10`方法加载了CIFAR-10数据集，并使用了`transforms.ToTensor`方法将数据转换成PyTorch张量格式。然后，使用`torch.utils.data.DataLoader`方法将数据集分成多个批次进行训练和测试。
接着，我们定义了损失函数和优化器：
```python
model = ConvNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
```
这里使用了`nn.CrossEntropyLoss`作为损失函数，这是一个适用于多分类问题的损失函数。使用了`optim.Adam`作为优化器，这是一种常用的自适应学习率优化算法。
然后，我们进行模型训练：
```python
for epoch in range(10):
for i, (images, labels) in enumerate(train_loader):
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
if (i+1) % 100 == 0:
print(f'Epoch [{epoch+1}/{10}], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')
```
这里进行了10个epoch的训练。每个epoch中，我们使用`enumerate`方法对训练数据集进行批次循环，获取每个批次的图像数据和标签数据。然后，将图像数据送入模型中进行前向传播，计算损失函数并进行反向传播，最后使用优化器更新模型参数。在每个epoch的训练过程中，每100个批次打印一次损失值。
最后，我们进行模型测试：
```python
with torch.no_grad():
correct = 0
total = 0
for images, labels in test_loader:
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the model on the test images: {:.2f}%'.format(100 * correct / total))
```
这里使用了`torch.no_grad`上下文管理器，表示在测试过程中不需要计算梯度。然后，对测试数据集进行循环，计算模型的预测结果和真实标签之间的正确率。最后，打印模型在测试数据集上的准确率。
3528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
