第2章：大模型是什么

本章解决的核心问题：什么是「大模型」？「大」到底指什么？神经网络和参数是什么意思？一个模型是怎么从海量文本里学出「智能」的？读完这一章，你不再是「知道 AI 能聊天」的外行——你开始理解它内部是怎么运作的。

2.1 先给你一个整体画面

在深入任何技术细节之前，先用一个比喻把整个大模型的工作方式装进脑子里。

想象你走进一间巨大的图书馆，里面有地球上出版过的所有书。一个孩子坐在图书馆中央，他既不认字，也不会说话。但他的任务很离奇：旁边的人从书架上抽取一页纸，盖住最后几个词，让他猜被盖住的是什么。 猜错了，旁边的人告诉他正确答案；猜对了，他也知道「对了」。

这个孩子每天猜 24 小时，连续猜了好几个月——把图书馆里每一个书架、每一本书、每一页、每一个段落、每一个句子都猜了一个遍。每次猜对他都在脑中的「参数」里强化某些连接，猜错就削弱。

到最后，这个孩子虽然不知道自己脑中的连接长什么样，但他已经有了一个惊人的能力：你给他一句话的开头，他能以惊人的准确率补完后面的内容。

这就是大语言模型——一个超级复杂的「下一个词预测器」。

这个比喻的每个要素都对应着技术现实中对应的概念：

下面，我们逐个拆解这些概念。

2.2 神经网络：一个极其简化的「脑细胞模拟」

2.2.1 从一个神经元开始

1943 年，神经科学家麦卡洛克和数学家皮茨发表了一篇论文，提出了人类历史上第一个人工神经元的数学模型。它的结构出奇地简单：

flowchart LR
    X1[x₁] -->|w₁| N[Σ 加权求和]
    X2[x₂] -->|w₂| N
    X3[x₃] -->|w₃| N
    N --> AF[激活函数]
    AF --> O[输出 y]

工作流程：

1. 输入信号（x₁, x₂, x₃, ...）进来，每个信号有一个权重（w₁, w₂, w₃, ...）。
2. 神经元把「每个输入 × 它的权重」加起来，得到一个总数。
3. 这个总数经过一个激活函数（决定要不要「激活」——也就是输出还是不输出），变成最终的输出。

用一个生活化的例子：你在决定「今天要不要去跑步」。

你把所有输入乘以权重加起来：5 + (-3) + 4 + (-6) = 0。如果激活函数的阈值是「>0 就去跑」，那么结果为 0，你的神经回路决定「不去」。

这个模型极其简化——真实的大脑神经元比这复杂无数倍。但就是这种简化模型的大量堆叠，产生了令人震惊的智能行为。

2.2.2 为什么叫「深度」学习

把成千上万个这样的「人工神经元」连接起来，一层一层地堆叠，就得到了神经网络：

flowchart TB
    subgraph input[输入层]
        I1[像素 1]
        I2[像素 2]
        I3[...]
        I4[像素 N]
    end
    subgraph hidden1[隐藏层 1]
        H1a[●]
        H1b[●]
        H1c[●]
    end
    subgraph hidden2[隐藏层 2]
        H2a[●]
        H2b[●]
        H2c[●]
    end
    subgraph output[输出层]
        O1[猫]
        O2[狗]
        O3[鸟]
    end
    I1 & I2 & I3 & I4 --> H1a & H1b & H1c
    H1a & H1b & H1c --> H2a & H2b & H2c
    H2a & H2b & H2c --> O1 & O2 & O3

• 输入层接收原始数据（比如图片的像素值、文本的 token）。
• 隐藏层一层一层地提取越来越抽象的特征。对于图片识别：
  • 第一层可能学会检测边缘和颜色
  • 第二层可能学会把边缘组合成形状（圆形、方形）
  • 第三层可能学会把形状组合成部件（眼睛、鼻子、耳朵）
  • 最后一层就能判断：「这些部件的组合 = 猫」
• 输出层给出最终答案。

「深」就是指隐藏层的数量多。一个只有 2-3 层的网络是「浅层网络」，AlexNet（2012）有 8 层，ResNet（2015）做到了 152 层，而今天的大语言模型（Transformer）动辄有几十到上百层。

直觉：层数越多，模型能表达的「抽象层次」就越多，能学到的规律就越复杂。但层数多了也会带来训练困难——梯度消失、梯度爆炸等问题，我们后面会提到。

2.3 参数：模型「学会」的东西

2.3.1 参数就是权重

在上面那个神经元的例子里，每个输入信号都有一个权重（w₁, w₂, w₃...）。在一个有几百万、几十亿个神经元的网络里，这些权重加起来就是所谓的参数。

参数 = 可调整的旋钮。 训练的过程 = 反复拧这些旋钮，让模型的输出越来越接近正确答案。

参数的数量决定了模型的「容量」——它能记住多复杂的模式。

2.3.2 参数量的量级

MoE（混合专家）的特别说明：像 DeepSeek-V3 这样的模型用了「混合专家」架构——它的总参数量有 6710 亿，但每次推理只激活其中一小部分（约 370 亿）。这就像一家公司有 6710 名员工，但完成一个任务只需要调动 370 人。我们在第4章会再提到。

2.3.3 参数不是「知识库」

这是一个非常常见的误解：以为模型把训练数据「存」在了参数里，需要的时候再「调出来」。不是这样的。

参数里存的不是原文，而是统计规律。模型不会一字不差地记住「中国首都是北京」，而是学到了（或者说调整了参数）这样一个特征：当前面一堆词涉及「中国的首都是哪里」时，输出「北京」这个词的概率非常高。

你可以把参数想象成被压缩到极致的世界模型——它不是一本百科全书，而是一张无比精密的「语言概率地图」。你在这个地图上随意走，每到一个路口，模型就根据前面走过的路，给你几个「接下来最可能往哪里走」的选项。

2.4 训练：模型是怎么「学」的

2.4.1 核心任务：下一个词预测

LLM 的训练任务出奇地简单——Next Token Prediction（下一个 token 预测）。

给模型一段文本的前半段，让它猜接下来的 token 是什么。猜错了就调整参数，让模型下次更接近正确答案。

输入：[今天] [天气] [真]
模型要猜：下一个 token 是什么？

可能答案：
"好"    (概率 0.47)
"热"    (概率 0.23)  
"不"    (概率 0.12)
"冷"    (概率 0.06)
...

如果训练数据中下个词是「好」，那就告诉模型：「你的参数应该让你在类似情况下给『好』更高的概率」。通过数百万亿次的这种微调，模型逐渐学到了语言的结构、事实、推理模式——都蕴含在「下一个词是什么」这个看似幼稚的问题里。

2.4.2 训练三件套：前向传播 → 计算损失 → 反向传播

每一轮训练包含三步，像一个极其枯燥但有效的循环：

flowchart LR
    A[① 前向传播
输入数据 → 模型输出
「模型猜一个答案」] --> B[② 计算损失
把模型的答案和
标准答案做对比
算出「差多远」]
    B --> C[③ 反向传播
从输出层往输入层
逐层计算每个参数的
「责任大小」然后调整]
    C --> A

第一步：前向传播（Forward）

输入数据从第一层走向最后一层，每一层的神经元按当前的权重计算并传递信号，最终产生一个输出（预测结果）。这一步只是「算」，不改变任何参数。

第二步：计算损失（Loss）

把模型的输出和「标准答案」做对比，用一个数学公式（损失函数）算出「你错了多少」。比如模型预测下一个词是「热」的概率是 23%，但标准答案是「好」——那损失值就比较大，表示「你猜得不太对」。

第三步：反向传播（Backpropagation）+ 梯度下降（Gradient Descent）

这是训练的核心魔法。一个形象的比喻：

你在山里，大雾弥漫，看不见路。你想走到山的最低点（损失最小的地方）。你在当前位置跺了一脚，感觉到地面往哪个方向倾斜——梯度告诉你「那边更低」。于是你往那个方向迈一小步——参数更新。然后你再跺一脚，再迈一步。重复重复再重复——直到你走到了谷底。

技术上说：

• 反向传播：从输出层往回传播误差信号，算出每个参数对最终错误的「贡献」——这就是梯度（偏导数）。
• 梯度下降：根据梯度调整参数——梯度大说明这个参数对错误的「贡献」大，需要大调；梯度小说明贡献小，调一点点就好。

学习率控制每一步迈多大：

• 太大 → 可能在最低点附近来回跳，永远到不了
• 太小 → 走得极慢，可能永远到不了
• 刚刚好 → 高效到达最低点

graph LR
    subgraph 学习率太大
        A1[⚫] --> A2[⚫] --> A3[⚫] --> A4[⚫]
    end
    subgraph 学习率太小
        B1[⚫] --> B2[⚫] --> B3[⚫] --> B4[⚫] --> B5[⚫] --> B6[⚫]
    end
    subgraph 学习率适中
        C1[⚫] --> C2[⚫] --> C3[⚫] --> C4[⚫]
    end

现代训练中，实际用的优化器（如 Adam、AdamW）远比朴素的梯度下降复杂——它们会自适应地调整每个参数的学习率、引入动量（惯性）来加速收敛等。但核心思想不变：算梯度 → 调参数 → 重复。

2.4.3 训练数据量级

GPT-3 的训练使用了大约 3000 亿个 token 的文本（不同来源的数据量估计略有出入）。这包括：

GPT-3 的训练用了大约 3640 petaflop/s-days 的计算量（这个单位我们会在第4章解释），在数千块 GPU 上跑了数周到数月。据估计，GPT-3 的训练电费就在百万美元级别。

2.5 规模定律：为什么「大」如此重要

2.5.1 缩放定律（Scaling Laws）

2020 年，OpenAI 发表了一篇极具影响力的论文《Scaling Laws for Neural Language Models》，提出了一个发现：模型的性能（以测试损失衡量）随模型规模、数据量、计算量的增加而有规律地提升，遵循幂律关系。

用人话说：把模型做大、用更多数据喂、用更多算力训，效果就会更好——而且这种改善是可预测的。 不存在那种「做到某个程度就没效果了」的天花板（至少到他们研究的范围为止）。

graph LR
    A[更多参数] --> D[更好的性能]
    B[更多数据] --> D
    C[更多算力] --> D

这篇论文直接推动了从 GPT-2（15 亿参数）到 GPT-3（1750 亿参数）的百倍跳跃——背后的逻辑就是：如果缩放定律是对的，那就值得花几千万美元去训练一个更大的模型。

2.5.2 涌现能力（Emergent Abilities）

「大」带来的最让人惊讶的现象是涌现——当模型规模跨过某个阈值后，突然出现了小模型完全不具备的能力。

小模型（< 10 亿参数）基本只会补全句子。但当参数量超过某个临界点（大约 600 亿到 1000 亿），模型开始表现出一系列没人专门教过它的能力：

• 上下文学习：给它几个示例（few-shot），它就能按示例模式完成任务。
• 思维链推理：当提示它「我们一步一步想」，它的回答质量显著提升。
• 多语言翻译：训练数据里主要是英文，但模型学会了把其他语言翻译成英文。
• 代码生成：在大量代码数据（GitHub 等）上训练后，模型能理解自然语言指令并写出代码。

关键洞察：没人专门给 GPT-3 写「你要学会推理」的代码。推理能力是从「预测下一个词」这个唯一任务中涌现出来的——当参数足够多、数据足够大时，语言统计规律本身包含了推理所需的模式。

这就像一个孩子读了很多书后，不需要专门上过「逻辑课」也能进行基本的推理——因为推理的规律已经蕴含在语言中了。

2.6 Transformer：大模型的核心架构

2017 年 Google 发表的《Attention Is All You Need》是 AI 历史上最重要的论文之一。Transformer 架构几乎完全取代了之前所有的序列模型（RNN、LSTM），成为今天每一款大模型的底层架构。

2.6.1 为什么 RNN 不够好

在 Transformer 之前，处理文本的主流方式是循环神经网络（RNN）。它的工作方式是按顺序一个词一个词地读：

输入：[我] → [爱] → [吃] → [苹果]

第 5 个词的处理必须等第 4 个词处理完；第 100 个词必须等前 99 个词处理完。这有三个致命问题：

1. 不能并行：必须串行，无法充分利用 GPU 的并行计算能力。
2. 长距离遗忘：读到第 100 个词时，第 1 个词的信息已经衰减得差不多了（梯度消失）。
3. 训练慢：串行处理让训练时间变得不可接受，尤其是数据量巨大的时候。

2.6.2 注意力机制：让每个词都能「看到」所有其他词

Transformer 的核心创新是自注意力（Self-Attention）机制。它的思想很简单但极其强大：

在处理一个词的时候，让模型同时「注意」句子中所有其他的词，并根据相关性给每个词分配不同的「注意力权重」。

以「小明把苹果给了小红，她很开心」为例。当模型处理「她」这个词时：

• 注意力机制让模型去审视句子中所有其他词——「小明」「苹果」「小红」。
• 模型自动学会把高注意力权重分配给「小红」，因为在这个语境里「她」最可能指「小红」。
• 这一判断不是靠「距离近」——RNN 只能捕捉邻近词的关系——而是靠语义上的「谁跟谁相关」。

flowchart LR
    subgraph 句子
        W1[小明] --- W2[把] --- W3[苹果] --- W4[给了] --- W5[小红] --- W6[她] --- W7[很] --- W8[开心]
    end
    W1 -.->|注意力：低| W6
    W3 -.->|注意力：低| W6
    W5 -.->|注意力：高| W6

自注意力之所以叫「自」，是因为同一个句子里的词互相看——查询（Query）、键（Key）、值（Value）这三个矩阵都来自同一个输入序列。每个词通过自己的 Query 去和所有词的 Key 做匹配，得到一个注意力分数，然后用这个分数去加权聚合所有词的 Value。

2.6.3 Transformer 的完整结构

Transformer 由两大块组成：

flowchart TB
    subgraph encoder[编码器]
        E1[输入嵌入]
        E2[位置编码]
        E3[多头自注意力]
        E4[前馈网络]
    end
    subgraph decoder[解码器]
        D1[输出嵌入]
        D2[带掩码的多头自注意力]
        D3[交叉注意力]
        D4[前馈网络]
        D5[线性层 + Softmax]
    end
    E1 --> E2 --> E3 --> E4
    D1 --> D2 --> D3 --> D4 --> D5
    E4 -.->|编码器输出| D3

• 编码器（Encoder）：把输入序列（如一句话）处理成包含上下文信息的向量表示。BERT 只用编码器。
• 解码器（Decoder）：根据编码器的输出和前文，一个 token 一个 token 地生成输出序列。GPT 系列只用解码器。
• 原始 Transformer（用于翻译）两者都用；GPT 系列只用解码器；BERT 系列只用编码器。

对于 ChatGPT 这样的生成式模型，它只用了解码器栈——一个单向的（从左到右）、掩码的自注意力解码器。它从输入 prompt 开始，生成下一个 token，然后把新生成的 token 追加到序列后面，再生成下一个——如此反复，直到生成结束标记或达到长度限制。

2.6.4 为什么 Transformer 这么成功

2.7 训练 vs 推理：两种完全不同的运行模式

很多人以为模型「一直在学习」——每次和 ChatGPT 对话，它都在变聪明。不是这样的。

flowchart TB
    subgraph training[训练 Training]
        T1[喂入海量数据]
        T2[前向 + 反向传播]
        T3[更新参数]
        T4[得到训练好的模型]
        T1 --> T2 --> T3 --> T4
    end
    subgraph inference[推理 Inference]
        I1[用户输入 Prompt]
        I2[前向传播]
        I3[生成 Token]
        I4[返回给用户]
        I1 --> I2 --> I3 --> I4
    end

关键结论：开箱即用的大模型是静态的。它不会在和你的对话中变聪明。你今天问了它一个问题，明天再问一遍，它给出的答案好不好取决于它的推理能力——而推理能力在训练结束的那一刻就固定了（直到下一次训练或微调）。

2.8 模型是怎么「说话」的：逐 Token 生成

当你给 ChatGPT 发一条消息「帮我写一首关于秋天的五言绝句」，它并不是在后台检索诗歌数据库然后拼接。它是这样工作的：

1. 把你的 prompt 转化成一系列 token（见第3章）。
2. 把这些 token 输入训练好的 Transformer 解码器。
3. Transformer 计算出一个概率分布——下一个 token 是「秋」的概率 0.31，是「金」的概率 0.17，是「落」的概率 0.09……
4. 根据采样策略（见第5章）选择一个 token 作为输出——假设选了「秋」。
5. 把「秋」追加到序列后面，重复步骤 3 → 生成「风」→ 重复 → 生成「萧」→ 重复……
6. 直到生成一个特殊的结束标记（如 <|endoftext|>）或达到最大长度。

flowchart LR
    P[Prompt: 帮我写一首
关于秋天的五言绝句] --> T1[生成: 秋]
    P --> T1
    T1 --> T2[生成: 风]
    P & T1 --> T2
    T2 --> T3[生成: 萧]
    P & T1 & T2 --> T3
    T3 --> T4[生成: 瑟]
    P & T1 & T2 & T3 --> T4
    T4 --> T5[...]

这个过程叫自回归生成（Autoregressive Generation）——每一步的输出成为下一步的输入，一步一步地「自己写自己」的延续。

本章小结

下一章预告

现在你理解了模型是怎么「长」出来的——从神经网络基础到训练过程到 Transformer 架构。但你有没有想过一个问题：模型是怎么「读」文字的？

它看到的不是「汉字」和「单词」，而是一串数字。这些数字是怎么来的？为什么同样的中文，有的模型处理起来费劲，有的很顺畅？为什么 API 按「token」计费而不是按「字数」？

→ 第3章：Token