基于pytorch的卷积神经网络cnn实例应用及详解

卷积神经网络（Convolutional Neural Network，CNN）是一类包含卷积计算且具有深度结构的前馈神经网络，是深度学习中应用最广泛的一种模型之一。下面以一个基于PyTorch实现的CNN实例应用为例，详细说明CNN的实现过程。

## 数据集

本例使用的是Fashion-MNIST数据集，该数据集包含了10个类别的服装图片，每个类别包含6000张28x28像素的灰度图像，其中训练集包含了60000张图片，测试集包含了10000张图片。可以使用PyTorch内置的函数`torchvision.datasets.FashionMNIST`来获取该数据集。

## 模型结构

本例使用了一个较为简单的CNN模型，包含两个卷积层和两个全连接层，具体结构如下：

CNN(
  (conv1): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1))
  (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1))
  (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (fc1): Linear(in_features=512, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)

其中`Conv2d`表示卷积层，`MaxPool2d`表示最大池化层，`Linear`表示全连接层。`conv1`用于提取图像的低级特征，`pool1`用于降低特征图的分辨率，`conv2`用于进一步提取图像的高级特征，`pool2`再次降低特征图的分辨率，最后通过两个全连接层进行分类。

## 实现过程

### 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(),
     transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.FashionMNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.FashionMNIST(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False, num_workers=2)

### 3. 定义CNN模型

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=5)
        self.pool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=5)
        self.pool2 = nn.MaxPool2d(kernel_size=2)
        self.fc1 = nn.Linear(512, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = nn.functional.relu(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = nn.functional.relu(x)
        x = self.pool2(x)
        x = x.view(-1, 512)
        x = self.fc1(x)
        x = nn.functional.relu(x)
        x = self.fc2(x)
        return x

net = CNN()

### 4. 定义损失函数和优化器

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

### 5. 训练模型

for epoch in range(10):  # 进行10轮训练
    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 % 200 == 199:    # 每200个batch输出一次损失函数
            print('epoch[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 200))
            running_loss = 0.0

### 6. 测试模型

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('Accuracy on test set: %d %%' % (100 * correct / total))

以上就是一个基于PyTorch实现的CNN模型的实现过程，如果有需要可以根据实际情况进行修改和优化。