15 章完整教程 · 从一个神经元到完整 CNN · 从零基础到能动手做项目
你可能听说过 ChatGPT、人脸识别、自动驾驶这些 AI 应用。它们背后都有一个共同的核心——模型。那模型到底是什么呢?
简单来说,模型就是一个数学函数。它接收输入,经过一系列计算,给出输出。这句话听起来很抽象,让我们用几个例子来理解:
想象你有一个神奇的翻译器:
• 你扔进去一张猫的照片,它告诉你"这是猫"
• 你扔进去一段英文,它告诉你中文意思
• 你扔进去一段语音,它告诉你文字内容
这个"翻译器"就是模型。它学会了一种"翻译规则"——把输入转换成输出。
想象一个有 30 年经验的老中医:
• 你告诉他症状(输入),他就能诊断你得了什么病(输出)
• 他的"诊断能力"来自于几十年看过的无数病人(训练数据)
• 他脑子里有一套"诊断规则"(模型参数)
模型也一样:通过大量数据"学习",形成一套"规则",然后用这套规则来做预测。
更具体地说,模型的本质是这样的:
让我们用一个最简单的例子来理解模型。假设我们要预测房价:
# 输入:房屋面积(平方米)
# 输出:预测价格(万元)
# 最简单的模型:线性模型
# 价格 = 面积 × 权重 + 偏置
def predict_price(area, weight, bias):
return area * weight + bias
# 假设我们"学到"了这样的参数:
weight = 2.5 # 每平方米 2.5 万元
bias = 50 # 基础价格 50 万元
# 预测
area = 100 # 100 平方米
price = predict_price(area, weight, bias)
print(f"预测价格:{price} 万元") # 300 万元
# 这就是一个最简单的"模型"!
# 它有 2 个参数:weight 和 bias
# 训练就是找到最好的 weight 和 bias
现在有很多现成的 AI 工具和 API,比如 ChatGPT、百度文心一言、通义千问。为什么还要学习自己造模型呢?
| 对比维度 | 用现成模型 | 自己造模型 |
|---|---|---|
| 上手难度 | 很简单,调用 API 即可 | 需要学习原理和代码 |
| 灵活性 | 受限于 API 提供的功能 | 完全自由,想怎么改就怎么改 |
| 数据隐私 | 数据要上传到云端 | 数据完全在本地 |
| 成本 | 按调用次数付费,长期成本高 | 只有硬件成本,长期成本低 |
| 理解深度 | 知其然不知其所以然 | 真正理解 AI 是怎么工作的 |
| 适用场景 | 通用任务、快速验证 | 特定领域、定制化需求 |
| 离线使用 | 需要联网 | 可以完全离线 |
| 可控性 | 黑盒,不知道内部发生了什么 | 完全透明,可以调试和优化 |
在这 15 章的旅程中,我们将从零开始构建一个手写数字识别器。这是一个经典的入门项目,原因如下:
# 加载训练好的模型
model = CNN()
model.load_state_dict(torch.load('mnist_cnn.pth'))
model.eval()
# 用模型识别一张手写数字图片
image = load_image('my_handwritten_3.png') # 加载你手写的数字
prediction = model(image) # 模型预测
print(f"模型认为这是数字:{prediction.argmax()}") # 输出:3
这是很多初学者最关心的问题。答案是:普通电脑完全够用!
CPU 就像一个全能型人才:
• 能做任何事情
• 每件事都做得很好
• 但一次只能做一件事(或者说几件事)
GPU 就像一群普通工人:
• 每个人只会做简单的事情
• 但有成千上万个工人
• 可以同时做很多件事
深度学习的计算特点是"大量简单的重复运算",所以 GPU 更适合。
| 硬件 | 能否运行 | 训练速度 | 适合场景 | 成本 |
|---|---|---|---|---|
| 普通笔记本(CPU) | ✅ 可以 | 较慢(几分钟到十几分钟) | 本教程的所有内容 | 免费(你已有的电脑) |
| 有独立显卡的电脑 | ✅ 可以 | 快 5-10 倍 | 本教程 + 更大的模型 | 免费(你已有的电脑) |
| Google Colab(免费) | ✅ 可以 | 快 10-50 倍 | 中等规模模型 | 免费 |
| 云 GPU(按需付费) | ✅ 可以 | 快 50-100 倍 | 大型模型训练 | 几元/小时 |
| 专业 GPU(A100/H100) | ✅ 可以 | 极快 | 工业级模型训练 | 几十元/小时 |
# 方法一:任务管理器
# 按 Ctrl + Shift + Esc 打开任务管理器
# 点击"性能"标签,可以看到 CPU 和 GPU 信息
# 方法二:命令行
# 按 Win + R,输入 cmd 回车
# 输入以下命令:
wmic cpu get name # 查看 CPU 型号
wmic path win32_videocontroller get name # 查看 GPU 型号
import torch
# 查看是否有 GPU
print(f"CUDA 可用:{torch.cuda.is_available()}")
if torch.cuda.is_available():
print(f"GPU 型号:{torch.cuda.get_device_name(0)}")
print(f"GPU 数量:{torch.cuda.device_count()}")
else:
print("没有检测到 GPU,将使用 CPU 训练")
下面是我们的学习路线,从基础到进阶,循序渐进:
在正式开始之前,有几条建议:
第一次做菜,你不需要知道为什么要放盐、为什么油温要七成热。你只需要按照菜谱一步步来,最后能吃到一盘菜。等你做了很多次之后,自然就理解了背后的原理。
学习造模型也一样——先跟着教程写代码,看到模型能识别数字了,有了成就感,再慢慢深入理解每一行代码在做什么。
很多人一听到"深度学习"就害怕,觉得需要很高深的数学。其实本教程只需要初中数学基础就够了。
深度学习的数学就像汽车的发动机——你可以开车而不需要懂发动机原理。但如果你想成为赛车手(调参高手),就需要深入了解发动机(数学)了。
本教程的目标是让你先学会开车,发动机的知识以后慢慢补。
在深度学习中,数据通常用向量和矩阵来表示。听起来很高大上,其实就是数字的排列方式。
想象 Excel 表格中的一行:
[170, 65, 25] 可以表示一个人的 [身高cm, 体重kg, 年龄]
这一行数字就是一个向量。就这么简单!
向量可以表示很多东西:
• [红, 绿, 蓝] = 一个颜色(RGB 值)
• [x, y] = 一个点的坐标
• [像素1, 像素2, ..., 像素784] = 一张 28×28 的图片
import numpy as np
# 创建一个向量(一行数字)
v = np.array([170, 65, 25])
print(v) # [170 65 25]
print(v.shape) # (3,) 表示有 3 个元素
print(len(v)) # 3
# 向量运算
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])
print(v1 + v2) # [5 7 9] 对应位置相加
print(v1 * 2) # [2 4 6] 每个元素乘以 2
print(v1 * v2) # [4 10 18] 对应位置相乘
print(np.dot(v1, v2)) # 32 向量点积(对应位置相乘再求和)
想象 Excel 表格中的多行数据:
[[170, 65, 25], ← 第一个人
[180, 80, 30], ← 第二个人
[165, 55, 22]] ← 第三个人
这个 3行×3列 的数字表格就是一个矩阵。
矩阵可以表示:
• 多个人的信息(行=人,列=特征)
• 一张图片(行=行像素,列=列像素)
• 一个神经网络的权重(行=输入神经元,列=输出神经元)
# 创建一个矩阵(一个表格)
m = np.array([[170, 65, 25],
[180, 80, 30],
[165, 55, 22]])
print(m)
# [[170 65 25]
# [180 80 30]
# [165 55 22]]
print(m.shape) # (3, 3) 表示 3 行 3 列
print(m[0]) # [170 65 25] 第 0 行
print(m[:, 0]) # [170 180 165] 第 0 列
# 矩阵运算
m1 = np.array([[1, 2], [3, 4]])
m2 = np.array([[5, 6], [7, 8]])
print(m1 + m2) # [[ 6 8] 对应位置相加
# [10 12]]
print(m1 * 2) # [[2 4] 每个元素乘以 2
# [6 8]]
矩阵乘法是深度学习中最核心的运算。让我们用一个直觉来理解:
想象你有 3 个学生,每个学生有 3 门课的成绩:
成绩矩阵 = [[90, 85, 95], ← 学生1
[80, 75, 85], ← 学生2
[70, 65, 75]] ← 学生3
每门课的权重不同:
权重矩阵 = [[0.5], ← 语文权重
[0.3], ← 数学权重
[0.2]] ← 英语权重
加权总分 = 成绩 × 权重:
学生1:90×0.5 + 85×0.3 + 95×0.2 = 45 + 25.5 + 19 = 89.5
这就是矩阵乘法的本质!
# 两个矩阵相乘
A = np.array([[1, 2], # 2行2列
[3, 4]])
B = np.array([[5, 6], # 2行2列
[7, 8]])
# 方法一:使用 @ 运算符(推荐)
C = A @ B
print(C)
# [[19 22] ← 1×5+2×7=19, 1×6+2×8=22
# [43 50]] ← 3×5+4×7=43, 3×6+4×8=50
# 方法二:使用 np.dot()
C = np.dot(A, B)
print(C) # 结果相同
# 手动计算过程:
# C[0][0] = A[0][0]*B[0][0] + A[0][1]*B[1][0] = 1*5 + 2*7 = 19
# C[0][1] = A[0][0]*B[0][1] + A[0][1]*B[1][1] = 1*6 + 2*8 = 22
# C[1][0] = A[1][0]*B[0][0] + A[1][1]*B[1][0] = 3*5 + 4*7 = 43
# C[1][1] = A[1][0]*B[0][1] + A[1][1]*B[1][1] = 3*6 + 4*8 = 50
导数是微积分的核心概念,但你不需要懂微积分。只需要理解一个直觉:
想象你在开车:
• 位置 = 你在哪里(比如离家 100 公里)
• 速度 = 位置变化的快慢(比如 60 km/h)
• 导数 = 速度,就是"变化有多快"
如果你的位置函数是 位置 = 60 × 时间,那么导数就是 60(每小时变化 60 公里)。
更直观的例子:
• 你在爬山,高度 = f(位置)
• 导数 = 山坡的陡峭程度
• 导数为正 = 上坡
• 导数为负 = 下坡
• 导数为 0 = 平地(山顶或山谷)
# 常见函数的导数(不需要背,了解即可)
# 1. 常数函数:f(x) = 5
# 导数 = 0(常数不变化)
# 2. 线性函数:f(x) = 3x + 2
# 导数 = 3(斜率)
# 3. 平方函数:f(x) = x²
# 导数 = 2x
# 4. 立方函数:f(x) = x³
# 导数 = 3x²
# 示例:当 x = 3 时
# f(x) = x² = 9
# f'(x) = 2x = 6
# 这意味着:如果 x 增加一点点,f(x) 会增加 6 倍那么多
在深度学习中,导数告诉我们:当我改变某个参数时,最终结果会变化多少?
# 假设 loss(损失)依赖于 weight(权重)
# loss = f(weight)
# 导数 dloss/dweight 告诉我们:
# 如果 weight 增加一点点,loss 会变化多少?
# 举例:
# 当 weight = 0.5 时,loss = 10
# 导数 dloss/dweight = 6(正数)
# 这意味着:
# 如果 weight 增加,loss 也会增加(变得更差)
# 所以我们应该减小 weight 来降低 loss!
# 这就是梯度下降的核心思想!
概率就是"某件事发生的可能性有多大",用 0 到 1 之间的数字表示:
在深度学习中,模型的输出通常是一组概率值。比如识别手写数字时:
# 模型看到一张手写数字图片后,输出 10 个概率值:
output = [0.01, 0.01, 0.01, 0.85, 0.01, 0.05, 0.01, 0.02, 0.02, 0.01]
# 0 1 2 3 4 5 6 7 8 9
# 解读:
# 数字 0 的概率 = 1%(模型认为不太可能是 0)
# 数字 1 的概率 = 1%
# 数字 2 的概率 = 1%
# 数字 3 的概率 = 85% ← 最高!模型认为这是数字 3
# 数字 4 的概率 = 1%
# 数字 5 的概率 = 5%
# 数字 6 的概率 = 1%
# 数字 7 的概率 = 2%
# 数字 8 的概率 = 2%
# 数字 9 的概率 = 1%
# 所有概率加起来 = 1.0(100%)
print(sum(output)) # 1.0
模型的原始输出是任意数字(可能是负数,也可能很大),我们需要把它转换成概率。这个转换叫 Softmax:
import torch
# 模型的原始输出(任意数字)
raw_output = torch.tensor([2.0, 1.0, 0.5, 5.0, 0.1, 1.5, 0.3, 0.8, 0.6, 0.2])
# 使用 Softmax 转换成概率
probabilities = torch.softmax(raw_output, dim=0)
print(probabilities)
# tensor([0.0539, 0.0199, 0.0119, 0.7214, 0.0080, 0.0324, 0.0100, 0.0162, 0.0132, 0.0089])
# 所有概率加起来 = 1
print(probabilities.sum()) # tensor(1.)
# 最大概率对应的位置就是预测结果
predicted_class = probabilities.argmax()
print(f"预测结果:数字 {predicted_class}") # 数字 3
损失函数是另一个重要概念。它衡量模型的预测和正确答案之间的差距。
想象考试满分 100 分:
• 你考了 90 分,损失 = 10 分
• 你考了 60 分,损失 = 40 分
损失越小,说明模型预测越准。训练的目标就是让损失尽可能小。
import torch.nn as nn
# 创建损失函数
criterion = nn.CrossEntropyLoss()
# 模型输出(10 个类别的分数)
output = torch.tensor([[1.0, 2.0, 3.0, 8.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0]])
# 正确答案(标签是 3)
target = torch.tensor([3])
# 计算损失
loss = criterion(output, target)
print(f"损失值:{loss.item():.4f}") # 损失值应该比较小
# 如果预测错误(标签是 0,但模型认为是 3)
wrong_target = torch.tensor([0])
wrong_loss = criterion(output, wrong_target)
print(f"错误预测的损失:{wrong_loss.item():.4f}") # 损失值会更大
如果你看到这里还是有点懵,没关系!有几个建议:
首先我们需要安装 Python。推荐使用 Anaconda,它是一个 Python 发行版,自带了很多数据科学需要的库,省去逐个安装的麻烦。
| 对比 | 原生 Python | Anaconda |
|---|---|---|
| 库管理 | 需要手动逐个安装 | 自带 250+ 常用库 |
| 环境管理 | 需要额外工具 | 自带 conda 环境管理 |
| 包管理 | pip | conda + pip |
| 适合人群 | 有经验的开发者 | 初学者、数据科学 |
anaconda.com/download,下载对应系统的版本(Windows/macOS/Linux)。文件大约 800MB。python --version
# 输出类似:Python 3.11.5
conda --version
# 输出类似:conda 23.7.4
# 如果输出版本号,说明安装成功!
PyTorch 是目前最流行的深度学习框架之一,由 Meta(Facebook)开发。它的优点是简单易学、调试方便、社区活跃。
| 框架 | 特点 | 使用者 |
|---|---|---|
| PyTorch | 简单易学、动态图、调试方便 | Meta、特斯拉、大多数研究者 |
| TensorFlow | 工业部署强、生态完善 | Google、很多企业 |
| JAX | 高性能、函数式编程 | Google DeepMind |
pytorch.org,找到 "Get Started" → "Start Locally"。pip install torch torchvision torchaudio
conda install pytorch torchvision torchaudio cpuonly -c pytorch
import torch
print(torch.__version__) # 输出类似:2.1.0
print(torch.cuda.is_available()) # 如果是 CPU 版本,输出 False,这是正常的
Jupyter Notebook 是数据科学和深度学习最常用的工具。它可以让你一段一段地运行代码,边写边看结果,非常适合学习和实验。
想象你在做实验:
普通 Python 脚本:写完整个程序才能运行,像写作文。
Jupyter Notebook:可以写一段运行一段,像做实验。写一行代码,运行看看结果,不对就改,再运行。非常灵活!
特别适合:
• 学习新知识(边学边练)
• 数据分析(探索数据)
• 模型实验(快速迭代)
jupyter notebook
# 或者使用 Jupyter Lab(更现代的界面)
jupyter lab
Shift + Enter 运行。Shift + Enter:运行当前单元格Ctrl + Enter:运行当前单元格,保持选中Esc + A:在上方插入新单元格Esc + B:在下方插入新单元格Esc + DD:删除当前单元格Esc + M:转为 Markdown(写笔记)Esc + Y:转为 Code(写代码)Ctrl + S:保存
除了 PyTorch,我们还需要几个常用的库。用 pip 一键安装:
pip install numpy matplotlib pandas scikit-learn
| 库名 | 作用 | 类比 | 本教程用途 |
|---|---|---|---|
| NumPy | 处理向量、矩阵等数值计算 | 科学计算器 | 数据处理、矩阵运算 |
| Matplotlib | 画图、可视化数据 | 画笔和画板 | 绘制训练曲线、可视化 |
| Pandas | 处理表格数据(类似 Excel) | Excel 表格 | 数据清洗、分析 |
| scikit-learn | 传统机器学习算法 | 工具箱 | 评估指标、数据划分 |
import torch
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.metrics import accuracy_score
print("所有库安装成功!")
print(f"PyTorch 版本:{torch.__version__}")
print(f"NumPy 版本:{np.__version__}")
print(f"Pandas 版本:{pd.__version__}")
如果你的电脑没有显卡,或者想用更快的 GPU 训练,可以用 Google Colab——它提供免费的 Jupyter Notebook 环境,还自带 GPU。
colab.research.google.com,用 Google 账号登录。import torch
print(f"GPU 可用:{torch.cuda.is_available()}")
if torch.cuda.is_available():
print(f"GPU 型号:{torch.cuda.get_device_name(0)}")
print(f"GPU 显存:{torch.cuda.get_device_properties(0).total_mem / 1024**3:.1f} GB")
# 输出:GPU 可用:True
# 输出:GPU 型号:Tesla T4
# 输出:GPU 显存:15.8 GB
pip 和你启动 Jupyter 的 python 是同一个!pip install torch 重新安装conda activate basewhich python(macOS/Linux)或 where python(Windows)查看 Python 路径
nvidia-smipip uninstall torchpip install jupyterjupyter lab 代替 jupyter notebook机器学习主要分为三大类。我们用生活中的例子来理解:
就像小学生做作业,每道题都有标准答案。你做完后老师批改,告诉你哪里错了,你下次就知道怎么改了。
本教程就是监督学习:我们给模型看大量的手写数字图片,每张图片都标注了正确的数字(标签)。模型通过对比自己的预测和正确答案来学习。
更多例子:
• 给模型看 10000 张猫狗照片,每张都标注"猫"或"狗"
• 给模型看 10000 封邮件,每封都标注"正常"或"垃圾"
• 给模型看 10000 个房子的信息,每个都标注了价格
就像把你扔到一个陌生城市,没有人告诉你路怎么走。你只能自己观察,发现规律——比如"这条路总是很堵"、"那个区域有很多餐厅"。
无监督学习的任务:
• 聚类:把相似的数据分成一组(比如把客户分成高价值/中价值/低价值)
• 降维:把复杂的数据简化(比如把 100 个特征压缩成 10 个)
• 异常检测:找出不正常的数据(比如信用卡欺诈检测)
就像训练小狗:做对了给零食(奖励),做错了不给(惩罚)。小狗慢慢学会哪些动作能得到零食。
例子:
• AlphaGo 下围棋,每下一步棋,根据最终胜负获得奖励或惩罚
• 机器人学走路,每走一步,根据是否摔倒获得奖励或惩罚
• 游戏 AI,每做一个动作,根据得分获得奖励或惩罚
| 类型 | 数据要求 | 典型应用 | 本教程 |
|---|---|---|---|
| 监督学习 | 需要标注好的数据 | 图片分类、语音识别、文本分类 | ✅ 使用这个 |
| 无监督学习 | 不需要标注 | 聚类、降维、异常检测 | ❌ 不涉及 |
| 强化学习 | 需要奖励信号 | 游戏AI、机器人控制 | ❌ 不涉及 |
监督学习又分为两大任务:
从固定的几个选项中选一个。
• 这张图片是猫还是狗?(二分类:2个选项)
• 这张图片是0-9哪个数字?(多分类:10个选项)
• 这封邮件是正常还是垃圾?(二分类)
• 这条评论是正面、负面还是中性?(多分类:3个选项)
特点:输出是离散的类别(有限个选项)
预测一个具体的数字。
• 这套房子值多少钱?(输出:500万)
• 明天气温多少度?(输出:28.5℃)
• 这个人的身高是多少?(输出:175.3cm)
• 这只股票明天会涨多少?(输出:+2.5%)
特点:输出是连续的数值(无限个可能)
机器学习的本质是什么?一句话:寻找一个函数。
那这个函数 f 长什么样呢?它就是我们的神经网络!神经网络本质上就是一个非常复杂的数学函数,有几百万个参数。训练就是通过数据来调整这些参数。
我们手上的数据不能全部用来训练,需要分成三份:
想象一个学生把考试原题都背下来了,考试当然能得满分。但他真的学会了吗?如果换个题就不会了。
模型也一样:如果用训练数据来测试,它可能只是"背"住了答案(这叫过拟合),而不是真正学会了识别数字。所以我们需要留出一部分数据作为"考试题",这些数据模型在训练时从未见过。
# MNIST 数据集已经帮你分好了:
# 训练集:60000 张图片
# 测试集:10000 张图片
# 我们通常再从训练集中分出一部分作为验证集:
# 训练集:50000 张(用于训练)
# 验证集:10000 张(用于调参)
# 测试集:10000 张(用于最终评估)
from torch.utils.data import random_split
# 划分训练集和验证集
train_size = 50000
val_size = 10000
train_dataset, val_dataset = random_split(train_dataset, [train_size, val_size])
print(f"训练集:{len(train_dataset)} 张")
print(f"验证集:{len(val_dataset)} 张")
print(f"测试集:{len(test_dataset)} 张")
训练模型时,你会经常看到这三个概念:
假设你有 10000 张训练图片,batch_size = 100:
Iteration(迭代):处理一个 batch 的数据
• 1 个 iteration = 处理 100 张图片
Epoch(轮次):完整遍历一次训练集
• 1 个 epoch = 10000 张图片都看了一遍
• 1 个 epoch = 100 个 iteration(10000 ÷ 100)
通常训练多个 epoch,比如 10 个 epoch:
• 总共看了 10 遍训练集
• 总共 1000 个 iteration
# 假设训练集有 60000 张图片,batch_size = 64
# 每个 epoch 的 iteration 数 = 60000 ÷ 64 ≈ 938
for epoch in range(10): # 训练 10 个 epoch
for batch_idx, (images, labels) in enumerate(train_loader):
# 这里是 1 个 iteration
# images 的形状:[64, 1, 28, 28](64 张图片)
# labels 的形状:[64](64 个标签)
if batch_idx % 100 == 0:
print(f"Epoch {epoch}, Iteration {batch_idx}/{len(train_loader)}")
# 输出:
# Epoch 0, Iteration 0/938
# Epoch 0, Iteration 100/938
# Epoch 0, Iteration 200/938
# ...
# Epoch 0, Iteration 900/938
# Epoch 1, Iteration 0/938
# ...
MNIST 是深度学习领域最经典的数据集,就像编程界的 "Hello World"。它包含 70000 张手写数字图片:
PyTorch 内置了 MNIST 数据集,一行代码就能下载:
from torchvision import datasets, transforms
# 定义数据预处理
transform = transforms.Compose([
transforms.ToTensor(), # 转换成 Tensor 格式,自动归一化到 0-1
])
# 下载训练集
train_dataset = datasets.MNIST(
root='./data', # 数据保存路径
train=True, # 这是训练集
download=True, # 如果没有就下载
transform=transform # 数据预处理
)
# 下载测试集
test_dataset = datasets.MNIST(
root='./data',
train=False,
download=True,
transform=transform
)
print(f"训练集大小:{len(train_dataset)}") # 60000
print(f"测试集大小:{len(test_dataset)}") # 10000
拿到数据后,第一件事就是看看它长什么样:
import matplotlib.pyplot as plt
# 取出前 20 张图片
fig, axes = plt.subplots(2, 10, figsize=(15, 4))
for i in range(20):
image, label = train_dataset[i] # 获取图片和标签
row = i // 10
col = i % 10
axes[row, col].imshow(image.squeeze(), cmap='gray') # 显示图片
axes[row, col].set_title(f'标签: {label}')
axes[row, col].axis('off')
plt.tight_layout()
plt.show()
运行后你会看到类似这样的图片:
# 获取一张图片
image, label = train_dataset[0]
print(f"图片形状:{image.shape}") # torch.Size([1, 28, 28])
print(f"图片标签:{label}") # 5
print(f"像素值范围:{image.min()} - {image.max()}") # 0.0 - 1.0
print(f"数据类型:{image.dtype}") # torch.float32
# 查看像素值(28×28 的矩阵)
print("像素值矩阵:")
print(image.squeeze().numpy())
原始的像素值是 0-255,我们需要把它转换到 0-1 之间。这个过程叫归一化。
想象你有两个特征:
• 身高:150-190 cm(数值大)
• 体重:40-100 kg(数值小)
如果不归一化,身高的数值比体重大得多,模型会误以为身高更重要。归一化后,两个特征都在 0-1 之间,模型才能公平地对待它们。
另一个好处:归一化后,梯度下降收敛更快,训练更稳定。
# 原始像素值:0-255
# 归一化后:0-1(除以 255)
# 方法一:使用 ToTensor(),自动归一化到 0-1
transform1 = transforms.ToTensor()
# 方法二:手动归一化到 -1 到 1(均值 0.5,标准差 0.5)
transform2 = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,)) # (值-0.5)/0.5
])
# 归一化前后对比
image_raw = train_dataset[0][0] # ToTensor 后,范围 0-1
image_norm = transform2(transforms.ToPILImage()(image_raw)) # 归一化到 -1 到 1
print(f"归一化前:{image_raw.min():.2f} - {image_raw.max():.2f}") # 0.00 - 1.00
print(f"归一化后:{image_norm.min():.2f} - {image_norm.max():.2f}") # -1.00 - 1.00
训练模型时,我们不是一张一张地喂数据,而是一批一批地喂。这个"一批"叫做 batch。
想象你在餐厅吃饭:
• 全量(batch_size=全部数据):厨师把所有菜都做好了才上桌。你等很久,但菜是一起上的。
• 逐个(batch_size=1):厨师每做好一道菜就上一道。你吃得快,但厨师很累(GPU 利用率低)。
• 小批量(batch_size=32/64):厨师每做好一批菜就上一批。兼顾效率和速度。
通常 batch_size 选择 32、64、128、256 等 2 的幂次方。
from torch.utils.data import DataLoader
# 创建 DataLoader
train_loader = DataLoader(
train_dataset,
batch_size=64, # 每批 64 张图片
shuffle=True # 打乱数据顺序(训练时需要)
)
test_loader = DataLoader(
test_dataset,
batch_size=64,
shuffle=False # 测试时不需要打乱
)
# 看看一个 batch 的形状
for images, labels in train_loader:
print(f"图片形状:{images.shape}") # [64, 1, 28, 28]
# ↑ ↑ ↑ ↑
# 批量 通道 高 宽
print(f"标签形状:{labels.shape}") # [64]
print(f"标签内容:{labels[:10]}") # tensor([5, 0, 4, 1, 9, 2, 1, 3, 1, 4])
break
[64, 1, 28, 28] 的意思是:真实世界的数据往往有各种问题:
| 问题 | 描述 | 解决方法 |
|---|---|---|
| 缺失值 | 某些数据缺失 | 删除或填充(均值、中位数) |
| 异常值 | 明显不合理的数据 | 删除或修正 |
| 标签错误 | 标注不正确 | 人工检查、众包验证 |
| 类别不平衡 | 某些类别数据太少 | 过采样、欠采样、数据增强 |
| 数据重复 | 同一条数据出现多次 | 去重 |
神经网络的灵感来自人脑。让我们先看看生物神经元是怎么工作的:
想象你决定要不要出门。你会考虑几个因素:
• 天气好不好?(权重:0.4)
• 有没有约会?(权重:0.5)
• 身体舒不舒服?(权重:0.1)
你会给每个因素一个"权重",重要的因素权重更大。然后综合考虑所有因素,做出"出门/不出门"的决定。
人工神经元做的事情完全一样!
一个神经元有两个可学习的参数:
# 假设输入有 3 个特征:x1, x2, x3
x = [2.0, 3.0, 1.0]
# 权重和偏置(随机初始化)
w = [0.5, -0.2, 0.8] # 权重
b = 0.1 # 偏置
# 计算过程
# 第1步:输入 × 权重
z = x1*w1 + x2*w2 + x3*w3 + b
= 2.0*0.5 + 3.0*(-0.2) + 1.0*0.8 + 0.1
= 1.0 - 0.6 + 0.8 + 0.1
= 1.3
# 第2步:通过激活函数(下一节会讲)
output = activation(1.3)
# 用 PyTorch 实现
import torch
import torch.nn as nn
# 创建一个神经元
neuron = nn.Linear(3, 1) # 输入3个特征,输出1个值
# 查看参数
print("权重:", neuron.weight)
print("偏置:", neuron.bias)
# 前向计算
x = torch.tensor([[2.0, 3.0, 1.0]])
output = neuron(x)
print("输出:", output)
如果神经元只有权重和偏置,它只能做线性变换(相当于一条直线)。但现实世界的问题往往是非线性的。所以我们需要激活函数来引入非线性。
import torch
# Sigmoid:把任意数字压缩到 0-1 之间
def sigmoid(x):
return 1 / (1 + torch.exp(-x))
# 示例
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
print(sigmoid(x))
# tensor([0.1192, 0.2689, 0.5000, 0.7311, 0.8808])
# 所有值都被压缩到 0-1 之间了!
# PyTorch 内置版本
print(torch.sigmoid(x)) # 结果相同
Sigmoid 的形状像一个 "S":
# ReLU:负数变 0,正数不变
def relu(x):
return torch.max(torch.zeros_like(x), x)
# 示例
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
print(relu(x))
# tensor([0., 0., 0., 1., 2.])
# PyTorch 内置版本
print(torch.relu(x)) # 结果相同
ReLU 是目前最常用的激活函数:
# Tanh:把任意数字压缩到 -1 到 1 之间
def tanh(x):
return torch.tanh(x)
# 示例
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
print(tanh(x))
# tensor([-0.9640, -0.7616, 0.0000, 0.7616, 0.9640])
| 激活函数 | 输出范围 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| Sigmoid | 0 到 1 | 输出可解释为概率 | 梯度消失、不以0为中心 | 二分类输出层 |
| ReLU | 0 到 +∞ | 计算快、不会梯度消失 | 死ReLU问题 | 隐藏层首选 |
| Tanh | -1 到 1 | 输出以 0 为中心 | 仍有梯度消失 | RNN、某些特殊场景 |
| Leaky ReLU | -∞ 到 +∞ | 解决死ReLU问题 | 需要调参 | ReLU的替代品 |
| GELU | 0 到 +∞ | Transformer常用 | 计算稍慢 | Transformer、BERT |
现在让我们用 PyTorch 实现一个最简单的神经元:
import torch
import torch.nn as nn
# 创建一个只有一个神经元的层
# 输入:3 个特征
# 输出:1 个值
neuron = nn.Linear(3, 1)
# 查看参数
print("权重形状:", neuron.weight.shape) # [1, 3]
print("权重值:", neuron.weight.data)
print("偏置形状:", neuron.bias.shape) # [1]
print("偏置值:", neuron.bias.data)
# 前向计算
x = torch.tensor([[2.0, 3.0, 1.0]]) # 1个样本,3个特征
output = neuron(x)
print("输出:", output)
# 手动验证计算过程
w = neuron.weight.data
b = neuron.bias.data
manual_output = x @ w.T + b
print("手动计算:", manual_output)
# 两个结果应该相同
nn.Linear(3, 1) 创建了一个层,它包含:output = x @ weight.T + biasnn.Linear 创建神经元
一个神经元的能力非常有限。要解决复杂问题,我们需要把很多神经元组合在一起,形成多层网络。
想象一个汽车工厂的流水线:
• 第 1 个车间:负责加工零件(提取低级特征,如边缘、线条)
• 第 2 个车间:负责组装部件(组合中级特征,如形状、纹理)
• 第 3 个车间:负责喷漆检验(形成高级特征,如物体、场景)
每个车间的工人都做一件简单的事,但串起来就能造出复杂的汽车。
神经网络也一样:每一层提取不同层次的特征,最终做出决策。
前向传播就是数据从输入层流向输出层的过程。每经过一层,数据就被变换一次。
import torch
import torch.nn as nn
# 输入:一张 28×28 的图片(展平成 784 维向量)
x = torch.randn(1, 784) # 1个样本,784个特征
print(f"输入形状:{x.shape}") # [1, 784]
# 第1层:784 → 128
w1 = torch.randn(784, 128) # 权重矩阵
b1 = torch.randn(128) # 偏置
h1 = x @ w1 + b1 # 线性变换
h1 = torch.relu(h1) # 激活函数
print(f"第1层输出形状:{h1.shape}") # [1, 128]
# 第2层:128 → 64
w2 = torch.randn(128, 64)
b2 = torch.randn(64)
h2 = h1 @ w2 + b2
h2 = torch.relu(h2)
print(f"第2层输出形状:{h2.shape}") # [1, 64]
# 第3层(输出层):64 → 10
w3 = torch.randn(64, 10)
b3 = torch.randn(10)
output = h2 @ w3 + b3
print(f"输出形状:{output.shape}") # [1, 10]
# 这 10 个值代表模型认为图片是 0-9 各数字的"分数"
print(f"输出值:{output}")
[1, 784] → [1, 128] → [1, 64] → [1, 10]训练开始前,权重需要随机初始化。但随机的方式有讲究:
import torch.nn as nn
# 创建一个层
layer = nn.Linear(784, 128)
# 方法1:Xavier 初始化(适合 Sigmoid/Tanh)
nn.init.xavier_uniform_(layer.weight)
# 方法2:Kaiming 初始化(适合 ReLU)
nn.init.kaiming_uniform_(layer.weight, nonlinearity='relu')
# 方法3:正态分布初始化
nn.init.normal_(layer.weight, mean=0, std=0.01)
# 方法4:PyTorch 默认初始化
# nn.Linear 默认使用 Kaiming 初始化,通常不用手动设置
print(f"权重形状:{layer.weight.shape}")
print(f"权重均值:{layer.weight.mean():.4f}")
print(f"权重标准差:{layer.weight.std():.4f}")
现在让我们用 PyTorch 搭建一个完整的 3 层网络:
import torch.nn as nn
# 定义网络结构
model = nn.Sequential(
nn.Linear(784, 128), # 第1层:784 → 128
nn.ReLU(), # 激活函数
nn.Linear(128, 64), # 第2层:128 → 64
nn.ReLU(), # 激活函数
nn.Linear(64, 10) # 第3层:64 → 10(输出层)
)
print(model)
print(f"\n总参数数量:{sum(p.numel() for p in model.parameters())}")
输出:
class MyNet(nn.Module):
def __init__(self):
super().__init__()
# 定义层
self.fc1 = nn.Linear(784, 128) # 第1层
self.fc2 = nn.Linear(128, 64) # 第2层
self.fc3 = nn.Linear(64, 10) # 第3层
self.relu = nn.ReLU() # 激活函数
self.dropout = nn.Dropout(0.2) # Dropout(防过拟合)
def forward(self, x):
# 定义前向传播
x = x.view(-1, 784) # 展平图片
x = self.dropout(self.relu(self.fc1(x))) # 第1层 + ReLU + Dropout
x = self.dropout(self.relu(self.fc2(x))) # 第2层 + ReLU + Dropout
x = self.fc3(x) # 第3层(输出层不加激活)
return x
# 创建模型
model = MyNet()
print(model)
# 测试前向传播
x = torch.randn(1, 1, 28, 28) # 1张图片
output = model(x)
print(f"输出形状:{output.shape}") # [1, 10]
nn.Sequential:简单,按顺序搭建,适合简单的网络nn.Module:灵活,可以自定义复杂的前向传播逻辑,适合复杂的网络让我们可视化看看每一层学到了什么:
# 获取中间层的输出
def get_features(model, x):
features = {}
x = x.view(-1, 784) # 展平
features['input'] = x
x = model.relu(model.fc1(x))
features['layer1'] = x
x = model.relu(model.fc2(x))
features['layer2'] = x
x = model.fc3(x)
features['output'] = x
return features
# 用一张图片测试
image, label = train_dataset[0]
features = get_features(model, image.unsqueeze(0))
print(f"输入形状:{features['input'].shape}") # [1, 784]
print(f"第1层输出:{features['layer1'].shape}") # [1, 128]
print(f"第2层输出:{features['layer2'].shape}") # [1, 64]
print(f"最终输出:{features['output'].shape}") # [1, 10]
# 可视化神经元激活值
import matplotlib.pyplot as plt
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
# 第1层激活值
axes[0].bar(range(128), features['layer1'][0].detach().numpy())
axes[0].set_title('第1层激活值')
axes[0].set_xlabel('神经元')
# 第2层激活值
axes[1].bar(range(64), features['layer2'][0].detach().numpy())
axes[1].set_title('第2层激活值')
axes[1].set_xlabel('神经元')
# 输出层
axes[2].bar(range(10), features['output'][0].detach().numpy())
axes[2].set_title('输出层')
axes[2].set_xlabel('数字类别')
plt.tight_layout()
plt.show()
了解模型有多少参数很重要,它决定了模型的大小和训练速度:
# 计算每层的参数数量
layer1 = nn.Linear(784, 128)
layer2 = nn.Linear(128, 64)
layer3 = nn.Linear(64, 10)
# 参数数量 = 输入维度 × 输出维度 + 偏置
print(f"第1层参数:{784 * 128 + 128}") # 100480
print(f"第2层参数:{128 * 64 + 64}") # 8256
print(f"第3层参数:{64 * 10 + 10}") # 650
print(f"总参数:{100480 + 8256 + 650}") # 109386
# PyTorch 快捷方式
model = nn.Sequential(layer1, nn.ReLU(), layer2, nn.ReLU(), layer3)
total_params = sum(p.numel() for p in model.parameters())
print(f"总参数数量:{total_params}") # 109386
在深入细节之前,先了解训练的整体流程:
训练模型的第一步是定义损失函数——它衡量模型的预测和正确答案之间的差距。
想象考试满分 100 分:
• 你考了 90 分,损失 = 10 分
• 你考了 60 分,损失 = 40 分
损失越小,说明模型预测越准。训练的目标就是让损失尽可能小。
对于分类问题,最常用的损失函数是交叉熵损失。
import torch
import torch.nn as nn
# 创建损失函数
criterion = nn.CrossEntropyLoss()
# 模型输出(10 个类别的分数,也叫 logits)
# 假设模型认为图片是数字 3 的分数最高
output = torch.tensor([[1.0, 2.0, 3.0, 8.0, 1.0, 2.0, 1.0, 1.0, 1.0, 1.0]])
# 正确答案(标签是 3)
target = torch.tensor([3])
# 计算损失
loss = criterion(output, target)
print(f"损失值:{loss.item():.4f}") # 损失值应该比较小
# 如果预测错误(标签是 0,但模型认为是 3)
wrong_target = torch.tensor([0])
wrong_loss = criterion(output, wrong_target)
print(f"错误预测的损失:{wrong_loss.item():.4f}") # 损失值会更大
# 交叉熵内部做了什么?
# 1. 对输出做 softmax,得到概率分布
# 2. 取正确类别对应的概率
# 3. 计算 -log(概率)
# 概率越高,损失越小
| 损失函数 | 用途 | 公式 | 特点 |
|---|---|---|---|
| CrossEntropyLoss | 多分类 | -log(p_correct) | 最常用,结合了 softmax |
| BCELoss | 二分类 | -[y*log(p) + (1-y)*log(1-p)] | 二分类专用 |
| MSELoss | 回归 | mean((y_pred - y_true)²) | 均方误差 |
| L1Loss | 回归 | mean(|y_pred - y_true|) | 平均绝对误差 |
有了损失函数,下一步就是减少损失。怎么减少?答案是梯度下降。
想象你站在一座山上,四周都是雾,看不清路。你的目标是走到山谷(损失最小的地方)。
你只能感觉到脚下的坡度(导数):
• 如果左边是下坡,就往左走
• 如果右边是下坡,就往右走
每次走一小步,慢慢就走到山谷了。这就是梯度下降!
反向传播是计算梯度的算法。它从输出层开始,一层一层往回计算每个参数的梯度。
loss.backward(),PyTorch 就会自动计算所有参数的梯度。import torch
import torch.nn as nn
# 创建一个简单的模型
model = nn.Sequential(
nn.Linear(10, 5),
nn.ReLU(),
nn.Linear(5, 2)
)
# 创建输入和目标
x = torch.randn(1, 10)
target = torch.tensor([1])
# 前向传播
output = model(x)
loss = nn.CrossEntropyLoss()(output, target)
# 反向传播:计算梯度
loss.backward()
# 查看梯度
for name, param in model.named_parameters():
if param.grad is not None:
print(f"{name}: 梯度形状 = {param.grad.shape}, 梯度均值 = {param.grad.mean():.4f}")
# 梯度告诉我们:
# 如果权重增加一点点,loss 会变化多少
# 我们应该沿着梯度的反方向更新权重
有了梯度,我们用优化器来更新参数。不同的优化器有不同的策略:
| 优化器 | 特点 | 适用场景 | 学习率 |
|---|---|---|---|
| SGD | 最基础,每次按梯度方向走一小步 | 简单问题、需要精细调参 | 0.01-0.1 |
| SGD + Momentum | 加上"惯性",不容易卡住 | 大多数场景 | 0.01-0.1 |
| Adam | 自适应学习率,自动调整步长 | 新手首选、大多数场景 | 0.001 |
| AdamW | Adam + 权重衰减,更稳定 | Transformer、大模型 | 0.001 |
import torch.optim as optim
# 创建模型
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Linear(128, 10)
)
# 创建优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
# lr 是学习率,控制每次更新的步长
# 太大:容易错过最优点,训练不稳定
# 太小:训练太慢,可能卡在局部最优
# 在训练循环中使用
for epoch in range(10):
for images, labels in train_loader:
# 前向传播
outputs = model(images.view(-1, 784))
loss = nn.CrossEntropyLoss()(outputs, labels)
# 反向传播和更新
optimizer.zero_grad() # 清空梯度(重要!)
loss.backward() # 计算梯度
optimizer.step() # 更新参数
学习率不是固定不变的。通常在训练初期用较大的学习率快速下降,后期用较小的学习率精细调整。
# 创建学习率调度器
scheduler = optim.lr_scheduler.StepLR(
optimizer,
step_size=10, # 每 10 个 epoch 调整一次
gamma=0.1 # 每次调整时学习率乘以 0.1
)
# 在训练循环中使用
for epoch in range(30):
# 训练代码...
train_one_epoch(...)
# 更新学习率
scheduler.step()
print(f"Epoch {epoch}, 学习率: {scheduler.get_last_lr()}")
# 学习率变化:
# Epoch 0-9: lr = 0.001
# Epoch 10-19: lr = 0.0001
# Epoch 20-29: lr = 0.00001
现在让我们把所有组件组合起来,完成第一次训练:
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
# 1. 准备数据
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
# 2. 定义模型
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 10)
)
# 3. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 4. 训练循环
num_epochs = 5
losses = [] # 记录损失变化
for epoch in range(num_epochs):
model.train() # 设置为训练模式
total_loss = 0
for batch_idx, (images, labels) in enumerate(train_loader):
# 展平图片
images = images.view(-1, 784)
# 前向传播
outputs = model(images)
loss = criterion(outputs, labels)
# 反向传播
optimizer.zero_grad() # 清空梯度
loss.backward() # 计算梯度
optimizer.step() # 更新参数
total_loss += loss.item()
# 每 100 个 batch 打印一次
if batch_idx % 100 == 0:
print(f"Epoch [{epoch+1}/{num_epochs}], Batch [{batch_idx}/{len(train_loader)}], Loss: {loss.item():.4f}")
# 打印每个 epoch 的平均损失
avg_loss = total_loss / len(train_loader)
losses.append(avg_loss)
print(f"Epoch [{epoch+1}/{num_epochs}], 平均损失: {avg_loss:.4f}")
print("训练完成!")
# 5. 绘制损失曲线
plt.figure(figsize=(10, 6))
plt.plot(losses, marker='o')
plt.xlabel('Epoch')
plt.ylabel('损失')
plt.title('训练损失曲线')
plt.grid(True)
plt.show()
运行结果:
学习率是最重要的超参数之一。选错了会怎样?
BatchNorm 是一种让训练更稳定的技术。它在每一层之后对数据进行归一化。
想象一个学生,每次考试前都会紧张。老师教他一个方法:考前做几次深呼吸,让自己平静下来。
BatchNorm 就像这个"深呼吸"——在数据进入下一层之前,先把它调整到一个合适的范围(均值为0,方差为1),让训练更稳定。
import torch.nn as nn
# 1D BatchNorm(用于全连接层)
model = nn.Sequential(
nn.Linear(784, 128),
nn.BatchNorm1d(128), # 批量归一化
nn.ReLU(),
nn.Linear(128, 64),
nn.BatchNorm1d(64), # 批量归一化
nn.ReLU(),
nn.Linear(64, 10)
)
# 2D BatchNorm(用于卷积层)
cnn_model = nn.Sequential(
nn.Conv2d(1, 16, 3, padding=1),
nn.BatchNorm2d(16), # 批量归一化
nn.ReLU(),
nn.Conv2d(16, 32, 3, padding=1),
nn.BatchNorm2d(32), # 批量归一化
nn.ReLU(),
)
# BatchNorm 的好处:
# 1. 加速训练收敛
# 2. 允许使用更大的学习率
# 3. 有轻微的正则化效果
# 4. 减少对权重初始化的敏感性
Dropout 是一种防止过拟合的技术。训练时随机"关掉"一部分神经元。
想象一个学生平时做作业时总抄同桌的答案(过拟合)。老师说:"考试时你不能抄,必须自己想。"
Dropout 就像"闭卷考试"——训练时随机让一些神经元"休息",迫使其他神经元也学会工作。这样模型就不能依赖某几个神经元,必须全面学习。
import torch.nn as nn
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Dropout(0.5), # 50% 的神经元会被随机关闭
nn.Linear(128, 64),
nn.ReLU(),
nn.Dropout(0.3), # 30% 的神经元会被随机关闭
nn.Linear(64, 10)
)
# 重要:训练和测试模式的切换
model.train() # 训练模式:Dropout 生效
# ... 训练代码 ...
model.eval() # 评估模式:Dropout 关闭,所有神经元都参与
# ... 测试代码 ...
# Dropout 率选择:
# 0.1-0.2:轻微正则化
# 0.3-0.5:中等正则化(常用)
# 0.5-0.8:强正则化(数据很少时)
model.train()model.eval()正则化是另一种防止过拟合的方法。它在损失函数上加一个"惩罚项",让权重不要太大。
import torch.optim as optim
# L2 正则化就是权重衰减
# 在优化器中设置 weight_decay 参数
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
# weight_decay 越大,正则化越强
# 常用值:1e-4 到 1e-2
# L2 正则化的原理:
# 在损失函数上加上所有权重的平方和
# loss_new = loss_original + weight_decay * sum(w²)
# 这会惩罚过大的权重,让模型更简单
数据不够怎么办?数据增强通过对现有数据做变换,创造出"新"的训练样本。
from torchvision import transforms
# 训练时使用数据增强
train_transform = transforms.Compose([
transforms.RandomRotation(10), # 随机旋转 ±10 度
transforms.RandomAffine(0, translate=(0.1, 0.1)), # 随机平移
transforms.RandomHorizontalFlip(), # 随机水平翻转(图片分类常用)
transforms.ColorJitter(brightness=0.2, contrast=0.2), # 颜色抖动
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 测试时不使用增强
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
# 数据增强的好处:
# 1. 增加训练数据量
# 2. 让模型对变换更鲁棒
# 3. 减少过拟合
# 4. 几乎免费(不需要额外收集数据)
早停法是在验证集表现不再提升时提前停止训练,防止过拟合。
best_val_loss = float('inf')
patience = 5 # 容忍多少个 epoch 没有提升
counter = 0
best_model_state = None
for epoch in range(100):
# 训练
train_loss = train_one_epoch(model, train_loader, criterion, optimizer)
# 验证
val_loss = evaluate(model, val_loader, criterion)
print(f"Epoch {epoch}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}")
# 检查是否需要早停
if val_loss < best_val_loss:
best_val_loss = val_loss
counter = 0
# 保存最佳模型
best_model_state = model.state_dict().copy()
print(f" → 验证损失下降,保存模型")
else:
counter += 1
print(f" → 验证损失未下降,已连续 {counter} 次")
if counter >= patience:
print(f"早停!在第 {epoch} 个 epoch 停止训练")
break
# 加载最佳模型
model.load_state_dict(best_model_state)
评估模型不只看"准确率"这一个指标。不同场景需要关注不同的指标。
想象你在抓坏人(检测垃圾邮件):
准确率(Accuracy):你抓的人里面,有多少是真正的坏人?
• 公式:正确预测数 / 总预测数
• 例子:100 封邮件,你判断对了 90 封,准确率 = 90%
精确率(Precision):你标记为"垃圾邮件"的里面,有多少真的是垃圾邮件?
• 公式:真正例 / (真正例 + 假正例)
• 例子:你标记了 15 封为垃圾邮件,其中 12 封确实是,精确率 = 80%
召回率(Recall):所有垃圾邮件里面,你抓到了多少?
• 公式:真正例 / (真正例 + 假负例)
• 例子:有 20 封垃圾邮件,你抓到了 12 封,召回率 = 60%
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
# 假设 y_true 是真实标签,y_pred 是模型预测
y_true = [0, 1, 1, 0, 1, 1, 0, 0, 1, 0]
y_pred = [0, 1, 0, 0, 1, 1, 0, 1, 1, 0]
print(f"准确率:{accuracy_score(y_true, y_pred):.2%}") # 80%
print(f"精确率:{precision_score(y_true, y_pred):.2%}") # 80%
print(f"召回率:{recall_score(y_true, y_pred):.2%}") # 80%
print(f"F1 分数:{f1_score(y_true, y_pred):.2%}") # 80%
# F1 分数 = 精确率和召回率的调和平均
# 当精确率和召回率都很高时,F1 才会高
混淆矩阵展示模型在每个类别上的表现,让你看到它"混淆"了哪些数字。
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
# 假设我们有测试集的真实标签和预测标签
y_true = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 100 # 1000个样本
y_pred = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 95 + [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] * 5 # 95%正确
# 计算混淆矩阵
cm = confusion_matrix(y_true, y_pred)
# 可视化
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
xticklabels=range(10), yticklabels=range(10))
plt.xlabel('预测标签')
plt.ylabel('真实标签')
plt.title('混淆矩阵')
plt.show()
这是训练模型时最常见的两个问题:
| 问题 | 训练损失 | 验证损失 | 原因 | 解决方法 |
|---|---|---|---|---|
| 欠拟合 | 大 | 大 | 模型太简单 | 增加层数、增加神经元、训练更久 |
| 过拟合 | 小 | 大 | 模型太复杂 | Dropout、正则化、数据增强、早停 |
| 正常 | 小 | 小 | — | — |
通过观察训练曲线,可以判断模型的状态:
import matplotlib.pyplot as plt
# 假设 train_losses 和 val_losses 是记录的损失值
train_losses = [0.5, 0.3, 0.2, 0.15, 0.12, 0.1, 0.09, 0.08, 0.07, 0.06]
val_losses = [0.6, 0.4, 0.35, 0.33, 0.35, 0.38, 0.42, 0.45, 0.48, 0.5]
plt.figure(figsize=(10, 6))
plt.plot(train_losses, label='训练损失', marker='o')
plt.plot(val_losses, label='验证损失', marker='s')
plt.xlabel('Epoch')
plt.ylabel('损失')
plt.title('训练曲线')
plt.legend()
plt.grid(True)
plt.show()
模型有很多"超参数"需要手动设置,比如学习率、层数、每层神经元数量等。怎么找到最好的组合?
# 常见的超参数
hyperparams = {
'learning_rate': [0.001, 0.01, 0.1],
'batch_size': [32, 64, 128],
'hidden_size': [64, 128, 256],
'dropout_rate': [0.1, 0.3, 0.5],
'num_layers': [2, 3, 4]
}
# 手动调参策略:
# 1. 先用默认值跑一遍,看看 baseline
# 2. 一次只调一个参数,观察效果
# 3. 记录每次实验的结果
# 4. 选择表现最好的组合
# pip install optuna
import optuna
def objective(trial):
# 定义搜索空间
lr = trial.suggest_loguniform('lr', 1e-5, 1e-1)
hidden_size = trial.suggest_categorical('hidden_size', [64, 128, 256])
dropout = trial.suggest_uniform('dropout', 0.1, 0.5)
# 创建模型
model = nn.Sequential(
nn.Linear(784, hidden_size),
nn.ReLU(),
nn.Dropout(dropout),
nn.Linear(hidden_size, 10)
)
# 训练和评估
accuracy = train_and_evaluate(model, lr)
return accuracy
# 运行优化
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)
print(f"最佳参数:{study.best_params}")
print(f"最佳准确率:{study.best_value:.2%}")
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
全连接网络处理图片有个问题:它忽略了图片的空间结构。
想象你在看一张照片:
全连接网络:把照片撕成一条一条的像素,然后看这些像素条。它不知道相邻的像素是有关系的。
CNN:用一个小窗口在照片上滑动,每次只看一小块区域。它能理解"相邻的像素组成线条,线条组成形状"。
卷积就是用一个小的"滤波器"在图片上滑动,对每个位置做计算。
想象你在黑暗的房间里,用手电筒(滤波器)照墙壁(图片):
• 手电筒的光圈大小 = 滤波器大小(如 3×3)
• 你移动手电筒的位置 = 步长(stride)
• 墙上被照亮的区域 = 输出特征图
每次手电筒照到一个区域,你记录下那个区域的"亮度总和"。
| 参数 | 含义 | 常用值 | 说明 |
|---|---|---|---|
| kernel_size | 滤波器大小 | 3×3, 5×5 | 越小参数越少 |
| stride | 步长(每次移动几步) | 1, 2 | 步长越大,输出越小 |
| padding | 边缘填充 | 0, 1 | 保持输出大小 |
| in_channels | 输入通道数 | 1, 3, 16 | 灰度=1, 彩色=3 |
| out_channels | 输出通道数(滤波器数量) | 16, 32, 64 | 越多特征越丰富 |
池化层的作用是缩小特征图的尺寸,减少计算量,同时保留重要信息。
现在让我们用 PyTorch 搭建一个 CNN:
import torch.nn as nn
class SimpleCNN(nn.Module):
def __init__(self):
super().__init__()
# 卷积层
self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1) # 1通道 → 16通道
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1) # 16通道 → 32通道
# 池化层
self.pool = nn.MaxPool2d(2, 2) # 2×2 最大池化
# 全连接层
self.fc1 = nn.Linear(32 * 7 * 7, 128) # 32通道 × 7×7 特征图
self.fc2 = nn.Linear(128, 10)
# 激活函数和 Dropout
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.25)
def forward(self, x):
# 卷积层 1
x = self.pool(self.relu(self.conv1(x))) # [1, 28, 28] → [16, 14, 14]
# 卷积层 2
x = self.pool(self.relu(self.conv2(x))) # [16, 14, 14] → [32, 7, 7]
# 展平
x = x.view(-1, 32 * 7 * 7) # [32, 7, 7] → [1568]
# 全连接层
x = self.dropout(self.relu(self.fc1(x)))
x = self.fc2(x)
return x
# 创建模型
model = SimpleCNN()
print(model)
# 测试前向传播
x = torch.randn(1, 1, 28, 28) # 1张图片
output = model(x)
print(f"输出形状:{output.shape}") # [1, 10]
我们可以可视化 CNN 的卷积核,看看它学到了什么:
import matplotlib.pyplot as plt
# 获取第一个卷积层的权重
conv1_weights = model.conv1.weight.data
# 可视化
fig, axes = plt.subplots(2, 8, figsize=(12, 3))
for i, ax in enumerate(axes.flat):
ax.imshow(conv1_weights[i, 0], cmap='gray')
ax.axis('off')
ax.set_title(f'滤波器 {i}')
plt.suptitle('第一层卷积核')
plt.tight_layout()
plt.show()
| 架构 | 年份 | 特点 | 层数 | Top-5 错误率 |
|---|---|---|---|---|
| LeNet-5 | 1998 | 第一个成功的 CNN,用于手写数字识别 | 5 | — |
| AlexNet | 2012 | 开启了深度学习革命,使用 GPU | 8 | 16.4% |
| VGG | 2014 | 用 3×3 小卷积核堆叠 | 16/19 | 7.3% |
| GoogLeNet | 2014 | 引入 Inception 模块 | 22 | 6.7% |
| ResNet | 2015 | 引入跳跃连接,可以训练很深的网络 | 50/101/152 | 3.6% |
模型做出了预测,但我们想知道为什么。这在很多场景下很重要:
Grad-CAM 是一种可视化技术,可以显示模型在做决策时"看"了图片的哪个部分。
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
def grad_cam(model, image, target_class):
"""
计算 Grad-CAM 热力图
"""
# 设置模型为评估模式
model.eval()
# 注册 hook 获取最后一层卷积的输出
features = None
gradients = None
def forward_hook(module, input, output):
nonlocal features
features = output
def backward_hook(module, grad_input, grad_output):
nonlocal gradients
gradients = grad_output[0]
# 注册 hook
handle_fwd = model.conv2.register_forward_hook(forward_hook)
handle_bwd = model.conv2.register_full_backward_hook(backward_hook)
# 前向传播
output = model(image)
# 反向传播
model.zero_grad()
output[0, target_class].backward()
# 计算权重
weights = torch.mean(gradients, dim=(2, 3), keepdim=True)
# 生成热力图
cam = torch.sum(weights * features, dim=1)
cam = F.relu(cam) # 只关注正向激活
cam = cam - cam.min()
cam = cam / cam.max()
# 移除 hook
handle_fwd.remove()
handle_bwd.remove()
return cam.detach()
# 使用示例
image, label = test_dataset[0]
image = image.unsqueeze(0)
cam = grad_cam(model, image, label)
# 可视化
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
axes[0].imshow(image.squeeze(), cmap='gray')
axes[0].set_title('原始图片')
axes[0].axis('off')
axes[1].imshow(cam.squeeze(), cmap='jet')
axes[1].set_title('Grad-CAM 热力图')
axes[1].axis('off')
axes[2].imshow(image.squeeze(), cmap='gray')
axes[2].imshow(cam.squeeze(), cmap='jet', alpha=0.5)
axes[2].set_title('叠加显示')
axes[2].axis('off')
plt.tight_layout()
plt.show()
我们可以可视化神经网络学到的特征:
# 可视化第一层卷积核学到的特征
def visualize_filters(model):
# 获取第一层卷积的权重
filters = model.conv1.weight.data
# 归一化到 0-1
filters = (filters - filters.min()) / (filters.max() - filters.min())
# 可视化
fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
if i < filters.shape[0]:
ax.imshow(filters[i, 0], cmap='gray')
ax.axis('off')
plt.suptitle('第一层卷积核')
plt.tight_layout()
plt.show()
visualize_filters(model)
LIME(Local Interpretable Model-agnostic Explanations)是另一种解释模型的方法。
想象你问一个复杂的 AI:"为什么这张图片是猫?"
AI 的回答太复杂了,你听不懂。于是你找了一个简单的翻译:
1. 你把图片稍微改一下(比如遮住耳朵、遮住眼睛)
2. 看 AI 对这些修改后的图片怎么判断
3. 用简单的规则总结:"有尖耳朵 → 更可能是猫"
这就是 LIME 的做法——用简单的局部模型来解释复杂模型。
# pip install lime
from lime import lime_image
from lime.wrappers.scikit_image import SegmentationAlgorithm
import numpy as np
from PIL import Image
# 创建 LIME 解释器
explainer = lime_image.LimeImageExplainer()
# 定义预测函数
def predict_fn(images):
"""LIME 需要的预测函数"""
model.eval()
batch = torch.stack([transform(Image.fromarray(img)) for img in images])
with torch.no_grad():
outputs = model(batch)
probs = torch.softmax(outputs, dim=1)
return probs.numpy()
# 解释一张图片
image_np = np.array(Image.open('test_cat.jpg').resize((224, 224)))
# 生成解释
explanation = explainer.explain_instance(
image_np,
predict_fn,
top_labels=2, # 解释前 2 个类别
hide_color=0, # 隐藏区域的颜色
num_samples=1000, # 生成的样本数
)
# 可视化
from lime import lime_image
import matplotlib.pyplot as plt
# 获取解释
temp, mask = explanation.get_image_and_mask(
explanation.top_labels[0],
positive_only=True, # 只显示正向贡献
num_features=5, # 显示前 5 个特征
hide_rest=True # 隐藏其他部分
)
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.imshow(image_np)
plt.title('原始图片')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(temp)
plt.title('LIME 解释')
plt.axis('off')
plt.show()
除了可视化,我们还可以分析哪些特征(像素)对预测最重要:
import torch
import matplotlib.pyplot as plt
def feature_importance(model, image, target_class):
"""分析每个像素对预测的重要性"""
model.eval()
image = image.clone().requires_grad_(True)
# 前向传播
output = model(image)
# 反向传播
output[0, target_class].backward()
# 获取梯度
gradients = image.grad.data
# 计算重要性(梯度的绝对值)
importance = torch.abs(gradients).squeeze()
return importance
# 使用示例
image, label = test_dataset[0]
image = image.unsqueeze(0)
importance = feature_importance(model, image, label)
# 可视化
fig, axes = plt.subplots(1, 3, figsize=(12, 4))
axes[0].imshow(image.squeeze(), cmap='gray')
axes[0].set_title('原始图片')
axes[0].axis('off')
axes[1].imshow(importance.numpy(), cmap='hot')
axes[1].set_title('特征重要性')
axes[1].axis('off')
axes[2].imshow(image.squeeze(), cmap='gray')
axes[2].imshow(importance.numpy(), cmap='hot', alpha=0.5)
axes[2].set_title('叠加显示')
axes[2].axis('off')
plt.tight_layout()
plt.show()
现在让我们把前面学到的所有内容整合成一个完整的项目:
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
# ============ 1. 数据准备 ============
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
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(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# ============ 2. 定义模型 ============
class CNN(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 16, 3, padding=1)
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(32 * 7 * 7, 128)
self.fc2 = nn.Linear(128, 10)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.25)
def forward(self, x):
x = self.pool(self.relu(self.conv1(x)))
x = self.pool(self.relu(self.conv2(x)))
x = x.view(-1, 32 * 7 * 7)
x = self.dropout(self.relu(self.fc1(x)))
x = self.fc2(x)
return x
model = CNN()
# ============ 3. 训练配置 ============
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# ============ 4. 训练模型 ============
num_epochs = 10
train_losses = []
val_losses = []
val_accuracies = []
for epoch in range(num_epochs):
# 训练阶段
model.train()
train_loss = 0
for images, labels in train_loader:
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss += loss.item()
train_losses.append(train_loss / len(train_loader))
# 验证阶段
model.eval()
val_loss = 0
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
outputs = model(images)
loss = criterion(outputs, labels)
val_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
val_losses.append(val_loss / len(test_loader))
accuracy = 100 * correct / total
val_accuracies.append(accuracy)
print(f"Epoch [{epoch+1}/{num_epochs}], "
f"训练损失: {train_losses[-1]:.4f}, "
f"验证损失: {val_losses[-1]:.4f}, "
f"准确率: {accuracy:.2f}%")
# ============ 5. 绘制训练曲线 ============
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
ax1.plot(train_losses, label='训练损失')
ax1.plot(val_losses, label='验证损失')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('损失')
ax1.legend()
ax1.set_title('损失曲线')
ax2.plot(val_accuracies, label='验证准确率')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('准确率 (%)')
ax2.legend()
ax2.set_title('准确率曲线')
plt.tight_layout()
plt.show()
# ============ 6. 保存模型 ============
torch.save(model.state_dict(), 'mnist_cnn.pth')
print("模型已保存!")
# 保存模型(只保存参数)
torch.save(model.state_dict(), 'mnist_cnn.pth')
# 加载模型
model = CNN()
model.load_state_dict(torch.load('mnist_cnn.pth'))
model.eval() # 切换到评估模式
# 保存完整模型(包括结构)
torch.save(model, 'mnist_cnn_full.pth')
# 加载完整模型
model = torch.load('mnist_cnn_full.pth')
model.eval()
Gradio 是一个快速创建 AI Demo 的工具,几行代码就能做出一个网页应用:
pip install gradio
import gradio as gr
import torch
from PIL import Image
import numpy as np
from torchvision import transforms
# 加载模型
model = CNN()
model.load_state_dict(torch.load('mnist_cnn.pth'))
model.eval()
# 定义预测函数
def predict(image):
# 预处理
if image is None:
return {str(i): 0.0 for i in range(10)}
# 转换图片
image = Image.fromarray(image).convert('L').resize((28, 28))
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
image = transform(image).unsqueeze(0)
# 预测
with torch.no_grad():
output = model(image)
probabilities = torch.softmax(output, dim=1)[0]
# 返回概率字典
return {str(i): float(probabilities[i]) for i in range(10)}
# 创建界面
demo = gr.Interface(
fn=predict,
inputs=gr.Sketchpad(shape=(28, 28)),
outputs=gr.Label(num_top_classes=3),
title="手写数字识别",
description="在画布上写一个数字,模型会识别它是几"
)
# 启动
demo.launch()
ONNX 是一种通用的模型格式,可以在不同框架之间转换:
# 导出为 ONNX 格式
dummy_input = torch.randn(1, 1, 28, 28)
torch.onnx.export(model, dummy_input, "mnist_cnn.onnx",
input_names=['input'], output_names=['output'])
print("模型已导出为 ONNX 格式!")
# ONNX 的好处:
# 1. 跨框架使用(PyTorch → TensorFlow → 移动端)
# 2. 更快的推理速度
# 3. 更小的模型体积
torch.save(model.state_dict(), 'model.pth')model.load_state_dict(torch.load('model.pth'))这是一个经典的二分类项目。相比 MNIST,猫狗分类更具挑战性:
MNIST:28×28 灰度图,背景干净,数字居中
猫狗分类:224×224 彩色图,背景复杂,动物位置不固定
所以我们需要更强大的模型和更多的技巧。
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
# 训练时使用数据增强
train_transform = transforms.Compose([
transforms.Resize((224, 224)), # 调整大小
transforms.RandomHorizontalFlip(), # 随机水平翻转
transforms.RandomRotation(15), # 随机旋转
transforms.ColorJitter(brightness=0.2, contrast=0.2), # 颜色抖动
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], # ImageNet 的均值
std=[0.229, 0.224, 0.225]) # ImageNet 的标准差
])
# 测试时不使用增强
test_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
# 加载数据集
# 假设目录结构:data/train/cats/, data/train/dogs/
train_dataset = datasets.ImageFolder('data/train', transform=train_transform)
test_dataset = datasets.ImageFolder('data/test', transform=test_transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
print(f"类别:{train_dataset.classes}") # ['cats', 'dogs']
print(f"训练集:{len(train_dataset)} 张")
print(f"测试集:{len(test_dataset)} 张")
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import models
# 使用预训练的 ResNet18
model = models.resnet18(pretrained=True)
# 冻结所有层(不训练)
for param in model.parameters():
param.requires_grad = False
# 替换最后一层(二分类)
# ResNet18 最后一层是 fc: 512 → 1000
# 我们改成:512 → 2
model.fc = nn.Linear(512, 2)
# 只训练最后一层
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
# 训练循环
num_epochs = 10
for epoch in range(num_epochs):
model.train()
train_loss = 0
correct = 0
total = 0
for images, labels in train_loader:
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss/len(train_loader):.4f}, Acc: {accuracy:.2f}%")
# 保存模型
torch.save(model.state_dict(), 'cat_dog_model.pth')
这是一个 NLP 项目,判断一段文字是正面还是负面评价:
import torch
from collections import Counter
# 示例数据
texts = [
"这部电影太好看了,强烈推荐!",
"演技很差,浪费时间",
"剧情精彩,值得一看",
"无聊透顶,看不下去",
# ... 更多数据
]
labels = [1, 0, 1, 0] # 1=正面, 0=负面
# 1. 分词(中文需要分词工具)
# 这里用简单的字符级分词
def tokenize(text):
return list(text) # 每个字符作为一个 token
# 2. 建立词汇表
all_tokens = []
for text in texts:
all_tokens.extend(tokenize(text))
counter = Counter(all_tokens)
vocab = {word: idx+2 for idx, (word, _) in enumerate(counter.most_common(1000))}
vocab[''] = 0 # 填充
vocab[''] = 1 # 未知词
print(f"词汇表大小:{len(vocab)}")
# 3. 文本转数字序列
def text_to_sequence(text, vocab, max_len=50):
tokens = tokenize(text)
sequence = [vocab.get(token, vocab['']) for token in tokens]
# 填充或截断
if len(sequence) < max_len:
sequence += [vocab['']] * (max_len - len(sequence))
else:
sequence = sequence[:max_len]
return sequence
# 4. 创建 Dataset
class SentimentDataset(torch.utils.data.Dataset):
def __init__(self, texts, labels, vocab, max_len=50):
self.texts = texts
self.labels = labels
self.vocab = vocab
self.max_len = max_len
def __len__(self):
return len(self.texts)
def __getitem__(self, idx):
sequence = text_to_sequence(self.texts[idx], self.vocab, self.max_len)
return torch.tensor(sequence), torch.tensor(self.labels[idx])
dataset = SentimentDataset(texts, labels, vocab)
loader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True)
class SentimentModel(nn.Module):
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes=2):
super().__init__()
# 词嵌入层:把数字转换成向量
self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
# LSTM 层:处理序列数据
self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True, num_layers=2, dropout=0.3)
# 全连接层:分类
self.fc = nn.Linear(hidden_dim, num_classes)
self.dropout = nn.Dropout(0.5)
def forward(self, x):
# x: [batch_size, seq_len]
embedded = self.embedding(x) # [batch_size, seq_len, embed_dim]
lstm_out, (h_n, c_n) = self.lstm(embedded) # h_n: [2, batch_size, hidden_dim]
# 取最后一层的隐藏状态
hidden = h_n[-1] # [batch_size, hidden_dim]
hidden = self.dropout(hidden)
output = self.fc(hidden) # [batch_size, num_classes]
return output
# 创建模型
vocab_size = len(vocab)
model = SentimentModel(vocab_size, embed_dim=128, hidden_dim=64)
# 训练
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
这是一个回归项目,预测房价:
import torch
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# 示例数据(实际项目中从文件加载)
# 特征:面积、卧室数、楼层、建筑年份、距离地铁距离
np.random.seed(42)
n_samples = 1000
area = np.random.uniform(50, 200, n_samples) # 面积 50-200 平米
bedrooms = np.random.randint(1, 5, n_samples) # 卧室 1-4
floor_num = np.random.randint(1, 30, n_samples) # 楼层 1-30
year_built = np.random.randint(1990, 2024, n_samples) # 建筑年份
distance_metro = np.random.uniform(0.1, 5, n_samples) # 距地铁距离 km
# 生成房价(简化模型)
price = (area * 3 +
bedrooms * 20 +
floor_num * 5 +
(year_built - 1990) * 10 -
distance_metro * 50 +
np.random.normal(0, 50, n_samples)) # 添加噪声
# 组合特征
X = np.column_stack([area, bedrooms, floor_num, year_built, distance_metro])
y = price
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 标准化特征
scaler = X StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# 转换为 Tensor
X_train = torch.FloatTensor(X_train)
X_test = torch.FloatTensor(X_test)
y_train = torch.FloatTensor(y_train).unsqueeze(1)
y_test = torch.FloatTensor(y_test).unsqueeze(1)
print(f"训练集:{X_train.shape[0]} 个样本")
print(f"特征数:{X_train.shape[1]}")
class RegressionModel(nn.Module):
def __init__(self, input_size):
super().__init__()
self.fc1 = nn.Linear(input_size, 64)
self.fc2 = nn.Linear(64, 32)
self.fc3 = nn.Linear(32, 1)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.2)
self.bn1 = nn.BatchNorm1d(64)
self.bn2 = nn.BatchNorm1d(32)
def forward(self, x):
x = self.dropout(self.relu(self.bn1(self.fc1(x))))
x = self.dropout(self.relu(self.bn2(self.fc2(x))))
x = self.fc3(x)
return x
# 创建模型
model = RegressionModel(input_size=5)
# 使用 MSE 损失(回归问题)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 训练
num_epochs = 100
for epoch in range(num_epochs):
model.train()
outputs = model(X_train)
loss = criterion(outputs, y_train)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (epoch + 1) % 20 == 0:
# 计算 MAE
with torch.no_grad():
mae = torch.mean(torch.abs(outputs - y_train))
print(f"Epoch [{epoch+1}/{num_epochs}], MSE Loss: {loss.item():.4f}, MAE: {mae.item():.4f}")
# 评估
model.eval()
with torch.no_grad():
predictions = model(X_test)
test_mse = criterion(predictions, y_test)
test_mae = torch.mean(torch.abs(predictions - y_test))
print(f"\n测试集 MSE: {test_mse.item():.4f}")
print(f"测试集 MAE: {test_mae.item():.4f} 万元")
Transformer 的核心是自注意力机制。它让模型能够"关注"输入中最重要的部分。
当你读一篇长文章时,你会自动"关注"重要的句子,忽略不重要的。比如读新闻时,你会关注"谁、什么时间、做了什么",而忽略一些修饰词。
自注意力机制做的事情类似:它计算每个词和其他词之间的"相关性",然后重点关注相关的词。
import torch
import torch.nn as nn
import math
class TransformerClassifier(nn.Module):
def __init__(self, vocab_size, d_model=128, nhead=4, num_layers=2, num_classes=2):
super().__init__()
# 词嵌入
self.embedding = nn.Embedding(vocab_size, d_model)
# 位置编码(Transformer 没有循环,需要告诉模型词的位置)
self.pos_encoder = PositionalEncoding(d_model)
# Transformer 编码器
encoder_layer = nn.TransformerEncoderLayer(
d_model=d_model,
nhead=nhead,
dim_feedforward=512,
dropout=0.1
)
self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
# 分类头
self.fc = nn.Linear(d_model, num_classes)
def forward(self, x):
# x: [batch_size, seq_len]
# 词嵌入 + 位置编码
x = self.embedding(x) # [batch_size, seq_len, d_model]
x = self.pos_encoder(x)
# Transformer 处理
x = x.permute(1, 0, 2) # [seq_len, batch_size, d_model]
x = self.transformer(x)
x = x.permute(1, 0, 2) # [batch_size, seq_len, d_model]
# 取 [CLS] token 或平均池化
x = x.mean(dim=1) # [batch_size, d_model]
# 分类
x = self.fc(x) # [batch_size, num_classes]
return x
class PositionalEncoding(nn.Module):
def __init__(self, d_model, max_len=5000):
super().__init__()
pe = torch.zeros(max_len, d_model)
position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
pe = pe.unsqueeze(0)
self.register_buffer('pe', pe)
def forward(self, x):
return x + self.pe[:, :x.size(1)]
# 使用示例
vocab_size = 10000
model = TransformerClassifier(vocab_size)
# 测试
x = torch.randint(0, vocab_size, (2, 50)) # batch_size=2, seq_len=50
output = model(x)
print(f"输出形状:{output.shape}") # [2, 2]
迁移学习是使用别人已经训练好的模型,在此基础上进行微调。
from torchvision import models
# 加载预训练的 ResNet18
model = models.resnet18(pretrained=True)
# 冻结所有层
for param in model.parameters():
param.requires_grad = False
# 只训练最后一层
model.fc = nn.Linear(512, 10) # 替换为你的分类数
# 只有最后一层会被训练
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
# 迁移学习的好处:
# 1. 训练更快(不需要从头学)
# 2. 需要的数据更少
# 3. 效果通常更好
# 4. 可以用在小数据集上
| 技术 | 原理 | 效果 | 适用场景 |
|---|---|---|---|
| 剪枝 | 删除不重要的权重 | 模型变小 2-10 倍 | 减少模型大小 |
| 量化 | 用低精度(如 INT8)代替浮点数 | 模型变小 4 倍,速度变快 | 边缘设备部署 |
| 知识蒸馏 | 用大模型教小模型 | 小模型获得大模型的能力 | 模型压缩 |
| 功能 | 代码 | 说明 |
|---|---|---|
| 创建张量 | torch.tensor([1, 2, 3]) | 从列表创建 |
| 随机初始化 | torch.randn(3, 4) | 标准正态分布 |
| 全零张量 | torch.zeros(3, 4) | 全 0 |
| 全一张量 | torch.ones(3, 4) | 全 1 |
| 形状变换 | x.view(-1, 784) | 展平 |
| 转到 GPU | x.to('cuda') | GPU 加速 |
| 线性层 | nn.Linear(in, out) | 全连接层 |
| 卷积层 | nn.Conv2d(in_ch, out_ch, kernel) | 2D 卷积 |
| 池化层 | nn.MaxPool2d(2, 2) | 最大池化 |
| 激活函数 | nn.ReLU() | ReLU 激活 |
| 损失函数 | nn.CrossEntropyLoss() | 交叉熵 |
| 优化器 | optim.Adam(params, lr) | Adam 优化器 |
| 英文 | 中文 | 解释 |
|---|---|---|
| Epoch | 轮次 | 完整遍历一次训练集 |
| Batch Size | 批量大小 | 每次训练的样本数 |
| Learning Rate | 学习率 | 参数更新的步长 |
| Loss | 损失 | 预测和真实值的差距 |
| Gradient | 梯度 | 参数更新的方向和大小 |
| Backpropagation | 反向传播 | 计算梯度的算法 |
| Overfitting | 过拟合 | 模型只记住了训练数据 |
| Underfitting | 欠拟合 | 模型太简单,没学会 |
| Regularization | 正则化 | 防止过拟合的技术 |
| Feature | 特征 | 输入数据的属性 |
| Weight | 权重 | 可学习的参数 |
| Bias | 偏置 | 可学习的偏移量 |
| Activation | 激活函数 | 引入非线性的函数 |
| Convolution | 卷积 | 用滤波器提取特征 |
| Pooling | 池化 | 缩小特征图尺寸 |
| Dropout | 随机失活 | 训练时随机关闭神经元 |
| BatchNorm | 批量归一化 | 稳定训练的技术 |
| Transfer Learning | 迁移学习 | 使用预训练模型 |
所有代码都可以在 GitHub 上找到:github.com/your-username/from-zero-to-model
model = model.to('cuda')data = data.to('cuda')
print(x.shape) 调试。
| 类型 | 资源 | 说明 |
|---|---|---|
| 视频课程 | 吴恩达《深度学习》 | Coursera 上的经典课程 |
| 视频课程 | 李宏毅《机器学习》 | B站免费,中文讲解 |
| 视频课程 | 3Blue1Brown | 最直观的数学可视化 |
| 书籍 | 《动手学深度学习》 | d2l.ai,代码丰富 |
| 书籍 | 《深度学习》(花书) | 经典教材 |
| 实践 | Kaggle | 数据科学竞赛平台 |
| 实践 | Hugging Face | 预训练模型库 |
| 文档 | PyTorch 官方文档 | pytorch.org |