PyTorch实战：ANN与CNN在分类任务中的应用

1. 神经网络基础与项目概述

在当今的人工智能领域，神经网络已经成为解决复杂问题的核心工具。作为从业多年的AI工程师，我经常被问到如何从零开始构建一个完整的神经网络项目。本文将分享两个经典的深度学习案例：使用ANN(人工神经网络)进行手机价格分类，以及使用CNN(卷积神经网络)进行CIFAR10图像分类。

这两个案例涵盖了深度学习项目的主要流程：

• 数据准备与预处理
• 模型架构设计
• 训练过程优化
• 模型评估与部署

我们将使用PyTorch框架实现这两个案例，因为它提供了灵活的张量计算和强大的GPU加速支持。特别值得一提的是，这两个项目都采用了模块化设计，使得代码结构清晰、易于维护和扩展。

2. ANN手机价格分类项目详解

2.1 数据准备与预处理

数据是机器学习的基石。在手机价格分类项目中，我们首先需要构建一个高质量的数据集。以下是关键的数据处理步骤：

python复制def create_dataset():
    data = pd.read_csv('手机价格预测.csv')
    x, y = data.iloc[:,:-1], data.iloc[:,-1]
    x = x.astype(np.float32)
    
    # 使用分层抽样划分训练集和测试集
    x_train, x_test, y_train, y_test = train_test_split(
        x, y, test_size=0.2, random_state=3, stratify=y)
    
    # 转换为PyTorch张量
    train_dataset = TensorDataset(torch.tensor(x_train.values), 
                                 torch.tensor(y_train.values))
    test_dataset = TensorDataset(torch.tensor(x_test.values), 
                                torch.tensor(y_test.values))
    
    return train_dataset, test_dataset, x_train.shape[1], len(np.unique(y))

关键技巧：使用stratify参数确保训练集和测试集中各类别的比例保持一致，这对于不平衡数据集尤为重要。

2.2 模型架构设计

我们的ANN模型包含两个隐藏层，采用Kaiming初始化方法：

python复制class MyModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super().__init__()
        self.l1 = nn.Linear(input_dim, 128)
        self.l2 = nn.Linear(128, 256)
        self.output = nn.Linear(256, output_dim)
        
        # 使用Kaiming初始化
        nn.init.kaiming_normal_(self.l1.weight)
        nn.init.zeros_(self.l1.bias)
        nn.init.kaiming_normal_(self.l2.weight)
        nn.init.zeros_(self.l2.bias)
        nn.init.kaiming_normal_(self.output.weight)
        nn.init.zeros_(self.output.bias)
    
    def forward(self, x):
        x = torch.relu(self.l1(x))
        x = torch.relu(self.l2(x))
        return self.output(x)  # CrossEntropyLoss会自动处理Softmax

设计要点：最后一层不使用Softmax激活，因为CrossEntropyLoss内部已经包含了Softmax计算，这样可以提高数值稳定性。

2.3 训练过程优化

训练过程需要考虑多个关键因素：

python复制def train(train_dataset, input_dim, output_dim, device):
    train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=True)
    model = MyModel(input_dim, output_dim).to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    for epoch in range(100):
        model.train()
        total_loss, batch_num = 0.0, 0
        
        for x, y in train_dataloader:
            x, y = x.to(device), y.to(device)
            y_pred = model(x)
            loss = criterion(y_pred, y)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            batch_num += 1
        
        print(f'epoch:{epoch+1}, loss:{total_loss/batch_num:.4f}')
    
    torch.save(model.state_dict(), './model/phone.pth')

训练技巧：

1. 使用Adam优化器，它结合了动量法和自适应学习率的优点
2. 每个epoch后打印平均损失，方便监控训练过程
3. 确保模型和数据都在同一设备(CPU/GPU)上

2.4 模型评估与性能分析

评估阶段我们需要关注模型的泛化能力：

python复制def evaluate(test_dataset, input_dim, output_dim, device):
    model = MyModel(input_dim, output_dim).to(device)
    model.load_state_dict(torch.load("./model/phone.pth", map_location=device))
    test_dataloader = DataLoader(test_dataset, batch_size=8, shuffle=False)
    
    total_samples = 0
    correct_predictions = 0
    
    model.eval()
    with torch.no_grad():
        for x, y in test_dataloader:
            x, y = x.to(device), y.to(device)
            y_pred = torch.argmax(model(x), dim=1)
            total_samples += y.size(0)
            correct_predictions += (y_pred == y).sum().item()
    
    accuracy = correct_predictions / total_samples * 100
    print(f"测试集准确率：{accuracy:.2f}%")
    return accuracy

评估要点：

1. 使用model.eval()切换模型到评估模式
2. 使用torch.no_grad()禁用梯度计算，减少内存消耗
3. 计算整体准确率而非批次准确率，更能反映真实性能

3. CNN图像分类项目实现

3.1 CIFAR10数据集处理

CIFAR10是一个经典的图像分类数据集：

python复制def create_dataset():
    train_dataset = CIFAR10(root='./cnn_data', train=True, 
                           transform=ToTensor(), download=False)
    test_dataset = CIFAR10(root='./cnn_data', train=False, 
                          transform=ToTensor(), download=False)
    return train_dataset, test_dataset

数据特点：

• 50,000张训练图像
• 10,000张测试图像
• 10个类别
• 32x32像素RGB图像

3.2 CNN模型架构设计

我们的CNN模型包含两个卷积块和三个全连接层：

python复制class MyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, kernel_size=3)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(6, 16, kernel_size=3)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        
        self.l1 = nn.Linear(576, 120)
        self.l2 = nn.Linear(120, 84)
        self.output = nn.Linear(84, 10)
        
        # 参数初始化
        nn.init.kaiming_normal_(self.l1.weight)
        nn.init.zeros_(self.l1.bias)
        nn.init.kaiming_normal_(self.l2.weight)
        nn.init.zeros_(self.l2.bias)
        nn.init.kaiming_normal_(self.output.weight)
        nn.init.zeros_(self.output.bias)
    
    def forward(self, x):
        x = self.pool1(torch.relu(self.conv1(x)))
        x = self.pool2(torch.relu(self.conv2(x)))
        x = x.reshape(x.size(0), -1)
        x = torch.relu(self.l1(x))
        x = torch.relu(self.l2(x))
        return torch.softmax(self.output(x), dim=1)

架构解析：

1. 第一卷积层：3输入通道(RGB)，6输出通道，3x3卷积核
2. 最大池化层：2x2窗口，步长2
3. 第二卷积层：6输入通道，16输出通道
4. 全连接层：576->120->84->10

3.3 训练策略与技巧

CNN训练需要特别注意以下几点：

python复制def train(train_dataset):
    train_dataloader = DataLoader(train_dataset, batch_size=8, shuffle=True)
    model = MyModel().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    for epoch in range(10):
        model.train()
        total_loss, total_correct, total_samples = 0.0, 0, 0
        
        for x, y in train_dataloader:
            x, y = x.to(device), y.to(device)
            y_pred = model(x)
            loss = criterion(y_pred, y)
            
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item() * len(y)
            total_correct += (torch.argmax(y_pred) == y).sum()
            total_samples += len(y)
        
        print(f'epoch:{epoch+1}, loss:{total_loss/total_samples:.5f}, '
              f'acc:{total_correct/total_samples:.5f}')
    
    torch.save(model.state_dict(), './cnn_model/image_model.pth')

训练建议：

1. 使用较小的batch size(如8)可以更好地利用GPU内存
2. 监控训练准确率可以及时发现模型是否学习
3. 10个epoch对于简单CNN通常足够看到趋势

3.4 性能评估与可视化

评估CNN模型时，我们还可以可视化一些结果：

python复制def evaluate(test_dataset):
    test_dataloader = DataLoader(test_dataset, batch_size=8, shuffle=False)
    model = MyModel().to(device)
    model.load_state_dict(torch.load('./cnn_model/image_model.pth'))
    
    total_correct, total_samples = 0, 0
    model.eval()
    with torch.no_grad():
        for x, y in test_dataloader:
            x, y = x.to(device), y.to(device)
            y_pred = torch.argmax(model(x), dim=-1)
            total_correct += (y_pred == y).sum()
            total_samples += len(y)
    
    print(f'测试准确率：{total_correct/total_samples:.2f}')

扩展思路：

1. 可以添加混淆矩阵分析各类别表现
2. 可视化卷积核可以理解模型学到了什么特征
3. 使用Grad-CAM等技术可视化关注区域

4. 项目优化与进阶技巧

4.1 超参数调优策略

在实际项目中，超参数调优是提升模型性能的关键：

1. 学习率选择：

   • 初始尝试：0.001(Adam的默认值)
   • 可尝试范围：1e-5到1e-2
   • 使用学习率调度器如ReduceLROnPlateau

2. 批量大小影响：

   • 较小batch(8-32)：训练更稳定，内存需求低
   • 较大batch(64-256)：训练更快，但可能影响泛化

3. 网络深度与宽度：

   • 对于ANN：隐藏层2-3层，每层神经元128-512
   • 对于CNN：逐步增加通道数(如32->64->128)

4.2 数据增强技术

对于图像分类任务，数据增强可以显著提升模型泛化能力：

python复制from torchvision import transforms

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1),
    transforms.ToTensor(),
])

常用增强方法：

• 随机水平翻转
• 小幅旋转(-15°到+15°)
• 颜色抖动
• 随机裁剪

4.3 模型部署注意事项

将训练好的模型部署到生产环境需要考虑：

1. 模型格式转换：

   • 保存完整模型：torch.save(model, 'model.pth')
   • 导出为ONNX格式：增强跨平台兼容性

2. 推理优化：

   • 使用torch.jit.script编译模型
   • 启用cudnn基准测试：torch.backends.cudnn.benchmark = True

3. 资源监控：

   • 显存使用：torch.cuda.memory_allocated()
   • 计算耗时：with torch.profiler.profile() as prof:

5. 常见问题与解决方案

5.1 训练不收敛问题排查

当模型训练不收敛时，可以检查以下方面：

1. 数据问题：

   • 检查输入数据是否归一化
   • 验证标签是否正确编码
   • 可视化部分样本确认数据质量

2. 模型问题：

   • 检查初始化是否合理
   • 尝试更简单的模型架构
   • 添加BatchNorm层稳定训练

3. 优化问题：

   • 尝试更小的学习率
   • 使用学习率finder确定合适范围
   • 检查梯度是否消失/爆炸

5.2 过拟合处理技巧

当模型在训练集表现很好但测试集表现差时：

1. 正则化技术：

   • 添加Dropout层(概率0.2-0.5)
   • 使用L2权重衰减(1e-4)
   • 早停法(监控验证集损失)

2. 数据层面：

   • 增加训练数据量
   • 使用更丰富的数据增强
   • 人工合成更多样本

3. 模型层面：

   • 减少模型复杂度
   • 使用预训练模型+微调
   • 尝试模型集成方法

5.3 GPU使用优化建议

充分利用GPU资源可以大幅加速训练：

1. 内存优化：

   • 使用混合精度训练(amp)
   • 减少不必要的中间变量
   • 适当减小batch size

2. 计算优化：

   • 使用非阻塞数据加载：pin_memory=True
   • 预取数据：DataLoader(prefetch_factor=2)
   • 启用cudnn自动调优

3. 监控工具：

   • nvidia-smi查看GPU利用率
   • PyTorch Profiler分析瓶颈
   • 使用torch.cuda.empty_cache()释放缓存

在实际项目中，我发现很多初学者容易忽视数据质量检查这一环节。花时间彻底理解你的数据集往往能事半功倍。例如在手机价格分类项目中，我通常会先做以下检查：

1. 检查缺失值比例
2. 分析特征分布
3. 观察异常值
4. 验证标签分布

这些前期工作虽然耗时，但能帮助我们在建模阶段做出更明智的决策。