如何用pytorch调用cnn包

在PyTorch中，您可以使用`torch.nn`模块中的CNN类来构建卷积神经网络。这个模块提供了一些常见的卷积层，如`Conv2d`和`MaxPool2d`。您可以使用这些层来构建自己的卷积神经网络。

以下是一个简单的例子，展示如何使用`torch.nn`模块中的卷积层：

import torch
import torch.nn as nn

# 定义一个简单的卷积神经网络
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5) # 输入通道数为1，输出通道数为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) # 全连接层，输入大小为16x5x5，输出大小为120
        self.fc2 = nn.Linear(120, 84) # 全连接层，输入大小为120，输出大小为84
        self.fc3 = nn.Linear(84, 10) # 全连接层，输入大小为84，输出大小为10

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x))) # 卷积层1 -> 激活函数 -> 池化层
        x = self.pool(nn.functional.relu(self.conv2(x))) # 卷积层2 -> 激活函数 -> 池化层
        x = x.view(-1, 16 * 5 * 5) # 将输出展平
        x = nn.functional.relu(self.fc1(x)) # 全连接层1 -> 激活函数
        x = nn.functional.relu(self.fc2(x)) # 全连接层2 -> 激活函数
        x = self.fc3(x) # 全连接层3
        return x

# 实例化模型
net = Net()

在这个例子中，我们定义了一个名为`Net`的类，它继承自`nn.Module`类。在`Net`类的构造函数中，我们定义了需要用到的卷积层、池化层和全连接层。在`forward`函数中，我们定义了模型的前向传播过程。在这个过程中，我们先将输入`x`传入卷积层1，然后使用ReLU激活函数进行非线性变换，接着将结果传入池化层1。然后，我们将结果传入卷积层2，再使用ReLU激活函数进行非线性变换，接着将结果传入池化层2。最后，我们将结果展平，传入三个全连接层，其中最后一个全连接层的输出就是模型的预测结果。

要训练这个模型，您可以使用PyTorch提供的优化器和损失函数。以下是一个简单的例子，展示如何使用PyTorch训练这个模型：

import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.datasets as datasets

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

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

# 训练模型
for epoch in range(10): # 迭代10次
    running_loss = 0.0
    for i, data in enumerate(train_dataset, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 1000 == 999: # 每1000个batch输出一次损失
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 1000))
            running_loss = 0.0

在这个例子中，我们首先加载了MNIST数据集，并定义了损失函数和优化器。然后，我们训练模型。在每个epoch中，我们遍历整个训练集，每次取一个mini-batch进行训练。我们首先将梯度清零，然后将输入传入模型得到输出。接着，我们计算损失并进行反向传播，最后使用优化器更新模型参数。在每个epoch中，我们还输出一次损失，以便了解模型的训练进度。