LLM时代为什么一定要补数学基础：从导数、向量到深度学习与大模型

很多人刚接触大模型时，都会有一个很自然的想法：

现在各种 AI API、开源模型、智能体框架都这么成熟了，我还需要学数学吗？

如果你的目标只是“会调用一个模型”，那数学确实不是第一优先级。
但如果你的目标是更进一步，真正理解下面这些问题：

  • 模型为什么能训练出来？
  • 损失函数到底在损失什么？
  • 为什么参数一更新，效果就变了？
  • 为什么大家天天在说向量、矩阵、张量、概率分布？
  • 为什么大模型的本质是“预测下一个 token 的概率”？

那你就绕不开数学。

而且，到了今天这个 LLM 时代，数学不是变得不重要了，反而变得更重要了。因为模型越来越强，系统越来越复杂，越往后走，你越会发现：那些看似高深的模型原理，最后都能落回到几块基础数学上。

这篇文章不是一份“考试型”数学笔记，也不是一篇只讲概念不落地的科普。
我想做的是一件更实用的事：

带你从零建立一张认知地图，弄明白微积分、线性代数、概率统计为什么是机器学习、深度学习和大模型的底层语言。

如果你是小白，不用怕。你不需要一开始就会推导 Transformer 全部公式。
你需要先建立直觉，知道每个公式到底在描述什么、解决什么问题、最终如何落到模型训练上。

一、先记住一条主线：模型到底在做什么

不管是传统机器学习、神经网络，还是今天的大模型，它们本质上都在做三件事：

  1. 表示信息
  2. 计算分数或概率
  3. 根据误差不断调整参数

换句话说，模型不是“凭空变聪明”的，它是通过大量数据，一点点把参数调到更合适的位置。

这背后分别对应着三类数学：

数学基础 在 AI 中对应什么 解决什么问题
微积分 导数、偏导、梯度、链式法则 参数怎么更新，模型怎么学习
线性代数 向量、矩阵、张量、内积 数据怎么表示，计算怎么高效进行
概率统计 概率分布、条件概率、似然、交叉熵 模型如何描述不确定性，如何做预测

如果把 AI 模型比作一个不断被训练的“超级函数”，那么：

  • 微积分告诉我们，这个函数该往哪个方向调
  • 线性代数告诉我们，这个函数内部怎么高效算
  • 概率统计告诉我们，这个函数输出的结果该如何解释

你可以把这篇文章理解成一场“拆机”。

我们不是为了学数学而学数学，而是为了拆开机器学习和大模型的外壳，看看里面的发动机到底是怎么运转的。

二、微积分：模型为什么能“学会”

很多人第一次听到“导数”“梯度下降”这些词时，会觉得这是纯数学家的世界。
实际上，微积分在 AI 里的角色很朴素：

模型之所以能学习，本质上是因为我们能衡量“改一点参数，结果会变好还是变坏”。

而这个“变化率”，就是导数要描述的东西。

1. 导数到底是什么

先别急着看公式，先看一个生活场景。

你开车时，速度表上的数字就在告诉你：
“此时此刻，位置变化得有多快。”

如果位置记作 $s(t)$，时间记作 $t$，那么速度就是位置对时间的导数：

$$
v(t) = s’(t) = \frac{ds}{dt}
$$

导数的标准定义是：

$$
f’(x)=\lim_{\Delta x \to 0}\frac{f(x+\Delta x)-f(x)}{\Delta x}
$$

这行公式看起来吓人，但它说的其实是：

当 $x$ 只变化一点点时，函数值 $f(x)$ 会变化多少。

也就是说，导数描述的是“局部变化速度”。

举个最简单的例子：

$$
f(x)=x^2
$$

它的导数是：

$$
f’(x)=2x
$$

这说明什么？

  • 当 $x=1$ 时，变化率是 $2$
  • 当 $x=10$ 时，变化率是 $20$

也就是说，随着 $x$ 变大，函数增长得越来越快。

这在模型里非常重要。因为训练模型时，我们最关心的一件事就是：

如果我把某个参数改一点点，损失会往哪个方向变？变化有多剧烈？

这就是导数第一次登场的地方。

2. 为什么训练模型一定要关心“变化率”

假设我们有一个很简单的损失函数：

$$
L(w)=(w-1)^2
$$

这里的 $w$ 是参数，$L(w)$ 是损失。
这个函数的最小值显然出现在 $w=1$。

那模型怎么知道该把 $w$ 调到 1 附近？

看导数：

$$
\frac{dL}{dw}=2(w-1)
$$

这行式子的信息量很大：

  • 如果 $w>1$，导数为正，说明继续往右走会让损失更大，所以应该往左走
  • 如果 $w<1$，导数为负，说明往右走会让损失更小，所以应该往右走
  • 如果 $w=1$，导数为 0，说明到了一个平衡点

所以，导数其实就是一个“导航器”。
它不直接告诉你答案是什么，但它会告诉你：

下一步往哪边走，更有可能变好。

这就是机器学习里最经典的更新思想：

$$
w \leftarrow w - \eta \frac{dL}{dw}
$$

其中：

  • $w$ 是参数
  • $\eta$ 是学习率，表示每次走多大一步
  • $\frac{dL}{dw}$ 是导数，表示当前方向上的变化率

这条式子就是梯度下降最核心的骨架。

3. 多个参数怎么办：偏导和梯度来了

现实中的模型当然不只一个参数。
一个线性回归可能有几十个参数，一个神经网络有几百万个参数，一个大模型甚至有几十亿、上百亿参数。

这时，损失函数就不再是：

$$
L(w)
$$

而更像是：

$$
L(w_1,w_2,\dots,w_n)
$$

也就是说，损失由很多变量共同决定。

这时候我们就不能只看普通导数了，而要看偏导数。

偏导数的意思是：

先固定其他变量不动，只看某一个变量变化时，函数会怎么变。

比如：

$$
f(x,y)=x^2+3y
$$

那么它对 $x$ 的偏导数是：

$$
\frac{\partial f}{\partial x}=2x
$$

对 $y$ 的偏导数是：

$$
\frac{\partial f}{\partial y}=3
$$

如果把所有偏导数收集起来，就得到了梯度：

$$
\nabla f(x,y)=
\begin{bmatrix}
\frac{\partial f}{\partial x}\
\frac{\partial f}{\partial y}
\end{bmatrix}
$$

梯度可以理解成一个箭头。
这个箭头指向函数增长最快的方向。

那如果我们想让损失下降得最快呢？

答案很自然：

朝着梯度的反方向走。

所以多参数情况下的梯度下降写成：

$$
\mathbf{w} \leftarrow \mathbf{w} - \eta \nabla L(\mathbf{w})
$$

这几乎是整个深度学习训练的灵魂公式。

4. 为什么反向传播离不开链式法则

很多人学神经网络，最怕“反向传播”。
但如果你先理解链式法则，反向传播就不再神秘。

链式法则说的是：

如果 $z$ 依赖于 $y$，而 $y$ 又依赖于 $x$，那么 $z$ 对 $x$ 的变化率，要把中间这层关系乘起来。

$$
\frac{dz}{dx}=\frac{dz}{dy}\cdot\frac{dy}{dx}
$$

这有什么用？

神经网络本质上就是一层一层函数套起来：

$$
\mathbf{x} \rightarrow \text{线性变换} \rightarrow \text{激活函数} \rightarrow \text{下一层} \rightarrow \text{损失}
$$

输出的误差想传回前面的参数，就必须一级一级往回算。
这就是反向传播的本质：

把误差通过链式法则，从后往前传回去。

所以你可以把反向传播理解成一句非常朴素的话：

模型最后错了，那前面每一层分别该负多大责任？

而链式法则就是这个“责任分摊系统”。

5. 一个极简代码例子：参数是怎么一步步逼近答案的

下面这段代码没有任何神经网络框架，但它已经把“损失函数 + 导数 + 更新参数”这件事展示出来了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import numpy as np

def loss(w):
    return (w - 1) ** 2

def grad(w):
    return 2 * (w - 1)

w = 5.0
lr = 0.1

for step in range(10):
    w = w - lr * grad(w)
    print(f"step={step}, w={w:.4f}, loss={loss(w):.6f}")

这段代码背后发生的事情只有一件：

模型先看看自己离目标有多远，再根据导数判断该往哪边走，然后一步步把参数推向损失更小的位置。

如果你能理解这一点，那么你已经理解了神经网络训练最核心的动力机制。

三、线性代数：为什么 AI 世界里到处都是向量、矩阵、张量

如果说微积分解决的是“怎么学”，那么线性代数解决的就是“怎么表示”和“怎么算得快”。

今天的 AI 系统，几乎一切都在向量化：

  • 一个用户画像可以表示成向量
  • 一个词可以表示成向量
  • 一张图片可以表示成矩阵或张量
  • 一段文本经过编码后会变成一串向量

所以你会发现，现代模型其实不是在直接处理“文字”“图片”“声音”，而是在处理这些对象对应的数值表示。

1. 标量、向量、矩阵、张量到底是什么

先把这几个概念讲人话。

  • 标量：一个数，比如温度 25、分数 0.9
  • 向量：一串有顺序的数，比如 $[1, 2, 3]$
  • 矩阵：二维表格形式的数据
  • 张量：更高维的数据结构，可以理解为“多维数组”

在 AI 里你会反复看到这些对象，是因为计算机最擅长处理数值，而大量复杂信息都可以编码成数值结构。

比如一个词“苹果”，模型不会直接理解汉字本身。
它通常会先把这个词映射成一个高维向量：

$$
\mathbf{e}_{\text{苹果}} = [0.12, -0.43, 0.78, \dots]
$$

这个向量里的每一维，不一定有肉眼可解释的含义，但整体上它能表达这个词在语义空间中的位置。

这就是为什么大家常说：

大模型先把语言变成向量，再在向量空间里做计算。

2. 向量为什么重要：它不只是“几列数字”

向量最重要的作用有两个：

  1. 表示对象
  2. 表示方向

在机器学习里，一个样本常常就可以表示成一个向量：

$$
\mathbf{x}=
\begin{bmatrix}
x_1\
x_2\
\vdots\
x_n
\end{bmatrix}
$$

这里的每个分量都可以是一个特征，比如：

  • 用户年龄
  • 点击次数
  • 停留时长
  • 历史购买行为

在深度学习里，一个词向量、句向量、图像特征向量，本质上也都是这种形式。

更关键的是，向量不仅能装数据，还能做运算。
比如两个向量的内积：

$$
\mathbf{x} \cdot \mathbf{w} = \sum_{i=1}^{n} x_i w_i
$$

这在机器学习里非常常见。

你可以把它理解成：

把每个特征乘上一个权重，再加起来，得到一个总分。

这不就是模型打分吗？

所以很多模型的第一步，本质上都可以写成：

$$
z=\mathbf{w}^T\mathbf{x}+b
$$

其中：

  • $\mathbf{x}$ 是输入特征
  • $\mathbf{w}$ 是参数权重
  • $b$ 是偏置
  • $z$ 是打分结果

线性回归、逻辑回归、神经网络中的线性层，骨架都离不开这一句。

3. 矩阵乘法为什么是深度学习的日常

如果一次只算一个样本，当然可以用向量。
但现实中我们会同时处理很多样本，还会有很多神经元一起算。

这时矩阵就登场了。

神经网络里最常见的一步是：

$$
\mathbf{y}=W\mathbf{x}+\mathbf{b}
$$

这叫做线性变换。

它的含义不是“机械地做乘法”，而是：

把输入向量映射到另一个空间里，形成新的表示。

为什么这很关键？

因为深度学习本质上就是不断做“表示变换”。

比如一句话最开始只是一个个 token，经过 embedding 之后变成向量；
经过若干层网络后，这些向量逐渐带上语法、语义、上下文关系；
到了最后，模型再根据这些表示去预测下一个 token。

也就是说，矩阵乘法不是配角，它是主干。

4. 一个简单的 NumPy 例子：线性层到底在算什么

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

x = np.array([0.8, 1.2, -0.5])   # 输入特征
W = np.array([
    [0.2, 0.5, -0.1],
    [-0.3, 0.7, 0.4]
])
b = np.array([0.1, -0.2])

y = W @ x + b
print(y)

这段代码可以理解为：

  • 输入向量有 3 个特征
  • 线性层有 2 个输出单元
  • 每个输出单元都会看完整个输入向量，并按自己的权重组合出一个新值

所以，矩阵乘法本质上不是“死算”，而是在做：

特征重组、信息压缩、方向投影和表示变换。

5. 范数、距离、相似度，为什么在 AI 里这么常见

线性代数里还有一类概念也特别重要：长度和距离。

向量的长度通常用范数来表示。
最常见的是 $L_2$ 范数：

$$
|\mathbf{x}|_2=\sqrt{x_1^2+x_2^2+\cdots+x_n^2}
$$

它可以理解成向量在空间中的“几何长度”。

这有什么用？

  • 在优化中，我们会限制参数不要太大，防止过拟合
  • 在推荐系统和检索系统中，我们会比较向量之间是否相似
  • 在大模型里，我们会用向量相似度去衡量语义接近程度

比如余弦相似度：

$$
\cos(\theta)=\frac{\mathbf{x}\cdot\mathbf{y}}{|\mathbf{x}||\mathbf{y}|}
$$

如果两个词的向量方向很接近，那么它们在语义上往往也更接近。

这就是为什么向量数据库、语义检索、Embedding 检索在今天这么重要。

到了这里，你应该已经能感觉到：

线性代数不是“AI 里的辅助工具”，它几乎就是 AI 计算的语言本身。

四、概率统计：模型为什么输出的是“可能性”，不是绝对真理

很多初学者会有一个误区：
觉得模型应该像计算器一样，只给出一个绝对正确的答案。

但现实世界不是这么运转的。
很多任务本来就带有不确定性。

比如一句话：

今天的天气真不错，适合去公园里吹吹____。

最后一个词可能是“风”，也可能是“风啊”，也可能是“晚风”。
这时候模型不是在算“唯一正确答案”，而是在计算：

哪个词在当前上下文下更有可能出现。

这就进入了概率论的世界。

1. 概率到底在 AI 里扮演什么角色

概率最朴素的意义，就是衡量一件事发生的可能性。

如果事件 $A$ 发生的概率记作 $P(A)$，那么：

  • $P(A)=1$ 表示一定发生
  • $P(A)=0$ 表示不可能发生
  • 中间的值表示可能性大小

在机器学习里，模型通常输出的不是“结论本身”，而是一个概率分布。

例如分类问题里，模型可能给出：

$$
P(\text{猫})=0.8,\quad P(\text{狗})=0.15,\quad P(\text{鸟})=0.05
$$

这表示模型更倾向于认为它是猫，但它并不是在宣告某种绝对真理，而是在表达置信程度。

2. 条件概率：为什么上下文这么重要

大模型最核心的目标之一，是预测下一个 token 的概率。

它关心的不是某个词单独出现的概率，而是：

在前文已经给定的情况下，下一个词出现的概率。

这就是条件概率：

$$
P(A|B)=\frac{P(A \cap B)}{P(B)}
$$

它的读法是：

“在 $B$ 已经发生的条件下，$A$ 发生的概率是多少。”

放到语言模型里，就是：

$$
P(x_t \mid x_1,x_2,\dots,x_{t-1})
$$

这行式子可以翻译成一句很接地气的话：

已经看了前面所有词之后，第 $t$ 个词最可能是什么？

所以，LLM 的“理解上下文”并不神秘。
至少从训练目标上看，它就是在不断学习条件概率分布。

3. 贝叶斯思维：新证据来了，我们就更新判断

贝叶斯公式是概率论里特别有“思维味道”的一个公式：

$$
P(A|B)=\frac{P(B|A)P(A)}{P(B)}
$$

它告诉我们：

当有了新证据之后，我们应该怎样更新原来的判断。

比如医疗检测里：

  • 一个病本身很少见
  • 检测阳性不代表一定患病
  • 还要综合先验概率、误报率、漏报率一起看

这套思路在 AI 中也非常重要。

因为模型不是在真空中思考，它总是在结合已有信息，不断修正对当前问题的判断。

贝叶斯公式本身不一定直接写在每个大模型代码里，但“根据证据更新信念”这件事，是整个智能系统设计里非常核心的思维方式。

4. 似然函数：不是“结果的概率”，而是“参数解释数据的能力”

这是很多初学者最容易混淆的概念之一。

概率通常是：

已知参数，问数据出现的可能性。

而似然则反过来：

已知数据，问哪组参数更能解释这些数据。

如果模型参数记作 $\theta$，数据记作 $D$，那么似然函数写作：

$$
L(\theta)=P(D|\theta)
$$

注意，这里形式上还是概率，但研究对象已经变了。
现在我们把数据看作固定，把参数看作变量。

这件事为什么关键？

因为机器学习训练，核心就在做这件事：

寻找一组参数，让训练数据在这组参数下“看起来最合理”。

这就是极大似然估计：

$$
\hat{\theta}=\arg\max_{\theta}P(D|\theta)
$$

为了计算方便，我们通常会取对数：

$$
\log L(\theta)=\sum_{i=1}^{n}\log P(x_i|\theta)
$$

把乘法变加法，计算更稳定，也更适合优化。

5. 交叉熵：为什么模型答错时会“疼”

在深度学习和大模型里，交叉熵几乎是你绕不开的损失函数。

公式是：

$$
H(p,q)=-\sum_i p_i \log q_i
$$

第一次看这个公式，很多人都会问：

这到底在算什么？

你可以先不用从信息论角度理解它，先用训练直觉理解：

如果真实答案是某一类，而模型给这类的概率很低，那么惩罚就会很大。

举个例子。
真实答案是“猫”：

  • 如果模型给猫的概率是 $0.9$，损失会比较小
  • 如果模型给猫的概率是 $0.01$，损失会非常大

为什么？

因为：

$$
-\log(0.9)
$$

很小，而：

$$
-\log(0.01)
$$

就很大。

这意味着交叉熵会逼着模型去做一件事：

把真实答案的概率抬高。

而这正是分类模型和语言模型训练中最核心的目标之一。

6. Softmax：为什么模型最后能输出一个“像概率”的东西

神经网络最后一层常常会输出一组分数，我们把它记作 $z_1,z_2,\dots,z_n$。
这些分数本身不是概率，因为它们可能有负数，也不一定加起来等于 1。

这时就需要 Softmax：

$$
\text{softmax}(z_i)=\frac{e^{z_i}}{\sum_j e^{z_j}}
$$

它的作用是把一组任意分数，变成一组合法的概率分布：

  • 每一项都大于 0
  • 所有项加起来等于 1

所以在分类任务里，Softmax + 交叉熵 是非常经典的一套组合。

而在 LLM 中，本质上也是类似的事情：

模型会对整个词表里的 token 打分，再把这些分数变成概率分布，然后从中选择下一个 token。

你也可以用几行 NumPy 先感受一下这个过程：

1
2
3
4
5
6
7
import numpy as np

logits = np.array([2.5, 1.0, 0.1])   # 模型对 3 个候选词的原始打分
exp_scores = np.exp(logits - logits.max())  # 减去最大值是为了数值稳定
probs = exp_scores / exp_scores.sum()

print(probs)

运行后你会得到一组加起来等于 1 的数。
这就是模型从“原始分数”走向“概率分布”的最基础过程。

如果你只记住一句话，那就是：

大模型并不是“凭感觉写字”，而是在一个巨大的词表上不断做概率分布预测。

五、从机器学习到深度学习，再到 LLM：这些数学是怎么串起来的

前面讲的微积分、线性代数、概率统计，看起来像三门课。
但真正到了 AI 里，它们不是分开的，而是紧紧扣在一起的。

下面我们把这条主线彻底串起来。

1. 传统机器学习：先做人能理解的特征，再让模型学习规律

早期机器学习更强调“特征工程”。

比如你要预测房价，可能会手工设计这些特征：

  • 面积
  • 地段
  • 房龄
  • 楼层
  • 学区

然后把它们组成一个向量 $\mathbf{x}$，再让模型学习一个函数：

$$
\hat{y}=f(\mathbf{x})
$$

训练过程通常是：

  1. 用参数对输入打分
  2. 和真实值比较，得到损失
  3. 求导，得到梯度
  4. 更新参数，重复很多轮

你看，线性代数在表示输入，概率和损失函数在衡量输出是否合理，微积分在负责优化。

2. 深度学习：不再只学答案，还学“表示”

深度学习相比传统机器学习，一个非常关键的变化是：

模型不仅学习如何预测，还学习如何自动构造中间特征。

这就是“深”的意义。

一个简单神经网络可以写成：

$$
\mathbf{h}=\sigma(W_1\mathbf{x}+\mathbf{b}_1)
$$

$$
\hat{\mathbf{y}}=W_2\mathbf{h}+\mathbf{b}_2
$$

这里：

  • 第一层先把输入变成隐藏表示 $\mathbf{h}$
  • 激活函数 $\sigma$ 提供非线性能力
  • 第二层再基于隐藏表示做输出

你可以把它理解成：

模型不是直接从原始输入跳到答案，而是先学会“怎么理解这个输入”，再做判断。

层数越多，表示能力通常越强。
这也是为什么深度学习能在图像、语音、文本等复杂任务上胜出的原因。

3. 大模型：把“表示学习”推到极致

到了大模型这里，思路又进一步升级了。

传统模型常常是为一个任务设计的，比如分类、回归、推荐。
而大模型做的是一种更通用的事情：

通过海量文本数据，学习语言世界里的统计规律、语义关系和上下文依赖。

它的训练目标看起来甚至很简单：

$$
P(x_t \mid x_{<t})
$$

也就是：

在前文给定的情况下，预测下一个 token。

如果把整段文本都考虑进去，训练时常见的目标可以写成：

$$
\mathcal{L} = - \sum_{t=1}^{T}\log P(x_t \mid x_{<t})
$$

这行公式特别值得初学者认真看一眼。

它的意思不是“背下来就完了”，而是：

  • 对序列中的每一个位置，模型都要预测下一个 token
  • 如果真实 token 的概率被模型打得很低，这一项损失就会很大
  • 把整段文本所有位置的损失加起来，就得到了整体训练目标

所以，LLM 训练从表面上看像是在“学语言”，从数学上看，其实是在不断降低整段文本预测的负对数似然。

但这件事之所以能变得这么强，是因为：

  • 数据量极大
  • 参数量极大
  • 表示空间极高维
  • 训练过程把语言中的大量规律都压缩进参数里了

所以，LLM 的本质不是背答案，而是在高维空间里学习一种复杂的条件概率分布。

4. 为什么 Transformer 会成为主流

讲到大模型，绕不开 Transformer。
而 Transformer 最核心的一个机制，就是注意力机制：

$$
\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
$$

第一次看到这个公式，很多人会直接劝退。
但你如果把它翻译成人话，其实没那么可怕。

它在做的事情大概是：

  1. 用 $Q$ 提出“我当前关心什么”
  2. 用 $K$ 判断“谁和我更相关”
  3. 用 $V$ 提供“真正需要汇总的信息”
  4. 再通过 softmax 把相关性变成权重
  5. 最后做加权求和，得到当前 token 的新表示

你会发现，这里面几乎每一步都和前面讲的数学直接相关：

  • $QK^T$ 是矩阵乘法和内积
  • softmax 是概率归一化
  • 权重加和是线性组合
  • 参数更新靠的是梯度下降和反向传播

所以所谓“注意力机制很高级”，并不意味着它脱离了基础数学。
恰恰相反，它是基础数学在复杂系统中的一次漂亮组合。

5. 为什么说 LLM 的底层逻辑可以浓缩成一句话

如果让我用一句话总结大模型训练的核心，我会这么说：

把文本变成向量，用矩阵做变换，用概率描述下一个 token，用梯度下降让参数不断变好。

你看，这里面依次出现了：

  • 向量和矩阵
  • 概率分布
  • 损失函数
  • 导数、梯度、链式法则

这也正是为什么一旦你理解了基础数学，很多 AI 概念会突然连起来。

以前你觉得这些词是零散的黑话：

  • Embedding
  • Attention
  • Loss
  • Backpropagation
  • Softmax
  • Cross Entropy

后来你会发现，它们其实都在讲同一个故事的不同部分。

六、为什么说“不会数学也能用 AI”，但“想走远必须补数学”

这是一个很现实的话题。

今天确实有很多人不懂太多数学，也能接 API、做应用、搭工作流、写提示词。
这完全没问题，而且也有很高的实际价值。

但如果你想进入下面这些更深一点的领域：

  • 看懂模型论文
  • 理解训练过程和调参逻辑
  • 自己实现基础模型
  • 理解为什么模型会过拟合、欠拟合、幻觉
  • 理解 embedding、检索、排序、重排背后的原理
  • 做更深入的机器学习、推荐系统、搜索系统和大模型工程

那数学就会越来越重要。

因为当你遇到真正复杂的问题时，最后帮你建立判断力的，不是流行词，不是框架名，而是底层原理。

举几个很典型的场景：

  • 学习率太大为什么会震荡？这是优化问题。
  • 为什么参数正则化能缓解过拟合？这和范数、约束有关。
  • 为什么概率低的正确答案会带来更大的损失？这和对数、交叉熵有关。
  • 为什么语义检索靠向量相似度就能工作？这和嵌入空间、距离度量有关。

所以，数学最大的价值，不是让你会做卷子，而是让你在复杂系统面前不慌。

七、给初学者的一条学习路线：现在该从哪里开始

如果你读到这里，已经对“为什么要学数学”有了感觉，那下一步最重要的不是贪多，而是建立顺序。

我建议你按下面这条路线来：

第一步：把微积分的核心概念学扎实

重点不是所有题型，而是这些概念：

  • 导数到底是什么
  • 偏导数是什么意思
  • 梯度为什么指向增长最快方向
  • 链式法则为什么能支持反向传播
  • 梯度下降为什么能优化损失函数

你学完这一块，再去看“反向传播”“优化器”“学习率”，理解会快很多。

第二步：把线性代数真正和 AI 场景对应起来

重点掌握：

  • 向量和矩阵的基本运算
  • 内积、矩阵乘法的几何和计算意义
  • 范数、距离、相似度
  • 张量的概念
  • 线性变换在神经网络里的作用

学这一块时，不要只停留在纸面。
一定要拿 NumPy 或 PyTorch 自己写一写矩阵乘法、线性层、向量相似度。

第三步：把概率统计从“背公式”变成“会解释”

重点掌握：

  • 概率分布是什么
  • 条件概率和贝叶斯公式是什么意思
  • 似然函数和极大似然估计在做什么
  • 期望、方差如何描述随机变量
  • 交叉熵为什么适合做分类和语言模型训练

这一块一旦打通，你对“模型输出概率分布”这件事就会有本质理解。

第四步：把数学和代码打通

很多人学数学卡住，不是因为概念太难，而是因为概念和代码之间断了层。

所以一定要做这类练习：

  • 用 NumPy 实现线性回归
  • 手写梯度下降
  • 手写 softmax
  • 手写交叉熵
  • 理解一个两层神经网络前向和反向传播在做什么

当你能把公式翻译成代码时，理解会发生质变。

第五步：再去看深度学习和大模型

这时候你再去看这些内容，会轻松很多：

  • 神经网络基础
  • 反向传播
  • 优化器
  • Embedding
  • Attention
  • Transformer
  • 预训练、微调、对齐

你会发现，大量“看起来很高级的概念”，不过是基础数学在更复杂系统中的组合应用。

八、最后做一个总结：你真正要建立的，不是公式记忆，而是数学直觉

到这里，我们回头看整件事。

为什么 LLM 时代还必须补数学基础？

因为大模型并没有消灭数学，只是把数学藏到了更深的地方。

你在界面上看到的是对话、生成、推理、检索、Agent、工作流。
但在模型内部，真正发生的是：

  • 文本被编码成向量
  • 向量经过矩阵变换
  • 模型输出概率分布
  • 损失函数衡量预测质量
  • 梯度把误差信号传回参数
  • 参数在无数次更新中逐渐学到规律

这就是现代 AI 的底层逻辑。

所以，如果你是初学者，我最想给你的建议不是：

“赶紧去把所有公式背下来。”

而是：

先理解每个数学概念到底在描述什么现实问题。

当你这样学的时候，你会发现：

  • 导数，不再只是求切线斜率，而是在回答“参数该怎么调”
  • 向量，不再只是几列数字，而是在回答“信息该怎么表示”
  • 概率，不再只是考试题，而是在回答“模型如何面对不确定性”

当这些点连起来以后，机器学习、深度学习、LLM 对你来说，就不再是一堆神秘黑箱，而会慢慢变成一张清晰的知识地图。

如果你愿意继续往下走，那么下一阶段你可以开始系统学三件事：

  1. 用代码实现几个最基础的机器学习模型
  2. 用 PyTorch 理解前向传播和反向传播
  3. 带着“向量 + 概率 + 优化”的视角再去看 Transformer

当你再回头看今天的大模型时，你会更容易意识到一件事：

所谓 AI 的“智能感”，很多时候并不是凭空出现的，而是数学、数据、计算和工程共同作用的结果。

这也正是它迷人的地方。

附：如果你只想先记住 10 句话

  1. 导数描述的是变化率，模型靠它知道参数该往哪边调。
  2. 偏导数处理的是多变量问题，梯度是所有偏导数组成的方向向量。
  3. 梯度下降的本质，是沿着损失下降最快的方向更新参数。
  4. 链式法则是反向传播的数学基础。
  5. 向量和矩阵是 AI 表示数据、组织计算的基本语言。
  6. 矩阵乘法本质上是在做线性变换和特征重组。
  7. 概率分布描述的是“可能性”，不是绝对确定性。
  8. 似然函数研究的是“哪组参数最能解释数据”。
  9. 交叉熵会惩罚模型低估真实答案的行为。
  10. LLM 的核心训练目标，可以理解为预测下一个 token 的条件概率。

如果你能把这 10 句话真正吃透，那么你已经走在理解 AI 原理的正确路上了。