从零创造一个小模型

15 章完整教程 · 从一个神经元到完整 CNN · 从零基础到能动手做项目

零基础友好 · 每个概念都讲透 · 配有生活类比 · 全程可运行代码 · 含 PyTorch 实战 · 新增:CNN可视化 / Grad-CAM / 迁移学习 / 模型压缩 / 3个实战项目

第一章:开篇——为什么要自己造模型?

1.1 AI 模型到底是什么?

你可能听说过 ChatGPT、人脸识别、自动驾驶这些 AI 应用。它们背后都有一个共同的核心——模型。那模型到底是什么呢?

简单来说,模型就是一个数学函数。它接收输入,经过一系列计算,给出输出。这句话听起来很抽象,让我们用几个例子来理解:

类比一:模型是一个"万能翻译器"

想象你有一个神奇的翻译器:

• 你扔进去一张猫的照片,它告诉你"这是猫"
• 你扔进去一段英文,它告诉你中文意思
• 你扔进去一段语音,它告诉你文字内容

这个"翻译器"就是模型。它学会了一种"翻译规则"——把输入转换成输出。

类比二:模型是一个"经验丰富的老师傅"

想象一个有 30 年经验的老中医:

• 你告诉他症状(输入),他就能诊断你得了什么病(输出)
• 他的"诊断能力"来自于几十年看过的无数病人(训练数据)
• 他脑子里有一套"诊断规则"(模型参数)

模型也一样:通过大量数据"学习",形成一套"规则",然后用这套规则来做预测。

更具体地说,模型的本质是这样的:

模型 = 一个数学函数 输入 → [一堆数学运算] → 输出 举例: • 输入:一张 28×28 的手写数字图片(784 个像素值) • 数学运算:几百万个参数进行加权求和、非线性变换 • 输出:10 个概率值(代表数字 0-9 的可能性) 用数学语言表示: output = f(x; θ) 其中: • x = 输入(比如图片像素) • θ = 参数(几百万个数字,需要通过训练学习) • f = 函数(神经网络的结构) • output = 输出(预测结果)

模型的三个核心要素

1
结构(Architecture)——决定这个数学函数长什么样。就像盖房子的图纸,决定了房子有几层、每层多大。比如:全连接网络、卷积神经网络(CNN)、循环神经网络(RNN)、Transformer 等。
2
参数(Parameters)——函数里的那些"可调节的数字"。一个大模型可能有几十亿个参数。训练的过程就是不断调整这些参数,让模型的预测越来越准。
3
训练(Training)——通过数据来学习参数的过程。就像学生做练习题,通过不断练习来提高成绩。

一个具体的例子:房价预测模型

让我们用一个最简单的例子来理解模型。假设我们要预测房价:

最简单的房价预测模型
# 输入:房屋面积(平方米)
# 输出:预测价格(万元)

# 最简单的模型:线性模型
# 价格 = 面积 × 权重 + 偏置

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
从简单到复杂 上面的房价预测模型只有 2 个参数。而像 ChatGPT 这样的大模型,有 1750 亿个参数(GPT-3)甚至更多。但本质是一样的——都是一个数学函数,只是更复杂而已。

本教程会带你从最简单的模型开始,一步步搭建更复杂的模型。

1.2 "造模型" vs "用现成模型"

现在有很多现成的 AI 工具和 API,比如 ChatGPT、百度文心一言、通义千问。为什么还要学习自己造模型呢?

对比维度用现成模型自己造模型
上手难度很简单,调用 API 即可需要学习原理和代码
灵活性受限于 API 提供的功能完全自由,想怎么改就怎么改
数据隐私数据要上传到云端数据完全在本地
成本按调用次数付费,长期成本高只有硬件成本,长期成本低
理解深度知其然不知其所以然真正理解 AI 是怎么工作的
适用场景通用任务、快速验证特定领域、定制化需求
离线使用需要联网可以完全离线
可控性黑盒,不知道内部发生了什么完全透明,可以调试和优化

什么时候该用现成模型?

适合用现成模型的场景 • 你的需求是通用的(比如文本翻译、语音识别、图片生成)
• 你只是想快速验证一个想法,不想投入太多时间
• 你没有专业的 AI 团队
• 你对数据隐私要求不高
• 你的预算充足,可以持续支付 API 费用

什么时候该自己造模型?

适合自己造模型的场景 • 你有特定的数据集,需要定制化训练(比如识别你的手写体、你的产品缺陷)
• 你想深入理解 AI 底层原理(学习、研究、面试)
• 你需要部署到边缘设备(手机、嵌入式设备、IoT)
• 你对数据隐私有严格要求(医疗、金融、政府)
• 你需要长期大规模使用,API 成本太高
• 你想做 AI 相关的工作或研究

1.3 本教程的目标:手写数字识别器

在这 15 章的旅程中,我们将从零开始构建一个手写数字识别器。这是一个经典的入门项目,原因如下:

1
数据简单——MNIST 数据集是灰度图片,只有 28×28 像素(784 个像素点),不需要强大的电脑就能处理。每张图片只有 784 个数字,而不是像高清照片那样有几百万个像素。
2
任务明确——识别 0-9 十个数字,是一个清晰的 10 分类问题。输出只有 10 种可能,容易理解和评估。
3
效果直观——你可以亲眼看到模型识别对不对,有成就感。不像某些任务(比如预测股票),效果很难直观判断。
4
经典地位——就像编程界的 "Hello World",深度学习界的入门项目就是 MNIST。几乎所有深度学习教程都从它开始。
5
资料丰富——网上有大量关于 MNIST 的教程、论文、代码,遇到问题很容易找到解决方案。

最终成果预览

你将能够: 1. 搭建一个神经网络(从单个神经元 → 多层网络 → CNN) 2. 用 MNIST 数据集训练它 3. 达到 98%+ 的识别准确率(100 张图片只错 1-2 张) 4. 做一个网页 Demo,上传手写数字照片实时识别 5. 理解模型内部在"看"什么(可视化) 6. 掌握举一反三,能做类似的项目(猫狗分类、情感分析等)

学习成果示例

训练完成后,你可以这样使用模型
# 加载训练好的模型
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

1.4 硬件要求:CPU vs GPU,普通电脑能跑吗?

这是很多初学者最关心的问题。答案是:普通电脑完全够用!

CPU vs GPU 的区别

CPU vs GPU = 一个人 vs 一群人

CPU 就像一个全能型人才:
• 能做任何事情
• 每件事都做得很好
• 但一次只能做一件事(或者说几件事)

GPU 就像一群普通工人:
• 每个人只会做简单的事情
• 但有成千上万个工人
• 可以同时做很多件事

深度学习的计算特点是"大量简单的重复运算",所以 GPU 更适合。

硬件能否运行训练速度适合场景成本
普通笔记本(CPU)✅ 可以较慢(几分钟到十几分钟)本教程的所有内容免费(你已有的电脑)
有独立显卡的电脑✅ 可以快 5-10 倍本教程 + 更大的模型免费(你已有的电脑)
Google Colab(免费)✅ 可以快 10-50 倍中等规模模型免费
云 GPU(按需付费)✅ 可以快 50-100 倍大型模型训练几元/小时
专业 GPU(A100/H100)✅ 可以极快工业级模型训练几十元/小时
好消息:本教程使用 MNIST 数据集 MNIST 非常小(只有 60000 张训练图片,每张只有 28×28 像素),用 CPU 训练一个简单网络只需要几分钟。即使你只有最普通的笔记本电脑,也能顺利完成所有内容。

我们会在第三章详细介绍如何使用 Google Colab(免费 GPU),如果你以后想训练更大的模型。

如何查看你的电脑配置

Windows 查看方法
# 方法一:任务管理器
# 按 Ctrl + Shift + Esc 打开任务管理器
# 点击"性能"标签,可以看到 CPU 和 GPU 信息

# 方法二:命令行
# 按 Win + R,输入 cmd 回车
# 输入以下命令:
wmic cpu get name          # 查看 CPU 型号
wmic path win32_videocontroller get name  # 查看 GPU 型号
Python 查看方法
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 训练")

1.5 学习路线图

下面是我们的学习路线,从基础到进阶,循序渐进:

第1-3章
基础准备概念理解 + 数学基础 + 环境搭建(约 2-3 小时)
第4-5章
数据先行机器学习概念 + 数据处理(约 2-3 小时)
第6-7章
网络搭建从单个神经元到完整网络(约 3-4 小时)
第8-9章
训练优化训练过程 + 各种优化技巧(约 3-4 小时)
第10-11章
评估进阶模型评估 + CNN 架构(约 3-4 小时)
第12-15章
实战应用模型解释 + 部署 + 扩展项目(约 4-5 小时)
预计总时长:15-20 小时 如果你每天学习 2 小时,大约 1-2 周可以完成。建议不要急于求成,每章学完后动手练习,确保理解了再继续。

1.6 学习建议

在正式开始之前,有几条建议:

1
一定要动手写代码。看懂了不等于学会了。就像看别人游泳和自己下水是两回事。每个代码示例都要自己敲一遍运行,不要复制粘贴。
2
不要怕数学。本教程会用最通俗的方式解释数学概念,你只需要初中数学基础就够了。如果某个公式看不懂,看文字解释就行,不需要手算。
3
遇到报错不要慌。报错信息是你的朋友,它在告诉你哪里出了问题。99% 的问题都能通过搜索引擎解决。复制报错信息,粘贴到搜索引擎,你就能找到答案。
4
先跑通再理解。有些概念第一遍看不懂没关系,先把代码跑通看到结果,再回头理解原理。就像学骑自行车,先骑起来,再研究平衡原理。
5
做笔记。把重要的概念、代码、自己的理解记录下来。这不仅帮助记忆,以后复习时也很有用。
6
加入社区。遇到问题可以到 GitHub、知乎、CSDN 等社区提问。也可以加入学习群,和其他同学一起讨论。
学习造模型就像学做菜

第一次做菜,你不需要知道为什么要放盐、为什么油温要七成热。你只需要按照菜谱一步步来,最后能吃到一盘菜。等你做了很多次之后,自然就理解了背后的原理。

学习造模型也一样——先跟着教程写代码,看到模型能识别数字了,有了成就感,再慢慢深入理解每一行代码在做什么。

本教程的约定 • 代码示例基于 PyTorch 框架(目前最流行的深度学习框架之一)
• 所有代码都可以直接复制运行
• 难懂的概念都会配生活类比
• 重要概念会用 加粗 标注
• 踩坑提醒会用红色 callout 标出
• 代码中的注释会解释每一行的作用

1.7 本章小结

本章要点回顾 • 模型 = 一个数学函数,接收输入,给出输出
• 模型有三个核心要素:结构、参数、训练
• 自己造模型 vs 用现成模型,各有优缺点
• 本教程目标:手写数字识别器(MNIST)
• 普通电脑(CPU)就能完成本教程所有内容
• 学习建议:动手写代码、不怕数学、先跑通再理解

第二章:数学基础——只需要这些就够了

2.1 你真的需要数学吗?

很多人一听到"深度学习"就害怕,觉得需要很高深的数学。其实本教程只需要初中数学基础就够了。

好消息:你不需要成为数学家 你不需要:
• 线性代数专家——不需要手算矩阵乘法
• 微积分大师——不需要手动求导
• 概率论教授——不需要推导公式

你只需要:
• 知道什么是乘法和加法(小学水平)
• 理解"斜率"的概念(初中水平)——上坡还是下坡
• 知道概率就是"可能性的大小"(初中水平)
• 会用计算器(或者让 Python 帮你算)
数学 vs 开车

深度学习的数学就像汽车的发动机——你可以开车而不需要懂发动机原理。但如果你想成为赛车手(调参高手),就需要深入了解发动机(数学)了。

本教程的目标是让你先学会开车,发动机的知识以后慢慢补。

2.2 向量和矩阵——用 Excel 理解

在深度学习中,数据通常用向量和矩阵来表示。听起来很高大上,其实就是数字的排列方式。

什么是向量?

向量 = 一行数字

想象 Excel 表格中的一行:

[170, 65, 25] 可以表示一个人的 [身高cm, 体重kg, 年龄]

这一行数字就是一个向量。就这么简单!

向量可以表示很多东西:
• [红, 绿, 蓝] = 一个颜色(RGB 值)
• [x, y] = 一个点的坐标
• [像素1, 像素2, ..., 像素784] = 一张 28×28 的图片

Python 中的向量
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列 的数字表格就是一个矩阵。

矩阵可以表示:
• 多个人的信息(行=人,列=特征)
• 一张图片(行=行像素,列=列像素)
• 一个神经网络的权重(行=输入神经元,列=输出神经元)

Python 中的矩阵
# 创建一个矩阵(一个表格)
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
为什么深度学习需要矩阵运算? 因为 GPU 擅长并行计算矩阵。把数据组织成矩阵形式,可以一次性处理成千上万个数据,速度比逐个处理快得多。

举个例子:
• 逐个处理 1000 张图片,需要循环 1000 次
• 用矩阵运算,可以一次性处理 1000 张图片,只需要 1 次计算

这就是为什么深度学习离不开 GPU。

2.3 导数——就是"变化的速度"

导数是微积分的核心概念,但你不需要懂微积分。只需要理解一个直觉:

导数 = 开车的速度表

想象你在开车:
• 位置 = 你在哪里(比如离家 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!

# 这就是梯度下降的核心思想!
不需要手动算导数! PyTorch 会自动帮你计算导数(这叫"自动微分")。你只需要理解导数的意义——它告诉你"该往哪个方向调整参数"。

就像你不需要手动计算汽车的速度,速度表会自动显示一样。

2.4 概率——可能性的大小

概率就是"某件事发生的可能性有多大",用 0 到 1 之间的数字表示:

概率的范围: 0 = 不可能发生(0%) 0.5 = 一半一半(50%) 1 = 一定会发生(100%) 举例: • 抛硬币正面朝上的概率 = 0.5(50%) • 明天太阳从东边升起的概率 ≈ 1.0(99.99...%) • 买彩票中头奖的概率 ≈ 0.0000001(几乎不可能) • 掷骰子掷出 6 的概率 = 1/6 ≈ 0.167(约 16.7%)

概率在深度学习中的应用

在深度学习中,模型的输出通常是一组概率值。比如识别手写数字时:

模型输出示例
# 模型看到一张手写数字图片后,输出 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:把数字变成概率

模型的原始输出是任意数字(可能是负数,也可能很大),我们需要把它转换成概率。这个转换叫 Softmax:

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

2.5 损失函数:衡量"错得有多离谱"

损失函数是另一个重要概念。它衡量模型的预测和正确答案之间的差距。

损失函数 = 考试扣分

想象考试满分 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}")  # 损失值会更大

2.6 数学不好怎么办?

如果你看到这里还是有点懵,没关系!有几个建议:

1
先动手写代码。很多时候,代码比公式更直观。你可以先跑通代码,再回头理解数学。
2
用 3Blue1Brown 的视频。B站搜索"3Blue1Brown 线性代数/微积分",有最直观的数学可视化讲解。强烈推荐!
3
记住直觉就够了。你不需要手算矩阵乘法或求导,只需要理解它们的意义。计算机帮你算。
4
遇到公式先跳过。本教程的所有公式都有直觉解释。如果公式看不懂,看文字解释就行。
5
用 ChatGPT 帮你解释。把看不懂的公式发给 ChatGPT,让它用通俗的语言解释。
数学是工具,不是目的 数学是帮助我们理解模型的工具,但不是学习的障碍。就像你不需要懂发动机原理也能开车一样,你不需要成为数学家也能训练模型。

当你需要深入优化模型时,再慢慢补数学也不迟。

2.7 本章小结

本章要点回顾 • 向量 = 一行数字,矩阵 = 一个表格
• 矩阵乘法 = 配对求和,是深度学习的核心运算
• 导数 = 变化的速度,告诉参数该往哪个方向调整
• 概率 = 可能性的大小,模型输出通常是一组概率
• 损失函数 = 衡量预测和正确答案的差距
• 不需要精通数学,理解直觉就够了

第三章:环境搭建——30分钟准备就绪

3.1 安装 Python 和 Anaconda

首先我们需要安装 Python。推荐使用 Anaconda,它是一个 Python 发行版,自带了很多数据科学需要的库,省去逐个安装的麻烦。

为什么推荐 Anaconda?

对比原生 PythonAnaconda
库管理需要手动逐个安装自带 250+ 常用库
环境管理需要额外工具自带 conda 环境管理
包管理pipconda + pip
适合人群有经验的开发者初学者、数据科学

安装步骤

1
下载 Anaconda:访问 anaconda.com/download,下载对应系统的版本(Windows/macOS/Linux)。文件大约 800MB。
2
运行安装程序:双击下载的文件,按照提示安装。所有选项保持默认即可。安装路径不要有中文或空格。
3
验证安装:打开终端(Windows: Anaconda Prompt;macOS: Terminal),输入:
终端
python --version
# 输出类似:Python 3.11.5

conda --version
# 输出类似:conda 23.7.4

# 如果输出版本号,说明安装成功!
Windows 用户注意 安装完成后,从开始菜单找到 Anaconda Prompt 并打开。不要用系统自带的 cmd,因为 Anaconda Prompt 会自动配置好环境变量。

3.2 安装 PyTorch

PyTorch 是目前最流行的深度学习框架之一,由 Meta(Facebook)开发。它的优点是简单易学、调试方便、社区活跃。

为什么选择 PyTorch?

框架特点使用者
PyTorch简单易学、动态图、调试方便Meta、特斯拉、大多数研究者
TensorFlow工业部署强、生态完善Google、很多企业
JAX高性能、函数式编程Google DeepMind
选择建议 如果你是初学者,推荐 PyTorch。它的语法最接近原生 Python,学习曲线最平缓。而且目前学术界主流都是 PyTorch,论文代码大多是 PyTorch 实现。

安装步骤

1
访问 PyTorch 官网:打开 pytorch.org,找到 "Get Started" → "Start Locally"。
2
选择配置:
• PyTorch Build: Stable(稳定版)
• Your OS: Windows / macOS / Linux
• Package: Pip 或 Conda(推荐 Pip)
• Language: Python
• Compute Platform: CPU(如果你没有 NVIDIA 显卡就选 CPU)
3
复制安装命令并粘贴到终端运行:
使用 Pip 安装(CPU 版本)
pip install torch torchvision torchaudio
使用 Conda 安装(CPU 版本)
conda install pytorch torchvision torchaudio cpuonly -c pytorch
4
验证安装:
Python 交互环境
import torch
print(torch.__version__)  # 输出类似:2.1.0
print(torch.cuda.is_available())  # 如果是 CPU 版本,输出 False,这是正常的
CUDA 版本选择 如果你有 NVIDIA 显卡,可以选择 CUDA 版本(GPU 加速)。在 PyTorch 官网选择对应的 CUDA 版本,安装命令会不同。

如果你不确定,就选 CPU 版本,本教程所有内容都能用 CPU 完成。

3.3 Jupyter Notebook 使用速成

Jupyter Notebook 是数据科学和深度学习最常用的工具。它可以让你一段一段地运行代码,边写边看结果,非常适合学习和实验。

为什么用 Jupyter?

Jupyter = 交互式笔记本

想象你在做实验:

普通 Python 脚本:写完整个程序才能运行,像写作文。

Jupyter Notebook:可以写一段运行一段,像做实验。写一行代码,运行看看结果,不对就改,再运行。非常灵活!

特别适合:
• 学习新知识(边学边练)
• 数据分析(探索数据)
• 模型实验(快速迭代)

启动 Jupyter

1
启动 Jupyter:在终端输入以下命令,浏览器会自动打开 Jupyter 界面。
终端
jupyter notebook

# 或者使用 Jupyter Lab(更现代的界面)
jupyter lab
2
创建新笔记本:点击右上角 "New" → "Python 3"。
3
运行代码:在单元格中输入代码,按 Shift + Enter 运行。

常用快捷键

Jupyter 快捷键(必须掌握) • Shift + Enter:运行当前单元格
• Ctrl + Enter:运行当前单元格,保持选中
• Esc + A:在上方插入新单元格
• Esc + B:在下方插入新单元格
• Esc + DD:删除当前单元格
• Esc + M:转为 Markdown(写笔记)
• Esc + Y:转为 Code(写代码)
• Ctrl + S:保存

3.4 必备库速览

除了 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__}")

3.5 使用 Google Colab(免费 GPU)

如果你的电脑没有显卡,或者想用更快的 GPU 训练,可以用 Google Colab——它提供免费的 Jupyter Notebook 环境,还自带 GPU。

Colab 的优势

Google Colab 的好处 • 免费使用 GPU(Tesla T4,比大多数笔记本 GPU 强)
• 不用在自己电脑上装环境
• 代码和结果保存在云端(Google Drive)
• 随时随地可以访问(有浏览器就行)
• 预装了所有常用库(PyTorch、TensorFlow、NumPy 等)

本教程的所有代码都可以在 Colab 中直接运行。

使用步骤

1
打开 Colab:访问 colab.research.google.com,用 Google 账号登录。
2
新建笔记本:点击 "New Notebook"。
3
开启 GPU:点击菜单 "Runtime" → "Change runtime type" → 选择 "T4 GPU"(免费)。
4
验证 GPU:在单元格中输入:
Colab 单元格
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

3.6 常见安装问题排查

问题:ModuleNotFoundError: No module named 'torch' 原因:PyTorch 没有安装成功,或者安装到了错误的 Python 环境。

解决步骤:
1. 确认你在终端中运行的 pip 和你启动 Jupyter 的 python 是同一个
2. 在 Jupyter 中运行 !pip install torch 重新安装
3. 如果用 Anaconda,确保激活了正确的环境:conda activate base
4. 运行 which python(macOS/Linux)或 where python(Windows)查看 Python 路径
问题:torch.cuda.is_available() 返回 False 原因:你安装的是 CPU 版本的 PyTorch,或者没有 NVIDIA 显卡。

解决:
• 如果没有 NVIDIA 显卡:这是正常的,CPU 版本也能完成本教程所有内容
• 如果有 NVIDIA 显卡但返回 False:
  1. 检查显卡驱动是否安装:nvidia-smi
  2. 卸载当前 PyTorch:pip uninstall torch
  3. 从官网重新安装 GPU 版本的 PyTorch
问题:Jupyter Notebook 打不开 解决:
1. 确认安装了 Jupyter:pip install jupyter
2. 尝试用 jupyter lab 代替 jupyter notebook
3. 检查防火墙是否阻止了浏览器打开

3.7 本章小结

本章要点回顾 • 推荐使用 Anaconda 管理 Python 环境
• PyTorch 是本教程使用的深度学习框架
• Jupyter Notebook 是交互式编程环境,适合学习和实验
• 必备库:NumPy、Matplotlib、Pandas、scikit-learn
• Google Colab 提供免费 GPU,适合没有好电脑的同学

第四章:机器学习基本概念

4.1 监督学习 vs 无监督学习 vs 强化学习

机器学习主要分为三大类。我们用生活中的例子来理解:

监督学习 = 有老师教的学习

就像小学生做作业,每道题都有标准答案。你做完后老师批改,告诉你哪里错了,你下次就知道怎么改了。

本教程就是监督学习:我们给模型看大量的手写数字图片,每张图片都标注了正确的数字(标签)。模型通过对比自己的预测和正确答案来学习。

更多例子:
• 给模型看 10000 张猫狗照片,每张都标注"猫"或"狗"
• 给模型看 10000 封邮件,每封都标注"正常"或"垃圾"
• 给模型看 10000 个房子的信息,每个都标注了价格

无监督学习 = 自己摸索的学习

就像把你扔到一个陌生城市,没有人告诉你路怎么走。你只能自己观察,发现规律——比如"这条路总是很堵"、"那个区域有很多餐厅"。

无监督学习的任务:
• 聚类:把相似的数据分成一组(比如把客户分成高价值/中价值/低价值)
• 降维:把复杂的数据简化(比如把 100 个特征压缩成 10 个)
• 异常检测:找出不正常的数据(比如信用卡欺诈检测)

强化学习 = 从奖惩中学习

就像训练小狗:做对了给零食(奖励),做错了不给(惩罚)。小狗慢慢学会哪些动作能得到零食。

例子:
• AlphaGo 下围棋,每下一步棋,根据最终胜负获得奖励或惩罚
• 机器人学走路,每走一步,根据是否摔倒获得奖励或惩罚
• 游戏 AI,每做一个动作,根据得分获得奖励或惩罚

类型数据要求典型应用本教程
监督学习需要标注好的数据图片分类、语音识别、文本分类✅ 使用这个
无监督学习不需要标注聚类、降维、异常检测❌ 不涉及
强化学习需要奖励信号游戏AI、机器人控制❌ 不涉及

4.2 分类 vs 回归

监督学习又分为两大任务:

分类 = 选择题

从固定的几个选项中选一个。

• 这张图片是猫还是狗?(二分类:2个选项)
• 这张图片是0-9哪个数字?(多分类:10个选项)
• 这封邮件是正常还是垃圾?(二分类)
• 这条评论是正面、负面还是中性?(多分类:3个选项)

特点:输出是离散的类别(有限个选项)

回归 = 填空题

预测一个具体的数字。

• 这套房子值多少钱?(输出:500万)
• 明天气温多少度?(输出:28.5℃)
• 这个人的身高是多少?(输出:175.3cm)
• 这只股票明天会涨多少?(输出:+2.5%)

特点:输出是连续的数值(无限个可能)

本教程的任务:多分类 手写数字识别是一个10 分类问题——给定一张图片,从 0-9 十个数字中选一个作为预测结果。

模型的输出是 10 个概率值,最大的那个就是预测结果。

4.3 训练的本质:寻找函数映射

机器学习的本质是什么?一句话:寻找一个函数。

我们想找一个函数 f,使得: f(手写数字图片) = 正确的数字标签 举例: f(图片A) = 3 ✓ 预测正确 f(图片B) = 7 ✓ 预测正确 f(图片C) = 2 ✗ 预测错误,应该是 5 训练的过程就是不断调整 f,让它预测得越来越准。

那这个函数 f 长什么样呢?它就是我们的神经网络!神经网络本质上就是一个非常复杂的数学函数,有几百万个参数。训练就是通过数据来调整这些参数。

关键理解 机器学习不是"编程"——我们不是手动告诉计算机规则(比如"如果像素是这样就是3"),而是让计算机从数据中自动学习规则。

传统编程:人写规则 → 计算机执行
机器学习:人提供数据 → 计算机自己学规则

4.4 训练集、验证集、测试集

我们手上的数据不能全部用来训练,需要分成三份:

1
训练集(Training Set)——用来训练模型的数据。就像学生做的练习题。约占总数据的 60-80%。模型通过这些数据学习规律。
2
验证集(Validation Set)——训练过程中用来检查模型表现的数据。就像模拟考试。约占 10-20%。用来调整超参数(比如学习率、层数)。
3
测试集(Test Set)——最后评估模型的数据,训练过程中绝对不能用。就像高考真题。约占 10-20%。用来评估模型的真实能力。
为什么不能用同一套数据训练和测试?

想象一个学生把考试原题都背下来了,考试当然能得满分。但他真的学会了吗?如果换个题就不会了。

模型也一样:如果用训练数据来测试,它可能只是"背"住了答案(这叫过拟合),而不是真正学会了识别数字。所以我们需要留出一部分数据作为"考试题",这些数据模型在训练时从未见过。

MNIST 数据集的划分
# 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)} 张")

4.5 什么是 Epoch、Batch、Iteration?

训练模型时,你会经常看到这三个概念:

Epoch、Batch、Iteration 的关系

假设你有 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
# ...

4.6 本章小结

本章要点回顾 • 监督学习:有标签的数据,本教程使用
• 无监督学习:没有标签,自己发现规律
• 强化学习:从奖惩中学习
• 分类:选择题(离散输出)
• 回归:填空题(连续输出)
• 训练的本质:寻找一个函数
• 数据要分成训练集、验证集、测试集
• Epoch = 遍历一次数据,Iteration = 处理一个 batch

第五章:数据——模型的"粮食"

5.1 MNIST 数据集介绍

MNIST 是深度学习领域最经典的数据集,就像编程界的 "Hello World"。它包含 70000 张手写数字图片:

MNIST 数据集详细信息: • 总共 70000 张图片 • 每张图片是 28×28 像素的灰度图 • 像素值范围:0(黑色)到 255(白色) • 标签:0-9 十个数字 • 训练集:60000 张 • 测试集:10000 张 • 每个数字大约有 6000-7000 张图片 示例: [图片:一个手写的数字 "3"] → 标签:3 [图片:一个手写的数字 "7"] → 标签:7 [图片:一个手写的数字 "0"] → 标签:0
MNIST 的历史 MNIST 数据集由 Yann LeCun(深度学习之父之一)在 1998 年创建。它是从美国人口普查局的员工和高中生手写的数字中收集的。

虽然 MNIST 很简单,但它在深度学习历史上的地位非常重要——很多重要的技术突破都是在 MNIST 上首次验证的。

5.2 下载并查看数据

PyTorch 内置了 MNIST 数据集,一行代码就能下载:

下载 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

5.3 数据可视化:看看我们的数据长什么样

拿到数据后,第一件事就是看看它长什么样:

可视化 MNIST 图片
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()

运行后你会看到类似这样的图片:

┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ │ 5 │ 0 │ 4 │ 1 │ 9 │ 2 │ 1 │ 3 │ 1 │ 4 │ ├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤ │ 9 │ 1 │ 5 │ 6 │ 8 │ 7 │ 4 │ 6 │ 3 │ 5 │ └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ 标签: 5 0 4 1 9 2 1 3 1 4 9 1 5 6 8 7 4 6 3 5

查看单张图片的详细信息

查看图片数据
# 获取一张图片
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())

5.4 数据预处理:为什么要归一化?

原始的像素值是 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
常见误区 归一化的参数(均值和标准差)应该只从训练集计算,不能从测试集计算。否则就是"偷看"了测试集的信息,会导致评估结果不准确。

5.5 DataLoader:批量喂数据的流水线

训练模型时,我们不是一张一张地喂数据,而是一批一批地喂。这个"一批"叫做 batch。

为什么用 batch?

想象你在餐厅吃饭:

• 全量(batch_size=全部数据):厨师把所有菜都做好了才上桌。你等很久,但菜是一起上的。
• 逐个(batch_size=1):厨师每做好一道菜就上一道。你吃得快,但厨师很累(GPU 利用率低)。
• 小批量(batch_size=32/64):厨师每做好一批菜就上一批。兼顾效率和速度。

通常 batch_size 选择 32、64、128、256 等 2 的幂次方。

创建 DataLoader
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] 的意思是:
• 64:这一批有 64 张图片
• 1:每张图片有 1 个通道(灰度图是 1,彩色图是 3)
• 28:图片高度是 28 像素
• 28:图片宽度是 28 像素

总共 64 × 1 × 28 × 28 = 50176 个数字

5.6 数据质量问题

真实世界的数据往往有各种问题:

问题描述解决方法
缺失值某些数据缺失删除或填充(均值、中位数)
异常值明显不合理的数据删除或修正
标签错误标注不正确人工检查、众包验证
类别不平衡某些类别数据太少过采样、欠采样、数据增强
数据重复同一条数据出现多次去重
好消息:MNIST 数据质量很好 MNIST 是一个"干净"的数据集,没有缺失值、异常值、标签错误等问题。你可以放心使用。

但当你处理自己的数据时,一定要先检查数据质量!

5.7 本章小结

本章要点回顾 • MNIST 是深度学习的 "Hello World",70000 张手写数字图片
• 数据可视化是理解数据的第一步
• 归一化让训练更稳定、收敛更快
• DataLoader 用来批量加载数据
• 真实数据需要检查质量问题

第六章:神经网络第一课——单个神经元

6.1 生物神经元 → 人工神经元

神经网络的灵感来自人脑。让我们先看看生物神经元是怎么工作的:

生物神经元的结构: 树突(接收信号) ↓ → 细胞体(处理信号)→ ↓ 轴突(输出信号) 工作原理: 1. 树突接收来自其他神经元的信号 2. 细胞体把所有信号加起来 3. 如果总信号超过某个阈值,就"激活"(发出信号) 4. 信号通过轴突传递给下一个神经元
人工神经元的结构: 输入 × 权重 → 求和 + 偏置 → 激活函数 → 输出 工作原理: 1. 每个输入乘以一个权重(重要程度) 2. 把所有加权后的输入求和 3. 加上一个偏置 4. 通过激活函数,得到输出
人工神经元 = 一个决策器

想象你决定要不要出门。你会考虑几个因素:

• 天气好不好?(权重:0.4)
• 有没有约会?(权重:0.5)
• 身体舒不舒服?(权重:0.1)

你会给每个因素一个"权重",重要的因素权重更大。然后综合考虑所有因素,做出"出门/不出门"的决定。

人工神经元做的事情完全一样!

6.2 权重、偏置的概念

一个神经元有两个可学习的参数:

1
权重(Weight)——每个输入的重要程度。权重越大,这个输入对输出的影响越大。权重可以是正数(增强)或负数(抑制)。
2
偏置(Bias)——一个额外的调整值。即使所有输入都是 0,偏置也能让神经元有输出。可以理解为"门槛"。
单个神经元的计算过程
# 假设输入有 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)

6.3 激活函数全家福

如果神经元只有权重和偏置,它只能做线性变换(相当于一条直线)。但现实世界的问题往往是非线性的。所以我们需要激活函数来引入非线性。

为什么需要激活函数? 没有激活函数,无论你叠多少层神经网络,最终都只是一个线性函数(相当于一层)。激活函数让网络能够学习复杂的非线性关系。

数学证明:
• 没有激活函数:f(g(x)) = W2(W1*x + b1) + b2 = W'*x + b'(还是线性)
• 有激活函数:f(g(x)) = W2*σ(W1*x + b1) + b2(非线性)

Sigmoid 函数

Sigmoid
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":

Sigmoid 函数图像: 1.0 | ___________ | / 0.5 | / | / 0.0 |________/ ───────────────────────→ x 特点: • 把任意输入压缩到 0-1 之间 • 输出可以解释为概率 • 0 附近的区域接近线性 缺点: • 梯度消失:当输入很大或很小时,梯度接近 0 • 输出不以 0 为中心 • 计算 exp 比较慢

ReLU 函数

ReLU(Rectified Linear Unit)
# 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 是目前最常用的激活函数:

ReLU 函数图像: | / | / | / | / 0.0 |_____/ ───────────────────────→ x 特点: • 负数变 0,正数不变 • 计算非常简单(只需要比较大小) • 不会梯度消失(正数区域梯度恒为 1) • 稀疏激活(很多神经元输出为 0) 缺点: • "死 ReLU":如果输入总是负数,梯度永远为 0,神经元"死掉" • 解决方案:Leaky ReLU、ELU、GELU

Tanh 函数

Tanh
# 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])

激活函数对比

激活函数输出范围优点缺点适用场景
Sigmoid0 到 1输出可解释为概率梯度消失、不以0为中心二分类输出层
ReLU0 到 +∞计算快、不会梯度消失死ReLU问题隐藏层首选
Tanh-1 到 1输出以 0 为中心仍有梯度消失RNN、某些特殊场景
Leaky ReLU-∞ 到 +∞解决死ReLU问题需要调参ReLU的替代品
GELU0 到 +∞Transformer常用计算稍慢Transformer、BERT
选择建议 • 隐藏层:默认用 ReLU(90% 的情况都是最佳选择)
• 二分类输出层:用 Sigmoid
• 多分类输出层:用 Softmax(后面会讲)
• Transformer:用 GELU

6.4 动手实现:一个神经元

现在让我们用 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)
# 两个结果应该相同
PyTorch 的 nn.Linear 做了什么? nn.Linear(3, 1) 创建了一个层,它包含:
• 3 个权重(对应 3 个输入)
• 1 个偏置
计算过程:output = x @ weight.T + bias

权重和偏置会自动初始化,训练时会不断更新。

6.5 本章小结

本章要点回顾 • 人工神经元 = 输入×权重 + 偏置 + 激活函数
• 权重表示每个输入的重要程度
• 偏置是一个额外的调整值
• 激活函数引入非线性,让网络能学习复杂关系
• 常用激活函数:ReLU(隐藏层)、Sigmoid(二分类)、Softmax(多分类)
• PyTorch 用 nn.Linear 创建神经元

第七章:搭建第一个网络——全连接层

7.1 从单个神经元到多层网络

一个神经元的能力非常有限。要解决复杂问题,我们需要把很多神经元组合在一起,形成多层网络。

多层网络 = 流水线工厂

想象一个汽车工厂的流水线:

• 第 1 个车间:负责加工零件(提取低级特征,如边缘、线条)
• 第 2 个车间:负责组装部件(组合中级特征,如形状、纹理)
• 第 3 个车间:负责喷漆检验(形成高级特征,如物体、场景)

每个车间的工人都做一件简单的事,但串起来就能造出复杂的汽车。

神经网络也一样:每一层提取不同层次的特征,最终做出决策。

全连接网络的结构

全连接网络结构(MLP - Multi-Layer Perceptron): 输入层 隐藏层1 隐藏层2 输出层 (784个) → (128个) → (64个) → (10个) │ │ │ │ │ 全连接 │ 全连接 │ 全连接 │ └─────────────┴─────────────┴─────────────┘ 特点: • 每一层的每个神经元都与下一层的所有神经元相连 • 这就是"全连接"名字的由来 • 也叫"密集连接"(Dense) 层数说明: • 输入层:接收数据(784个像素) • 隐藏层1:128个神经元,提取特征 • 隐藏层2:64个神经元,进一步提取特征 • 输出层:10个神经元,对应10个数字

7.2 前向传播:数据如何流动

前向传播就是数据从输入层流向输出层的过程。每经过一层,数据就被变换一次。

前向传播过程(详细版)
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]

注意每经过一层,数据的维度就变了。权重矩阵的形状决定了维度的变化:
• 权重 [784, 128] 把 784 维变成 128 维
• 权重 [128, 64] 把 128 维变成 64 维
• 权重 [64, 10] 把 64 维变成 10 维

矩阵乘法的规则:[1, 784] @ [784, 128] = [1, 128]

7.3 权重初始化

训练开始前,权重需要随机初始化。但随机的方式有讲究:

为什么不能全初始化为 0? 如果所有权重都是 0,那么每个神经元的输出都一样,它们就学不到不同的特征。这就像一个工厂里所有工人做完全相同的事,没有分工。

数学解释:如果所有权重相同,那么所有神经元的梯度也相同,更新后还是相同。所以它们永远学不到不同的特征。
常用的初始化方法
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}")

7.4 用 PyTorch 搭建 3 层网络

现在让我们用 PyTorch 搭建一个完整的 3 层网络:

方法一:使用 nn.Sequential(简单直观)
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())}")

输出:

Sequential( (0): Linear(in_features=784, out_features=128, bias=True) (1): ReLU() (2): Linear(in_features=128, out_features=64, bias=True) (3): ReLU() (4): Linear(in_features=64, out_features=10, bias=True) ) 总参数数量:109386
方法二:使用 nn.Module(更灵活)
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:灵活,可以自定义复杂的前向传播逻辑,适合复杂的网络

建议:先用 Sequential 快速实验,需要自定义时再用 Module。

7.5 每一层在做什么?

让我们可视化看看每一层学到了什么:

提取中间层输出
# 获取中间层的输出
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()
理解每一层的作用 • 输入层:原始像素,没有抽象概念
• 第1层:可能学会了检测边缘、线条等低级特征
• 第2层:把边缘组合成更复杂的形状(如圆圈、拐角)
• 输出层:根据形状判断是哪个数字

这就是深度学习的核心思想:逐层抽象,从低级特征到高级特征。

7.6 参数数量计算

了解模型有多少参数很重要,它决定了模型的大小和训练速度:

计算参数数量
# 计算每层的参数数量
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

7.7 本章小结

本章要点回顾 • 全连接网络:每一层的每个神经元都与下一层的所有神经元相连
• 前向传播:数据从输入层流向输出层
• 权重初始化不能全为 0,常用 Kaiming 初始化
• nn.Sequential 适合简单网络,nn.Module 适合复杂网络
• 每一层提取不同层次的特征(逐层抽象)
• 参数数量 = 输入维度 × 输出维度 + 偏置

第八章:训练模型——让网络学会思考

8.1 训练的整体流程

在深入细节之前,先了解训练的整体流程:

训练循环(Training Loop): for each epoch: for each batch: 1. 前向传播:计算预测值 2. 计算损失:预测值 vs 真实值 3. 反向传播:计算梯度 4. 更新参数:用梯度调整权重 5. 清空梯度:准备下一轮 代码结构: for epoch in range(num_epochs): for images, labels in train_loader: outputs = model(images) # 1. 前向传播 loss = criterion(outputs, labels) # 2. 计算损失 optimizer.zero_grad() # 5. 清空梯度 loss.backward() # 3. 反向传播 optimizer.step() # 4. 更新参数

8.2 损失函数:错得有多离谱

训练模型的第一步是定义损失函数——它衡量模型的预测和正确答案之间的差距。

损失函数 = 考试扣分

想象考试满分 100 分:
• 你考了 90 分,损失 = 10 分
• 你考了 60 分,损失 = 40 分

损失越小,说明模型预测越准。训练的目标就是让损失尽可能小。

交叉熵损失(Cross-Entropy Loss)

对于分类问题,最常用的损失函数是交叉熵损失。

交叉熵损失详解
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(概率)
# 概率越高,损失越小
直觉理解交叉熵 交叉熵衡量的是"模型的预测概率分布"和"真实的概率分布"之间的距离。

如果模型非常确定图片是 3(比如输出 [0.01, 0.01, 0.01, 0.9, ...]),交叉熵会很小。
如果模型很迷茫(比如输出 [0.1, 0.1, 0.1, 0.1, ...]),交叉熵会很大。

其他常用损失函数

损失函数用途公式特点
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|)平均绝对误差

8.3 梯度下降:如何减少错误

有了损失函数,下一步就是减少损失。怎么减少?答案是梯度下降。

梯度下降 = 下山

想象你站在一座山上,四周都是雾,看不清路。你的目标是走到山谷(损失最小的地方)。

你只能感觉到脚下的坡度(导数):
• 如果左边是下坡,就往左走
• 如果右边是下坡,就往右走

每次走一小步,慢慢就走到山谷了。这就是梯度下降!

梯度下降的直觉: 损失 ↑ │ * ← 你在这里(损失很大) │ \ │ \ │ \ │ * ← 走到这里(损失变小了) │ \ │ \ │ * ← 最终到达山谷(损失最小) └─────────────────→ 训练步数 数学表示: weight_new = weight_old - lr × gradient 其中: • weight_old:当前权重 • lr:学习率(步长) • gradient:梯度(方向)

8.4 反向传播:计算梯度

反向传播是计算梯度的算法。它从输出层开始,一层一层往回计算每个参数的梯度。

不需要手动计算! PyTorch 的自动微分功能会帮你计算梯度。你只需要调用 loss.backward(),PyTorch 就会自动计算所有参数的梯度。

这就是为什么 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 会变化多少
# 我们应该沿着梯度的反方向更新权重

8.5 优化器大比拼

有了梯度,我们用优化器来更新参数。不同的优化器有不同的策略:

优化器特点适用场景学习率
SGD最基础,每次按梯度方向走一小步简单问题、需要精细调参0.01-0.1
SGD + Momentum加上"惯性",不容易卡住大多数场景0.01-0.1
Adam自适应学习率,自动调整步长新手首选、大多数场景0.001
AdamWAdam + 权重衰减,更稳定Transformer、大模型0.001
使用 Adam 优化器
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()       # 更新参数
选择建议 如果你不知道用什么优化器,就用 Adam,学习率设为 0.001。这在大多数情况下都能工作得很好。

等你熟悉了之后,可以尝试其他优化器,看看效果有没有提升。

8.6 学习率调度:什么时候该走快/走慢

学习率不是固定不变的。通常在训练初期用较大的学习率快速下降,后期用较小的学习率精细调整。

学习率调度器
# 创建学习率调度器
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

8.7 第一次训练:见证学习过程

现在让我们把所有组件组合起来,完成第一次训练:

完整的训练循环
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()

运行结果:

Epoch [1/5], Batch [0/938], Loss: 2.3012 Epoch [1/5], Batch [100/938], Loss: 0.4523 Epoch [1/5], Batch [200/938], Loss: 0.3215 ... Epoch [1/5], 平均损失: 0.4523 Epoch [2/5], 平均损失: 0.1876 Epoch [3/5], 平均损失: 0.1342 Epoch [4/5], 平均损失: 0.1056 Epoch [5/5], 平均损失: 0.0889 训练完成! 可以看到损失在不断下降,说明模型在学习!
恭喜!你完成了第一次模型训练! 虽然代码不多,但你已经训练了一个能识别手写数字的神经网络。接下来我们会学习如何评估它的表现,以及如何让它变得更强。

8.8 本章小结

本章要点回顾 • 训练循环:前向传播 → 计算损失 → 反向传播 → 更新参数
• 损失函数:衡量预测和正确答案的差距
• 梯度下降:沿着梯度反方向更新参数
• 反向传播:PyTorch 自动计算梯度
• Adam 是最常用的优化器,学习率默认 0.001
• 学习率调度:训练后期减小学习率

第九章:优化技巧——让模型更强

9.1 学习率的选择艺术

学习率是最重要的超参数之一。选错了会怎样?

学习率太大: 损失 ↑ │ * * * ← 损失来回震荡,不下降 │ \ / \ / │ * * └─────────────────→ 训练步数 学习率太小: 损失 ↑ │ * │ \ │ \ ← 下降很慢,需要很长时间 │ \ │ \ └─────────────────→ 训练步数 学习率合适: 损失 ↑ │ * │ \ │ \ │ \___ ← 快速下降,然后趋于平稳 └─────────────────→ 训练步数
学习率选择建议 • 默认使用 0.001(Adam 的默认值)
• 如果训练不稳定(损失震荡),尝试减小到 0.0001
• 如果训练太慢,尝试增大到 0.01
• 使用学习率调度器自动调整
• 可以用学习率查找器(Learning Rate Finder)自动找到最佳学习率

9.2 批量归一化(BatchNorm)

BatchNorm 是一种让训练更稳定的技术。它在每一层之后对数据进行归一化。

BatchNorm = 考试前的心理调节

想象一个学生,每次考试前都会紧张。老师教他一个方法:考前做几次深呼吸,让自己平静下来。

BatchNorm 就像这个"深呼吸"——在数据进入下一层之前,先把它调整到一个合适的范围(均值为0,方差为1),让训练更稳定。

使用 BatchNorm
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. 减少对权重初始化的敏感性

9.3 Dropout:防止死记硬背

Dropout 是一种防止过拟合的技术。训练时随机"关掉"一部分神经元。

Dropout = 闭卷考试

想象一个学生平时做作业时总抄同桌的答案(过拟合)。老师说:"考试时你不能抄,必须自己想。"

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:强正则化(数据很少时)
重要:训练和测试模式的切换 Dropout 只在训练时生效,测试时所有神经元都要参与。
• 训练时:model.train()
• 测试时:model.eval()

如果忘记切换,测试结果会不准确!

9.4 L1/L2 正则化:给模型加"紧箍咒"

正则化是另一种防止过拟合的方法。它在损失函数上加一个"惩罚项",让权重不要太大。

L2 正则化(权重衰减)
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²)
# 这会惩罚过大的权重,让模型更简单

9.5 数据增强:变出更多数据

数据不够怎么办?数据增强通过对现有数据做变换,创造出"新"的训练样本。

数据增强示例
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. 几乎免费(不需要额外收集数据)

9.6 早停法(Early Stopping)

早停法是在验证集表现不再提升时提前停止训练,防止过拟合。

早停法实现
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)

9.7 本章小结

本章要点回顾 • 学习率是最关键的超参数,默认用 0.001
• BatchNorm 让训练更稳定,加速收敛
• Dropout 防止过拟合,训练时随机关闭神经元
• L2 正则化(权重衰减)惩罚过大的权重
• 数据增强增加训练数据,减少过拟合
• 早停法在验证集不再提升时停止训练

第十章:评估与调试——模型考了多少分

10.1 准确率、精确率、召回率

评估模型不只看"准确率"这一个指标。不同场景需要关注不同的指标。

准确率 vs 精确率 vs 召回率

想象你在抓坏人(检测垃圾邮件):

准确率(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 才会高

10.2 混淆矩阵:哪里容易犯错

混淆矩阵展示模型在每个类别上的表现,让你看到它"混淆"了哪些数字。

绘制混淆矩阵
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()
混淆矩阵示例(MNIST): 预测 → 0 1 2 3 4 5 6 7 8 9 真实 ↓ 0 [974 0 1 0 0 2 2 1 0 0] 1 [ 0 1130 2 1 0 1 1 0 0 0] 2 [ 3 1 1020 2 1 0 1 4 1 0] 3 [ 0 0 3 1000 0 3 0 3 1 0] ... 解读: • 对角线上的数字越大越好(正确预测) • 非对角线上的数字表示"混淆" • 比如第 3 行第 8 列的 3,表示有 3 张数字 3 被误认为 8

10.3 过拟合 vs 欠拟合

这是训练模型时最常见的两个问题:

欠拟合:模型太简单,没学会规律 训练集表现:差(准确率低) 测试集表现:差(准确率低) 类比:学生平时不学习,考试也不会 原因:模型太简单、训练不充分 解决:增加网络层数、增加训练时间、增加模型复杂度 ───────────────────────────────────── 过拟合:模型太复杂,记住了答案 训练集表现:好(准确率高) 测试集表现:差(准确率低) 类比:学生只会做原题,换个题就不会 原因:模型太复杂、数据太少 解决:Dropout、正则化、数据增强、早停
问题训练损失验证损失原因解决方法
欠拟合大大模型太简单增加层数、增加神经元、训练更久
过拟合小大模型太复杂Dropout、正则化、数据增强、早停
正常小小——

10.4 训练曲线分析

通过观察训练曲线,可以判断模型的状态:

绘制训练曲线
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()
正常训练曲线: 损失 ↑ │ 训练损失 │ \ │ \___ 验证损失 │ \___ └─────────────────→ Epoch 两条线都在下降,且差距不大 → 模型学得好 ───────────────────────────────────── 过拟合曲线: 损失 ↑ │ 训练损失 │ \ │ \___ │ \___ 验证损失 │ ----\____ └─────────────────→ Epoch 训练损失下降,但验证损失开始上升 → 过拟合了! ───────────────────────────────────── 欠拟合曲线: 损失 ↑ │ 训练损失 验证损失 │ --------________ │ │ └─────────────────→ Epoch 两条线都很高,下降很慢 → 模型太简单

10.5 超参数调优

模型有很多"超参数"需要手动设置,比如学习率、层数、每层神经元数量等。怎么找到最好的组合?

手动调参
# 常见的超参数
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. 选择表现最好的组合
使用 Optuna 自动调参
# 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%}")

10.6 常见问题排查手册

问题:训练损失不下降 可能原因:
• 学习率太大或太小
• 数据没有正确预处理
• 模型结构有问题
• 标签和数据不匹配

排查步骤:
1. 检查数据:打印几个样本看看是否正确
2. 检查学习率:尝试 0.001, 0.0001, 0.00001
3. 检查模型:用简单模型先跑通
4. 检查损失函数:是否和任务匹配
问题:训练损失下降,但测试损失不下降 可能原因:过拟合

解决方法:
• 增加 Dropout(0.3-0.5)
• 使用正则化(weight_decay=1e-4)
• 数据增强
• 减少模型复杂度
• 使用早停法
问题:梯度消失或爆炸 表现:损失变成 NaN 或者非常大的数

解决方法:
• 使用 BatchNorm
• 使用 ResNet 跳跃连接
• 减小学习率
• 使用合适的权重初始化(Kaiming)
• 使用梯度裁剪:torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

10.7 本章小结

本章要点回顾 • 准确率、精确率、召回率、F1 是常用评估指标
• 混淆矩阵展示模型在每个类别上的表现
• 过拟合:训练好、测试差;欠拟合:训练差、测试差
• 训练曲线可以判断模型状态
• 超参数调优可以提升模型表现

第十一章:进阶——卷积神经网络(CNN)

11.1 为什么图片需要特殊处理

全连接网络处理图片有个问题:它忽略了图片的空间结构。

全连接 vs 卷积

想象你在看一张照片:

全连接网络:把照片撕成一条一条的像素,然后看这些像素条。它不知道相邻的像素是有关系的。

CNN:用一个小窗口在照片上滑动,每次只看一小块区域。它能理解"相邻的像素组成线条,线条组成形状"。

CNN 的优势 • 局部连接:每个神经元只看一小块区域,而不是整张图片
• 参数共享:同一个滤波器在整张图片上滑动,大大减少参数量
• 平移不变性:不管物体在图片的哪个位置,都能识别出来

11.2 卷积操作的直觉理解

卷积就是用一个小的"滤波器"在图片上滑动,对每个位置做计算。

卷积 = 用手电筒扫描

想象你在黑暗的房间里,用手电筒(滤波器)照墙壁(图片):

• 手电筒的光圈大小 = 滤波器大小(如 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越多特征越丰富

输出大小计算公式

输出大小公式: output_size = (input_size - kernel_size + 2 × padding) / stride + 1 举例: • 输入:28×28 • 滤波器:3×3 • 步长:1 • 填充:1 输出 = (28 - 3 + 2×1) / 1 + 1 = 28 (大小不变) • 输入:28×28 • 滤波器:3×3 • 步长:2 • 填充:1 输出 = (28 - 3 + 2×1) / 2 + 1 = 14 (缩小一半)
卷积操作示意: 输入图片(5×5) 滤波器(3×3) 输出特征图(3×3) ┌─────────────────┐ ┌─────────┐ ┌─────────────┐ │ 1 0 1 0 1 │ │ 1 0 1 │ │ 4 3 4 │ │ 0 1 0 1 0 │ │ 0 1 0 │ → │ 2 4 3 │ │ 1 0 1 0 1 │ │ 1 0 1 │ │ 4 3 4 │ │ 0 1 0 1 0 │ └─────────┘ └─────────────┘ │ 1 0 1 0 1 │ └─────────────────┘ 计算过程(第一个位置): 1×1 + 0×0 + 1×1 + 0×0 + 1×1 + 0×0 + 1×1 + 0×0 + 1×1 = 4 滤波器在图片上滑动,每个位置做对应元素相乘再求和
滤波器的作用 不同的滤波器可以检测不同的特征:
• 水平边缘滤波器:检测水平线
• 垂直边缘滤波器:检测垂直线
• 模糊滤波器:让图片变模糊
• 锐化滤波器:让图片更清晰

CNN 的厉害之处在于:它能自动学习这些滤波器,不需要人工设计。

11.3 池化层:压缩信息

池化层的作用是缩小特征图的尺寸,减少计算量,同时保留重要信息。

最大池化(2×2): 输入(4×4) 输出(2×2) ┌─────────────┐ ┌─────────┐ │ 1 3 │ 2 4 │ │ 3 │ 4 │ │ 5 2 │ 1 3 │ → ├─────┼───│ │──────┼──────│ │ 6 │ 8 │ │ 6 1 │ 8 5 │ └─────────┘ │ 3 4 │ 2 7 │ └─────────────┘ 每个 2×2 区域取最大值 好处: 1. 减少计算量(尺寸缩小一半) 2. 保留重要特征(最大值) 3. 增加平移不变性

11.4 搭建一个简单的 CNN

现在让我们用 PyTorch 搭建一个 CNN:

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]

11.5 CNN 可视化:每一层在"看"什么

我们可以可视化 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()
CNN 各层学到的特征: 第 1 层:边缘、线条、颜色 ┌──────────────────────────────┐ │ │ │ ─ ─ ╲ ╱ ○ │ └──────────────────────────────┘ 第 2 层:纹理、简单形状 ┌──────────────────────────────┐ │ 网格 条纹 圆圈 拐角 │ └──────────────────────────────┘ 第 3 层:复杂形状、物体部件 ┌──────────────────────────────┐ │ 眼睛 轮子 叶子 窗户 │ └──────────────────────────────┘ 第 4 层:完整物体 ┌──────────────────────────────┐ │ 猫脸 汽车 花朵 房子 │ └──────────────────────────────┘

11.6 经典 CNN 架构巡礼

架构年份特点层数Top-5 错误率
LeNet-51998第一个成功的 CNN,用于手写数字识别5—
AlexNet2012开启了深度学习革命,使用 GPU816.4%
VGG2014用 3×3 小卷积核堆叠16/197.3%
GoogLeNet2014引入 Inception 模块226.7%
ResNet2015引入跳跃连接,可以训练很深的网络50/101/1523.6%

11.7 本章小结

本章要点回顾 • CNN 是处理图片的首选架构
• 卷积操作:用滤波器在图片上滑动,提取特征
• 池化层:缩小特征图尺寸,保留重要信息
• CNN 的优势:局部连接、参数共享、平移不变性
• 不同层学习不同层次的特征

第十二章:模型解释性——为什么这样预测

12.1 可解释性的重要性

模型做出了预测,但我们想知道为什么。这在很多场景下很重要:

为什么需要可解释性? • 医疗诊断:医生需要知道模型为什么认为这是肿瘤
• 金融风控:需要解释为什么拒绝贷款申请
• 法律合规:某些场景要求 AI 决策可解释
• 调试模型:找出模型在哪里犯错
• 建立信任:用户需要理解 AI 的决策依据

12.2 Grad-CAM:看模型关注图片的哪里

Grad-CAM 是一种可视化技术,可以显示模型在做决策时"看"了图片的哪个部分。

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()

12.3 特征可视化:神经网络学到了什么

我们可以可视化神经网络学到的特征:

特征可视化
# 可视化第一层卷积核学到的特征
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)

12.4 LIME:局部可解释性

LIME(Local Interpretable Model-agnostic Explanations)是另一种解释模型的方法。

LIME 的核心思想 1. 对于一个要解释的样本,生成它周围的"邻居"样本
2. 用模型对这些邻居进行预测
3. 用一个简单的模型(如线性模型)来拟合这些预测
4. 用简单模型的权重来解释原样本的预测
LIME = 局部"翻译"

想象你问一个复杂的 AI:"为什么这张图片是猫?"

AI 的回答太复杂了,你听不懂。于是你找了一个简单的翻译:
1. 你把图片稍微改一下(比如遮住耳朵、遮住眼睛)
2. 看 AI 对这些修改后的图片怎么判断
3. 用简单的规则总结:"有尖耳朵 → 更可能是猫"

这就是 LIME 的做法——用简单的局部模型来解释复杂模型。

LIME 代码示例(需要安装 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()

12.5 特征重要性分析

除了可视化,我们还可以分析哪些特征(像素)对预测最重要:

特征重要性分析
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()

12.6 本章小结

本章要点回顾 • 可解释性在医疗、金融、法律等领域很重要
• Grad-CAM 显示模型关注图片的哪个部分
• 特征可视化展示模型学到了什么
• LIME 提供局部可解释性

第十三章:完整项目——从数据到部署

13.1 整合所有代码

现在让我们把前面学到的所有内容整合成一个完整的项目:

完整项目代码
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("模型已保存!")

13.2 模型保存与加载

保存和加载模型
# 保存模型(只保存参数)
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()

13.3 做一个简单的 Web Demo(Gradio)

Gradio 是一个快速创建 AI Demo 的工具,几行代码就能做出一个网页应用:

安装 Gradio
pip install gradio
创建 Web Demo
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()
运行效果 运行代码后,浏览器会打开一个网页。你可以在画布上手写一个数字,模型会实时识别并显示结果。

13.4 模型导出:ONNX 格式

ONNX 是一种通用的模型格式,可以在不同框架之间转换:

导出 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. 更小的模型体积

13.5 本章小结

本章要点回顾 • 整合所有代码,完成完整项目
• 模型保存:torch.save(model.state_dict(), 'model.pth')
• 模型加载:model.load_state_dict(torch.load('model.pth'))
• Gradio 可以快速创建 Web Demo
• ONNX 格式支持跨框架部署

第十四章:实战项目扩展

14.1 项目 A:猫狗分类器(二分类)

这是一个经典的二分类项目。相比 MNIST,猫狗分类更具挑战性:

MNIST vs 猫狗分类

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')
迁移学习的关键点 • 使用在 ImageNet 上预训练的模型(已经学会了识别各种物体)
• 冻结前面的层(保留已学到的特征提取能力)
• 只训练最后的分类层(让它学会区分猫和狗)
• 这样即使数据很少,也能取得不错的效果

14.2 项目 B:情感分析(文本分类)

这是一个 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)

模型定义

LSTM 情感分析模型
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)
NLP 项目的关键步骤 1. 分词:把文本切分成单词或字符
2. 建立词汇表:每个词对应一个数字
3. 文本转序列:把句子变成数字列表
4. 填充/截断:让所有序列长度相同
5. 词嵌入:把数字转换成有意义的向量

14.3 项目 C:房价预测(回归任务)

这是一个回归项目,预测房价:

数据准备

房价数据处理
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} 万元")
回归 vs 分类的区别 • 输出层:回归用 1 个神经元(无激活),分类用 N 个神经元(softmax)
• 损失函数:回归用 MSE/MAE,分类用 CrossEntropy
• 评估指标:回归用 MSE/MAE/R²,分类用准确率/F1

14.4 从零到一的项目模板

完整的项目流程: 1. 定义问题 - 分类/回归/生成? - 输入是什么?输出是什么? - 成功标准是什么?(准确率>95%?MAE<10万?) 2. 收集数据 - 公开数据集(Kaggle、UCI) - 自己收集(爬虫、问卷) - 数据清洗、标注 - 数据探索和可视化(EDA) 3. 搭建模型 - 从简单模型开始(baseline) - 记录每次实验结果 - 逐步增加复杂度 4. 训练调优 - 调整超参数(学习率、层数、神经元数) - 使用优化技巧(BatchNorm、Dropout、数据增强) - 交叉验证 - 早停法 5. 评估部署 - 测试集评估 - 混淆矩阵分析 - 导出模型(ONNX) - 创建 Demo(Gradio) - 监控和维护

14.5 本章小结

本章要点回顾 • 猫狗分类:二分类任务,使用迁移学习(ResNet18)
• 情感分析:NLP 任务,使用 LSTM + 词嵌入
• 房价预测:回归任务,使用 MSE 损失、BatchNorm
• 项目模板:定义问题 → 收集数据 → 搭建模型 → 训练调优 → 评估部署
• 每个项目都有完整的代码示例

第十五章:下一步——通往大模型的路

15.1 从 MLP 到 Transformer 的进化史

神经网络发展史: 1958 感知机(单层网络)- Frank Rosenblatt ↓ 1986 多层感知机(MLP)+ 反向传播 - Rumelhart, Hinton ↓ 1998 卷积神经网络(CNN)- LeNet - Yann LeCun ↓ 2012 深度 CNN - AlexNet(GPU 时代开始)- Krizhevsky ↓ 2014 生成对抗网络(GAN)- Ian Goodfellow ↓ 2015 残差网络(ResNet)- 跳跃连接 - Kaiming He ↓ 2017 Transformer - 注意力机制 - Vaswani et al. ↓ 2018 BERT / GPT - 预训练大模型 - Google / OpenAI ↓ 2022 ChatGPT - 大语言模型爆发 - OpenAI ↓ 2024 多模态大模型 - GPT-4, Claude, Gemini

15.2 自注意力机制简介

Transformer 的核心是自注意力机制。它让模型能够"关注"输入中最重要的部分。

自注意力 = 阅读理解时划重点

当你读一篇长文章时,你会自动"关注"重要的句子,忽略不重要的。比如读新闻时,你会关注"谁、什么时间、做了什么",而忽略一些修饰词。

自注意力机制做的事情类似:它计算每个词和其他词之间的"相关性",然后重点关注相关的词。

为什么 Transformer 比 LSTM 更强? • LSTM:按顺序处理,必须一个词一个词地看,像逐字阅读
• Transformer:并行处理,可以同时看所有词,像一目十行

而且 Transformer 可以捕捉长距离依赖——比如一篇文章开头和结尾的关联。

自注意力的直觉理解

自注意力计算过程: 输入:The cat sat on the mat 1. 计算 Query, Key, Value Q = W_q × input K = W_k × input V = W_v × input 2. 计算注意力分数 scores = Q × K^T / sqrt(d_k) 3. 归一化(softmax) attention_weights = softmax(scores) 4. 加权求和 output = attention_weights × V

PyTorch 实现 Transformer

简单的 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]
Transformer 的关键组件 • 词嵌入:把词转换成向量
• 位置编码:告诉模型每个词的位置
• 自注意力:让词之间相互"交流"
• 前馈网络:进一步处理特征
• 残差连接:防止梯度消失

15.3 迁移学习:站在巨人肩膀上

迁移学习是使用别人已经训练好的模型,在此基础上进行微调。

迁移学习示例
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. 可以用在小数据集上

15.4 模型压缩:剪枝、量化、蒸馏

技术原理效果适用场景
剪枝删除不重要的权重模型变小 2-10 倍减少模型大小
量化用低精度(如 INT8)代替浮点数模型变小 4 倍,速度变快边缘设备部署
知识蒸馏用大模型教小模型小模型获得大模型的能力模型压缩

15.5 推荐学习路线

学习路线图: 第一阶段:基础(你现在在这里) ├── Python 编程 ✓ ├── PyTorch 基础 ✓ ├── 全连接网络 ✓ ├── CNN ✓ └── 训练技巧 ✓ 第二阶段:进阶 ├── 更多 CNN 架构(ResNet, VGG, EfficientNet) ├── 目标检测(YOLO, Faster R-CNN) ├── 图像分割(U-Net) ├── 数据增强进阶 └── 模型部署(TensorRT, ONNX Runtime) 第三阶段:前沿 ├── Transformer 架构 ├── 自然语言处理(NLP) ├── 生成模型(GAN, Diffusion) ├── 多模态学习 └── 强化学习 第四阶段:应用 ├── 大模型微调(LoRA, QLoRA) ├── 边缘计算(手机、嵌入式) ├── AI 产品开发 └── 研究论文复现
学习资源推荐 • 课程:吴恩达《深度学习》、李宏毅《机器学习》、斯坦福 CS231n
• 书籍:《动手学深度学习》(d2l.ai)、《深度学习》(花书)
• 实践:Kaggle 比赛、论文复现、开源项目贡献
• 社区:GitHub、知乎、CSDN、Hugging Face

15.6 本章小结

本章要点回顾 • 神经网络从 MLP → CNN → Transformer 不断进化
• 自注意力机制是 Transformer 的核心
• 迁移学习可以站在巨人肩膀上
• 模型压缩让模型可以在边缘设备上运行
• 持续学习,跟上 AI 发展的步伐

附录:速查手册

A. PyTorch 常用 API

功能代码说明
创建张量torch.tensor([1, 2, 3])从列表创建
随机初始化torch.randn(3, 4)标准正态分布
全零张量torch.zeros(3, 4)全 0
全一张量torch.ones(3, 4)全 1
形状变换x.view(-1, 784)展平
转到 GPUx.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 优化器

B. 术语表

英文中文解释
Epoch轮次完整遍历一次训练集
Batch Size批量大小每次训练的样本数
Learning Rate学习率参数更新的步长
Loss损失预测和真实值的差距
Gradient梯度参数更新的方向和大小
Backpropagation反向传播计算梯度的算法
Overfitting过拟合模型只记住了训练数据
Underfitting欠拟合模型太简单,没学会
Regularization正则化防止过拟合的技术
Feature特征输入数据的属性
Weight权重可学习的参数
Bias偏置可学习的偏移量
Activation激活函数引入非线性的函数
Convolution卷积用滤波器提取特征
Pooling池化缩小特征图尺寸
Dropout随机失活训练时随机关闭神经元
BatchNorm批量归一化稳定训练的技术
Transfer Learning迁移学习使用预训练模型

C. 全书代码仓库

所有代码都可以在 GitHub 上找到:github.com/your-username/from-zero-to-model

D. 常见错误与解决方案

RuntimeError: Expected all tensors to be on the same device 原因:有些数据在 CPU,有些在 GPU。
解决:确保所有数据和模型在同一设备上。

model = model.to('cuda')
data = data.to('cuda')
IndexError: Target X is out of bounds 原因:标签的值超过了模型输出的范围。
解决:检查标签是否从 0 开始,输出层神经元数量是否正确。
ValueError: Expected input batch_size to match target batch_size 原因:数据和标签的批次大小不匹配。
解决:检查 DataLoader 的设置,确保数据和标签一一对应。
RuntimeError: mat1 and mat2 shapes cannot be multiplied 原因:矩阵形状不匹配。
解决:检查输入维度和层的维度是否匹配。可以用 print(x.shape) 调试。

E. 学习资源清单

类型资源说明
视频课程吴恩达《深度学习》Coursera 上的经典课程
视频课程李宏毅《机器学习》B站免费,中文讲解
视频课程3Blue1Brown最直观的数学可视化
书籍《动手学深度学习》d2l.ai,代码丰富
书籍《深度学习》(花书)经典教材
实践Kaggle数据科学竞赛平台
实践Hugging Face预训练模型库
文档PyTorch 官方文档pytorch.org