卷积神经网络 python

### 如何用Python实现卷积神经网络（CNN）

#### 使用PyTorch实现简单卷积神经网络

卷积神经网络是一种广泛应用于计算机视觉任务的深度学习模型[^1]。下面是一个基于PyTorch库实现的简单卷积神经网络的例子，该例子展示了如何创建一个用于图像分类的任务。

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


class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 定义卷积层
        self.conv_layer = nn.Sequential(
            nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        # 定义全连接层
        self.fc_layer = nn.Sequential(
            nn.Linear(32 * 5 * 5, 120),  
            nn.ReLU(),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, 10)   
        )

    def forward(self, x):
        """定义前向传播过程"""
        batch_size = x.size(0)

        # 卷积操作
        x = self.conv_layer(x)
        # 展平数据准备进入全连接层
        x = x.view(batch_size, -1)
        # 全连接操作
        x = self.fc_layer(x)
        return x


def train(model, device, train_loader, optimizer, criterion, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()       # 清除梯度
        output = model(data)        # 前向传播
        loss = criterion(output, target)     # 计算损失函数
        loss.backward()             # 反向传播求解梯度
        optimizer.step()            # 更新参数
        
        if batch_idx % 100 == 0:
            print(f'Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}')


if __name__ == '__main__':
    # 设置设备为GPU或CPU
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # 加载MNIST训练集并设置批量大小
    transform = ToTensor()
    dataset = MNIST(root='./data', download=True, transform=transform)
    dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
    
    # 初始化模型、优化器以及损失函数
    cnn_model = SimpleCNN().to(device)
    optimizer = optim.Adam(cnn_model.parameters(), lr=0.001)
    criterion = nn.CrossEntropyLoss()

    epochs = 5
    
    for e in range(epochs):
        train(cnn_model, device, dataloader, optimizer, criterion, e + 1)

这段代码实现了简单的两层卷积神经网络，并将其应用到了MNIST手写数字识别上。此程序首先导入必要的包和模块，接着定义了一个`SimpleCNN`类继承自`torch.nn.Module`，其中包含了两个主要部分——卷积层(`conv_layer`)与全连接层(`fc_layer`)。最后，在主函数中完成了模型初始化、数据加载、训练循环等功能。