企业官网建设流程全解析

上一课最后，我们已经把文字送到了神经网络的大门口。

整条链路是：

Text

↓

Tokenizer

↓

Token

↓

Token ID

比如一句话：

人工智能正在改变软件开发。

经过某个 Tokenizer 以后，会被拆成若干 Token，再进一步变成一串 Token ID。

具体怎样切、具体 ID 是多少，取决于具体 Tokenizer。

没有指定模型时：

Information Not Available

但上一课有一个结论，与具体 Tokenizer 完全无关：

Token ID 只是编号。

或者说得更准确一点：

Token ID 是地址，不是意义。

假设：

猫 → 4217 狗 → 9821 数据库 → 315

4217 和 9821 本身没有任何地方写着：

“猫”和“狗”都是动物。

315 也没有告诉模型：

“数据库”属于软件和计算机领域。

甚至：

cat → 100 quantum → 101

两个 ID 只差 1，也完全不代表它们语义接近。

于是第七课走到最后，留下了一个非常关键的断点：

Text

↓

Token

↓

Token ID

↓

?

↓

Transformer

这个问号是什么？

答案就是今天这一课：

Embedding

但这一课真正要回答的，不只是：

Embedding 是什么？

而是一个更根本的问题：

为什么一串毫无意义的 Token ID，经过 Embedding 以后，竟然能够逐渐变成模型可以使用的 Representation？

这件事一旦想通，后面的 Attention、Hidden State、Transformer，才真正有了入口。

一、第七课解决的是“你是谁”，第八课开始解决“你是什么样的”

先把两件事彻底分开。

Tokenizer 做完以后：

“猫” → Token ID 4217

这个 4217 很重要。

因为模型必须能够唯一确定：

现在输入的是 Vocabulary 里的哪一个 Token？

所以 Token ID 的任务是：

Identity

也就是：

身份识别。

但语言模型只知道身份远远不够。

因为它还要逐渐学习：

“猫”经常出现在哪些 Context？

“猫”和“狗”有什么共同使用模式？

“猫”和“微积分”为什么通常不属于同一类语言环境？

“bank”在不同句子里为什么可能承担不同含义？

这些已经不是：

Identity

的问题。

而是：

Representation

也就是：

表示。

所以从今天开始，我们第一次需要严格区分：

Token ID 负责告诉模型“这是谁”。

Representation 负责让模型形成“这个东西应该怎样被计算”。

Embedding，就是从 Identity 走向 Representation 的第一步。

二、为什么不能把 Token ID 直接当成普通数字？

假设我们的 Vocabulary 极小，只有五个 Token：

如果直接把：

0 1 2 3 4

当成普通数值交给神经网络，会发生一个很奇怪的问题。

普通数字天然带着数学关系：

4 > 3 > 2 > 1 > 0

还有：

4 - 3 = 1 1 - 0 = 1

甚至：

4 = 2 × 2

但这些数学关系和 Token 之间的语言关系毫无关系。

“跑步”并不比“银行”大 1。

“苹果”也不是“狗”的两倍。

所以：

Token ID 虽然是数字，但不能把它当成具有普通数值意义的 Feature。

它更像数据库里的 Primary Key。

例如：

Employee ID = 17352

不意味着编号 17353 的员工就和他性格特别接近。

编号只是：

找到这个对象的地址。

于是问题继续向前。

既然普通数字会制造不存在的大小和距离关系，

我们能不能换一种表示方式？

三、第一种自然答案：One-hot

还是刚才五个 Token。

我们不要再把“猫”表示成：

0

而是表示成：

[1, 0, 0, 0, 0]

“狗”：

[0, 1, 0, 0, 0]

“苹果”：

[0, 0, 1, 0, 0]

“银行”：

[0, 0, 0, 1, 0]

“跑步”：

[0, 0, 0, 0, 1]

这就是：

One-hot Encoding

One-hot 有一个非常漂亮的性质。

每一个 Token 都只是：

在属于自己的那个位置上放一个 1。

其他位置全部是 0。

于是：

“狗”不是数字 1

它只是：

第二个位置被激活

这样一来：

“狗比猫大 1”

这种虚假的数学关系就消失了。

从 Identity 的角度看，One-hot 非常干净。

但它很快就出现了第二个问题。

四、One-hot 解决了假关系，却没有创造真正的关系

假设真实 Vocabulary 有：

V = 100000

也就是十万个 Token。

那么每一个 Token 的 One-hot Vector 都需要：

100000 维

例如：

[0,0,0,0,...,1,...,0,0]

十万个位置里：

99999 个是 0 1 个是 1

非常稀疏。

这当然很浪费。

但更严重的问题其实还不是存储。

真正的问题是：

One-hot 仍然只知道“它是谁”。

它没有表达：

“它和其他 Token 有什么关系。”

例如：

“猫”和“狗”

在人类语言里显然存在大量相似使用环境。

它们都可能和：

宠物 主人 喂养 毛 动物

这些概念共同出现。

而“猫”和“微积分”的语言使用模式通常完全不同。

可是，在 One-hot 空间里：

猫 = [1,0,0,0,...] 狗 = [0,1,0,0,...]

它们和：

猫 = [1,0,0,0,...] 微积分 = [0,0,1,0,...]

从这种表示本身看，没有天然的：

“第一组更相似”。

所有不同 Token 都被完全分开。

所以 One-hot 做到的是：

Identity without Relationship

有身份，

没有关系。

而语言模型真正需要的是：

一种不仅能够区分 Token，还能够被训练成有用内部结构的表示方式。

这就把我们逼到了 Embedding。

五、如果 One-hot 太稀疏，那就把它投影到一个更小的空间

假设 Vocabulary Size 是：

V

我们给模型准备一张矩阵：

E∈ ℝV×d

这里：

V

是：

Vocabulary Size

而：

d

是：

Embedding Dimension

假设：

V = 100000 d = 4096

那么这张矩阵就是：

100000 × 4096

它有十万行。

每一行都有 4096 个数字。

可以把它画成：

这张表就是：

Embedding Matrix

现在假设：

“猫”的 Token ID = 4217

模型不再把：

4217

这个数字直接交给 Transformer。

而是做一件非常简单的事：

去 Embedding Matrix 找第 4217 行

假设这一行是：

[0.21, -0.73, 1.18, 0.44, ...]

那么真正进入后续神经网络的，就是这一整条向量。

数学上：

e4217 =E[4217]

突然之间，第七课那句话就完整了。

Token ID 是地址。

因为它真正做的事情就是告诉模型：

去 Embedding Matrix 的哪一行取数据。

而：

Embedding Vector 才是后续网络真正计算的对象。

六、这时候你会发现：第七课里那个 V × d 终于不是一个伏笔了

上一课我们讨论 Vocabulary Size 时，已经提前看到过：

V×d

当时我们只是说：

如果 Vocabulary 变大，

Embedding Matrix 相关参数规模也会随之变化。

现在终于可以真正理解为什么。

因为 Vocabulary 每新增一个 Token，

Embedding Matrix 原则上就需要多出一行对应它的向量。

所以：

Vocabulary Size

↓

Embedding Matrix 行数

↓

Embedding Parameters

它们根本不是三个彼此独立的概念。

Tokenizer 负责定义：

有哪些 Token。

Vocabulary 负责定义：

每个 Token 的 ID 是什么。

Embedding Matrix 接着定义：

每个 Token ID 初始对应哪一条连续向量。

所以现在完整的数据入口已经变成：

Raw Text

↓

Tokenizer

↓

Token

↓

Token ID

↓

Embedding Lookup

↓

Vector

第七课解决：

Symbol → ID

第八课开始解决：

ID → Vector

七、One-hot 为什么还值得讲？因为它能让你真正看懂 Embedding Lookup

这里有一个非常漂亮的线性代数关系。

假设 Vocabulary 只有 5 个 Token。

“狗”的 Token ID 是 1。

那么它的 One-hot 是：

x= [0, 1, 0, 0, 0]

再假设 Embedding Matrix 是：

E=

e0

e1

e2

e3

e4

现在做：

xE

由于：

x= [0, 1, 0, 0, 0]

只有第二个位置是 1，

所以矩阵乘法最后留下的就是：

xE=e1

也就是：

“狗”的 Embedding。

这件事很重要。

因为它告诉我们：

Embedding Lookup 从数学上可以看成 One-hot Vector 与 Embedding Matrix 相乘。

但工程实现中根本没必要真的创建一个十万维甚至更大的 One-hot Vector。

因为 Token ID 已经告诉我们应该取哪一行了。

所以实际操作更接近：

Embedding(ID) = E[ID]

直接查表。

于是：

One-hot × Embedding Matrix

和：

Embedding Lookup

在结果上可以对应起来。

这也是为什么 Embedding Layer 看起来像“查表”，

背后却仍然可以放在线性代数框架里理解。

八、但如果 Embedding 只是查表，那“意义”到底从哪里来？

现在真正的大问题出现了。

假设：

猫 → [0.21, -0.73, 1.18, ...] 狗 → [0.25, -0.69, 1.09, ...]

谁写的这些数字？

工程师提前规定的吗？

是不是有人在训练前告诉模型：

第 1 维 = 是否是动物 第 2 维 = 是否可爱 第 3 维 = 是否是宠物 ...

都不是。

真正关键的一句话是：

Embedding Matrix 本身就是模型参数。

也就是说：

E⊂ θ

它属于我们前面几课一直在讲的：

θ

训练刚开始时，

这些数字并没有今天想象中的丰富语言结构。

接下来发生的事情，就是第一课到第六课已经讲过的整套 Training Loop：

Data

↓

Model

↓

Prediction

↓

Loss

↓

Gradient

↓

Optimizer

↓

Parameter Update

只不过现在我们终于发现：

Embedding Matrix 也是 Parameter。

所以 Gradient 不只更新 Attention、MLP 等后续网络参数。

它也可以一路影响到 Embedding 相关参数。

整条链现在变成：

Text

↓

Tokenizer

↓

Token ID

↓

Embedding

↓

Neural Network

↓

Prediction

↓

Loss

↓

Backpropagation

↓

Gradient

↓

Embedding Update

到这里，第八课第一次真正重新接回了第一课。

九、模型从来没有被要求“学习语义”

这一点特别值得停下来想一会。

训练语料里没有一张表：

猫 = 动物 狗 = 动物 巴黎 = 城市 法国 = 国家

也没有一个监督标签告诉模型：

猫和狗的向量距离应该是 0.18 猫和数据库的距离应该是 0.91

模型真正被要求做的事情，从第二课开始就只有一个：

把下一个 Token 预测得更准。

例如训练数据不断出现：

我养了一只猫 这只猫很可爱 给猫喂食 狗也是常见宠物 我带狗出去散步

如果模型想在这些 Context 中降低 Loss，

它的内部参数就必须逐渐形成一些：

对预测有帮助的结构。

“猫”和“狗”会出现在大量相似或相关的语言环境里。

如果某种 Representation 能够让后续网络更容易利用这些统计规律，

那么：

Loss

↓

Gradient

↓

Parameter Update

就可能不断强化这种 Representation。

注意这里最重要的措辞。

不是：

“模型被告诉猫和狗应该靠近。”

而是：

某些内部表示方式如果更有利于完成预测任务，就更可能在训练过程中被保留下来。

这就是：

Representation Learning

表示学习。

十、所以 Embedding 真正神奇的地方，不是“数字很多”

很多人第一次听 Embedding，会产生一个错觉：

Token ID 是一个数字，没有意义。

Embedding 有 4096 个数字，所以终于有意义了。

这个因果关系是不对的。

并不是：

数字越多 → 越有意义

真正关键的是：

这些数字是可学习参数组成的 Representation，而且会因为训练目标不断被调整。

如果随机生成 4096 个数字然后永远不训练，

它并不会自动获得语言意义。

Embedding 真正重要的三个条件是：

连续向量

＋

可学习参数

＋

训练目标驱动

它们结合起来以后，

模型才拥有了一个可以逐渐组织语言规律的连续空间。

十一、为什么是高维向量，而不是一个数字？

假设我们强行规定：

每一个 Token 只能用一个数字表示。

例如：

猫 = 0.31 狗 = 0.34 银行 = 0.82 跑步 = 0.57

问题很快就会出现。

一个 Token 的语言使用模式可能同时涉及：

语法角色、

主题、

搭配关系、

实体属性、

语言类别、

上下文习惯、

代码结构、

语义关系，

以及大量我们甚至很难直接命名的统计特征。

一个坐标根本没有足够的自由度去形成这么复杂的结构。

于是模型使用：

e= [e1,e2,e3, …,ed]

这样的高维向量。

例如：

d= 4096

那么一个 Token 的初始 Representation 就处在一个 4096 维空间中。

我们通常把这种空间叫：

Vector Space

或者更广义地说：

Representation Space

但这里马上要防止一个非常常见的误区。

十二、4096 维，不代表 4096 个可以被人类命名的属性

千万不要把 Embedding 想象成：

第 1 维 = 是否是动物 第 2 维 = 是否是名词 第 3 维 = 是否与金融有关 第 4 维 = 是否褒义 第 5 维 = 是否属于科技领域 ...

真实神经网络通常远没有这么整齐。

更常见的情况是：

某种信息分布在许多维度、许多参数以及它们的组合关系中。

一个概念不一定属于某一个单独维度。

同一个维度也不一定只承担一种人类可以直接命名的含义。

这就是：

Distributed Representation

分布式表示。

所以面对：

[0.21, -0.73, 1.18, 0.44, ...]

不要执着地问：

“0.21 到底是什么意思？”

有时候更合理的问题应该是：

这一整组数字形成的模式，在后续计算中发挥了什么作用？

这才更接近现代神经网络内部 Representation 的真实样子。

十三、那“知识存在高维向量里”这句话到底对不对？

这是一个很容易说过头的问题。

如果说：

“大模型所有知识都存在 Embedding Matrix 里。”

这是不准确的。

Embedding 的确非常重要，

但模型的知识和能力会分布在大量地方：

Embedding Parameters Attention Parameters MLP Parameters 其他网络权重 运行时 Hidden States 以及它们之间的复杂交互

所以更准确的说法应该是：

模型能够把对任务有用的信息结构编码进高维 Representation，而知识以分布式形式存在于整个网络之中。

Embedding 是：

Representation 的入口

不是：

整个知识仓库

这两个概念一定不要混在一起。

十四、Latent 到底是什么意思？

从这一课开始，你会越来越频繁地在论文里看到一个词：

Latent

例如：

Latent Representation

Latent Space

Latent State

很多人第一次看到会觉得它特别玄学。

其实最核心的意思没有那么神秘。

Token ID 是：

4217

这是我们人为定义的显式编号。

但经过模型以后：

4217

↓

[0.21, -0.73, 1.18, ...]

这些内部坐标到底应该怎样组织，

并不是人类逐维规定好的。

它们是在训练过程中形成的。

所以可以把 Latent 理解成：

模型内部形成、但没有被人类预先规定成人类可读字段的内部表示。

换句话说：

我们规定任务。

模型通过 Optimization 自己寻找：

什么样的内部坐标系统最有利于完成任务。

这就是 Latent Representation 最值得理解的地方。

十五、有了向量，我们终于可以第一次谈“相似”

Token ID 本身不能谈距离。

因为：

4217 和 4218

数值接近，

不代表 Token 语义接近。

但变成 Vector 以后，情况不同了。

我们终于可以使用线性代数的方法分析两个 Representation。

例如：

ecat

和：

edog

之间是否呈现某种相似结构。

一个很常见的分析工具叫：

Cosine Similarity

公式是：

cos(a,b) =a·b|a| |b|

直觉上，

它主要比较：

两个向量的方向有多相似。

通常：

接近 1

意味着方向较相似。

接近 0

意味着方向关系较弱。

接近 -1

意味着方向相反。

但这里必须特别谨慎。

不能把它简单理解成：

Cosine Similarity 就是完整的“语义相似度”。

尤其在现代 LLM 中，

语言结构远不只存在于最初的 Token Embedding 里。

所以更严谨的说法是：

Cosine Similarity 是研究 Vector Representation 几何关系的一种工具。

而不是：

“模型的全部语义已经被压缩成一个距离。”

十六、Embedding 最大的限制终于出现了：它还不知道当前 Context

现在来看一句：

苹果发布了新的设备。

再看另一句：

我吃了一个苹果。

为了教学方便，假设某个 Tokenizer 中的“苹果”在这里最终对应同一个 Token ID。

那么它刚刚进入 Embedding Layer 时：

Token ID 相同

↓

查同一行 Embedding Matrix

↓

得到同一个初始 Token Embedding

问题来了。

第一句话里的“苹果”可能更偏向某个实体或品牌语境。

第二句话里的“苹果”显然处于食物语境。

可是最开始 Lookup 出来的 Token Embedding 可以是相同的。

这意味着：

Input Embedding 并不等于 Token 在当前句子里的最终含义。

Embedding 解决的是：

这个 Token 以什么向量作为进入网络的起点？

但它还没有完整解决：

这个 Token 在当前 Context 中到底是什么意思？

这一区分极其重要。

十七、于是我们第一次需要区分 Embedding 和 Hidden State

以后看 Transformer 论文或代码时，

你会不停遇到：

Embedding

Hidden State

Representation

这几个词。

先建立一个最基本的框架。

Token ID

身份编号：

4217

它只是 Index。

Token Embedding

通过 Embedding Matrix 查出来的初始向量：

e4217

它是 Token 进入模型时的：

Initial Representation

Hidden State

Token 经过 Transformer Layer 一层又一层处理以后，

形成：

hi(l)

其中：

i

代表 Token Position，

l

代表 Layer。

这时候的向量已经不只是最初的 Token Embedding。

它开始受到：

Context、

Attention、

MLP、

Residual、

以及前面多层网络变换

的影响。

所以以后看到一个 Vector，

一定要先问：

这是刚进入模型的 Token Embedding，还是已经经过网络处理的 Hidden Representation？

两者不能混为一谈。

十八、真正的“上下文意义”，要等 Token 之间开始交流

Embedding 到这里解决了一个非常重要的问题：

Discrete Token

↓

Continuous Vector

但语言真正麻烦的地方，从来不只是理解孤立的 Token。

例如：

小明告诉小李，他明天不会来了。

“他”到底更可能指谁？

又比如代码：

user_count = 10

几百个 Token 以后再次出现：

user_count

模型需要把现在这个位置，

和前面出现过的信息关联起来。

只靠最初的 Token Embedding，

显然还做不到。

因为：

Embedding 让每个 Token 拥有了可以计算的 Representation。

但：

这些 Representation 还需要根据 Context 互相影响。

只有经过后续网络，

一个 Token 的 Hidden State 才可能逐渐从：

“我是谁”

走向：

“我在当前上下文里是什么。”

而这正是 Transformer 接下来真正要解决的问题。

十九、为什么 Embedding 是整个 LLM 非常关键的一次“世界转换”？

回顾一下。

Embedding 之前：

模型面对的是：

猫 银行 Python return 人工智能

这些离散符号。

而 Embedding 之后：

一句长度为：

T

的 Token Sequence，

可以变成：

x1,x2,x3, …,xT

其中每一个：

xi ∈ ℝd

于是从这一刻开始，

模型终于能够对语言做：

矩阵乘法、

点积、

线性投影、

加法、

归一化、

Attention、

MLP、

Residual。

也就是说：

Transformer 从来不是直接对“文字”做矩阵乘法。

Transformer 真正处理的是：

Vector

所以这一课最重要的一次转换就是：

Symbol → Vector

人类世界里的离散语言，

第一次真正进入了神经网络擅长的连续数学世界。

二十、现在把前八课第一次完整串起来

到这里，我们终于可以把前八课拼成一台完整机器。

第一课：

模型为什么会学习？

核心：

Loss

↓

Gradient

↓

Parameter Update

第二课：

LLM 到底在学什么？

核心：

Context

↓

Next Token Prediction

第三课：

模型输出的到底是什么？

核心：

Logits

↓

Softmax

↓

Probability Distribution

接下来我们一路理解：

Cross Entropy、

Backpropagation、

Optimizer。

第七课终于转到输入端：

Text

↓

Tokenizer

↓

Token

↓

Token ID

而今天这一课把最后一个入口补上：

Token ID

↓

Embedding

↓

Vector

于是整个 LLM 的基本数据流第一次可以写成：

Raw Text

↓

Tokenizer

↓

Tokens

↓

Token IDs

↓

Embedding

↓

Vectors

↓

Transformer

↓

Hidden States

↓

LM Head

↓

Logits

↓

Softmax

↓

Next Token Probability

这时候再看“大模型读文字”这句话，

你应该已经有完全不同的画面了。

模型并没有一个叫：

理解文字()

的神秘函数。

真正发生的是：

离散语言被编码成离散 Token。

Token 被映射成连续 Vector。

神经网络对 Vector 进行大量数学变换。

最后再把内部状态映射回 Vocabulary 上的概率分布。

这才是 LLM 真正的数据世界。

二十一、现在终于可以回答标题里的问题

为什么把一个 Token 变成几千个数字以后，

它反而开始有“意义”了？

严格来说，

并不是：

因为它变成了几千个数字，所以产生了意义。

而是因为：

第一，

这些数字构成了一个：

Continuous Representation。

它们能够真正参与神经网络计算。

第二，

这些数字不是固定的人为编码，

而属于：

Learnable Parameters。

第三，

这些参数持续受到：

Prediction

↓

Loss

↓

Gradient

↓

Optimization

的训练压力。

第四，

为了降低预测误差，

模型会逐渐形成：

对完成任务有用的内部结构。

所以更准确的一句话应该是：

Embedding 不是把人类定义好的“意义”塞进 Vector。

而是：

为模型提供一个可以通过训练逐渐形成有用 Representation 的连续空间。

这才是 Embedding 真正值得学懂的地方。

二十二、学完这一课，最容易犯的五个错误

误区一：Token ID 本身包含语义

不包含。

Token ID 首先只是 Vocabulary Index。

ID 相近不代表语义相近。

误区二：Embedding 是工程师提前设计好的语义表

通常不是。

Embedding Matrix 是模型参数的一部分，

会参与 Training。

误区三：Embedding 每一维都有明确的人类含义

通常不能这样理解。

现代神经网络大量使用：

Distributed Representation。

误区四：一个 Token 的 Embedding 就是这个词在所有语境中的完整意义

不是。

Token Embedding 只是进入模型时的初始 Representation。

Contextual Meaning 需要后续网络进一步形成。

误区五：大模型的知识全部存在 Embedding Matrix

不对。

模型的能力和知识分布在整个网络参数与运行时 Representation 中。

Embedding 只是入口之一。

二十三、如果你真的理解这一课，应该能够回答这几个问题

现在不要背定义。

尝试自己回答：

为什么 Token ID 不能直接被当成普通数值 Feature？

为什么 One-hot 消除了虚假的大小关系，却仍然不是理想 Representation？

为什么：

OneHot × EmbeddingMatrix

可以对应一次 Embedding Lookup？

为什么 Embedding Matrix 属于：

θ

也就是模型参数？

如果训练数据从来没有显式告诉模型：

“猫和狗比较相似。”

为什么训练仍然可能形成对语言任务有帮助的内部结构？

为什么 Embedding Dimension 很高，

却不能简单解释成：

“每一维对应一个语义属性？”

为什么同一个 Token 的初始 Embedding 可以相同，

经过 Transformer 后的 Hidden State 却可能完全不同？

如果这些问题你都能顺着：

Token ID

↓

Embedding Matrix

↓

Vector

↓

Loss

↓

Gradient

↓

Representation Learning

解释出来，

那 Embedding 就真的学懂了。

二十四、但现在又出现了一个更基础的问题：只有 Vector，模型怎么知道顺序？

这一课结束以后，

一句话已经从：

Token₁ Token₂ Token₃ ... Tokenₜ

变成：

x1,x2,x3, …,xT

很好。

每一个 Token 都已经拥有一个 Vector。

Transformer 终于有东西可以算了。

但现在出现一个看似不起眼、实际上非常致命的问题。

假设有两句话：

狗咬人

和：

人咬狗

Token 都差不多。

Embedding 也都有。

可两句话的意思显然完全不同。

区别在哪里？

顺序。

问题是：

如果 Transformer 看到的只是：

Vector Vector Vector Vector

这些向量本身哪里写着：

谁是第一个？

谁是第二个？

谁在谁前面？

Embedding 告诉模型：

我是谁。

可是它并没有自动告诉模型：

我在哪里。

于是第八课结束以后，

我们自然遇到了 Transformer 的下一个问题：

Token

↓

Embedding

↓

Vector

↓

???

如果所有 Token 最终都只是 Vector，

模型到底从哪里知道它们的顺序？

这就是下一课要解决的问题：

Position

下一课，我们会正式进入：

Position Encoding、Position Embedding，以及 RoPE。

然后再继续向前，

来到整个 Transformer 最核心的问题：

这些已经拥有身份、拥有位置的 Vector，究竟怎样彼此寻找和交换信息？

那个答案，就是：

Attention

下一课

大模型训练原理（09）｜如果 Transformer 看到的只是一堆 Vector，它到底怎么知道谁在前、谁在后？——Position 与 RoPE

第七课解决的是：

文字怎么变成模型可以索引的编号。

第八课解决的是：

编号怎么变成模型真正能够计算的 Representation。

第九课则要继续追问：

有了 Representation 以后，模型到底怎么知道这些 Token 的顺序？

到这里，

我们已经真正从人类看到的：

Language

一步一步走进模型看到的：

Vector Space

而 Transformer 的世界，

现在才刚刚开始。