基于Pytorch的CNN的简单框架

在PyTorch中，构建一个基本的卷积神经网络（CNN）框架通常包括以下几个步骤：定义网络结构、定义前向传播、定义损失函数和优化器、训练网络以及测试网络。下面是一个简单的CNN框架示例。

1. 导入必要的库

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

2. 定义CNN模型

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

        # 卷积层1：输入通道数为1（灰度图像），输出通道数为32，卷积核大小为3x3
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)

        # 卷积层2：输入通道数为32，输出通道数为64，卷积核大小为3x3
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)

        # 最大池化层：池化窗口大小为2x2
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)

        # 全连接层1：输入特征数为64*7*7（假设输入图像为28x28，经过两次池化后为7x7），输出特征数为128
        self.fc1 = nn.Linear(in_features=64 * 7 * 7, out_features=128)

        # 全连接层2：输入特征数为128，输出特征数为10（假设有10个类别）
        self.fc2 = nn.Linear(in_features=128, out_features=10)

        # Dropout层：防止过拟合
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # 第一层卷积 + ReLU激活函数 + 池化
        x = self.pool(F.relu(self.conv1(x)))

        # 第二层卷积 + ReLU激活函数 + 池化
        x = self.pool(F.relu(self.conv2(x)))

        # 展平操作：将多维张量展平为一维
        x = x.view(-1, 64 * 7 * 7)

        # 全连接层1 + ReLU激活函数 + Dropout
        x = self.dropout(F.relu(self.fc1(x)))

        # 全连接层2 + 输出
        x = self.fc2(x)

        return x

3. 定义数据预处理和数据加载

# 数据预处理：将图像转换为张量，并进行归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))  # MNIST数据集的均值和标准差
])

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

# 创建数据加载器
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)

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

# 实例化模型
model = SimpleCNN()

# 定义损失函数：交叉熵损失
criterion = nn.CrossEntropyLoss()

# 定义优化器：Adam优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

5. 训练模型

# 训练模型
def train(model, train_loader, criterion, optimizer, epochs=5):
    model.train()  # 设置模型为训练模式
    for epoch in range(epochs):
        running_loss = 0.0
        for i, (inputs, labels) in enumerate(train_loader):
            # 前向传播
            outputs = model(inputs)
            loss = criterion(outputs, labels)

            # 反向传播和优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            running_loss += loss.item()

        print(f'Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(train_loader):.4f}')

train(model, train_loader, criterion, optimizer, epochs=5)

6. 测试模型

# 测试模型
def test(model, test_loader):
    model.eval()  # 设置模型为评估模式
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print(f'Accuracy of the model on the test images: {100 * correct / total:.2f}%')

test(model, test_loader)

7. 保存和加载模型

# 保存模型
torch.save(model.state_dict(), 'simple_cnn.pth')

# 加载模型
model = SimpleCNN()
model.load_state_dict(torch.load('simple_cnn.pth'))