使用pytorch进行图像分类的详细步骤

pip install torch torchvision matplotlib

import torch
import torch.nn as nn  # 用于构建神经网络
import torch.optim as optim  # 用于优化网络
import torchvision  # 包含了流行的数据集和模型
import torchvision.transforms as transforms  # 用于数据增强和预处理
import matplotlib.pyplot as plt  # 用于绘图和数据可视化

transform = transforms.Compose([
    transforms.Resize((32, 32)),  # 将所有图像调整为32x32像素
    transforms.ToTensor(),  # 将图像转换为Tensor格式，范围为[0, 1]
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 标准化到[-1, 1]范围
])

# 加载训练集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)

# 加载测试集
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2)

# CIFAR-10数据集中的类别
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # 第一层卷积，输入通道3（RGB），输出通道6，卷积核大小5x5
        self.pool = nn.MaxPool2d(2, 2)  # 最大池化层，窗口大小2x2
        self.conv2 = nn.Conv2d(6, 16, 5)  # 第二层卷积，输入通道6，输出通道16，卷积核大小5x5
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 全连接层，输入维度16*5*5，输出维度120
        self.fc2 = nn.Linear(120, 84)  # 第二个全连接层，输入维度120，输出维度84
        self.fc3 = nn.Linear(84, 10)  # 最后一层，全连接层，输出维度10（对应CIFAR-10的10个类别）

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 卷积 -> ReLU激活 -> 最大池化
        x = self.pool(F.relu(self.conv2(x)))  # 卷积 -> ReLU激活 -> 最大池化
        x = x.view(-1, 16 * 5 * 5)  # 展平操作，将卷积层的输出展平成一维向量
        x = F.relu(self.fc1(x))  # 全连接 -> ReLU激活
        x = F.relu(self.fc2(x))  # 全连接 -> ReLU激活
        x = self.fc3(x)  # 全连接层输出分类结果
        return x

net = Net()

criterion = nn.CrossEntropyLoss()  # 交叉熵损失，用于分类任务
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)  # 随机梯度下降优化器，带动量

for epoch in range(2):  # 训练2个epoch
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data  # 获取输入数据和对应的标签

        optimizer.zero_grad()  # 清零梯度缓存

        outputs = net(inputs)  # 前向传播：计算输出
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播：计算梯度
        optimizer.step()  # 更新模型参数

        running_loss += loss.item()
        if i % 2000 == 1999:  # 每2000个mini-batch打印一次损失
            print(f'[Epoch {epoch + 1}, Mini-batch {i + 1}] loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('Finished Training')

correct = 0
total = 0
with torch.no_grad():  # 禁用梯度计算，以节省内存和加速计算
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)  # 获取最大值的索引，即预测的类别
        total += labels.size(0)  # 累计样本总数
        correct += (predicted == labels).sum().item()  # 累计正确预测的样本数

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