Andrej Karpathy
现代千亿级参数大模型与微型网络在链式法则求导与梯度下降闭环上完全一致,PyTorch等工业框架的张量化封装本质上只是为硬件加速服务的工程实现。
AI-assisted summary of The spelled-out intro to neural networks and backpropagation: building micrograd — original source. Check the original for full context.
Source published:
Key ideas
- Andrej Karpathy 从零构建了标量级自动求导引擎 micrograd,仅用约 150 行 Python 代码(engine.py 与 nn.py)完整实现了反向传播与多层感知机训练闭环。 (4:33)
- 反向传播在计算图多路径汇聚时必须采用梯度累加(+=)而非直接赋值(=),以严格符合多元微积分链式法则并避免分支梯度覆盖 Bug。 (82:28)
- 自动微分引擎中算子的抽象粒度可自由定制,无论是封装粗粒度 tanh 还是拆解为指数、乘法、加法等原子运算,叶子节点求得的梯度在数学上完全等价。 (96:20)
- 在训练循环中,每次调用 loss.backward() 之前必须显式执行 zero_grad 重置参数梯度,否则累加机制会导致历史梯度无限叠加破坏训练收敛。 (128:43)
Detailed notes
## Background 该视频由 Andrej Karpathy 发布于 YouTube,旨在提供对神经网络反向传播及训练过程最详尽的循序渐进式讲解。视频内容仅要求观众具备基本的 Python 编程知识和高中程度的微积分概念,是其“Neural Networks: Zero to Hero”系列课程中的核心教程。
## TL;DR 视频通过从零构建微型自动求导引擎 micrograd,深入浅出地演示了神经网络背后的数学本质。Karpathy 带领观众通过定义 Value 对象、实现运算符重载与链式法则,完成了反向传播机制的手动推导,并最终将其扩展为完整的神经元、层和多层感知机(MLP)模型。通过对比手动实现与 PyTorch 等工业级框架,观众能够清晰理解梯度下降驱动权重优化的底层逻辑,从而掌握训练现代神经网络的核心原理。
## Atmosphere & style 视频氛围亲切且极具启发性,Karpathy 展现了一位资深专家将复杂技术“去魅”的卓越教学能力。他以一种类似结对编程的叙事节奏,耐心调试代码中的逻辑漏洞,甚至故意保留了教学中的有趣错误,使整个过程既像是一场严肃的学术研讨,又像是一次轻松的代码探险。这种手把手构建的教学方式不仅消除了对深度学习的恐惧感,更带给观众一种在底层数学中抽丝剥茧、最终获得洞见的深度成就感。
## Bulletin - [04:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=273s) Andrej Karpathy 从零构建了标量级自动求导引擎 micrograd,仅用约 150 行 Python 代码(engine.py 与 nn.py)完整实现了反向传播与多层感知机训练闭环。 - [01:22:28](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4948s) 反向传播在计算图多路径汇聚时必须采用梯度累加(+=)而非直接赋值(=),以严格符合多元微积分链式法则并避免分支梯度覆盖 Bug。 - [01:36:20](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5780s) 自动微分引擎中算子的抽象粒度可自由定制,无论是封装粗粒度 tanh 还是拆解为指数、乘法、加法等原子运算,叶子节点求得的梯度在数学上完全等价。 - [02:08:43](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7723s) 在训练循环中,每次调用 loss.backward() 之前必须显式执行 zero_grad 重置参数梯度,否则累加机制会导致历史梯度无限叠加破坏训练收敛。
## Key takeaways - [00:00](https://www.youtube.com/watch?v=VMj-3S1tku0&t=0s) 反向传播是 PyTorch 和 JAX 等现代深度学习库的数学内核,其实质是通过拓扑遍历高效评估损失函数关于权重的偏导数。 - [04:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=273s) micrograd 采用标量求导引擎而非高维张量是出于教学目的,以避免张量维度掩盖微积分与链式法则的直觉,二者在底层数学机制上毫无二致。 - [09:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=573s) 神经网络训练不能依赖符号求导或有限差分数值近似,而是通过计算图中局部导数与上游梯度的链式连乘实现解析级的高效反向传播。 - [43:07](https://www.youtube.com/watch?v=VMj-3S1tku0&t=2587s) 加法节点在反向传播中充当“梯度路由器”,其局部导数恒为 1.0,能够将上游损失梯度无损分发给所有输入子节点。 - [47:07](https://www.youtube.com/watch?v=VMj-3S1tku0&t=2827s) 乘法节点在反向传播时将上游梯度与配对操作数的当前数值进行交叉相乘并向下传递。 - [01:09:02](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4142s) 在 Value 对象中通过捕获父节点与局部导数的闭包函数(_backward),可以在前向运算时动态绑定链式求导逻辑。 - [01:17:32](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4652s) 全图自动反向传播依赖有向无环图的拓扑排序,节点必须等待其所有后继依赖节点处理完毕后方可触发自身的梯度回传。 - [01:22:28](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4948s) 计算图中同一节点若被多次引用,多元微积分链式法则要求梯度必须使用 += 累加,否则后续分支会覆盖先前的梯度导致求导错误。 - [01:31:52](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5512s) 通过重载 Python 的 __rmul__、__pow__、__neg__ 等魔术方法,能将减法与除法优雅地降级为加法、乘法与幂运算的组合。 - [01:36:20](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5780s) 将 tanh 拆解为指数与除法等原子操作所得的梯度与黑盒算子完全一致,证明自动微分引擎可按需在任意抽象层次定义算子。 - [02:21:10](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8470s) PyTorch 底层在 C++/CUDA 内核中计算 tanh 梯度的核心数学逻辑依然是 grad * (1.0 - output * output),与标量实现本质相同。 - [01:47:55](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6475s) 构建多层感知机(MLP)仅需逐层抽象神经元(Neuron)、层(Layer)与网络模块,通过累加各层权重偏置的参数列表即可支持统一优化。 - [02:01:12](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7272s) 梯度下降沿负梯度方向更新网络参数以最小化均方误差损失,学习率选取过大会引发数值震荡甚至发散,过小则收敛缓慢。 - [02:08:43](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7723s) 每一次训练迭代必须严格执行“清零梯度 -> 前向传播求损失 -> 反向传播求梯度 -> 参数更新”四步闭环,遗漏梯度清零是深度学习初学者的常见 Bug。 - [02:14:03](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8043s) 拥有数千亿参数的现代巨型语言模型(如 GPT)在计算图机制、链式反向传播和梯度下降更新逻辑上,与 41 个参数的微型网络完全同构。
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=VMj-3S1tku0&t=0s) 课程目标与 micrograd 概览
Andrej Karpathy 开篇介绍自己训练深度神经网络已有十余年时间。在本讲座中,他希望向大家展示神经网络训练“引擎盖下”(under the hood)的真实面貌。课程将从一个完全空白的 Jupyter Notebook 开始,一步步构建出完整的代码,最终定义并训练一个神经网络,让学习者在直观层面彻底理解其底层运作机制。
Andrej 将带领大家从零构建 micrograd。这是他在大约两年前开源在 GitHub 上的一个微型库,但当时只上传了源码,没有配套讲解,学习者只能自行摸索。micrograd 本质上是一个轻量级的自动求导引擎(autograd engine,即 automatic gradient 的缩写),它的核心功能是实现反向传播(backpropagation)。反向传播算法能够极其高效地评估某个损失函数(loss function)关于神经网络权重的梯度(gradient)。一旦拥有了这些梯度,我们便可以通过迭代微调网络的权重来最小化损失函数,进而提升网络的准确率。因此,反向传播构成了当今 PyTorch 或 JAX 等现代深度学习库的数学内核。
```mermaid flowchart LR accTitle: micrograd 自动求导与反向传播工作流 accDescr: 展示从输入变量构建计算图前向传播,再通过反向传播自动递归应用链式法则计算梯度的过程。
subgraph Inputs["输入层"] A["a: Value(-4.0)"] B["b: Value(2.0)"] end
subgraph Graph["表达式图 (前向传播)"] C["中间节点 c, d, e, f"] G["输出节点 g: Value(24.7)"] end
subgraph Backprop["反向传播 (g.backward)"] Grads["递归链式法则<br/>计算所有节点梯度<br/>a.grad=138, b.grad=645"] end
A --> C B --> C C --> G G -.->|"g.backward()"| Grads ```
- micrograd 是一个实现自动求导与反向传播算法的核心引擎。 - 反向传播的用途:求取损失函数相对于权重的梯度,进而通过微调参数来最小化损失、提高模型精度。 - 它是包括 PyTorch 和 JAX 在内的现代深度学习库的底层数学支柱。
[01:24](https://www.youtube.com/watch?v=VMj-3S1tku0&t=84s) 表达式图的前向计算与反向求导机制
为了直观展示 micrograd 的工作原理,Andrej 演示了一个构建数学表达式的示例。在这个例子中,输入标量 $a = -4.0$ 与 $b = 2.0$ 被封装进 micrograd 的核心 `Value` 对象中。通过这个对象,可以对它们进行加法、乘法、常数幂次运算、偏移 1、取负、在 0 处截断(squash at zero,即 ReLU)、平方、除以常数等丰富的数学运算,逐步生成中间变量 $c$、$d$、$e$、$f$,最终输出标量 $g$。
在后台,micrograd 会自动维护整个计算图(expression graph)的数据结构。例如,它知道 $c$ 也是一个 `Value`,是由加法操作生成的,并且 $c$ 维护着指向其子节点 $a$ 和 $b$ 的指针。运行前向传播(forward pass)时,通过访问 `g.data` 属性可以得到最终的计算数值,在这个例子中结果为 $24.7$。
然而真正的关键在于反向传播:直接调用 `g.backward()`,即可从输出节点 $g$ 开始反向回溯整个计算图,递归地应用微积分中的链式法则(chain rule)。这一过程不仅能求出 $g$ 相对于内部中间节点(如 $e$、$d$、$c$)的导数,还能求出它相对于初始输入节点 $a$ 和 $b$ 的导数。查询 `a.grad` 和 `b.grad`,会发现数值分别为 $138$ 和 $645$。导数的物理意义在此十分明确:如果我们将 $a$ 向上轻微扰动(使其略微增大),$138$ 这个斜率表明 $g$ 也将随之增长;同样,$b$ 对应的增长斜率则是 $645$。它精确地刻画了微调输入时输出响应的灵敏度。
- 示例中的输入为 $a = -4.0$ 与 $b = 2.0$,封装为 `Value` 对象。 - 前向计算得到输出 $g.data = 24.7$。 - 调用 `g.backward()` 自动递归执行链式法则,求出各节点对 $g$ 的偏导数。 - 得到梯度的实际值:`a.grad = 138`,`b.grad = 645`,代表微调输入时 $g$ 变化的斜率。
[04:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=273s) 标量引擎与现代张量库的设计差异
对于示例中构建的繁复表达式,Andrej 调侃道,这只是他随便编造出来展示 micrograd 支持操作的无意义表达式。但事实表明,神经网络本身也只是数学表达式,甚至比这个随手捏造的表达式还要规整:它以输入数据和网络权重作为输入,经过层层计算,输出预测值或损失值。反向传播更具普适性,它并不针对神经网络,而是适用于任何数学表达式,只是恰好被应用到了神经网络的优化训练中。
Andrej 特别指出,micrograd 是一个标量值(scalar-valued)自动求导引擎,它将神经网络拆解为最底层的原子标量以及一个个基础的加号与乘号。在实际生产环境中,绝不会用这种标量引擎来训练网络,这样设计的目的完全是出于教学考量。现代深度学习框架使用高维张量(tensors),但从数学本质来看,张量只是把这些标量打包成大数组,以便利用计算机底层体系结构的并行计算能力加速处理,“所有的数学运算没有发生任何改变,做张量化纯粹是为了计算效率”。如果一开始就从张量切入,反而会掩盖微积分与链式法则的核心直觉。
他强调,micrograd 的代码其实极度精简,整个库仅包含两个核心文件: 1. `engine.py`:纯粹的自动求导引擎,对神经网络一无所知,仅用约 100 行极其平实的 Python 代码就实现了完整的反向传播; 2. `nn.py`:搭建在求导引擎之上的神经网络组件,定义神经元(Neuron)、由神经元构成的层(Layer)以及层堆叠形成的多层感知机(Multi-Layer Perceptron, MLP)。
Andrej 评价道:“nn.py 这个基于 autograd 引擎构建的神经网络库,简直就像个玩笑……所以基本上,仅仅通过 150 行代码就能产生巨大的威力。”这 150 行代码正是理解神经网络训练核心所需的全部内容,剩下的不过是工程优化。
“My claim is that micrograd is what you need to train your networks and everything else is just efficiency so you'd think that micrograd would be a very complex piece of code and that turns out to not be the case.” —— Andrej Karpathy
- micrograd 与现代框架的核心区别:标量计算图 vs. 多维张量(tensors)。 - 张量化(vectorization)仅为了并行度与运行效率,底层的数学与链式法则机制完全相同。 - micrograd 的极简代码结构: - `engine.py`:约 100 行代码,实现标量表达式图与链式法则反向求导。 - `nn.py`:约 50 行代码,定义 Neuron、Layer 和 MLP。 - 总计仅约 150 行代码,即构成了深度学习训练的完整内核。
[08:08](https://www.youtube.com/watch?v=VMj-3S1tku0&t=488s) 标量函数的导数直觉与几何可视化
为了确保大家对导数建立扎实的直觉,Andrej 开始带领大家在 Jupyter Notebook 中从最基础的单变量标量函数切入。他首先导入了常用的标准库,接着定义了一个简单的单输入、单输出二次函数:
$$f(x) = 3x^2 - 4x + 5$$
当传入 $x = 3.0$ 时,函数计算返回的结果为 $20.0$。从数学形式很容易看出这是一条抛物线。为了观察它的几何形状,Andrej 利用 NumPy 创建了一个输入数组,范围取自 $[-5, 5)$,步长为 $0.25$(即 `np.arange(-5, 5, 0.25)`)。将这个数组直接传给函数 $f$,NumPy 会独立作用于数组中的每一个元素,得到对应的因变量数组 `ys`。随后利用 Matplotlib 进行绘制(`plt.plot(xs, ys)`),便在屏幕上清晰呈现出一条光滑的抛物线图像。这一可视化为接下来探讨微小扰动 $h$、斜率以及导数的极限定义打下了几何直觉的基础。
- 导入基本工具并定义标量测试函数:$f(x) = 3x^2 - 4x + 5$。 - 计算测试点取值:$f(3.0) = 3(3)^2 - 4(3) + 5 = 27 - 12 + 5 = 20.0$。 - 采样区间:利用 `np.arange(-5, 5, 0.25)` 构造测试点序列。 - 绘图展示:借助 Matplotlib 绘制出抛物线图像,用于直观感知输入与输出之间的响应关系。
[09:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=573s) 单输入简单函数的导数与微积分直觉
安德烈·卡帕西(Andrej Karpathy)首先提出了一个基础问题:对于一个简单的单变量函数 $f(x) = 3x^2 - 4x + 5$,在任意输入点 $x$ 处的导数是什么?在传统的微积分课堂上,我们通常会拿出纸和笔,应用乘积法则等各种求导公式,推导出该函数的解析导数表达式,然后代入不同的 $x$ 值来计算具体导数。然而,卡帕西指出,在神经网络中我们不能采用这种符号化的方法:
> “在神经网络中,实际上没有人会去写出整个神经网络的数学表达式,那将是一个极其庞大的表达式……它会有成千上万个项,当然没有人会去手动推导它的导数,所以我们不会采用这种符号化的方法。”
因此,卡帕西带大家重新温习了导数的数学定义: $$\lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$$ 导数本质上衡量的是敏感度:如果你在某个点 $x$ 处将输入稍微增加一个极小的值 $h$,函数值会如何响应?它会上升还是下降?变化的幅度有多大?这个响应的斜率就是该点处的导数。
为了在 Python 中数值化地评估这个导数,卡帕西选择了一个极小的 $h = 0.001$。以 $x = 3.0$ 为例,此时 $f(x) = 20$。如果我们将 $x$ 稍微向正方向微调(nudge)一点,由于该点处的斜率是正的,我们预期 $f(x+h)$ 会略大于 20。通过计算变化量并除以 $h$(即 $\frac{\text{rise}}{\text{run}}$,也就是斜率),我们就能得到导数的数值近似。卡帕西解释说,虽然 $h$ 越趋近于 0 结果越精确,但在计算机中不能无限制地增加 $h$ 的零的个数:
> “在某一个点上,我会得到一个错误的结果,因为我们使用的是浮点数运算,而所有这些数字在计算机内存中的表示都是有限的,到了一定程度我们就会遇到麻烦。”
在 $x = 3.0$ 处,通过这种数值方法算出的斜率约为 $14.0$。如果我们通过解析法求导, $f'(x) = 6x - 4$,代入 $x = 3$ 同样得到 $18 - 4 = 14$,两者完全吻合。随后,卡帕西又测试了 $x = -3.0$ 处的情况,此时向正方向微调 $x$ 会导致函数值下降,因此算出的斜率是负数(约为 $-22.0$)。而在该函数的顶点 $x = 2/3$(约 $0.666$)处,微调输入几乎不会引起函数值的变化,因此该点处的导数趋近于 $0$。
---
[14:12](https://www.youtube.com/watch?v=VMj-3S1tku0&t=852s) 多输入函数的偏导数与数值估算
为了进一步逼近神经网络的实际情况,卡帕西引入了一个稍微复杂的多元函数。该函数包含三个标量输入 $a$、$b$ 和 $c$,以及一个标量输出 $d$,其数学表达式为: $$d = a \cdot b + c$$
在代码中,卡帕西将输入初始化为 $a = 2.0$、$b = -3.0$、$c = 10.0$,此时输出 $d = 2.0 \cdot (-3.0) + 10.0 = 4.0$。接着,他希望通过数值微调的方法,分别求出 $d$ 对 $a$、$b$ 和 $c$ 的偏导数,以此来直观感受每个输入对输出的影响力。
```mermaid flowchart LR accTitle: d = a * b + c 的计算图 accDescr: 一个简单的计算图,展示了输入 a、b 和 c 如何通过乘法和加法操作生成输出 d。 a["a (2.0)"] --> mul["*"] b["b (-3.0)"] --> mul mul -->|"e (-6.0)"| add["+"] c["c (10.0)"] --> add add --> d["d (4.0)"] ```
为了评估 $d$ 对 $a$ 的导数,卡帕西将 $a$ 增加了 $h = 0.0001$。因为 $b$ 是负数($-3.0$),增加 $a$ 意味着我们在 $d$ 中加上了一个更负的数,因此预期函数值会下降。实验结果确实如此,输出从 $4.0$ 降到了约 $3.9996$,算出的斜率为 $-3.0$。这与解析导数 $\frac{\partial d}{\partial a} = b = -3.0$ 完全一致。
同理,当微调 $b$ 时,因为 $a$ 是正数($2.0$),增加 $b$ 会使输出 $d$ 增加,算出的斜率为 $2.0$,与解析导数 $\frac{\partial d}{\partial b} = a = 2.0$ 一致。而当微调 $c$ 时,由于 $c$ 是直接加在表达式末尾的,它的变化会 1:1 地反映在输出上,因此其斜率为 $1.0$(即 $\frac{\partial d}{\partial c} = 1.0$)。通过这些例子,卡帕西帮助大家建立起了清晰的直觉:导数就是当你在输入端进行微小的调整时,输出端随之变化的速率。
---
[19:09](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1149s) 构建 micrograd 的核心 Value 对象
在理解了导数的物理意义后,卡帕西开始着手构建神经网络库。由于神经网络本质上是极其庞大的数学表达式,我们需要设计一种能够自动追踪并维护这些表达式的数据结构。为此,他开始在 Jupyter Notebook 中构建 `Value` 类,这也是整个 `micrograd` 库的核心。
卡帕西首先写出了 `Value` 类的基础骨架。这个类非常简单,它包裹并追踪一个单一的标量数值(`data`),并实现了一个友好的字符串表示方法 `__repr__`,以便在 Python 中打印时能够清晰地看到其包裹的数据:
```python class Value: def __init__(self, data): self.data = data
def __repr__(self): return f"Value(data={self.data})" ```
通过这个定义,我们可以实例化一个对象,例如 `a = Value(2.0)`。然而,此时如果我们尝试将两个 `Value` 对象相加(如 `a + b`),Python 会抛出类型错误(TypeError),因为 Python 此时还不知道如何对两个自定义的 `Value` 对象进行加法运算。为了解决这个问题,卡帕西指出,我们需要在类中实现 Python 的特殊双下划线方法(dunder methods),比如 `__add__`,从而逐步赋予这个对象进行数学运算的能力。
[20:26](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1226s) 实现运算符重载与 `Value` 对象的核心逻辑
在 Python 中,为了让自定义对象能够直接使用数学运算符(如 `+` 和 `*`),必须定义特殊的双下划线方法(dunder methods)。当代码中执行 `a + b` 时,Python 内部实际上调用的是 `a.__add__(b)`。在这个方法中,`self` 指向 `a`,而传入的 `other` 则是 `b`。方法执行后会返回一个新的 `Value` 实例,该实例内部包裹了 `self.data + other.data` 的计算结果。需要注意的是,此时 `self.data` 和 `other.data` 均为 Python 内置的标准浮点数,因此这里调用的加法就是原生的浮点数相加,而非 `Value` 对象之间的递归加法。对于输入 `a = Value(2.0)` 与 `b = Value(-3.0)`,相加得到的新对象包含的值即为 `-1.0`。
```python class Value: def __init__(self, data, _children=(), _op='', label=''): self.data = data self.grad = 0.0 self._prev = set(_children) self._op = _op self.label = label
def __repr__(self): return f"Value(data={self.data})"
def __add__(self, other): out = Value(self.data + other.data, (self, other), '+') return out
def __mul__(self, other): out = Value(self.data * other.data, (self, other), '*') return out ```
乘法运算的实现遵循完全相同的模式,只需定义 `__mul__` 方法并在内部将底层数值相乘即可。例如创建 `c = Value(10.0)` 后,计算 `a * b` 会返回封装了 `-6.0` 的新 `Value` 对象。关于 `__repr__` 方法,如果不提供该实现,打印对象时只会显示一段晦涩难懂的内存地址;实现 `__repr__` 则能让终端清晰地输出类似 `Value(data=-6.0)` 的直观表达。有了 `__add__` 与 `__mul__` 之后,像 `a * b + c` 这样的复合表达式就能被顺利解析:它等价于 `(a.__mul__(b)).__add__(c)`,最终求值结果为 `4.0`。
- `a.__add__(b)`:加法运算重载,内部提取浮点数相加后返回封装结果的新 `Value` 对象。 - `a.__mul__(b)`:乘法运算重载,内部提取底层数值相乘并返回新对象。 - `__repr__`:提供格式化的字符串表示,避免输出晦涩的 Python 原生对象内存描述符。
---
[22:45](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1365s) 构建计算图的骨架:父子指针与操作符追踪
仅仅能进行前向数值运算还远远不够,自动求导需要整个数学表达式的“结缔组织”(connective tissue)。系统必须清楚地记录下表达式图结构中的指针:到底是由哪些节点(输入值)通过何种运算生成了当前的节点(输出值)。为此,在 `Value` 类的构造函数中引入了新的属性参数。构造函数接收一个默认为空元组的 `_children`,并在对象内部将其转化为集合保存在私有属性 `self._prev` 中。对于像通过输入数据直接初始化的叶子节点,其 `_children` 为空元组,`_prev` 自然也是空集合;但当节点是通过加法或乘法生成时,调用方会将运算的操作数 `(self, other)` 作为子节点元组传递进去,成为新节点的来源记录。
除了记录子节点,系统还需要知道每个新值是由何种操作符生成的。因此,构造函数中加入了字符串变量 `_op`。对于原始输入的叶子节点,`_op` 默认为空字符串 `''`;而由加法生成的节点其 `_op` 被标记为 `'+'`,由乘法生成的节点则被标记为 `'*'`。这样一来,若将 `d = a * b + c` 计算出的节点打印检查,通过访问 `d._prev`,可以看到它来自封装了 `-6.0` 的中间节点和封装了 `10.0` 的节点 `c`;通过访问 `d._op`,则能准确确认生成它的是加法操作 `'+'`。
> “Looking at my code here I can't remember exactly the reason, I believe it was efficiency, but this underscore children will be a tuple for convenience but then when we actually maintain it in the class it will be just this set, yeah I believe for efficiency.” —— Andrej Karpathy
- `self._prev`:使用集合维护产生当前节点的所有前驱节点(子节点引用),构造函数参数输入元组,内部转为集合存储以提高查找效率。 - `self._op`:记录产生该节点的计算操作符(如 `'+'`、`'*'`),叶子节点默认为空字符串。 - 完整表达式网络追踪:每个中间节点都具备追踪上游输入和所用操作符的能力,从而构成了完整的有向无环计算图(DAG)。
---
[24:54](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1494s) 使用 Graphviz 可视化前向计算图
随着计算表达式逐渐变大,代码会变得复杂且难以仅靠文本阅读来理清关系,因此直观的可视化工具不可或缺。为此,Karpathy 引入了一个名为 `draw_dot` 的辅助函数,该函数依赖开源的图形渲染库 Graphviz 及其 Python 接口。`draw_dot` 首先调用辅助遍历函数 `trace`,从根节点开始递归收集计算图中所有的节点和有向边,然后遍历这些元素,在 Graphviz 图中创建对应的形状。
为了让可视化更加清晰,`draw_dot` 在图中不仅为每个 `Value` 对象创建长方形的数值节点,还额外创建了一批“虚拟操作节点”(fake operation nodes),用圆圈标记其对应的算符(如 `+` 或 `*`),并将输入变量指向这些操作节点,再由操作节点指向输出变量。Karpathy 强调,这些操作节点只是为了让图形看起来更清晰而在绘图逻辑中生成的虚拟占位符,在底层实际存储的计算图中并不存在对应的数据结构,真正的计算图节点只有那些代表数值的矩形框。
为了使图例具有更强的可读性,Karpathy 进一步修改了 `Value` 类,为其添加了可选的字符串标签 `label`。通过为各个节点设置标识符(例如将 `a * b` 的结果赋值给中间节点 `e` 并打上标签 `'e'`,将后续加法结果命名为 `d` 并打上标签 `'d'`),图形节点内部就能通过类似 `{ label | data }` 的格式将变量名与其数值一并展示出来。
```mermaid flowchart LR accTitle: 前向计算图结构 accDescr: 展示变量 a、b、c 经过乘法和加法运算生成节点 d 的拓扑连接关系。
subgraph Inputs["输入叶子节点"] A["a | data: 2.0"] B["b | data: -3.0"] C["c | data: 10.0"] end
subgraph MulStage["乘法阶段"] OpMul(("*")) E["e | data: -6.0"] end
subgraph AddStage["加法阶段"] OpAdd(("+")) D["d | data: 4.0"] end
A --> OpMul B --> OpMul OpMul --> E E --> OpAdd C --> OpAdd OpAdd --> D ```
- `trace` 函数:负责深度优先遍历给定的根节点,枚举出整个表达式网络中所有涉及的节点与有向边集合。 - 虚拟操作节点(Op Nodes):在 Graphviz 绘图逻辑中额外构造的圆形运算符节点,仅用于视觉展示拓扑分支,并非底层的 `Value` 实体。 - 节点标签(`label`):为各个中间及叶子变量赋予人类可读的字符串标识,与底层数值并在同一图例格子中展示。
---
[28:10](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1690s) 扩展网络深度与反向传播的物理意义
为了让整个计算图的结构更接近真实的神经网络结构,Karpathy 将表达式又加深了一层。在节点 `d` 的基础上,新引入了叶子节点 `f = Value(-2.0, label='f')`,并将最终输出定义为变量 `L`,计算公式为 `L = d * f`。在给定了 `d = 4.0` 和 `f = -2.0` 之后,最终输出变量 `L` 的数值为 `-8.0`。至此,整个计算的前向传播过程(Forward Pass)全部完成:输入变量 `a, b, c, f` 汇集入一个纯由加法和乘法构成的标量运算网络中,最终在终点产生了一个单一标量输出 `L`。
随后,讲解转向了核心概念——反向传播(Backpropagation)。在前向传播完成之后,算法需要从最终的输出标量 `L` 倒着向回走,逆向计算 `L` 相对于表达式中每一个中间节点及叶子节点的导数(梯度)。输出对自身的导数 $\frac{\partial L}{\partial L}$ 显然恒等于 $1.0$。从终点出发,系统将沿着计算路径逐级倒推求解:$\frac{\partial L}{\partial f}$、$\frac{\partial L}{\partial d}$、$\frac{\partial L}{\partial c}$、$\frac{\partial L}{\partial e}$、$\frac{\partial L}{\partial b}$,直至最底层的 $\frac{\partial L}{\partial a}$。
Karpathy 明确点出了这套机制在神经网络中的核心意义:在真实的神经网络训练中,最终输出 `L` 通常代表度量预测误差的损失函数(Loss Function),而像 `a, b, c, f` 这样的叶子节点中,有一部分代表不可更改的固定输入数据(Data),而另一部分则代表神经网络的权重参数(Weights)。训练模型的核心诉求,正是计算损失函数相对于所有可学习权重的导数,获知如何调整权重能使损失下降。输入数据虽然也位于叶子节点,但我们并不关心损失对它的导数,因为数据是固定不变的;相反,权重必须根据梯度信息不断迭代更新。
为了在代码中追踪这些梯度值,Karpathy 在 `Value` 对象的构造函数中添加了名为 `grad` 的实例属性,其初始值被默认设为 `0.0`。初始值赋为 `0.0` 具有明确的直观意义:它代表在尚未进行反向求导时,假定各个节点对最终输出没有任何影响或改变量。
> “And in the neural network setting you'd be very interested in the derivative of basically this loss function L with respect to the weights of a neural network.” —— Andrej Karpathy
- 计算图终点定义:$L = d \times f$,数值为 $4.0 \times (-2.0) = -8.0$。 - 反向传播本质:从标量输出节点 $L$ 沿着有向图的反方向进行遍历,求出链条上每个节点相对于 $L$ 的偏导数。 - 权重与数据的区别:叶子节点分为不可变的数据与可训练的参数,梯度计算的最终受众是参数节点,用于后续的梯度下降。 - `self.grad` 属性:在每个 `Value` 节点内维护其相对于根输出的标量导数,初始赋值为 `0.0`(代表对结果无影响)。
[31:16](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1876s) 初始化梯度并在可视化图中展示
在构建反向传播的核心机制时,首先需要给变量赋予一个默认状态。如果一个变量的梯度是 0,说明改变这个变量并不会改变最终的损失函数(Loss Function),即它对输出结果没有任何影响。因此,所有节点的梯度 `grad` 默认均初始化为 `0.0`。
``` data: 4.0000 | grad: 0.0000 ```
更新可视化渲染函数后,每个节点不仅能显示自身的标量数值 `data`(格式化为 `%.4f`),还能并排展示对应的梯度值 `grad`。节点中的 `grad` 始终代表着最终输出变量(在此例中为节点 $L$)对当前变量的偏导数,即 $\frac{\partial L}{\partial v}$,例如 $\frac{\partial L}{\partial f}$、$\frac{\partial L}{\partial d}$ 等。随着图渲染完成,所有节点的梯度值初始状态均为 0,整个流程准备进入手动反向传播阶段。
- 梯度的初始语义:梯度为 0 意味着微调该输入不会引起最终输出产生任何变化。 - 梯度的定义目标:图中每个节点的 `grad` 存储的都是最终标量损失 $L$ 对该节点的导数,并非局部导数。
---
[32:10](https://www.youtube.com/watch?v=VMj-3S1tku0&t=1930s) 手动反向传播第一步:终点节点与乘法节点的导数推导
手动反向传播必须从整个计算图的最末端开始逐步向前推进。最末端的节点正是输出变量 $L$ 本身。第一个要解决的问题是:$L$ 对自身的导数 $\frac{\partial L}{\partial L}$ 是多少?若将 $L$ 改变一个极微小的量 $h$,$L$ 产生的变化量同样也是 $h$,两者的变化成正比例关系,因此其导数恒为 1。
为了严谨地对推导进行检验,可以使用数值梯度(Numerical Gradient)进行验证。在 Jupyter Notebook 中定义一个临时的辅助函数 `def lol():`,这样可以避免污染全局命名空间,确保所有的变量修改都局限在函数内部。通过在基准表达式 $L_1$ 之外构建一个微调版本 $L_2$(将目标变量增加 $h$),并计算差商 $\frac{L_2.\text{data} - L_1.\text{data}}{h}$,即可得到数值估计。当测试对 $L$ 增加 $h$ 时,输出的导数恰好为 1.0。将这一步作为反向传播的基准情况(Base Case),手动执行赋值并刷新绘图:
```python L.grad = 1.0 ```
接着向前回溯至节点 $D$ 和 $F$。由于节点 $L$ 是由 $D$ 和 $F$ 相乘得到的(即 $L = D \times F$),根据导数的微积分定义:
$$\frac{\partial L}{\partial D} = \lim_{h \to 0} \frac{(D + h)F - DF}{h} = \lim_{h \to 0} \frac{DF + hF - DF}{h} = \lim_{h \to 0} \frac{hF}{h} = F$$
同理,根据对称性,$\frac{\partial L}{\partial F} = D$。已知节点数据 $D.\text{data} = 4.0$,$F.\text{data} = -2.0$,因此对应的梯度可直接赋值:
```python F.grad = 4.0 # 即 D 的值 D.grad = -2.0 # 即 F 的值 ```
随后利用辅助函数 `lol()` 进行内联梯度检查(Inline Gradient Check):对变量 $F$ 加上 $h$ 后计算差商,由于浮点精度极限打印出的值极其逼近 4.0;对变量 $D$ 加上 $h$,算出的数值导数精准命中 -2.0。
```mermaid flowchart LR accTitle: 乘法节点的反向传播梯度流 accDescr: 展示最终节点 L 通过乘法运算将导数回传给输入节点 D 和 F 的过程
subgraph Inputs["输入节点"] D["D<br/>data: 4.0<br/>grad: -2.0"] F["F<br/>data: -2.0<br/>grad: 4.0"] end
subgraph Operation["运算与输出"] Mul["*"] L["L<br/>data: -8.0<br/>grad: 1.0"] end
D --> Mul F --> Mul Mul --> L
L -.->|"dL/dF = D = 4.0"| F L -.->|"dL/dD = F = -2.0"| D ```
- 数值梯度检查机制:通过差商公式 $\frac{f(x+h) - f(x)}{h}$ 对推导出的解析梯度进行即时验证。 - 乘法求导法则:对于双输入乘法 $L = D \times F$,每个输入对应的偏导数恰好等于另一个输入的数值。
---
[38:08](https://www.youtube.com/watch?v=VMj-3S1tku0&t=2288s) 加法节点的局部导数与链式法则(Chain Rule)的核心推导
在解决完输出端的直连节点后,计算图进入到了最关键的一环——推导 $\frac{\partial L}{\partial C}$ 和 $\frac{\partial L}{\partial E}$。Andrej Karpathy 强调了这一节点在整个深度学习教学中的分量:“Now we're getting to the crux of backpropagation so this will be the most important node to understand because if you understand the gradient for this node you understand all of back propagation and all of training of neural nets basically.”
面临的核心问题在于:已知 $L$ 对中间变量 $D$ 的敏感度($\frac{\partial L}{\partial D} = -2.0$),但 $C$ 并未直接连接到 $L$,$C$ 是通过影响 $D$(通过加法 $D = C + E$)进而连带影响到最终输出 $L$ 的。解决这一问题的拆解步骤分为“局部导数”与“链式合成”两部分:
1. **局部导数(Local Derivative):** 观察加法运算 $D = C + E$。从纯局部的视角来看,这个加法节点完全不关心自身处于多么庞大的网络拓扑之中。根据极限定义:
$$\frac{\partial D}{\partial C} = \lim_{h \to 0} \frac{((C + h) + E) - (C + E)}{h} = \lim_{h \to 0} \frac{h}{h} = 1.0$$
对称地,$\frac{\partial D}{\partial E} = 1.0$。加法运算对两个输入的局部导数均为 1.0。
2. **微积分链式法则(The Chain Rule):** 尽管 Wikipedia 上的数学表述容易让人头晕眼花,但其逻辑极其简洁:若变量 $z$ 取决于 $y$,而 $y$ 又取决于 $x$,则 $z$ 依赖于 $x$ 的瞬时变化率可以通过两段变化率相乘来计算:
$$\frac{dz}{dx} = \frac{dz}{dy} \times \frac{dy}{dx}$$
因此,对于复合路径 $C \to D \to L$,复合导数的计算方式即为全局回传梯度与局部导数的乘积:
$$\frac{\partial L}{\partial C} = \frac{\partial L}{\partial D} \times \frac{\partial D}{\partial C}$$
这就是反向传播算法的基石所在:复合函数求导本质上就是各个局部环节导数沿着路径进行的连续相乘。
- 局部导数特征:加法节点充当了一个局部的独立单元,其对各输入的局部导数恒为 1.0,完全独立于网络的后续层级。 - 链式传递直觉:已知 $z$ 相对 $y$ 的变化率以及 $y$ 相对 $x$ 的变化率,二者相乘即刻锁定了 $z$ 相对 $x$ 的变化速度。
[43:07](https://www.youtube.com/watch?v=VMj-3S1tku0&t=2587s) 链式法则的直观理解与加法节点的梯度路由
为了建立对微积分中链式法则(Chain Rule)的直观认知,Andrej Karpathy 举了一个生动的物理速度比喻:如果一辆汽车的速度是一辆自行车的 2 倍,而自行车的速度又是一个步行者的 4 倍,那么这辆汽车相对于步行者的速度就是 $2 \times 4 = 8$ 倍。Karpathy 强调:“And so this makes it very clear that the correct thing to do sort of is to multiply.” 这种将中间变化率(Rates of Change)相乘的做法,在直觉上直接印证了链式法则的核心思想。
将这一思想代入计算图:目标是求解损失(或最终输出)$L$ 对中间变量 $c$ 的导数,即 $\frac{dL}{dc}$。在此之前,已经推导出 $L$ 对加法节点输出 $d$ 的导数 $\frac{dL}{dd} = -2.0$。加法运算在局部极其简单,因为 $d = c + e$,其局部导数 $\frac{\partial d}{\partial c}$ 恒等于 $1.0$。根据链式法则:
$$\frac{dL}{dc} = \frac{dL}{dd} \times \frac{\partial d}{\partial c} = (-2.0) \times 1.0 = -2.0$$
同理,由于运算的对称性,加法节点的另一个输入分支 $e$ 对应的局部导数 $\frac{\partial d}{\partial e}$ 同样为 $1.0$,因此 $\frac{dL}{de} = -2.0$。
Karpathy 进而揭示了加法节点(`+` 节点)在反向传播中的本质作用:它本质上是一个梯度路由器(Gradient Router)。因为加法节点的局部梯度恒为 $1.0$,上游传来的梯度与其相乘后保持原样不变,直接无损分发给它的所有子节点(Children Nodes)。Karpathy 随后通过在代码中直接修改测试用例来验证这一结论:分别对 `c.data` 和 `e.data` 增加扰动步长 $h$,运行求导检查后得到的数值结果均精确符合理论预测的 $-2.0$。
```mermaid flowchart LR accTitle: 加法节点的梯度路由机制 accDescr: 展示上游梯度如何通过加法节点无损分发给两个输入子节点
subgraph Inputs ["加法输入节点"] C["Node c<br/>grad = -2.0"] E["Node e<br/>grad = -2.0"] end
subgraph AddOp ["加法与输出"] Plus["Op: +<br/>局部导数 = 1.0"] D["Node d<br/>grad = -2.0"] end
D -->|"上游梯度 (-2.0)"| Plus Plus -->|"路由 (x 1.0)"| C Plus -->|"路由 (x 1.0)"| E ```
---
[47:07](https://www.youtube.com/watch?v=VMj-3S1tku0&t=2827s) 乘法节点的反向传播与局部梯度求解
完成对中间节点 $c$ 和 $e$ 的梯度推导后,反向传播继续向叶子节点递归。针对子表达式 $e = a \times b$,已知上游梯度 $\frac{dL}{de} = -2.0$,需要求出 $\frac{dL}{da}$ 和 $\frac{dL}{db}$。
Karpathy 形象地站在计算图中运算节点的视角展开推理:“So I'm a little times node inside a massive graph, and I only know that I did $a \times b$ and I produced an $e$.” 对这个局部的乘法节点(`*` 节点)而言,它根本不需要理解整个巨型图的结构,只需要关注自身的局部输入与输出。对于乘法 $e = a \cdot b$:
- $e$ 对 $a$ 的局部导数即为另一个乘数的值:$\frac{\partial e}{\partial a} = b$(当前数值为 $-3.0$)。 - $e$ 对 $b$ 的局部导数即为 $a$ 的值:$\frac{\partial e}{\partial b} = a$(当前数值为 $2.0$)。
根据链式法则将上游梯度与局部梯度相乘: - `a.grad` $= \frac{dL}{de} \times \frac{\partial e}{\partial a} = (-2.0) \times (-3.0) = 6.0$ - `b.grad` $= \frac{dL}{de} \times \frac{\partial e}{\partial b} = (-2.0) \times 2.0 = -4.0$
将这些梯度赋值到计算图可视化中刷新后,Karpathy 通过有限差分代码(对 `a.data += h` 及 `b.data += h`)进行严格校验,数值梯度输出分别为 $6.0$ 与 $-4.0$(伴随极微小的浮点舍入误差),完全吻合解析推导。
Karpathy 总结道,整个反向传播的本质非常纯粹:沿着计算图从最终输出端逐步向后递归遍历每一个节点,在每个局部节点上取出当前操作的局部导数,并将其乘以上游回传的梯度。这一全流程正是微积分链式法则在有向无环图上的递归执行过程。
---
[51:10](https://www.youtube.com/watch?v=VMj-3S1tku0&t=3070s) 梯度驱动的单步优化演示
为了展示反向传播所求梯度的实际效用,Karpathy 现场演示了一次极其纯粹的单步参数优化(Optimization Step)。优化目标是让计算图最终的输出标量 $L$ 增大(向正方向移动)。根据微积分定义,导数指示了函数增长最快的方向,因此只需将具有控制权的叶子节点输入向着梯度的正方向推进一步(Nudge in the direction of the gradient):
- 设定一个微小的步长 `step_size`(即学习率),对叶子节点 $a$、$b$、$c$、$f$ 的数值分别进行更新: $$\text{param.data} \mathrel{+}= \text{step\_size} \times \text{param.grad}$$ - 在该例中,更新前的基准输出 $L$ 约为 $-8.0$。 - 执行更新并重新运行前向传播(Forward Pass)后,$L$ 的值从 $-8.0$ 上升到了约 $-7.0$(变得不那么负了),成功实现了输出值的正向增长。
Karpathy 强调,这就是神经网络训练的核心机制:“And really does gradient just give us some power because we know how to influence the final outcome, and this will be extremely useful for training neural networks as well as you'll see.”
---
[52:52](https://www.youtube.com/watch?v=VMj-3S1tku0&t=3172s) 神经元数学模型与 tanh 激活函数
在完成了基础玩具示例后,Karpathy 转向一个更贴近实际、结构更复杂的对象:对一个人工神经元(Neuron)进行手动反向传播。
在最常见的两层多层感知机(Multi-Layer Perceptron, MLP)架构中,层与层之间的神经元是全连接的(Fully Connected)。生物学意义上的神经元结构极为精细复杂,但在深度学习中,人们采用了高度抽象的数学模型: 1. **突触输入与权重乘积**:神经元接收多个输入信号 $x_i$,突触连接具有权重参数 $w_i$,二者在突触处以乘法形式交互,向胞体(Cell Body)传递的数据流为 $\sum_i w_i x_i$。 2. **偏置项(Bias)**:胞体内部还包含一个偏置项 $b$。Karpathy 将其通俗地描述为神经元“天生的触发敏感度”(innate sort of trigger happiness),偏置可以在完全独立于外部输入的情况下,让神经元整体上更容易或更难被激活。 3. **激活函数(Activation Function)**:线性组合 $\sum w_i x_i + b$ 汇聚后,必须通过一个非线性的“挤压函数”(Squashing Function),如 Sigmoid 或双曲正切函数(tanh)。
```mermaid flowchart LR accTitle: 人工神经元计算流程 accDescr: 展示输入与权重相乘、偏置相加并经由双曲正切激活函数挤压的过程
subgraph Inputs ["突触输入"] X1["x1"] W1["w1"] X2["x2"] W2["w2"] end
subgraph CellBody ["胞体汇聚与偏置"] Mul1["w1 * x1"] Mul2["w2 * x2"] Sum["求和: sum(w*x)"] Bias["偏置: b"] PreAct["净输入: sum + b"] end
subgraph Activation ["激活挤压"] Tanh["tanh(z)"] Out["输出: Output"] end
X1 --> Mul1 W1 --> Mul1 X2 --> Mul2 W2 --> Mul2 Mul1 --> Sum Mul2 --> Sum Sum --> PreAct Bias --> PreAct PreAct --> Tanh Tanh --> Out ```
为了直观展现 tanh 的几何特性,Karpathy 在 Jupyter Notebook 中调用 `numpy.tanh` 绘制了一条连续曲线: - 当输入 $z = 0$ 时,输出严格为 $0$。 - 当输入向正方向增大时,输出曲线平滑上升并饱和渐近于上限 $1.0$。 - 当输入向负方向减小时,输出曲线平滑下降并饱和渐近于下限 $-1.0$。 无论输入信号的绝对值有多大,tanh 都会平滑地将整个实数空间“挤压”并映射到区间 $[-1.0, 1.0]$ 之内。
[55:04](https://www.youtube.com/watch?v=VMj-3S1tku0&t=3304s) 搭建神经元数学图结构与为何直接实现 tanh
Andrej Karpathy 接着上一节对 tanh 激活函数(一种“挤压函数”,squashing function)的介绍,说明一个典型神经元的输出就是对权重与输入的点积再加上偏置后,整体输入到激活函数中所得到的结果。为了节省打字时间,他通过复制代码在 Notebook 中定义了一个二维神经元的结构:输入为 $x_1$ 和 $x_2$,对应的突触权重(synaptic strengths)为 $w_1$ 和 $w_2$,再加上神经元的偏置 $b$。在计算过程中,他特意拆解为多个细小步骤,分别创建中间变量并打上标签(如 $x_1 \cdot w_1$、$x_2 \cdot w_2$ 以及两者的和),最后再加上偏置 $b$ 得到神经元细胞体在未经过激活函数时的原始激活值 $n$。用 `draw_dot(n)` 渲染计算图后,可以看到输入相乘后逐级相加的清晰拓扑。
想要得到最终输出 $o$,需要执行 `o = n.tanh()`。然而,此时的 `Value` 类只支持加法和乘法,而双曲函数 $\tanh$ 需要指数运算($\text{math.exp}$)。Karpathy 指出,虽然我们可以先实现底层的指数操作符 `exp`,再用加法、除法等基本原语拼装出 $\tanh$,但他在此处刻意选择直接在 `Value` 中将 $\tanh$ 作为单一复合操作来实现。他借此强调了自动求导的核心思想:“我们完全可以根据需要,在任意抽象层级上构建函数,无论是极其微小的原子操作如加法,还是相对复杂的复合函数,选择完全取决于我们;唯一的硬性要求,就是我们必须清楚如何对该操作求导,只要知道输入对输出的局部导数即可。”
```mermaid flowchart LR accTitle: 神经元计算图拓扑结构 accDescr: 展示二维输入、权重与偏置经过加权求和后通过 tanh 激活函数生成最终输出的过程。
subgraph Inputs["输入与权重分支"] X1["x1: 2.0"] W1["w1: -3.0"] X2["x2: 0.0"] W2["w2: 1.0"] end
subgraph Mult["乘法运算"] M1["* (x1w1)"] M2["* (x2w2)"] end
subgraph Accumulation["累加与偏置"] A1["+ (x1w1 + x2w2)"] B["b: 6.881373587"] A2["+ (细胞体原始激活 n)"] end
subgraph Output["激活输出"] T["tanh"] O["输出 o: ~0.7071"] end
X1 --> M1 W1 --> M1 X2 --> M2 W2 --> M2 M1 --> A1 M2 --> A1 A1 --> A2 B --> A2 A2 --> T T --> O ```
- 在 `Value` 类内部实现 `tanh` 方法时,利用公式 $t = \frac{e^{2x} - 1}{e^{2x} + 1}$ 计算出前向传播的数值,并返回一个新的 `Value(t, (self,), 'tanh')` 对象。 - 当把偏置调大到 $8$ 时,输入到 $\tanh$ 的值约为 $2$,输出达到 $0.96$,直观展现了输出平滑逼近 $1$ 的饱和挤压效应。 - Karpathy 随后将偏置 $b$ 精确设定为 `6.8813735870195432`,目的是让后续反向传播中的中间梯度呈现出极其整齐漂亮的数值(如 $0.5$),以便用直觉进行心算和验证。
---
[01:01:36](https://www.youtube.com/watch?v=VMj-3S1tku0&t=3696s) 手动反向传播:从输出节点到偏置分支的梯度推导
设置好计算图后,Karpathy 开始手动推导梯度,为每个节点填入 `.grad`。他提醒大家,在真正的神经网络中,整个网络往往包含成千上万个相连的神经元,最终由一个损失函数衡量整体预测表现;而最受关注的梯度永远是针对权重参数(如 $w_1, w_2$)的梯度,因为优化算法正是通过更新权重来减少损失。
求导从最末端节点 $o$ 出发。作为基础情形,根据定义输出对其自身的导数 $\frac{\partial o}{\partial o} = 1.0$,因此直接赋予 `o.grad = 1.0`。接下来需要沿着网络逆向跨过 `tanh` 操作。微积分中 $\tanh(x)$ 的导数形式为 $\frac{d}{dx}\tanh(x) = 1 - \tanh^2(x)$。由于当前节点的前向值已经存储了 $\tanh(n)$ 的结果(即 $o$ 的数值),局部导数直接等于 $1 - o^2$。将 $o$ 的具体数值代入公式计算后,恰好得到极为规整的数值:$1 - o^2 = 0.5$。根据链式法则,$\frac{\partial o}{\partial n} = \frac{\partial o}{\partial o} \times \frac{\partial o}{\partial n} = 1.0 \times 0.5 = 0.5$,所以细胞体原始求和节点 $n$ 的梯度为 `n.grad = 0.5`。
紧随其后的是累加偏置的加法节点。Karpathy 称赞道:“加法节点是我最喜欢的反向传播操作,因为它的处理极其简单。”加法操作的局部导数恒为 $1.0$,其实质就是一个“梯度分发器”(gradient distributor)。因此,流入 $n$ 的梯度 $0.5$ 被不折不扣、均等地分发给上一级的两个分支——偏置节点 $b$ 和中间和节点 $x_1 w_1 + x_2 w_2$。继续往前遇到另一个加法节点,同样把 $0.5$ 的梯度一分为二传递给 $x_1 w_1$ 与 $x_2 w_2$ 两个乘法输出节点。Karpathy 强调,每个节点的梯度都在物理层面上指示着方向:当梯度为正时,说明若要增大神经元的最终输出 $o$,增加这些中间项的数值将会带来正向贡献。
- 节点 $o$(最终输出)的梯度初始设置为 `1.0`。 - 借助导数公式 $\frac{do}{dn} = 1 - o^2$,计算得到输入 $n$ 处的梯度 `n.grad = 0.5`。 - 遇到加法节点时,上游梯度按 $1.0$ 的局部权重原样传递:偏置 `b.grad` 为 $0.5$,同时乘积项之和节点的梯度也为 $0.5$。 - 另一个加法节点继续分发,使得 `(x1*w1).grad` 与 `(x2*w2).grad` 均为 $0.5$。
---
[01:06:20](https://www.youtube.com/watch?v=VMj-3S1tku0&t=3980s) 乘法节点的反向传播与链式法则应用
在完成了所有加法分支的梯度传递后,反向传播到达了具体的输入乘法运算环节,即 $x_2 \cdot w_2$ 与 $x_1 \cdot w_1$。在乘法操作中,局部导数表现为“交叉项”法则:对于表达式 $z = x \cdot y$,$\frac{\partial z}{\partial x} = y$,而 $\frac{\partial z}{\partial y} = x$。
Karpathy 引导观众共同心算推导:在计算输入特征 $x_2$ 的梯度 `x2.grad` 时,需要将局部导数(即对应的权重数据 `w2.data`)与来自上游输出节点 $x_2 w_2$ 的梯度 `(x2*w2).grad` 相乘。应用链式法则后,其具体数值即为 `w2.data * (x2*w2).grad`。这一步骤展示了神经网络如何通过局部权重与上游回传信号的逐层连乘,将最终输出对每一个底层输入特征与突触权重的敏感度精确量化。
[01:06:51](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4011s) 完成人工反向传播并直观理解局部梯度
通过链式法则,计算图中最后几个叶子节点的梯度计算得以完成。对于节点乘法 $x_2 \times w_2$,局部导数交叉相乘:$w_2\text{.grad} = x_2\text{.data} \times (x_2 w_2)\text{.grad}$,而 $x_2\text{.grad} = w_2\text{.data} \times (x_2 w_2)\text{.grad}$。重新绘制计算图后发现,$w_2$ 的梯度为 0,因为其对应的输入数据 $x_2\text{.data} = 0$;而 $x_2$ 的梯度为 0.5(由于 $w_2\text{.data} = 1.0$ 且上游梯度为 0.5)。对此给出了极具直觉的解释:导数度量的是微调某个变量对最终输出产生的影响;如果输入为 0,无论如何微调其权重 $w_2$,由于被乘以 0 彻底“扼杀(squashing)”,最终输出都不会发生任何改变,因此其导数为 0 完全合情合理。
紧接着处理另一个分支 $x_1 \times w_1$。上游传递过来的梯度同样为 0.5。乘法的局部导数对 $x_1$ 而言是 $w_1\text{.data}$,对 $w_1$ 而言是 $x_1\text{.data}$。经过链式法则相乘,最终求得 $x_1\text{.grad} = -1.5$(由 $-3.0 \times 0.5$ 得到),而 $w_1\text{.grad} = 1.0$(由 $2.0 \times 0.5$ 得到)。整个神经元表达式的人工反向传播至此彻底完成。Andrej Karpathy 总结道,如果我们希望提高神经元的输出,目前调节 $w_2$ 没有任何效果,但增大 $w_1$ 则能成比例地让神经元输出增加。
- 节点 $w_2$ 的最终梯度为 0.0,因其输入端 $x_2\text{.data} = 0$ - 节点 $x_2$ 的最终梯度为 0.5($1.0 \times 0.5$) - 节点 $x_1$ 的最终梯度为 -1.5($-3.0 \times 0.5$) - 节点 $w_1$ 的最终梯度为 1.0($2.0 \times 0.5$) - 调优结论:“so if this weight goes up then this neuron's output would have gone up and proportionally because the gradient is one”(因此如果该权重增加,神经元的输出也会相应增加,且比例与为 1 的梯度一致)。
---
[01:09:02](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4142s) 在 Value 类中实现运算的 `_backward` 闭包
纯手工计算每个节点的导数繁琐且不切实际。为了告别这种折磨,必须将反向传播的自动化逻辑内置到 `Value` 对象中。核心思路是在每个节点上存储一个内部方法 `self._backward`。当节点由某种数学运算生成时,该方法利用 Python 闭包(closure)捕获输入节点和局部链式法则逻辑,负责将当前节点(`out`)的全局梯度反向传播至其父节点(`self` 和 `other`)。
对于加法操作 `__add__`,局部导数恒为 1.0,因此闭包函数直接将输出梯度复制给参与相加的两个输入节点: ```python def _backward(): self.grad += 1.0 * out.grad other.grad += 1.0 * out.grad out._backward = _backward ``` 对于乘法操作 `__mul__`,局部导数是对方节点的数值,因此闭包将上游梯度乘上对应数值并传递: ```python def _backward(): self.grad += other.data * out.grad other.grad += self.data * out.grad out._backward = _backward ``` 对于激活函数 `tanh`,其局部导数为 $1 - t^2$(其中 $t$ 为 `tanh` 的输出数值),因此闭包为: ```python def _backward(): self.grad += (1.0 - t**2) * out.grad out._backward = _backward ```
对于叶子节点,默认赋予一个无操作的空函数 `lambda: None`。在此过程中 Karpathy 遇到了一个典型 bug:误写成 `out._backward = _backward()`,从而执行了该函数并赋了返回值 `None`,导致后续调用时抛出 `'NoneType' object is not callable` 错误。他幽默地决定保留这一调试失误:“I thought about redoing it but I figured I should just leave the error in here because it's pretty funny”(我本想重录这段,但觉得留着这个错误挺有意思的),以此强调我们是在把函数对象本身保存下来,而不是在定义时直接调用它。
```mermaid flowchart LR accTitle: Value 对象的 _backward 闭包机制 accDescr: 展示输出节点通过 _backward 闭包将自身梯度与局部导数相乘并传递回父节点
subgraph Inputs ["输入父节点"] S["self (数值: self.data)"] O["other (数值: other.data)"] end
subgraph Operation ["前向计算与闭包绑定"] OP{"运算节点 (+ / * / tanh)"} end
subgraph OutputNode ["输出节点 out"] OUT["out.data & out.grad"] BW["out._backward() 闭包"] end
S --> OP O --> OP OP --> OUT OUT -.->|"触发反向传播"| BW BW -->|"chain rule: local derivative * out.grad"| S BW -->|"chain rule: local derivative * out.grad"| O ```
---
[01:13:56](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4436s) 手动调用 `_backward` 逐步验证梯度传递
重新修复并定义好 `Value` 类后,神经元表达式被重新构建,所有节点的梯度初始重置为 0。自动化反向传播的第一步是基准设定:必须手动将最终输出节点 `o.grad` 显式设为 1.0,因为根据微积分恒等式 $\frac{\partial o}{\partial o} = 1.0$;如果不初始化,所有乘以上游梯度的计算都将因初始值 0 而归零。
随后依次调用各个节点的 `_backward` 方法: 1. 调用 `o._backward()`:通过 `tanh` 将梯度传递给激活前的和节点 $n$,计算得出 $n\text{.grad} = 0.5$。 2. 调用 `n._backward()`:加法操作将 0.5 复制给两个分支节点,分别将偏置 $b$ 和加法节点 $x_1 w_1 + x_2 w_2$ 的梯度更新为 0.5。 3. 试图在叶子节点 $b$ 上调用 `b._backward()`:由于 $b$ 是叶子节点,其绑定的默认闭包为空函数,调用后不产生任何副作用。 4. 调用加法节点 $(x_1 w_1 + x_2 w_2)\text{._backward()}$:将 0.5 再次分流至乘积节点 $x_1 w_1$ 与 $x_2 w_2$。 5. 分别调用 $(x_1 w_1)\text{._backward()}$ 与 $(x_2 w_2)\text{._backward()}$。
重新渲染图形化界面后,计算图中各节点的数值与梯度完全还原了之前手动计算的结果($0$、$0.5$、$-1.5$、$1.0$)。这验证了通过闭包封装局部链式法则的正确性。
---
[01:17:32](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4652s) 引入拓扑排序实现整图自动反向传播
虽然每个节点不再需要手动写公式计算梯度,但仍然必须人工按从右向左的顺序一个一个执行 `_backward()`。为了实现彻底的自动化,整个表达式计算图的逆向执行顺序必须由程序自动确定。
在有向无环图(DAG)中,只有当一个节点的所有后继节点(即所有依赖它的计算)都已完成了反向传播并将梯度汇入该节点后,该节点才能安全地触发自身的 `_backward()`。这种在依赖图上排列节点先后次序的经典算法即为**拓扑排序**(Topological Sort)。Karpathy 指出,拓扑排序的直观含义就是对图中的所有节点进行线性排列,使得图中所有的有向边仅从左向右单向延伸。只要构建出这种从输入到输出的正向依赖拓扑序列,然后将其完全翻转(reverse),即可得到严格自输出向输入推进的反向传播调用序列,从而实现端到端的 `o.backward()`。
[01:18:46](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4726s) 拓扑排序与整图反向传播的自动化实现
为了让整个计算图能够自动执行反向传播,必须按照依赖顺序逆向遍历所有节点。Karpathy 详细演示了如何通过拓扑排序(Topological Sort)来实现这一点。算法的核心是维护一个已访问节点的集合 `visited`,从输出根节点(例如单个神经元的输出 $o$)开始递归构建有向无环图(DAG)的节点序列。对于当前访问的节点,先检查其是否已访问过;若未访问,则将其标记为已访问,并递归遍历其所有子节点(即输入操作数),调用构建函数。只有当当前节点的所有子节点全部处理完成并加入列表后,该节点自身才会被追加到 `topo` 列表中。
```mermaid flowchart LR accTitle: 拓扑排序构建反向传播调用链 accDescr: 展示拓扑排序自左向右构建的节点顺序,以及反向传播时逆序执行的过程
subgraph TopoOrder["拓扑排序正向依赖序列 (topo)"] Inputs["输入变量<br/>(x1, w1, x2, w2, b)"] --> Intermediates["乘积与求和中间节点<br/>(x1w1, x2w2, x1w1 + x2w2, n)"] Intermediates --> OutputNode["根节点<br/>o (0.7071)"] end
subgraph BackwardPass["反向传播执行流 (reversed(topo))"] direction RL BackRoot["o.grad = 1.0<br/>o._backward()"] --> BackInter["中间节点调用<br/>_backward()"] BackInter --> BackInputs["叶子节点计算完毕"] end ```
这种机制保证了一个关键的不变量(invariant):“so basically this node that we're going to call it on like say o is only going to add itself to the topo list after all of the children have been processed and that's how this function is guaranteeing that you're only going to be in the list once all your children are in the list and that's the invariant that is being maintained”。在神经元图上执行此函数后,输出列表的最后一个元素就是数值为 $0.707$ 的根节点 $o$,其前置节点为 $n$,其余所有节点均从左到右严格依照依赖关系排列。
接下来,Karpathy 将整个反向传播过程串联起来: 1. 将所有节点的梯度重置为 $0$。 2. 将基准情况 $o.\text{grad}$ 设为 $1.0$。 3. 对生成的 `topo` 列表调用 Python 内置的 `reversed()` 进行反向遍历,依次对每个节点调用 `node._backward()`。
代码执行后,终端中打印出的各节点梯度与此前纯手动链式求导的结果完全一致。为了让 API 像 PyTorch 一样优雅,Karpathy 将整套逻辑封装到 `Value` 类的公有方法 `backward()` 中:该方法内部自动完成以 `self` 为起点的拓扑排序,将 `self.grad` 设为 $1.0$,并倒序调用所有节点的内部私有方法 `_backward()`。用户只需在最终标量输出上轻轻调用一次 `o.backward()`,无需再编写任何繁琐的拓扑遍历代码。
[01:22:28](https://www.youtube.com/watch?v=VMj-3S1tku0&t=4948s) 多分支复用节点的梯度覆盖 Bug 与累加修复
当自动化反向传播封装完毕后,Karpathy 警告大家先别高兴得太早:“now we shouldn't be too happy with ourselves actually because we have a bad bug um and we have not surfaced the bug because of some specific conditions that we are we have to think about right now”。这个 Bug 在当前神经元图中被掩盖了,因为计算图中的每一个节点恰好都只被后续操作使用了一次。然而,只要一个变量在后续表达式中被引用多次,当前的求导实现就会彻底崩溃。
Karpathy 现场写下了一个最小复现用例:定义变量 $a = 3.0$,然后定义 $b = a + a$,最后调用 $b.\text{backward()}$。在前向传播中,$b$ 的数值正确地得到了 $6.0$。但在微积分的数学直觉上,$\frac{\partial b}{\partial a} = \frac{\partial (a + a)}{\partial a} = 1 + 1 = 2$。而当前的程序运行后,$a.\text{grad}$ 却变成了 $1$!
```mermaid flowchart TD accTitle: 变量复用时的梯度反向传播 accDescr: 显示一个变量在图中多次被消费时,反向传播分支必须汇聚相加
subgraph ForwardPass["前向传播:变量复用"] A["a"] -->|"左输入分支"| B["b = a + a"] A -->|"右输入分支"| B end
subgraph BackwardBug["错误机制(覆盖赋值)"] B_grad["b._backward()"] -.->|"self.grad = 1.0"| A_grad1["a.grad = 1.0"] B_grad -.->|"other.grad = 1.0 (覆盖!)"| A_grad2["a.grad = 1.0 (最终为 1)"] end
subgraph BackwardFix["正确机制(多元微积分链式法则)"] B_back["b._backward()"] ==>|"+= 1.0"| A_acc["a.grad = 0 + 1.0 + 1.0 = 2.0"] end ```
出现这一严重 Bug 的底层原因在于加法反向传播的赋值逻辑:在 `__add__` 的私有求导中,代码写的是 `self.grad =...` 和 `other.grad =...`。当执行 $a + a$ 时,`self` 和 `other` 指向的是内存中的同一个对象(即 $a$)。反向传播执行时,先将 $a.\text{grad}$ 设为 $1$,紧接着又将其重新赋值为 $1$,第二条分支的梯度直接覆盖了第一条分支。在更复杂的结构中,例如 $d = a \times b$、$e = a + b$、$f = d \times e$,变量 $a$ 和 $b$ 同时流向乘法和加法两条支路,当从输出 $f$ 反向穿过 $e$ 和 $d$ 时,后执行的反向函数会无情地洗掉先前计算出的梯度贡献。
从多元微积分的链式法则(Multivariate Chain Rule)来看,如果一个变量的输出影响了多个下游分支,那么该变量的总梯度必须是所有下游分支反向传播回来的梯度之和。因此,修复这一 Bug 的方案极其直观简洁: - 将所有操作符(`+`、`*`、`tanh` 等)内部的梯度赋值语句 `self.grad =...` 全部替换为累加语句 `self.grad +=...`。 - 因为所有节点的梯度在初始时都严格被置为 $0$,所以来自不同支路的梯度贡献自然会在各自的节点上叠加累积。
Karpathy 随手把代码修改为 `+=` 并重新运行测试:$b = a + a$ 算出的 $a.\text{grad}$ 瞬间修正为 $2.0$;复杂分支网络中的多路贡献也全部正确汇总。
[01:27:05](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5225s) 支持标量运算:重载操作符的类型包装
解决完梯度累加的 Bug 后,Karpathy 动手清理了 Jupyter Notebook 中用于验证的临时单元格,只保留核心的 `Value` 类和图形绘制代码。此时他的目光转向了此前实现的激活函数 $\tanh$。在之前的代码里,$\tanh$ 被作为一个不可分割的黑盒原子算子整体实现。但事实上,$\tanh$ 在数学上可以展开为以自然常数 $e$ 为底的指数运算:
$$\tanh(x) = \frac{e^{2x} - 1}{e^{2x} + 1}$$
Karpathy 强调,虽然直接实现 $\tanh$ 更加快捷,但将其拆解为更基础的微观算子(指数、除法、减法、加法)具有极大的教学价值:“i would like to do that now because i want to prove to you that you get all the same results and all those ingredients but also because it forces us to implement a few more expressions”。这样做不仅能向学习者直观证明黑盒函数与底层算子组合在求导结果上完全等价,更倒逼微架构补充一系列必须的基础数学运算。
然而,在尝试拆解 $\tanh$ 时,首先暴露出来的工程障碍是数据类型的兼容性。在 Python 中,如果用户尝试写形如 `a + 1` 或 `a * 2`(其中 `a` 为 `Value` 实例)的代码,解释器会当场抛出异常:`AttributeError: 'int' object has no attribute 'data'`。这是因为在 `__add__(self, other)` 和 `__mul__(self, other)` 内部,代码直接尝试访问 `other.data`,而原生 Python 的 `int` 或 `float` 显然没有这个属性。
为了提供像 PyTorch 那样符合人体工学的优雅语法体验,Karpathy 在算子入口处增加了类型安全校验与自动封装: - 在 `__add__` 中:如果传入的 `other` 并非 `Value` 的实例,则自动将其视为普通数值并封装为 `Value(other)`。 - 在 `__mul__` 中:采用完全相同的防御性逻辑,若 `other` 不是 `Value` 实例,则包装为 `Value(other)`。
修改后,`a + 1` 和 `a * 2` 均能顺畅运行并保留梯度的流通通路。然而 Karpathy 紧接着抛出了一个更为隐蔽的语言陷阱:“now here's a kind of unfortunate and not obvious part a times two works we saw that but two times a is that gonna work you'd expect it to right but actually it will not”。当操作数位置颠倒写成 `2 * a` 时,Python 默认会首先尝试调用整数对象的乘法方法 `int.__mul__(2, a)`,而标准的 Python 整数显然完全不认识用户自定义的 `Value` 类,程序再次面临报错崩溃的边缘。这一微妙细节为后续引入 Python 的反射双目运算符(如 `__rmul__`)埋下了伏笔。
[01:29:22](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5362s) Python 反向乘法机制 `__rmul__` 的引入
在进行数值运算时,`a * 2` 会自然触发 Python 底层的 `a.__mul__(2)` 调用,这对自定义的 `Value` 对象来说完全没问题。然而,当操作数顺序调换写成 `2 * a` 时,Python 会首先尝试调用整数对象的乘法方法 `2.__mul__(a)`。由于内置的整数 `int` 完全不知道该如何与自定义的 `Value` 对象相乘,这个调用会直接报错困惑。
为了解决这个问题,Andrej Karpathy 解释了 Python 的后备降级(fallback)机制:实现 `__rmul__` 方法。当 Python 发现左侧操作数无法执行乘法时,会主动检查右侧操作数 `a` 是否知道如何乘上 `2`,进而触发 `Value` 上的 `__rmul__`。Karpathy 为此编写的代码极其优雅直观,只需调换操作数顺序即可:
```python def __rmul__(self, other): return self * other ```
“So because Python can't do 2 times a, it will check: is there an `__rmul__` in `Value`? And because there is, it will now call that.” Andrej Karpathy 解释道。借由这一重定向,`2 * a` 会交由 `__rmul__` 接管并转回已经实现好的 `a * 2`,再次运行后表达式顺利求值为 `4`。
---
[01:30:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5433s) 实现指数运算 `exp` 及其反向传播
为了能够将复合的双曲正切函数(tanh)完全拆解为更基础的数学运算,系统还需要支持指数与除法。Karpathy 首先着手实现单变量的指数运算 `exp()`。该方法在结构上与 `tanh` 十分相似,都是接收一个标量输入并输出一个标量。前向传播直接取出内部数值 `self.data`,调用标准库的 `math.exp()` 进行计算,并将其包装为新的 `Value` 返回。
随后,Karpathy 留出思考空档,引导大家推导其反向传播的链式法则。指数函数有一个广为人知的微积分特性:$e^x$ 对 $x$ 的导数依然是 $e^x$。因为前向传播的结果已经保存在 `out.data` 中,本地导数无需重复计算,只需将其与输出节点的梯度 `out.grad` 相乘,即可完成梯度的反向回传:
$$\frac{\partial L}{\partial x} = \frac{\partial L}{\partial \text{out}} \cdot \frac{\partial \text{out}}{\partial x} = \text{out.grad} \cdot \text{out.data}$$
代码中直接累加至 `self.grad += out.data * out.grad`。这一实现简洁高效,成功为 `Value` 对象赋予了指数运算与导数链式传递的能力。
---
[01:31:52](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5512s) 泛化除法运算:基于幂函数 `__pow__` 的实现
在处理除法时,Karpathy 没有直接编写单独的除法求导逻辑,而是选择实现一种更为通用、数学上更强大的算子:常数幂运算 `__pow__`。由于除法 $a / b$ 在代数上严格等价于 $a \cdot b^{-1}$,只要系统支持 $x^k$ 形式的幂运算,除法就变成了幂运算与乘法的组合特例:
$$\frac{a}{b} = a \cdot b^{-1}$$
在编写 `__pow__(self, other)` 时,Karpathy 明确做出类型断言,要求指数 `other` 必须是标准的 Python `int` 或 `float` 数值,而不能是图中的 `Value` 节点,因为变量作为底数和常数作为指数的导数形式与两节点互求导数截然不同。对于幂函数 $y = x^n$,微积分中的幂法则(Power Rule)表明其导数为:
$$\frac{d}{dx} x^n = n \cdot x^{n - 1}$$
对应的链式法则反向传播实现如下:
```python def _backward(): self.grad += (other * (self.data ** (other - 1))) * out.grad ```
在此基础上,除法运算 `__truediv__(self, other)` 仅用单行代码即可优雅实现:`return self * (other**-1)`。
紧接着,Karpathy 又以极简方式补齐了减法 `__sub__(self, other)`。由于减法本质上是加上一个相反数($a - b = a + (-1 \cdot b)$),因此直接将其定义为 `self + (-other)`,而一元取负 `__neg__` 则由 `self * -1` 构成。所有高级算子都被分解并映射到加法、乘法与常数幂三个核心基石上。
```mermaid flowchart LR accTitle: 复合运算向核心基础算子的映射关系 accDescr: 展示减法与除法如何通过幂运算与乘法间接实现 subgraph Composite["高阶运算定义"] Sub["减法 a - b"] Div["除法 a / b"] end subgraph CoreOps["核心基础算子"] Neg["取负 (-1 * b)"] Add["加法 a + (-b)"] Pow["幂运算 b^(-1)"] Mul["乘法 a * b^(-1)"] end
Sub --> Neg --> Add Div --> Pow --> Mul ```
- **幂法则对应关系**:指数 `n` 对应传入的标量 `other`,底数 $x$ 取自内部属性 `self.data`。 - **运算优先级自洽**:Python 中幂运算符 `**` 优先级高于乘法 `*`,运算表达式执行顺序天然严谨。 - **正向验证正确**:输入 `Value(2.0) / Value(4.0)`,前向计算精准返回期待值 `0.5`。
---
[01:36:20](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5780s) 拆解双曲正切 tanh 验证梯度等价性
准备好完整的算子体系后,Karpathy 回到最初构建的双输入神经元案例,着手进行核心验证:将原本黑盒封装的单一激活函数节点 `tanh`,拆解为底层的微观数学算式:
$$\tanh(x) = \frac{e^{2x} - 1}{e^{2x} + 1}$$
在代码实现中,输入经过仿射变换得到加权和 $n$ 之后,系统先计算中间节点 $e = (2 \cdot n).\text{exp}()$,随后将输出定义为 $o = (e - 1) / (e + 1)$。
“Number one we're expecting to see a much longer graph here because we've broken up tanh into a bunch of other operations. But those operations are mathematically equivalent, and so what we're expecting to see is number one the same result here so the forward pass works, and number two because of that mathematical equivalence we expect to see the same backward pass and the same gradients on these leaf nodes.” Andrej Karpathy 强调道。
运行反向传播并绘制计算图后,整张拓扑图明显拉长,原先紧凑的单一 `tanh` 节点被细粒度地展开为一连串由指数节点 `exp`、乘法节点 `*`、加法节点 `+` 以及包含 `-1` 幂次方的复合子网络。核对各叶子节点的最终导数: - 偏置与第二组输入权重:`w2.grad = 0.0`,`x2.grad = 0.5` - 第一组输入与权重:`w1.grad = 1.0`,`x1.grad = -1.5`
计算出的叶子节点梯度与此前使用整体 `tanh` 公式推导的结果完全一致。Karpathy 指出,这次试验的核心启示在于:**在自动微分引擎中,实现操作节点的粒度完全取决于开发者自身**。既可以细致入微地为每一个独立的 `+` 或 `*` 编写微观反向传播,也可以将任意复合逻辑(如整个 `tanh`)打包成一个独立粗粒度节点,只要其局部微积分导数推导正确,宏观上的链式求导结果在数学上必然等价。
[01:39:03](https://www.youtube.com/watch?v=VMj-3S1tku0&t=5943s) 复合运算的本质与对标工业级框架 PyTorch
在此前对 $\tanh$ 进行细粒度拆解与梯度反向传播后,Andrej Karpathy 总结道,算子分解成原子级的步骤从根本上讲是一种抽象视角:“只要你能写出局部梯度,就能链式传递梯度并继续反向传播,因此这些函数的设计完全取决于你”(“if you can write the local gradients you can chain the gradient and you can continue back propagation so the design of what those functions are is completely up to you”)。随后,他转向展示如何使用现代深度学习工业级库 PyTorch 来复现一模一样的计算图。Micrograd 的底层架构在设计之初就大致参考了 PyTorch 的 API 规范。
```mermaid flowchart LR accTitle: Comparison between Micrograd and PyTorch accDescr: Micrograd operates on scalar Value objects while PyTorch wraps data in multi-dimensional Tensors. subgraph Micrograd["Micrograd (标量级引擎)"] direction TB MVal["Value(2.0)<br/>标量对象"] MData["属性:.data,.grad"] MVal --> MData end
subgraph PyTorch["PyTorch (工业级张量引擎)"] direction TB PTen["torch.Tensor([2.0])<br/>float64 标量张量"] PReq["requires_grad=True"] PData["属性:.data,.grad<br/>取值:.item()"] PTen --> PReq --> PData end ```
Micrograd 本质上是一个标量引擎,只能处理 `2.0` 这样的单个数字;而在 PyTorch 中,所有运算均基于张量(Tensor),即由标量组成的 $n$ 维数组。为了完全对标,Karpathy 构造了只包含单一元素的标量张量。在默认情况下,PyTorch 的浮点张量采用 32 位单精度(`float32`),但由于原生 Python 的浮点数是 64 位双精度,为了确保数值计算完全一致,他在创建张量时显式将其强转为双精度(`double`,即 `float64`)。此外,出于计算效率考量,PyTorch 对网络输入叶子节点的求导追踪默认是关闭的(`requires_grad=False`),因此在定义叶子节点时必须显式声明 `requires_grad=True`。
- Micrograd 专注于单标量数据结构,而 PyTorch 原生支持多维标量数组(例如 $2 \times 3$ 维张量),能够高效执行并行矩阵运算。 - Python 原生浮点数为双精度,PyTorch 默认张量类型为 `float32`;通过 `.double()` 转换为 `float64` 可以与 Python 精度完全匹配。 - 叶子节点必须手动配置 `x.requires_grad = True`,PyTorch 默认不为叶子节点计算梯度以节省开销。
[01:42:01](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6121s) PyTorch 前向传播与梯度验证
定义好包含叶子节点的标量张量后,Karpathy 演示了使用 PyTorch 执行加法、乘法以及 `torch.tanh` 运算的过程。PyTorch 计算得到的结果对象依然是张量,并且与 Micrograd 的设计完全对称,同样具有 `.data` 和 `.grad` 属性。调用反向传播方法 `o.backward()` 后,可以通过 `.grad` 检查各输入的偏导数。如果需要从单元素张量中解包出原生的 Python 浮点数,只需调用 `.item()` 即可。
执行代码后,PyTorch 的前向传播输出为 `0.707`,反向传播所得的叶子节点梯度分别为 `0.5`、`0.0`、`-1.5` 与 `1.0`。这与此前在 Micrograd 中手动计算以及通过拆解算子计算出的数值完全一致。Karpathy 总结道,Micrograd 所构建的一切,实际上就是 PyTorch 在所有张量均为单元素标量时的特殊情况;而 PyTorch 之所以强大,在于它能够在此数学抽象之上利用底层高效张量进行大规模并行处理。
| 节点对象 | Micrograd 前向输出 / 梯度 | PyTorch 前向输出 / 梯度 (`.item()`) | 结论 | |:--- |:--- |:--- |:--- | | **输出 $o$** | 0.7071 | 0.7071 | 前向计算完全一致 | | **输入 $x_1$ 梯度** | 0.5 | 0.5 | 局部偏导完全对标 | | **权重 $w_1$ 梯度** | 0.0 (微小浮点误差趋向 0) | 0.0 | 局部偏导完全对标 | | **输入 $x_2$ 梯度** | -1.5 | -1.5 | 局部偏导完全对标 | | **权重 $w_2$ 梯度** | 1.0 | 1.0 | 局部偏导完全对标 |
[01:43:55](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6235s) 搭建神经网络库:单个神经元实现
确立了自动求导引擎的可靠性后,Karpathy 开始在 Micrograd 之上自底向上搭建神经网络库。他指出,神经网络本质上就是一类特殊的数学表达式。为了使代码架构规范化,他仿照 PyTorch 的 `nn.Module` 设计风格,开始构建多层感知机(MLP,Multi-Layer Perceptron)的组件。第一步是实现一个可调用的单个神经元类 `Neuron`。
```mermaid flowchart LR accTitle: Computation inside a single Neuron accDescr: Inputs are paired with weights, multiplied, summed with bias, and squashed by tanh. subgraph Inputs["输入与权重"] X["输入向量 x"] W["随机权重 w ~ [-1, 1]"] end
subgraph DotProduct["点积求和"] Mul["pairwise 逐项相乘: wi * xi"] Bias["偏置 b ~ [-1, 1]"] Sum["sum(..., start=b)<br/>累加激活值 act"] end
subgraph Activation["非线性激活"] Tanh["act.tanh()"] Out["输出 out"] end
X & W --> Mul --> Sum Bias --> Sum --> Tanh --> Out ```
`Neuron` 的构造函数接收输入维度 `nin`(Number of Inputs),并为每个输入通道在 $[-1.0, 1.0]$ 区间内均匀随机初始化一个标量权重 `w`,同时初始化一个控制神经元触发门槛的标量偏置 `b`。在 Python 中,通过实现特殊方法 `__call__(self, x)`,可以使类实例支持类似于函数调用的语法(例如 `n(x)`)。神经元的前向计算过程即经典的加权点积运算加上偏置:$act = \sum (w_i \cdot x_i) + b$。
- 在 `__call__` 的实现中,Karpathy 运用 Python 内置函数 `zip(self.w, x)` 将权重列表和输入向量按位置配对打包成元组迭代器。 - 为了实现优雅的累加,他利用内置函数 `sum` 的第二个可选参数 `start`,将起始值直接设为偏置 `self.b`(即 `sum((wi * xi for wi, xi in zip(self.w, x)), self.b)`),免去额外的加法操作。 - 累加所得的原始激活值 `act` 经过非线性激活函数 `act.tanh()` 压缩后返回,确保神经元具备非线性表达能力。
[01:47:55](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6475s) 神经元层(Layer)的抽象封装
在单个神经元搭建完成后,Karpathy 进一步抽象出神经网络层(`Layer`)。根据多层感知机的拓扑设计,同一层内的各个神经元之间互不相连,但每个神经元都全连接(Fully Connected)到上一层传入的全部输入。因此,一个神经元层在概念上就是一组独立对相同输入进行评估的神经元集合。
Karpathy 编写了 `Layer` 类:其构造函数接收两个参数——单个神经元的输入维度 `nin`,以及当前层包含的神经元数量 `nout`(即该层的输出维度)。该类内部维护一个由 `nout` 个独立初始化的 `Neuron(nin)` 构成的列表。当对该层实例进行调用时,它会对传入的输入向量依次执行各个神经元的计算,并以列表形式返回包含所有神经元输出的新向量。通过实例化一个接收 2 维输入、包含 3 个神经元的层(`Layer(2, 3)`),并传入示例输入,程序成功输出了由 3 个标量激活值构成的列表,完成了向多层感知机架构迈进的关键一步。
[01:48:53](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6533s) 构建完整的多层感知机(MLP)
在完成单个神经元和单层神经元的构建后,Andrej Karpathy 将这两者组合以构建完整的**多层感知机**(MLP, Multi-Layer Perceptron)。在 MLP 中,网络各层按顺序依次首尾相接,前一层的输出直接作为后一层的输入。为了节省时间,Karpathy 快速贴出实现代码并进行拆解:初始化方法接收输入维度 `nin` 以及一个列表 `nouts`,该列表明确指定了 MLP 中每一层的神经元数量(例如 `[4, 4, 1]` 表示两个包含 4 个神经元的隐藏层和一个单输出神经元层)。代码将 `[nin] + nouts` 拼成一个完整的尺寸列表,遍历相邻的尺寸元组依次实例化各个 `Layer` 对象;在 `__call__` 方法中,输入 `x` 沿着这些层被顺序调用并传递下去。
为了匹配之前的架构图,Karpathy 实例化了一个包含 3 个输入、两个 4 神经元隐藏层和 1 个输出神经元的网络结构:`MLP(3, [4, 4, 1])`。在测试前向传播时,传入一个 3 维输入向量(如 `[2.0, 3.0, -1.0]`),网络顺利返回结果。不过 Karpathy 注意到,因为每一层都默认返回列表,即使输出层只有 1 个神经元,得到的结果也是被包裹在列表中的单元素 `[Value(...)]`。为了调用上的方便,他在 `Layer` 的实现中加入了一行判断逻辑:如果输出列表长度恰好为 1,则直接解包返回单个 `outs[0]`,否则返回完整列表。随后,他尝试调用 `draw_dot(n(x))` 绘制计算图。整个 MLP 前向传播展开后是一张庞大且错综复杂的计算图,层层推进直至最终的单个输出值。Karpathy 感叹道,这种表达式在纸笔上求导几乎不可想象,但借助 micrograd 的自动化机制,反向传播可以轻而易举地穿透整张图,计算出所有层神经元权重的导数。
```mermaid flowchart LR accTitle: MLP Architecture Flow accDescr: A visual diagram showing a multi-layer perceptron with 3 inputs, two hidden layers of 4 neurons each, and 1 output neuron.
subgraph Inputs["输入层 (3 维)"] X["x: [x0, x1, x2]"] end
subgraph Layer1["Layer 1 (4 个神经元)"] L1["Layer(3, 4)"] end
subgraph Layer2["Layer 2 (4 个神经元)"] L2["Layer(4, 4)"] end
subgraph Layer3["输出层 (1 个神经元)"] L3["Layer(4, 1)"] end
subgraph Output["最终输出"] Y["单个标量 Value (非列表)"] end
X --> L1 L1 --> L2 L2 --> L3 L3 --> Y ```
[01:51:04](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6664s) 构造小型数据集与定义均方误差损失函数(Loss)
有了可用的 MLP,Karpathy 构建了一个微型玩具数据集用于二分类任务。该数据集包含 4 个样本(每个样本是 3 维特征向量)以及对应的 4 个目标标签(`ys = [1.0, -1.0, -1.0, 1.0]`)。当网络在未经训练的初始状态下对这 4 个样本执行前向预测(`[n(x) for x in xs]`)时,输出结果分别为 `0.91`、`0.88`、`0.80` 和 `0.80`。Karpathy 逐一核对当前预测与真实标签的偏差:第一个样本预测值接近 1.0(表现良好),但中间两个样本的目标是 -1.0,当前输出却全是约 0.88 和 0.80,差距极大。
为了量化网络的预测质量并调整权重,深度学习的通用思路是“计算一个单一标量来衡量神经网络的整体表现,我们称这个数值为损失(loss)”。Karpathy 直言: > “The trick used in deep learning to achieve this is to calculate a single number that somehow measures the total performance of your neural net and we call this single number the loss.”
当前网络的损失必然很高,优化的目标就是使损失最小化。Karpathy 现场实现了**均方误差**(MSE, Mean Squared Error)损失: 1. 使用 `zip(ys, ypred)` 逐一配对真实标签与预测值。 2. 对每对标签计算差值并平方:`(yout - ygt)**2`。平方既能消除正负号的影响(类似于绝对值,确保非零误差始终为正),又能在预测与标签完全一致时让单项损失恰好为 0。 3. 将这 4 个样本的平方误差直接相加,得到总损失。
当前总损失约为 7.12。紧接着,Karpathy 执行了 `loss.backward()`,这行代码触发了全自动的梯度回溯。此时检查第一层第一个神经元的首个权重 `n.layers[0].neurons[0].w[0]`,其 `.grad` 已经填入了具体的导数值(为负数)。负梯度意味着如果微幅增加该权重,总损失就会下降。
- 输入数据集:4 个样本,每个样本为 3 个特征构成的输入向量。 - 目标标签:`ys = [1.0, -1.0, -1.0, 1.0]`。 - 初始未优化预测值:`[0.91, 0.88, 0.80, 0.80]`。 - 初始 MSE 损失值:约 `7.12`(其中第 2、3 个样本各贡献了约 3.5 左右的平方误差)。
[01:56:13](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6973s) 庞大的计算图与网络参数(Parameters)收集
Karpathy 使用 `draw_dot(loss)` 渲染了整个损失函数的计算图。由于该图包含了全部 4 个样本的完整前向传播过程以及顶层的 MSE 损失归约,图形变得极其巨大且复杂,以至于他不禁惊呼:“哦天哪,我们现在构建出的这张图简直太夸张了。”整张庞大图谱以标量损失(7.12)作为根节点,反向传播算法沿着每一条前向路径反向渗透,将导数一路传递到最前端的输入层以及散布在各个神经元内部的权重($w$)和偏置($b$)。
Karpathy 指出,输入数据点(如输入的 `1.0`)同样被赋予了梯度,但这些梯度对训练并无实际价值,因为输入数据是固定的客观环境,无法人为篡改;唯独各层神经元的权重与偏置参数是可调节的。为了能够批量、统一地操作所有需要更新的变量,网络需要一个便捷接口来归拢全部参数。他在 `Neuron` 类中实现了 `parameters()` 方法,将神经元的权重列表与偏置拼接后返回:`self.w + [self.b]`。他提到,这种设计完全复刻了 PyTorch 中各个 `nn.Module` 的 `parameters()` 行为,其核心目的就是“收集神经网络的所有参数到一个数组中,以便我们能基于梯度信息同时对它们进行微调”。
[01:58:44](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7124s) 为网络层与多层感知机实现参数收集接口
在处理完单个神经元的参数导出后,Andrej Karpathy 接着为更高层级的结构编写 `parameters` 方法。在 PyTorch 中,各种模块(Module)会返回参数张量(Tensors),而在 micrograd 中,返回的则是标量对象列表。`Layer` 本身也是一个模块,最初他写了一段直观但略显冗长的前向遍历代码:先声明一个空的 `params` 列表,用 `for neuron in self.neurons` 遍历层中的每个神经元,调用 `neuron.parameters()`,再通过 `params.extend(...)` 拼接到列表中。Karpathy 随即指出:“这代码量实在太冗长了(this is way too much code)”,并在 Python 中将其重构成嵌套列表推导式(list comprehension):`return [p for neuron in self.neurons for p in neuron.parameters()]`。
```mermaid flowchart TD accTitle: micrograd Parameter Aggregation Flow accDescr: Diagram showing how parameters propagate from Neuron to Layer to MLP.
subgraph SG1 ["MLP 级别"] A["MLP.parameters()"] end
subgraph SG2 ["Layer 级别"] B["Layer.parameters()"] end
subgraph SG3 ["Neuron 级别"] C["Neuron.parameters()"] D["权重 w 与偏置 b<br/>(共 41 个标量)"] end
A -->|"推导式遍历每层"| B B -->|"推导式遍历每个神经元"| C C -->|"返回 Value 列表"| D ```
紧接着,Karpathy 对顶层的多层感知机 `MLP` 应用了完全相同的结构,写出 `return [p for layer in self.layers for p in layer.parameters()]`。由于刚给类添加了新的接口方法,而运行环境中的实例仍属于尚未定义该方法的旧类定义,Karpathy 只能重新实例化神经网络 `n`。重新初始化导致随机生成的权重发生了微小改变,损失函数的初始输出从之前的数值略微变成了 4.84。Karpathy 通过打印 `n.parameters()` 验证了这一机制,确认整个 3 层 MLP(输入 3 维,隐层各 4 维,输出 1 维)中所有权重和偏置总共包含 41 个参数标量。
- `Layer` 的参数提取实现:单行嵌套推导式 `[p for neuron in self.neurons for p in neuron.parameters()]` - `MLP` 的参数提取实现:单行嵌套推导式 `[p for layer in self.layers for p in layer.parameters()]` - 网络重新初始化导致预测值产生微小随机扰动,当前整个 MLP 的总参数量确定为 41 个
[02:01:12](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7272s) 梯度下降的核心逻辑与符号推导
有了所有参数的统一接口后,下一步就是根据反向传播计算出的梯度来更新它们。Karpathy 选取了网络中的某个具体神经元参数进行直观剖析:该参数当前的数值 `p.data` 是 0.85,而其在当前损失上的梯度 `p.grad` 是一个负数。他解释说,如果希望沿着梯度方向调整参数,在梯度下降(gradient descent)的直觉中,“梯度向量指向的是损失增加的方向(in gradient descent we are thinking of the gradient as a vector pointing in the direction of increased loss)”。
为了最小化损失,更新方向必须与梯度方向相反。Karpathy 仔细推导了正负号的关系:如果采用 `p.data += 0.01 * p.grad`,由于该参数的梯度为负,参数本身会被减小(例如从 0.85 变到 0.84 左右);但是偏导数为负意味着“增加该数值反而会使损失下降”,若将其减小,损失反而会上升。因此必须引入负号: ```python p.data += -0.01 * p.grad ``` 加上负号后,该参数从 0.854 微调上升到了 0.857。Karpathy 在单元格中重新运行前向传播验证了改动效果,整体损失果然如预期一般从 4.84 成功下降到了 4.36。
- 单步测试学习率(step size):选用小步长如 0.01 - 符号逻辑:梯度为负意味着参数增大将使损失变小,因此更新量必须减去步长乘以梯度(即相反方向) - 首步更新验证:单次微调后损失从 4.84 下降到 4.36,证明符号与梯度传导完全正确
[02:05:08](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7508s) 手动单步迭代与步长(学习率)的微妙平衡
在确认损失下降后,Karpathy 开始手动反复交替执行三步流程:前向传播计算损失、调用 `loss.backward()` 计算梯度、执行更新语句 `p.data += -0.01 * p.grad`。随着每一次手动点击运行,损失一路顺畅滑落:4.36、3.90、3.66、3.47。查看此时的预测向量 `ypred`,各个数值都在逐渐朝预定目标(1, -1, -1, 1)靠拢。
为了加速收敛,Karpathy 尝试将步长提高至 0.1。损失在极短时间内暴跌到了 0.31,并在随后降到了 0.04,此时输出预测值已经非常接近目标(如 0.99 级别的精度)。但在继续加大步幅激进点击时,训练过程瞬间出现了数值震荡(overstepping)。Karpathy 警示道,梯度仅代表局部变化率,如果步子迈得太大,就可能跳入一个损失曲面完全不同的区域,甚至导致损失爆炸。庆幸的是,在随后的一次迭代中数值奇迹般地恢复并收敛至超低状态(损失达到 $7 \times 10^{-9}$)。Karpathy 借此感慨道:“因此寻找恰到好处的步长在某种程度上是一门精妙的艺术,尤其是在使用这种朴素梯度下降算法时(finding the step size to be just right it's it's a pretty subtle art sometimes when you're using sort of vanilla gradient descent)”。
- 手动迭代路径:损失连续下降(4.36 -> 3.90 -> 3.66 -> 3.47) - 提高学习率到 0.1 后:损失先迅速下降至 0.04,随后因步长过大产生颠簸 - 最终收敛状态:损失跌至极低点 $7 \times 10^{-9}$,模型完美拟合目标数据 - 学习率权衡:过小收敛极慢,过大则会由于局部线性假设失效而越过极小点甚至发散
[02:08:38](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7718s) 编写完整的梯度下降训练循环
在手动单步调优验证了整个流程之后,Karpathy 将散落的步骤整合为一个更规范、更具工程规范的自动化训练循环(training loop)。他清空了之前的临时测试代码,将整个网络和初始数据重新初始化,并设计了一个运行 20 个迭代步(steps)的 `for k in range(20):` 循环。
```mermaid flowchart LR accTitle: Standard Gradient Descent Optimization Loop accDescr: The iterative cycle of forward pass, backward pass, and parameter update.
A["前向传播<br/>Forward Pass"] --> B["计算损失<br/>Calculate Loss"] B --> C["反向传播<br/>loss.backward()"] C --> D["参数更新<br/>Update via -lr * p.grad"] D -->|"下一个 Step"| A ```
在循环体内部,流程被严格固定为三个经典阶段: 1. **前向传播(Forward pass)**:遍历数据输入得到当前预测 `ypred`,进而计算均方误差损失 `loss`。 2. **反向传播(Backward pass)**:调用 `loss.backward()`,让反向传播算法沿着整个计算图自动计算出每个标量参数对最终损失的导数。 3. **参数更新(Update / Gradient Descent)**:遍历 `n.parameters()` 中的所有参数,根据反向传播计算出的梯度沿着负梯度方向更新每个标量的数值。
对于超参数的选取,Karpathy 结合刚才的实验经验指出,学习率设为 0.01 略显缓慢,而设为 0.1 又有发散风险,因此折中挑选了一个介于两者之间的值,并设置打印语句以便在控制台中清晰追踪每一个 step 的数值变化。
[02:09:59](https://www.youtube.com/watch?v=VMj-3S1tku0&t=7799s) 梯度未清零的经典 Bug 与修复
优化过程再次运行后,损失函数以一种更受控、更平缓的速度下降到了极低的值,预测值 `ypred` 看起来也非常接近目标。然而就在此时,Andrej Karpathy 发现了一个潜藏在代码中的严重漏洞。他自嘲道:“这真的有点尴尬,但我们代码里其实藏着一个非常严重的 Bug,而且是个很隐蔽、极其常见的 Bug,我真不敢相信自己这辈子已经是第 20 次犯这个错误了,尤其还是在镜头前录制的时候。”他原本可以把整段视频重录一遍,但他认为把这一幕留下来更有趣,也能让大家体会到平时和神经网络打交道时的真实常态。
```mermaid flowchart TD accTitle: 训练循环中的梯度重置流程 accDescr: 展示了每次迭代中梯度清零、前向传播、反向传播与参数更新的正确执行顺序。
subgraph StepLoop["单步训练循环 (Training Step)"] A["1. zero_grad 重置梯度<br/>(p.grad = 0.0)"] --> B["2. 前向传播<br/>(计算 ypred 与 Loss)"] B --> C["3. 反向传播<br/>(loss.backward() 累加梯度)"] C --> D["4. 参数更新<br/>(p.data += -learning_rate * p.grad)"] end ```
这个错误正是 Karpathy 很久以前发推列出的“神经网络最常见错误”排行榜里的第三名:**在调用 `backward()` 前忘记将梯度归零(zero grad)**。在 Micrograd 的设计中,所有权重参数都拥有 `data` 和 `grad` 两个属性。初始时 `grad` 为 0,第一次前向传播并调用 `backward()` 后,梯度被填入;随后虽然根据梯度更新了 `data`,但并没有清空 `grad`。当进入第二轮迭代再次调用 `backward()` 时,由于计算图中所有节点的反向传播操作都使用了 `+=`(累加),上一轮留下的梯度不仅没有被重置,反而在当前轮次中越积越大。
修复这个问题的方法非常直接,必须在反向传播前遍历神经网络的所有参数,显式地将梯度重置为零:
```python for p in n.parameters(): p.grad = 0.0 ```
Karpathy 解释称,这就等同于 PyTorch 中的 `zero_grad` 操作。之前之所以带有如此严重 Bug 的代码依然能够收敛,完全是因为当前处理的数据集和网络结构太过简单,神经网络能够极其轻易地拟合这 4 个样本;累积的梯度在效果上相当于无形中成倍放大了步长,导致优化速度快得反常。而在正式加入梯度清零操作并重新初始化网络后,损失下降的过程明显变得平稳且缓慢,需要增加迭代步数才能达到很低的损失值。Karpathy 提醒道:“搞神经网络有时非常棘手,因为代码里哪怕有一堆 Bug,网络可能依然看起来在正常工作;但如果面对的是复杂问题,这种 Bug 就会导致根本无法把损失优化下去。”
- 错误根源:反向传播中的梯度计算是累加模式(`+=`),若不显式清理,上一轮的梯度就会无限叠加进下一轮。 - 掩盖现象:在极简单任务下,未清零的梯度被反复累加,相当于产生了一个巨大的有效学习率步长,给出了“快速收敛”的假象。 - 调试教训:在复杂问题上,此类梯度累积错误会导致训练直接崩盘或陷入糟糕局部解。
---
[02:14:03](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8043s) 神经网络与梯度下降的核心原理总结
排除了 Bug 之后,Karpathy 对整个教学过程进行了体系化回顾。所谓的神经网络,本质上就是一串相对简单的数学表达式。以多层感知机(MLP)为例,它将输入数据以及网络自身的权重、偏置等参数结合起来,通过前向传播计算出输出,紧接着接入一个损失函数(Loss Function)。损失函数负责衡量网络预测的好坏程度:当预测值与目标值高度吻合时,损失就会很低;反之亦然。整个训练的核心思想,就是人工构建并操控这个损失函数,使得“当损失降到最低时,网络所做的事情正好是我们希望它完成的目标任务”。
定义好前向过程和损失后,算法通过反向传播(Backpropagation)计算出损失关于每一个参数的局部导数,进而得知如何微调参数以在局部降低损失;通过将这一过程不断循环迭代——即所谓的梯度下降(Gradient Descent),网络就能沿着梯度的反方向逐步逼近最优解。Karpathy 感慨道,虽然当前构建的只是一个仅有 41 个参数的微型网络,但现代那些具有数百亿乃至上万亿参数的巨型模型(如 GPT),本质上也是建立在完全相同的基石之上。
对于更大规模的模型而言,虽然网络结构更加精密、参数规模膨胀到了庞大无匹的“模拟神经组织”级别,但其内核并未改变: 1. **统一的表征与计算**:前向传播依然由数值(Value)与计算图构成,反向传播依然是沿着图追踪链式法则积累梯度。 2. **训练模式相同**:依然遵循前向计算、损失求导、梯度更新的迭代闭环。 3. **细分技术差异**:工程实践中会采用更高级的优化算法(而非极度简化的随机梯度下降),在自然语言预测等任务中会使用交叉熵损失(Cross-Entropy Loss)而非均方误差(MSE)。
Karpathy 强调,正是这种简单的数学机制经过海量参数与大规模数据的催化,才展现出了令人震撼的涌现能力(Emergent Properties):“你在整个互联网文本上训练这个模型,它就会展现出非常惊人的涌现特性;但从根本原理来说,它的底层运转机制与我们今天手写的代码是完全一致的。”
---
[02:16:46](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8206s) Micrograd 源码深度解析:Engine 与 NN 模块
Karpathy 随后带领大家逐行检视了 Micrograd GitHub 仓库里的真实源码,以验证视频开头所说的承诺——“学到最后,你将彻底看懂 Micrograd 的每一个细节”。代码库的结构非常紧凑:根目录下的 `__init__.py` 是空文件,核心逻辑主要收敛在 `engine.py` 和 `nn.py` 两个核心模块中。
| 模块 / 文件 | 核心类与内容 | 职责与技术细节 | |:--- |:--- |:--- | | `engine.py` | `Value` 类 | 包含 `data`、`grad`、`_backward`、`_prev`(子节点集合)以及 `_op` 操作符。<br/>实现了基础加法、乘法与标量幂运算;所有衍生运算(如减法、除法)均由基础算子组合而成。 | | `engine.py` | 激活函数 | 源码当前内置了 ReLU 激活函数及其导数。<br/>与视频教学中推导的双曲正切函数(`tanh`)相比,ReLU 和 `tanh`、`sigmoid` 都可以作为非线性变换,视频中之所以选用 `tanh`,是因为其平滑的数学形式能更好地锻炼局部梯度的链式法则推导。 | | `nn.py` | `Module` 父类 | 借鉴了 PyTorch 的 `nn.Module` 接口规范,抽离出了公共方法,包括统一的 `zero_grad()` 梯度清零以及 `parameters()` 参数收集。 | | `nn.py` | `Neuron`、`Layer`、`MLP` | 分别继承自 `Module`,逐层抽象神经元输入加权求和、多神经元并行层、以及多层全连接感知机结构。 | | `test/` 单元测试 | 梯度与前向校验 | 在微型表达式上同时运行 Micrograd 和 PyTorch 代码,对前向输出值与反向计算得到的每一个梯度做逐一严格对比,断言结果完全相同。 | | `demo.ipynb` | 分类实战演练 | 演示了一个比教程中 4 个点更复杂的二维平面二分类任务(红蓝点月牙/同心圆分类),使用规模稍大的 MLP 模型进行端到端训练。 |
Karpathy 解释了设计上的微小差异:Micrograd 源码中采用了基类 `Module` 来抽离 `zero_grad` 等通用逻辑,这完全是为了在 API 层面与 PyTorch 的 `torch.nn.Module` 保持高度统一。单元测试部分则通过对照 PyTorch 验证了代码的数学准确性。至此,从底层标量自动求导引擎到高层神经网络 API,整个框架的每一个模块都做到了完全透明、清晰可见。
[02:19:24](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8364s) 批处理、高级损失函数与完整训练流程
Andrej Karpathy 接着梳理了 micrograd 官方仓库中展示的更完整训练示例。在之前的简易演示中,数据集仅包含 4 个样本,因此可以直接对全量数据执行前向传播。但在真实的工业级场景中,数据集规模动辄达数百万条,无法一次性塞入内存或单次计算图中。实际做法是随机抽取数据子集(即批次 batch),仅针对该批次进行前向传播、反向传播与参数更新,避免了在完整训练集上反复做昂贵的全量计算。
```mermaid flowchart LR accTitle: Batch Training Loop Flowchart accDescr: Micrograd full training loop showing data batching, forward loss calculation with regularization, backward step, and learning rate decay update.
subgraph Data["1. 数据采样"] B["抽取随机批次 (Batch)"] end
subgraph Compute["2. 前向与损失"] FP["前向传播 (Forward)"] L["Max-Margin 损失 + L2 正则化"] B --> FP --> L end
subgraph Optimize["3. 反向传播与优化"] ZG["梯度清零 (zero_grad)"] BP["反向传播 (backward)"] UPD["参数更新 (学习率衰减)"] L --> ZG --> BP --> UPD end ```
在该进阶示例中,损失函数的设计也更为复杂:它采用了常用于二分类支持向量机(SVM)的 max-margin 损失,而视频此前演示中使用的是最容易理解的均方误差(Mean Squared Error, MSE)。此外,二元交叉熵损失(Binary Cross Entropy, BCE)也是常用的二分类目标,但在简单示例中它们的表现差异并不显著。该实现还引入了用于控制机器学习过拟合并提升泛化能力的 L2 正则化项(L2 Regularization)。整个训练循环由熟悉的标准步骤组成——前向计算、梯度清零、反向传播、梯度更新。值得注意的是,更新步骤中引入了学习率衰减(Learning Rate Decay):初始阶段采用较高的学习率快速收敛,随着迭代推进逐步缩小步长,以帮助网络稳定捕捉决策边界的微调细节。最终,可视化生成的决策边界清晰展示了模型如何根据输入坐标成功将红蓝数据点完全分隔开。
- 进阶示例支持批处理(batching),避免对海量数据集进行全量前向计算。 - 引入 max-margin 损失替代之前的 MSE,并加入了 L2 正则化来抑制模型过拟合。 - 学习率随迭代次数增加而衰减(Learning Rate Decay),在训练初期保持高步长、后期细化微调。
---
[02:21:10](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8470s) 深入 PyTorch 生产级底层实现:寻找 tanh 的反向传播代码
为了让观众感受“工业级实战”(real stuff)与教学玩具 micrograd 之间的差异,Karpathy 尝试在 PyTorch 的开源代码库中寻找 `tanh` 的反向传播实现。在 micrograd 中,`tanh` 的导数公式清晰透明:$\frac{d}{dx}\tanh(x) = (1 - t^2) \times \text{out.grad}$(其中 $t$ 为前向传播的输出值,后半部分来自链式法则)。Karpathy 希望在 PyTorch 庞大的 C++/CUDA 底层源码里找到完全相同的逻辑。
然而在工业级项目中定位核心代码极其困难。正如 Andrej Karpathy 所说:“And that's because these libraries unfortunately they grow in size and entropy and if you just search for tanh you get apparently 2800 results and 406 files so I don't know what these files are doing honestly.”这类工业级代码库由于历史演化和复杂度熵增,其设计初衷是便于调用而非便于拆解检视。在翻找约 15 分钟无果后,他借助一份试图修改 `tanh` 反向传播逻辑的提交讨论,顺藤摸瓜找到了 CPU 和 GPU(CUDA)对应的核函数(Kernel)。
在 CPU 内核中,代码之所以异常臃肿,是因为必须覆盖复数类型(complex types)、低精度类型(如 Bfloat16)等各种边界分支;剥除这些包装后,终于在名为 `BinaryOpsKernel` 的代码深处找到了核心逻辑:`a * (1 - b * b)`(其中 `b` 为 `tanh` 输出,`a` 为传入的梯度 `grad_output`)。类似地,在 CUDA 的 GPU 核函数里也找到了纯粹执行该代数运算的单行逻辑。这证实了工业级框架底层数学本质与 micrograd 完全相同,只是裹上了大量适配硬件与数据类型的繁复工程实现。
- 在 PyTorch 源码库搜索 `tanh` 会得到多达 2,800 条结果、涉及 406 个文件。 - 底层实现按硬件平台划分为 CPU Kernel 和 GPU (CUDA) Kernel。 - 底层 C++/CUDA 代码为了适配 `bfloat16`、复数计算及向量化优化而极度冗长,但核心计算本质依然是 `grad * (1.0 - output * output)`。
---
[02:23:43](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8623s) 自定义 PyTorch 算子:如同乐高积木般的计算图拓展
Karpathy 展示了 PyTorch 官方文档中关于如何为系统注册自定义算子的示例。以实现三阶勒让德多项式(Legendre Polynomial 3)为例,开发者只需创建一个继承自 `torch.autograd.Function` 的类,并分别定义两个静态方法:`forward`(前向传播计算结果并保存必要上下文)与 `backward`(接收上游梯度并应用局部导数计算下游梯度)。
正如 Andrej Karpathy 所总结:“As long as you can do the forward pass of this little function piece that you want to add and as long as you know the local derivative the local gradients which are implemented in the backward PyTorch will be able to backpropagate through your function and then you can use this as a Lego block in a larger Lego castle of all the different Lego blocks that PyTorch already has.” 只要向框架提供局部的正向变换与局部导数逻辑,PyTorch 的自动微分引擎就能无缝接管并沿计算图完成反向传递。
- 继承 `torch.autograd.Function` 并实现 `forward` 与 `backward`,即可让自定义算子无缝接入 PyTorch 自动求导机制。 - 只要提供局部导数(Local Gradient),框架就能依据链式法则在由各色算子构建的“乐高城堡”中全局传导。
---
[02:24:39](https://www.youtube.com/watch?v=VMj-3S1tku0&t=8679s) 总结与花絮
在全课结尾,Karpathy 总结了整个 micrograd 构建旅程,希望观众通过从零手写标量引擎、反向传播与多层感知机,获得了对神经网络运作机理的本质洞察。他表示会在视频简介中提供相关链接与讨论社区,方便大家深入交流,并可能制作答疑视频汇总高频问题。在视频最后的趣味花絮(Outtakes)中,记录了录制过程中的多次吃螺蛳与口误瞬间:在推导梯度时突然卡壳自问“Wait what is the problem?”;把 micrograd 不小心念成了“micro-crab”(微型螃蟹);以及在测试乘法算子重载边界时不慎报错爆出的“oops”。录制在轻松幽默的气氛中落下帷幕。
## Notable quotes > [04:33](https://www.youtube.com/watch?v=VMj-3S1tku0&t=273s) My claim is that micrograd is what you need to train your networks and everything else is just efficiency so you'd think that micrograd would be a very complex piece of code and that turns out to not be the case. — Andrej Karpathy
> [01:51:04](https://www.youtube.com/watch?v=VMj-3S1tku0&t=6664s) The trick used in deep learning to achieve this is to calculate a single number that somehow measures the total performance of your neural net and we call this single number the loss. — Andrej Karpathy
## Mentioned Andrej Karpathy, micrograd, PyTorch, JAX, Python, Jupyter Notebook, NumPy, Matplotlib, Graphviz, GitHub, CUDA, GPT, ReLU, SVM, Bfloat16
## Video description This is the most step-by-step spelled-out explanation of backpropagation and training of neural networks. It only assumes basic knowledge of Python and a vague recollection of calculus from high school.
Links: - micrograd on github: https://github.com/karpathy/micrograd - jupyter notebooks I built in this video: https://github.com/karpathy/nn-zero-to-hero/tree/master/lectures/micrograd - my website: https://karpathy.ai - my twitter: https://twitter.com/karpathy - "discussion forum": nvm, use youtube comments below for now :) - (new) Neural Networks: Zero to Hero series Discord channel: https://discord.gg/3zy8kqD9Cp , for people who'd like to chat more and go beyond youtube comments
Exercises: you should now be able to complete the following google collab, good luck!: https://colab.research.google.com/drive/1FPTx1RXtBfc4MaTkf7viZZD4U2F9gtKN?usp=sharing
Chapters: 00:00:00 intro 00:00:25 micrograd overview 00:08:08 derivative of a simple function with one input 00:14:12 derivative of a function with multiple inputs 00:19:09 starting the core Value object of micrograd and its visualization 00:32:10 manual backpropagation example #1: simple expression 00:51:10 preview of a single optimization step 00:52:52 manual backpropagation example #2: a neuron 01:09:02 implementing the backward function for each operation 01:17:32 implementing the backward function for a whole expression graph 01:22:28 fixing a backprop bug when one node is used multiple times 01:27:05 breaking up a tanh, exercising with more operations 01:39:31 doing the same thing but in PyTorch: comparison 01:43:55 building out a neural net library (multi-layer perceptron) in micrograd 01:51:04 creating a tiny dataset, writing the loss function 01:57:56 collecting all of the parameters of the neural net 02:01:12 doing gradient descent optimization manually, training the network 02:14:03 summary of what we learned, how to go towards modern neural nets 02:16:46 walkthrough of the full code of micrograd on github 02:21:10 real stuff: diving into PyTorch, finding their backward pass for tanh 02:24:39 conclusion 02:25:20 outtakes :)
[Source](https://www.youtube.com/watch?v=VMj-3S1tku0)