【深度学习】学习PyTorch基础

介绍PyTorch

深度学习框架是一种软件工具，旨在简化和加速构建、训练和部署深度学习模型的过程。深度学习框架提供了一系列的函数、类和工具，用于定义、优化和执行各种深度神经网络模型。这些框架帮助研究人员和开发人员专注于模型的设计和创新，而无需过多关注底层的数值计算和优化。

主要的深度学习框架通常具有以下特点：

1. 图计算表示： 深度学习框架通常使用图计算来表示神经网络模型，其中节点表示操作，边表示数据流向。这种表示方式有助于优化计算和自动求导。
2. 自动微分： 深度学习框架提供自动微分功能，允许用户计算模型中各个参数的梯度，从而进行反向传播和优化。
3. 模块化设计： 框架允许用户将神经网络分解为模块，如层（层）、激活函数、优化器等，从而可以灵活地构建和修改模型。
4. 优化器： 深度学习框架提供了多种优化算法，如随机梯度下降（SGD）、Adam 等，用于在训练过程中调整模型参数以最小化损失函数。
5. 硬件加速： 多数深度学习框架支持使用图形处理单元（GPU）进行加速，这能够显著提升训练和推断性能。
6. 预训练模型： 一些框架提供了预训练的模型，这些模型在大型数据集上进行了训练，可以用作迁移学习的起点。
7. 部署和推断： 框架通常提供能够将训练好的模型部署到生产环境中的功能，以进行推断和应用。

常见的深度学习框架包括 TensorFlow、PyTorch、Keras、Caffe、MXNet 等。

PyTorch 是一个备受欢迎的开源机器学习库，由 Facebook 的人工智能研究小组开发并维护。它在深度学习领域中被广泛使用，特别适合研究和开发新的神经网络模型，以及进行实验和原型开发。其安装方式请参考官网教程。

张量操作

导入库

import torch

创建张量

创建一个空的张量（包含未初始化的随机值）

empty_tensor = torch.empty(3, 2)  # 创建一个3行2列的空张量

创建一个随机初始化的张量

random_tensor = torch.rand(3, 2)  # 创建一个3行2列的随机张量，值在0到1之间

创建一个全零的张量

zeros_tensor = torch.zeros(3, 2)  # 创建一个3行2列的全零张量

创建一个全一的张量

ones_tensor = torch.ones(3, 2)    # 创建一个3行2列的全一张量

从现有数据创建张量

data = [[1, 2], [3, 4]]
tensor_from_data = torch.tensor(data)  # 从Python列表创建张量

张量计算

tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6], [7, 8]])

# 加法
result_add = tensor1 + tensor2
# tensor([[ 6,  8],
#         [10, 12]])

# 减法
result_sub = tensor1 - tensor2
# tensor([[-4, -4],
#         [-4, -4]])

# 乘法（逐元素相乘）
result_mul = tensor1 * tensor2
# tensor([[ 5, 12],
#         [21, 32]])

# 矩阵乘法
result_matmul = torch.matmul(tensor1, tensor2)
# tensor([[19, 22],
#         [43, 50]])

张量索引和切片

tensor = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 获取单个元素
element = tensor[1, 2]  # 获取第2行第3列的元素，注意索引从0开始
# tensor(6)

# 切片操作
slice = tensor[0:2, 1:3]  # 获取第1行和第2行，第2列和第3列的切片
# tensor([[2, 3],
#         [0, 6]])

# 修改元素
tensor[1, 1] = 0  # 将第2行第2列的元素设置为0
# tensor([[1, 2, 3],
#         [4, 0, 6],
#         [7, 8, 9]])

张量形状操作

tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 获取张量的形状
shape = tensor.shape  # 返回一个元组，表示张量的形状
# torch.Size([2, 3])

# 改变张量的形状
reshaped_tensor = tensor.view(3, 2)  # 将原来的2行3列张量转换为3行2列
# tensor([[1, 2],
#         [3, 4],
#         [5, 6]])

自动微分

PyTorch 的自动微分（Automatic Differentiation）是其在深度学习中的一大亮点，它使得构建和训练神经网络变得更加便捷。自动微分允许你计算函数的导数，特别适用于反向传播算法，它是训练神经网络的核心。

梯度计算和反向传播

在 PyTorch 中，你可以在需要求导的张量上调用 .requires_grad_() 方法，将其标记为需要计算梯度。之后，所有在这个张量上执行的操作都会被记录，以便后续计算梯度。

import torch

# 创建一个张量，并标记为需要计算梯度
x = torch.tensor([2.0], requires_grad=True)

# 执行一些操作
y = x**2 + 3*x + 1

# 计算 y 对 x 的梯度
y.backward()

# 输出梯度
print(x.grad)  # 输出：tensor([7.])，即 y = x**2 + 3*x + 1 对 x 的导数

在上述示例中，我们创建了一个张量 x，并标记它需要计算梯度。然后我们执行一些操作来计算 y，并使用 y.backward() 计算关于 x 的梯度。最终，我们使用 x.grad 获取梯度值。

上下文管理器 torch.no_grad()

有时候，在进行推断（不需要梯度计算）时，你可以使用 torch.no_grad() 上下文管理器，从而避免不必要的梯度计算，提高性能。

with torch.no_grad():
    # 在这个上下文中，所有操作都不会计算梯度
    # 适用于不需要反向传播的情况，如模型推断
    pass

使用自动微分进行优化

自动微分在优化算法中的应用非常广泛。你可以使用优化器来自动地更新模型参数，以最小化损失函数。

import torch.optim as optim

# 创建一个需要优化的张量
weights = torch.tensor([1.0], requires_grad=True)

# 定义损失函数
loss_fn = torch.nn.MSELoss()

# 创建优化器，如随机梯度下降（SGD）
optimizer = optim.SGD([weights], lr=0.01)

# 进行多轮优化
for _ in range(100):
    optimizer.zero_grad()  # 清零梯度
    predictions = weights * 3  # 假设的模型预测
    loss = loss_fn(predictions, torch.tensor([10.0]))  # 计算损失
    loss.backward()  # 计算梯度
    optimizer.step()  # 更新参数

在上面的示例中，我们首先创建了一个需要优化的权重张量，并定义了损失函数和优化器。在每轮循环中，我们将梯度清零，计算预测，计算损失，然后通过调用 backward() 计算梯度。最后，使用 optimizer.step() 来更新权重。

总之，PyTorch 的自动微分使得计算梯度变得非常简便，为神经网络的训练和优化提供了强大的支持。

利用自动微分梯度下降案例

首先需要计算函数关于自变量的梯度，然后迭代更新自变量以逐步逼近最小值。

import torch
import math

# 初始化自变量 x
x = torch.tensor([0.0], requires_grad=True)

# 定义优化器，使用随机梯度下降（SGD）
optimizer = torch.optim.SGD([x], lr=0.1)

# 定义迭代次数
num_iterations = 1000

for i in range(num_iterations):
    optimizer.zero_grad()  # 清零梯度
    y = x**2 - torch.sin(x)  # 定义函数 y = x^2 - sin(x)
    y.backward()  # 计算梯度
    optimizer.step()  # 更新 x

# 最终的 x 就是函数的最小值点
minimum = x.item()

# 计算最小值对应的 y
minimum_value = minimum**2 - math.sin(minimum)

print(f"最小值点：x = {minimum:.4f}, y = {minimum_value:.4f}")
# 最小值点：x = 0.4502, y = -0.2325

在上述代码中，我们首先初始化自变量 x，并使用 SGD 优化器进行梯度下降。在每次迭代中，我们计算函数值 y，然后通过调用 backward() 计算梯度，并使用 optimizer.step() 更新自变量 x。最终，我们可以得到函数的最小值点和对应的最小值。

数据加载和预处理

数据加载

首先，你需要将原始数据加载到内存中。数据可以是图像、文本、音频等类型。PyTorch 提供了 torch.utils.data.Dataset 类来帮助你自定义数据集。

torch.utils.data.Dataset 类： 这个类是一个抽象类，你可以通过继承它来创建自定义数据集。你需要实现 __len__ 方法和 __getitem__ 方法，分别用于获取数据集大小和获取单个样本。

假设你有一组包含图像文件和对应标签的数据，你可以按照以下步骤创建一个自定义的数据集类：

import torch
from torch.utils.data import Dataset
from PIL import Image  # 用于图像读取
import os

class CustomDataset(Dataset):
    def __init__(self, data_dir, transform=None):
        self.data_dir = data_dir
        self.transform = transform
        self.images, self.labels = self.load_data()

    def load_data(self):
        # 获取图像文件列表和标签
        image_list = sorted(os.listdir(os.path.join(self.data_dir, 'images')))
        label_list = sorted(os.listdir(os.path.join(self.data_dir, 'labels')))
        
        images = [os.path.join(self.data_dir, 'images', img) for img in image_list]
        labels = [os.path.join(self.data_dir, 'labels', lbl) for lbl in label_list]
        
        return images, labels
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        img_path = self.images[idx]
        lbl_path = self.labels[idx]
        
        image = Image.open(img_path)
        label = torch.load(lbl_path)
        
        if self.transform:
            image = self.transform(image)
        
        return image, label

数据预处理

一般来说，原始数据需要经过一些预处理才能被用于模型训练。预处理可能包括图像缩放、剪裁、标准化、数据增强等。PyTorch 提供了各种转换函数，可以在加载数据时对其进行预处理。

torchvision.transforms 模块： 这个模块提供了许多用于图像预处理的函数，比如图像缩放、剪裁、翻转、标准化等。你可以将这些函数应用于数据集的样本。

import torch
from torchvision import transforms
from PIL import Image

# 定义数据预处理的转换
transform = transforms.Compose([
    transforms.Resize((128, 128)),  # 将图像缩放为 128x128
    transforms.RandomHorizontalFlip(),  # 随机水平翻转
    transforms.ToTensor(),  # 将图像转换为张量
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])  # 标准化
])

# 读取图像
image = Image.open('path_to_image.jpg')

# 应用预处理转换
transformed_image = transform(image)

在上面的代码示例中，我们首先导入了 transforms 模块。然后，我们定义了一个数据预处理的转换序列，其中包括了图像缩放、随机水平翻转、转换为张量和标准化。接着，我们使用 Image.open 从文件中读取了一个图像，然后使用 transform 对图像进行预处理。

你可以根据需要组合不同的预处理操作，以适应你的任务和数据集。torchvision.transforms 模块提供了多种函数，如图像剪裁、色彩变换、随机增强等，可以在数据加载前对图像进行灵活的处理。

数据加载器

为了高效地训练模型，你可以使用 torch.utils.data.DataLoader 类，它可以将预处理后的数据划分为小批次，进行随机或顺序加载，同时还可以提供多线程加载。

torch.utils.data.DataLoader 类： 这个类将数据集包装成一个可迭代的对象，每次返回一个小批次的数据。你可以设置批次大小、随机化、多线程等参数。

以下是一些 DataLoader 的常见参数和用法：

pythonCopy codeimport torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 定义数据预处理的转换
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

# 创建数据集
dataset = datasets.ImageFolder(root='path_to_dataset', transform=transform)

# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)

在上面的示例中，我们首先定义了数据预处理的转换。然后，我们使用 datasets.ImageFolder 创建了一个图像数据集。接下来，我们使用 DataLoader 创建了一个数据加载器。参数解释如下：

• dataset: 你想要加载的数据集。
• batch_size: 每个批次包含的样本数量。
• shuffle: 是否在每个 epoch 中随机化数据顺序。
• num_workers: 加载数据时使用的线程数。

接下来，你可以通过迭代 dataloader 来获取每个批次的数据进行训练：

for batch_images, batch_labels in dataloader:
    # 在这里进行模型训练
    pass

在循环中，每个 batch_images 和 batch_labels 都是一个批次的图像和对应的标签。

DataLoader 类在实际训练中非常有用，可以帮助你有效地加载和处理数据，使训练过程更加高效。

构建神经网络

PyTorch 提供了多种方法来构建神经网络，以适应不同的需求和编程风格。

1.继承 nn.Module

这是创建自定义神经网络的常见方法。你可以创建一个类继承自 nn.Module，然后在构造函数中定义网络的层和参数，以及在 forward 方法中定义数据的前向传播过程。这种方法允许你自由地定义和组合各种层。

import torch
import torch.nn as nn

class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.layer1 = nn.Linear(in_features=784, out_features=128)
        self.layer2 = nn.Linear(in_features=128, out_features=10)
    
    def forward(self, x):
        x = self.layer1(x)
        x = torch.relu(x)
        x = self.layer2(x)
        return x

2.使用 nn.Sequential

这是一种更简单的方法，适用于顺序层的堆叠。你可以使用 nn.Sequential 来创建一个网络，其中每个层按顺序连接。

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(in_features=784, out_features=128),
    nn.ReLU(),
    nn.Linear(in_features=128, out_features=10)
)

3.自定义层

除了使用 nn.Module 创建网络，你还可以自定义层。你可以继承 nn.Module 并实现自己的层的前向传播。

import torch
import torch.nn as nn

class CustomLayer(nn.Module):
    def __init__(self, in_features, out_features):
        super(CustomLayer, self).__init__()
        self.weights = nn.Parameter(torch.randn(in_features, out_features))
        self.bias = nn.Parameter(torch.randn(out_features))
    
    def forward(self, x):
        return torch.matmul(x, self.weights) + self.bias

4.使用预训练模型

PyTorch 提供了许多预训练的模型，如 VGG、ResNet、BERT 等。你可以使用这些模型作为基础，进行微调或迁移学习。

import torch
import torchvision.models as models

model = models.resnet18(pretrained=True)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)

训练神经网络模型

模型训练的主要步骤

在 PyTorch 中训练神经网络模型涉及到以下主要步骤：

1. 选择网络架构： 首先，你需要选择适合你任务的神经网络架构。你可以使用 PyTorch 提供的预训练模型，也可以自定义网络。
2. 定义损失函数： 根据你的问题类型，选择适当的损失函数，如均方误差（MSE）、交叉熵损失（CrossEntropyLoss）等。
3. 选择优化器： 选择一个优化算法，如随机梯度下降（SGD）、Adam 等。你可以设置学习率和其他超参数。
4. 数据加载： 使用 torch.utils.data.Dataset 和 torch.utils.data.DataLoader 加载和处理训练数据。
5. 训练循环： 在训练循环中，你需要进行以下操作：
   • 遍历数据加载器，获取输入数据和对应标签。
   • 将数据送入网络，得到预测结果。
   • 计算损失，反向传播计算梯度。
   • 使用优化器更新网络参数。
6. 验证： 在训练过程中，你可以定期使用验证数据集评估模型性能，以避免过拟合。
7. 保存和加载模型： 在训练完成后，你可以保存模型的权重和参数，以便在未来进行推断或继续训练。

以下是一个基本的训练循环示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 数据预处理和加载
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
train_dataset = datasets.CIFAR10(root='data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 定义网络
class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        # 定义网络结构
        # ...

    def forward(self, x):
        # 前向传播
        # ...

model = CustomModel()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练循环
for epoch in range(num_epochs):
    for inputs, labels in train_loader:
        optimizer.zero_grad()  # 清零梯度
        outputs = model(inputs)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

    # 在每个 epoch 结束后，可以进行验证、保存模型等操作

损失函数模块

在 PyTorch 中，损失函数（也称为目标函数）用于度量模型预测与实际标签之间的差异。它是模型训练的关键部分，通过优化损失函数来调整模型的参数，使得模型的预测更加接近真实值。PyTorch 提供了许多常见的损失函数，适用于不同类型的任务。

以下是一些常见的 PyTorch 损失函数：

1. nn.MSELoss： 均方误差损失函数，适用于回归问题。它计算预测值与真实值之间的平方差。

   criterion = nn.MSELoss()
   loss = criterion(predictions, targets)
   

2. nn.CrossEntropyLoss： 交叉熵损失函数，适用于多类别分类问题。通常用于分类问题的输出不经过 softmax 激活函数。

   criterion = nn.CrossEntropyLoss()
   loss = criterion(predictions, labels)
   

3. nn.BCELoss 和 nn.BCEWithLogitsLoss： 二元交叉熵损失函数，用于二元分类问题。BCELoss 需要在预测值上手动应用 sigmoid 函数，而 BCEWithLogitsLoss 同时包括 sigmoid 和交叉熵计算。

   criterion = nn.BCEWithLogitsLoss()
   loss = criterion(predictions, labels)
   

4. nn.NLLLoss： 负对数似然损失函数，通常与 nn.LogSoftmax 结合使用，适用于多类别分类问题。

   criterion = nn.NLLLoss()
   log_probs = nn.LogSoftmax(dim=1)(predictions)
   loss = criterion(log_probs, labels)
   

5. 自定义损失函数： 你也可以根据任务的特性定义自己的损失函数，只需继承 nn.Module 并实现前向传播。

class CustomLoss(nn.Module):
   def __init__(self):
       super(CustomLoss, self).__init__()

   def forward(self, predictions, targets):
       # 自定义损失计算逻辑
       return loss_value

注意，选择正确的损失函数取决于任务的性质。不同的损失函数适用于不同的问题类型，你需要根据问题的特点来选择合适的损失函数。

优化器模块

在 PyTorch 中，优化器是用于更新神经网络模型参数以最小化损失函数的工具。PyTorch 提供了多种优化器，每个优化器都使用不同的更新规则来调整模型的参数，以使模型能够更好地拟合训练数据。以下是一些常见的 PyTorch 优化器：

1. torch.optim.SGD： 随机梯度下降（SGD）优化器是一种基本的优化算法。它在每次迭代中使用每个训练样本的梯度来更新模型参数。

import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

2. torch.optim.Adam： Adam 优化器结合了自适应学习率和动量的特点，适用于多种问题。它在许多情况下表现良好。

import torch.optim as optim
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

3. torch.optim.RMSprop： RMSprop 优化器使用移动平均的方式来调整学习率，适用于非平稳目标。

import torch.optim as optim
optimizer = optim.RMSprop(model.parameters(), lr=learning_rate)

4. 自定义优化器： 你也可以根据需要定义自己的优化器，只需继承 torch.optim.Optimizer 并实现必要的方法。

class CustomOptimizer(optim.Optimizer):
	def __init__(self, params, lr=0.01):
		super(CustomOptimizer, self).__init__(params, defaults)
       	# 自定义初始化逻辑

   	def step(self, closure=None):
       # 自定义参数更新逻辑
       pass

在训练循环中，你需要执行以下操作来更新模型参数：

optimizer.zero_grad()  # 清零梯度
outputs = model(inputs)  # 前向传播
loss = criterion(outputs, labels)  # 计算损失
loss.backward()  # 反向传播，计算梯度
optimizer.step()  # 更新参数

在实际应用中，选择正确的优化器取决于问题的性质，不同的优化器可能会在不同的任务中表现更好。

保存和加载模型

在 PyTorch 中，你可以使用 torch.save 函数来保存模型的权重、参数和其他相关信息，以及使用 torch.load 函数来加载保存的模型。以下是保存和加载模型的示例代码：

保存模型

import torch

# 定义模型
class CustomModel(torch.nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.fc = torch.nn.Linear(10, 2)

    def forward(self, x):
        return self.fc(x)

model = CustomModel()

# 保存模型权重和参数
torch.save(model.state_dict(), 'model.pth')

在上面的代码中，我们定义了一个简单的模型 CustomModel，然后使用 model.state_dict() 将模型的权重和参数保存到文件 model.pth 中。

加载模型

import torch

# 定义模型
class CustomModel(torch.nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.fc = torch.nn.Linear(10, 2)

    def forward(self, x):
        return self.fc(x)

model = CustomModel()

# 加载模型权重和参数
model.load_state_dict(torch.load('model.pth'))
model.eval()  # 设置模型为评估模式

在上面的代码中，我们定义了相同的模型结构 CustomModel，然后使用 torch.load 加载之前保存的权重和参数文件 model.pth。注意，加载后的模型需要调用 .eval() 方法来将模型设置为评估模式，以便在推断时使用。

请注意，当你加载模型时，模型的结构也需要保持一致。如果你的模型结构发生了变化，可能需要手动调整或者重新定义模型的结构。

完整项目案例

MNIST数据集是一个经典的手写数字图像数据集，包含了大量0到9的单个手写数字图像样本，每个图像都有对应的标签表示其所代表的数字。这个数据集广泛用于测试和验证机器学习算法，特别是图像分类算法的性能。每个图像都是28x28像素大小的灰度图像，被展平成一维向量，使其适用于各种机器学习模型。

使用卷积神经网络（CNN）来解决MNIST手写数字数据集分类问题的过程涉及数据预处理，构建卷积层、池化层和全连接层的网络结构，定义损失函数和优化器进行模型训练，在训练集上通过梯度下降优化参数，最终在测试集上评估模型性能，以得出一个在数字分类上表现良好的卷积神经网络模型。

下面是一个使用PyTorch的简单卷积神经网络（CNN）模型来解决MNIST手写数字数据集分类问题的基本步骤：

步骤 1: 导入必要的库和模块

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

步骤 2: 准备数据集

# 定义数据预处理的转换
transform = transforms.Compose([
    transforms.ToTensor(),  # 将图像转换为Tensor
    transforms.Normalize((0.5,), (0.5,))  # 标准化，将像素值映射到[-1, 1]
])

# 下载并加载MNIST数据集
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)

步骤 3: 定义卷积神经网络模型

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(16 * 14 * 14, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = x.view(-1, 16 * 14 * 14)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型实例
model = SimpleCNN()

步骤 4: 定义损失函数和优化器

criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器

步骤 5: 训练模型

num_epochs = 10

for epoch in range(num_epochs):
    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}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')

步骤 6: 测试模型

model.eval()  # 将模型切换到评估模式
correct = 0
total = 0

with torch.no_grad():
    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(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')

这个简单的卷积神经网络模型将会在MNIST数据集上实现一个基本的手写数字分类器。你可以根据需要进行更多的调整、优化和改进，例如增加更多的卷积层、调整超参数、添加正则化等来提升性能。

loss = criterion(outputs, labels)
loss.backward()
optimizer.step()

    if (i+1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(train_loader)}], Loss: {loss.item():.4f}')

步骤 6: 测试模型

```python
model.eval()  # 将模型切换到评估模式
correct = 0
total = 0

with torch.no_grad():
    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(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')

这个简单的卷积神经网络模型将会在MNIST数据集上实现一个基本的手写数字分类器。你可以根据需要进行更多的调整、优化和改进，例如增加更多的卷积层、调整超参数、添加正则化等来提升性能。