02.大模型这个函数的工作流程

Mercury-keep

404人浏览 · 2026-05-11 17:24:19

Mercury-keep · 2026-05-11 17:24:19 发布

1 引子：从“字典”到“坐标”

想象一下，函数 y = f(x) 里的 x 和 y 必须是数字。而我们的“Prompt”（比如“你好”）是一串文字符号。为了让函数能处理它，需要一个步骤：把文字“向量化”。

这就像我们在现实世界中把地址（如“南京市鼓楼区XX号”）映射成地图上的经纬度坐标（118.7°E, 32.0°N）。地址是文字，坐标是数字。

输入 → 函数f计算 → 原始分数(Logits) → Softmax转换 → 概率分布 → 采样选择

2 工作流程

2.1 第一步：把输入 `x`（Prompt）变成数字

当你输入“苹果好吃吗？”，大模型并不会读到笔画，而是会做这三件事：

分词（Tokenization）：先把句子切成一个个最小的语义单元（Token）。例如：["苹果", "好吃", "吗", "?"]。
查表（Embedding）：每个Token去一张巨大的“数字地图”里，查找自己对应的向量。这个向量通常是一长串小数，比如 [0.12, -0.56, 0.78, ..., 0.33]（可能有几百或几千个维度）。
打包：整句话就变成了一个向量列表（矩阵）。

所以，你输入的 x 实际上是一个矩阵，矩阵里的每个元素都是数字。只不过人类看到的是文字，计算机看到的是这个数字矩阵。

2.2 第二步：函数 `f` 如何运作（纯数学计算）

现在我们有了输入 x（一堆数字组成的矩阵），接下来把它送入函数 f。这个 f 由几十层甚至上百层“神经元”组成。每一层都在做同一件事：
输出 = 激活函数( 输入 × 权重矩阵 + 偏置 )

输入：上一层的数字结果。
权重矩阵：模型里那几百上千亿个参数，本质上全是小数。
激活函数：一个简单的数学公式（比如 ReLU：max(0, x)），用来决定哪些数字被保留。
运算：主要就是矩阵乘法和加法。

在这个过程中，没有任何“理解”、“思考”或“灵感”。有的只是源源不断的浮点数计算。计算机疯狂地做着 (0.12 * 0.34) + (0.56 * 0.78) ... 这样的运算。

2.3 第三步：把输出 `y`（数字）变回文字

经过上百层的矩阵乘法后，函数 f 输出了一大堆数字。但这些数字还不是最终的“苹果很好吃”。

概率分布：最后一层通常会输出一个和字典大小一样的向量，例如 [0.0001, 0.0003, ..., 0.85, 0.01]。这个向量里的每个数字，代表字典里对应那个词的概率。比如，[0.85] 对应的位置是“很”字。（输出所有词的概率）
采样：模型根据这些概率抽一个词（通常是概率最高的那个）。抽到“很”。
迭代：把“很”加回输入，再跑一遍函数 f，得到下一个词“好”，然后是“吃”。
反查：最终把 ["很", "好", "吃"] 这些数字索引，通过字典反查回文字“很好吃”。

3 总结：完整的类比表

函数中的要素	大模型中的对应物	它是数字吗？
自变量 x	你输入的 Prompt（如“你好”）	是。它被映射为了一个高维向量（浮点数列表）。
函数 f	上百层的 Transformer 网络	是。它由权重矩阵（数字）、偏置（数字）、激活函数（数学公式）构成。
因变量 y	模型预测出的 Token 概率分布	是。它是几千个概率值（0.0到1.0之间的数字）。
反函数 `g(y)`	解码器（将概率变成汉字）	否。这是最后一步查表映射，将数字索引变回“好”这个文字。

4 极简例子

4.1 设定

字典大小：4个词 ["苹果", "好吃", "很", "吗"]，索引分别是 [0, 1, 2, 3]
词向量维度：2维（为了手算简单）

4.2 第一步：输入转换为向量

输入"苹果好吃吗"：

"苹果" → [1, 0]

"好吃" → [0, 1]

"吗" → [1, 1]

输入 x = [[1,0], [0,1], [1,1]]

4.2 第二步：通过函数f计算

假设函数f对最后一个Token"吗" [1,1] 进行处理，输出原始分数（Logits），长度等于字典大小（4）：

# 假设的线性变换：Logits = W × [1,1] + b
# W是一个 4×2 的权重矩阵，b是长度为4的偏置

W = [[2, 0],   # 对应“苹果”的权重
     [0, 2],   # 对应“好吃”的权重  
     [1, 1],   # 对应“很”的权重
     [0, 0]]   # 对应“吗”的权重

b = [0.5, 0.5, 0, -1]

# 计算
Logits = W × [1,1] + b
= [2×1 + 0×1 + 0.5,    # “苹果”的分数
   0×1 + 2×1 + 0.5,    # “好吃”的分数
   1×1 + 1×1 + 0,      # “很”的分数
   0×1 + 0×1 + (-1)]    # “吗”的分数

= [2.5, 2.5, 2, -1]

4.3 第三步：Softmax转换成概率

4.3.1 输出概率

Softmax公式：P(i) = e^(logit_i) / Σ e^(logit_j)，j从0到3

logits = [2.5, 2.5, 2, -1]

# 计算e^(logit)
e^2.5 ≈ 12.18
e^2.5 ≈ 12.18  
e^2   ≈ 7.39
e^-1  ≈ 0.37

# 求和
sum = 12.18 + 12.18 + 7.39 + 0.37 = 32.12

# 得到概率分布
P(苹果) = 12.18 / 32.12 ≈ 0.379 (37.9%)
P(好吃) = 12.18 / 32.12 ≈ 0.379 (37.9%)
P(很)   = 7.39 / 32.12  ≈ 0.230 (23.0%)
P(吗)   = 0.37 / 32.12  ≈ 0.012 (1.2%)

输出 → 概率分布，最终的输出 y 是：[0.379, 0.379, 0.230, 0.012]。这才是一个标准的概率分布：

每个值在0到1之间
所有值的和等于1
模型认为“苹果”和“好吃”的概率最高（各37.9%）

4.3.2 采样选择下一个词

模型会根据这个概率分布来“抽”下一个词：

有37.9%的概率选“苹果”
有37.9%的概率选“好吃”
有23.0%的概率选“很”
有1.2%的概率选“吗”

最常见的方式是贪心采样：选概率最大的（“苹果”或“好吃”）。但如果总选最大的，回复会变得机械。所以现代模型会用温度采样（Temperature Sampling）让低概率词也有机会被选中，增加回答的多样性。

4.4 完整的输入— 输出流程

输入x: "苹果 好吃 吗"
         ↓
    [Token IDs]
    [1, 2, 4]  (假设的ID映射)
         ↓
    [向量化]
[[1,0], [0,1], [1,1]]
         ↓
    [函数f]
    (矩阵乘法)
         ↓
   [原始分数]
    [2.5, 2.5, 2, -1]
         ↓
    [Softmax]
         ↓
输出y: [0.379, 0.379, 0.230, 0.012]
         ↓
    [采样]
         ↓
下一个词: "苹果" 或 "好吃"