Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！

系列文章目录

Pytorch基础篇

01-PyTorch新手必看：张量是什么？5 分钟教你快速创建张量！
02-张量运算真简单！PyTorch 数值计算操作完全指南
03-Numpy 还是 PyTorch？张量与 Numpy 的神奇转换技巧
04-揭秘数据处理神器：PyTorch 张量拼接与拆分实用技巧
05-深度学习从索引开始：PyTorch 张量索引与切片最全解析
06-张量形状任意改！PyTorch reshape、transpose 操作超详细教程
07-深入解读 PyTorch 张量运算：6 大核心函数全面解析，代码示例一步到位！
08-自动微分到底有多强？PyTorch 自动求导机制深度解析

Pytorch实战篇

09-从零手写线性回归模型：PyTorch 实现深度学习入门教程
10-PyTorch 框架实现线性回归：从数据预处理到模型训练全流程
11-PyTorch 框架实现逻辑回归：从数据预处理到模型训练全流程
12-PyTorch 框架实现多层感知机（MLP）：手写数字分类全流程详解
13-PyTorch 时间序列与信号处理全解析：从预测到生成
14-深度学习必备：PyTorch数据加载与预处理全解析
15-PyTorch实战：手把手教你完成MNIST手写数字识别任务
16-PyTorch 训练循环全攻略：从零到精通的深度学习秘籍
17-PyTorch实现CNN：CIFAR-10图像分类实战教程

---

---

前言

在如今这个图像无处不在的时代，从你手机里随手拍下的自拍，到医生用来诊断疾病的医学影像，图像数据正在深刻改变我们的生活。而让计算机“读懂”这些图像的核心技术之一，就是卷积神经网络（CNN）。它就像是赋予了机器一双“眼睛”，让它们能够识别猫狗、区分颜色，甚至判断一张X光片是否异常。

如果你对人工智能充满好奇，或者想亲手打造一个能识别图像的模型，这篇文章将是你的完美起点。我们将使用PyTorch这个简单又强大的深度学习工具，从零开始搭建一个CNN，并在CIFAR-10数据集上实现图像分类。无论你是完全的新手，还是希望巩固基础的开发者，我都会用最通俗的语言带你一步步走进深度学习的世界。从数据准备到模型训练，再到结果分析，你将收获一个完整的实战项目。准备好了吗？让我们一起揭开CNN的神秘面纱，开启这场技术冒险！

---

一、卷积神经网络（CNN）基础

1.1 什么是卷积神经网络？

1.1.1 CNN 的核心组件

卷积神经网络（CNN）是一种专为处理图像等网格数据设计的神经网络。它通过层层结构，将原始图像转化为可理解的分类结果。CNN 的主要组件包括：

• 卷积层：使用卷积核扫描图像，提取边缘、纹理等局部特征。
• 池化层：缩小特征图尺寸，减少计算量，同时保留关键信息。
• 激活函数：通常用 ReLU，增加非线性，帮助模型学习复杂模式。
• 全连接层：将提取的特征整合起来，输出分类结果。

这些组件协作，让 CNN 能高效处理图像数据。

1.1.2 CNN 为什么适合图像分类？

相比传统神经网络，CNN 有三大优势：

• 参数共享：卷积核在图像上滑动时共享权重，大幅减少参数量。
• 局部感知：只关注图像的局部区域，符合人类识别图像的习惯。
• 平移不变性：无论目标在图像的哪个位置，CNN 都能识别。

这些特性让 CNN 在图像分类任务中表现出色。

1.2 CIFAR-10 数据集简介

1.2.1 数据集概览

CIFAR-10 是一个经典的图像分类数据集，包含 60,000 张 32x32 的彩色图像，分为 10 个类别（如飞机、汽车、猫等），每个类别 6,000 张。其中，50,000 张用于训练，10,000 张用于测试。

1.2.2 数据特点与挑战

CIFAR-10 的图像分辨率低，细节少，且类别间差异有时较小（如猫和狗），这对模型的特征提取能力提出了挑战。但它体积适中，非常适合初学者练习。

---

二、PyTorch 环境准备

2.1 安装 PyTorch

2.1.1 安装步骤

PyTorch 是一个强大的深度学习框架，支持 GPU 加速。安装步骤如下：

1. 打开 PyTorch 官网（https://pytorch.org/）。
2. 根据你的操作系统（Windows/Linux/Mac）和是否使用 GPU（CUDA 版本）选择安装命令。
3. 执行命令，例如：

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126

这将安装支持 CUDA 12.6 的 PyTorch。

2.1.2 验证安装

安装完成后，运行以下代码检查：

import torch
print(torch.__version__)  # 显示版本号
print(torch.cuda.is_available())  # 检查 GPU 是否可用

如果输出版本号且 GPU 可用，说明安装成功。

2.2 导入必要库

在开始之前，我们需要导入 PyTorch 及相关工具：

import torch
import torch.nn as nn  # 神经网络模块
import torch.optim as optim  # 优化器
import torchvision  # 图像处理工具
import torchvision.transforms as transforms  # 数据预处理
from torch.utils.data import DataLoader  # 数据加载器

这些库将贯穿整个项目。

---

三、数据准备与预处理

3.1 加载 CIFAR-10 数据集

3.1.1 使用 torchvision 加载

PyTorch 的 torchvision 提供了便捷的数据加载接口：

transform = transforms.Compose([
    transforms.ToTensor(),  # 转换为张量
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 归一化到 [-1, 1]
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

• root：数据保存路径。
• train=True/False：分别加载训练集和测试集。
• download=True：若本地无数据，自动下载。

3.1.2 数据预处理的意义

• ToTensor()：将图像从 PIL 格式转为张量，范围从 [0, 255] 变为 [0, 1]。
• Normalize()：标准化数据，减少数值差异对模型训练的影响。

3.2 创建数据加载器

3.2.1 DataLoader 的作用

DataLoader 能将数据集分批加载，支持打乱数据和多线程加速，提升训练效率。

3.2.2 配置 DataLoader

batch_size = 64
trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)

• batch_size：每批次图像数，64 是一个折中选择。
• shuffle：训练时打乱数据，增加随机性；测试时保持顺序。
• num_workers：多线程加载，加速数据读取。

---

四、构建 CNN 模型

4.1 设计 CNN 架构

4.1.1 网络结构概览

我们将搭建一个简单的 CNN，包含：

• 卷积层 1：3 输入通道（RGB），6 输出通道，5x5 卷积核。
• 池化层 1：2x2 最大池化。
• 卷积层 2：6 输入通道，16 输出通道，5x5 卷积核。
• 池化层 2：2x2 最大池化。
• 全连接层：逐步降维，最终输出 10 个类别。

4.1.2 模型代码实现

import torch.nn.functional as F  # 激活函数模块

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # 卷积层 1
        self.pool = nn.MaxPool2d(2, 2)  # 池化层
        self.conv2 = nn.Conv2d(6, 16, 5)  # 卷积层 2
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 全连接层 1
        self.fc2 = nn.Linear(120, 84)  # 全连接层 2
        self.fc3 = nn.Linear(84, 10)  # 输出层

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 卷积 + 激活 + 池化
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)  # 展平特征图
        x = F.relu(self.fc1(x))  # 全连接 + 激活
        x = F.relu(self.fc2(x))
        x = self.fc3(x)  # 输出
        return x

• view(-1, 16 * 5 * 5)：将特征图展平为一维向量，-1 表示自动计算 batch 大小。

4.2 模型初始化

4.2.1 实例化模型

net = Net()

4.2.2 支持 GPU 加速

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)

若有 GPU，模型会自动移到 GPU 上运行。

---

五、训练模型

5.1 定义损失函数和优化器

5.1.1 交叉熵损失

对于分类任务，常用交叉熵损失：

criterion = nn.CrossEntropyLoss()

它结合了 softmax 和损失计算，适合多分类问题。

5.1.2 SGD 优化器

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

• lr：学习率，控制参数更新步长。
• momentum：动量，加速梯度下降。

5.2 训练循环

5.2.1 训练代码

for epoch in range(10):  # 10 个 epoch
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()  # 清零梯度
        outputs = net(inputs)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        running_loss += loss.item()
        if i % 200 == 199:  # 每 200 批次打印一次
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 200:.3f}')
            running_loss = 0.0
print('Finished Training')

5.2.2 训练过程解析

• zero_grad()：防止梯度累积。
• backward()：计算梯度。
• step()：根据梯度更新权重。

---

六、测试模型

6.1 在测试集上评估

6.1.1 测试代码

correct = 0
total = 0
with torch.no_grad():  # 禁用梯度计算
    for data in testloader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)  # 取最大概率的类别
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total:.2f}%')

6.1.2 结果解读

准确率显示模型在测试集上的表现，通常 50%-70% 是该简单模型的合理范围。

6.2 性能分析

6.2.1 混淆矩阵可视化

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

all_preds, all_labels = [], []
with torch.no_grad():
    for data in testloader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        all_preds.extend(predicted.cpu().numpy())
        all_labels.extend(labels.cpu().numpy())

cm = confusion_matrix(all_labels, all_preds)
sns.heatmap(cm, annot=True, fmt='d')
plt.show()

混淆矩阵展示每个类别的分类情况，对角线数值越大越好。

---

七、完整代码实现

为了让你能够快速上手并复现整个项目，这里提供了一段完整的PyTorch代码，涵盖数据加载、模型定义、训练和测试的全过程。直接运行这段代码，你就能在CIFAR-10数据集上训练一个CNN模型。

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

# 数据预处理：转换为张量并归一化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载CIFAR-10数据集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

# 创建数据加载器
batch_size = 64
trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)

# 定义CNN模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # 输入3通道，输出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)  # 全连接层
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)     # 输出10类

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 卷积+激活+池化
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)           # 展平
        x = F.relu(self.fc1(x))              # 全连接+激活
        x = F.relu(self.fc2(x))
        x = self.fc3(x)                      # 输出层
        return x

# 实例化模型并支持GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net = Net().to(device)

# 定义损失函数和优化器
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(trainloader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()        # 清零梯度
        outputs = net(inputs)        # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()             # 反向传播
        optimizer.step()            # 更新参数
        running_loss += loss.item()
        if i % 200 == 199:          # 每200批次打印一次损失
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 200:.3f}')
            running_loss = 0.0
print('训练完成！')

# 测试模型
correct = 0
total = 0
with torch.no_grad():  # 不计算梯度
    for data in testloader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print(f'测试集准确率: {100 * correct / total:.2f}%')

代码说明

• 数据预处理：通过transforms.Compose将图像转为张量并归一化，确保输入数据适合模型处理。
• 数据集加载：使用torchvision.datasets.CIFAR-10下载并加载训练和测试数据，DataLoader负责批量读取。
• 模型结构：定义了一个简单的CNN，包括2个卷积层（带ReLU激活和池化）和3个全连接层，最终输出10个类别。
• 训练流程：使用SGD优化器和交叉熵损失函数，训练10个epoch，每200个批次打印一次损失。
• 测试评估：在测试集上计算模型的准确率，直观展示分类性能。

这段代码是一个完整的起点，你可以直接运行它，或者根据需要调整参数和网络结构，进一步优化模型效果。

---

八、总结

通过这篇文章的学习，你已经完成了一次从零到一的深度学习实践旅程。以下是本文的主要内容总结：

• CNN的核心概念：你了解了卷积神经网络的基本结构，包括卷积层、池化层和全连接层，以及它们如何帮助机器“看懂”图像。
• PyTorch环境搭建：你学会了如何安装PyTorch并准备开发环境，为后续实验打下基础。
• 数据处理技巧：通过加载和预处理CIFAR-10数据集，你掌握了数据清洗和标准化的实用方法。
• 模型设计与构建：你从头设计了一个CNN模型，理解了每一层的作用，并用PyTorch实现了它。
• 模型训练与优化：你定义了损失函数和优化器，完成了模型的训练过程，并学会了如何调整参数提升效果。
• 性能评估与可视化：通过测试集验证模型准确率，并利用混淆矩阵分析分类结果，掌握了评估模型表现的方法。

---