利用pytorch，搭建一个十分类的卷积神 经网络模型用子数字识别，数据集使用 MNIST，一次卷积必须有一次池化卷积， 要求使用Sequential函数，并注释清楚，及 import的库

好的，以下是代码和注释：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# 定义数据预处理方法
transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量
    transforms.Normalize((0.1307,), (0.3081,))  # 标准化
])

# 加载MNIST数据集
train_dataset = datasets.MNIST('data/', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('data/', train=False, download=True, transform=transform)

# 定义批大小和加载器
batch_size = 128
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义模型
model = nn.Sequential(
    # 第一层卷积，输入通道数为1，输出通道数为10，卷积核大小为5x5
    nn.Conv2d(1, 10, kernel_size=5),
    nn.MaxPool2d(kernel_size=2),  # 池化层，池化核大小为2x2
    nn.ReLU(inplace=True),  # ReLU激活函数

    # 第二层卷积，输入通道数为10，输出通道数为20，卷积核大小为5x5
    nn.Conv2d(10, 20, kernel_size=5),
    nn.Dropout2d(),  # Dropout层，防止过拟合
    nn.MaxPool2d(kernel_size=2),  # 池化层，池化核大小为2x2
    nn.ReLU(inplace=True),  # ReLU激活函数

    nn.Flatten(),  # 展开成一维向量
    nn.Linear(320, 50),  # 全连接层，输入大小为320，输出大小为50
    nn.ReLU(inplace=True),  # ReLU激活函数
    nn.Linear(50, 10)  # 全连接层，输入大小为50，输出大小为10
)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters())  # Adam优化器

# 训练模型
epochs = 10
for epoch in range(epochs):
    train_loss = 0.0
    train_correct = 0

    for data, target in train_loader:
        optimizer.zero_grad()  # 梯度清零
        output = model(data)  # 前向传播
        loss = criterion(output, target)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数

        # 统计训练损失和正确率
        train_loss += loss.item() * data.size(0)
        _, predicted = torch.max(output.data, 1)
        train_correct += (predicted == target).sum().item()

    train_loss = train_loss / len(train_loader.dataset)
    train_acc = train_correct / len(train_loader.dataset)

    # 在测试集上测试模型性能
    model.eval()
    test_loss = 0.0
    test_correct = 0

    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            loss = criterion(output, target)

            # 统计测试损失和正确率
            test_loss += loss.item() * data.size(0)
            _, predicted = torch.max(output.data, 1)
            test_correct += (predicted == target).sum().item()

    test_loss = test_loss / len(test_loader.dataset)
    test_acc = test_correct / len(test_loader.dataset)

    # 打印训练结果
    print('Epoch [{}/{}], Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'
          .format(epoch+1, epochs, train_loss, train_acc, test_loss, test_acc))

这个模型使用了两层卷积，每层卷积后都有一层池化，然后经过一个全连接层，最后输出十个分类的概率。训练过程中使用Adam优化器和交叉熵损失函数。