01. 什么是大语言模型：从神经网络到文本生成

本章从零开始。如果你知道什么是神经网络，可以快速浏览；如果不知道，这一章会帮你建立完整的基础直觉。

一、从最简单的问题开始

假设你想写一个程序，输入一张照片，输出”这是猫还是狗”。

传统编程的思路：写规则。“如果耳朵是尖的，就是猫”——但尖耳朵的狗呢？“如果有胡须，就是猫”——但照片模糊看不到胡须呢？

你会发现：规则写不完。

神经网络的思路完全不同：给它 10 万张标好”猫”或”狗”的照片，让它自己学出区分规则。

这就是机器学习的核心思想：不写规则，而是从数据中学习规则。

二、神经元：最小的计算单元

2.1 一个神经元在做什么

一个神经元做的事情极其简单——加权求和，然后判断：

输入:   x1 = 0.8 (耳朵尖度)
        x2 = 0.3 (体型大小)
        x3 = 0.6 (毛发长度)

权重:   w1 = 0.5
        w2 = -0.3
        w3 = 0.2

加权求和: z = w1*x1 + w2*x2 + w3*x3 + b
           = 0.5*0.8 + (-0.3)*0.3 + 0.2*0.6 + 0.1
           = 0.4 - 0.09 + 0.12 + 0.1
           = 0.53

激活函数: output = f(0.53)

其中：

• 权重 (w)：每个输入的重要程度。w1 = 0.5 说明”耳朵尖度”比较重要
• 偏置 (b)：一个常数偏移，这里是 0.1
• 激活函数 f：决定这个神经元是否”激活”

2.2 激活函数：为什么需要它

如果没有激活函数，神经元只是做线性运算（加权求和）。多个线性运算叠加还是线性运算——无论叠多少层，效果等于一层。

激活函数引入了非线性，让网络能学到复杂的模式。

常见的激活函数：

ReLU（最常用的入门激活函数）：

ReLU(x) = max(0, x)

例:
  ReLU(0.53)  = 0.53   (正数不变)
  ReLU(-0.2)  = 0       (负数变零)

Sigmoid（把值压缩到 0-1 之间）：

sigmoid(x) = 1 / (1 + exp(-x))

例:
  sigmoid(0.53) = 1 / (1 + exp(-0.53)) = 1 / (1 + 0.589) = 0.629
  sigmoid(-2.0) = 1 / (1 + exp(2.0))   = 1 / (1 + 7.389) = 0.119
  sigmoid(0)    = 0.5

Sigmoid 的输出可以理解为”概率”——0.629 表示 62.9% 的可能性是猫。

GELU（大语言模型中最常用的）：

GELU(x) ≈ x * sigmoid(1.702 * x)

例:
  GELU(0.53) ≈ 0.53 * sigmoid(0.902) ≈ 0.53 * 0.711 = 0.377
  GELU(-0.5) ≈ -0.5 * sigmoid(-0.851) ≈ -0.5 * 0.299 = -0.150

GELU 比 ReLU 更平滑：负数不是直接归零，而是乘以一个接近零的小数，允许小量负值信号流过。这在训练中更稳定。

2.3 单个神经元的局限

一个神经元只能学到一条”分界线”。猫狗分类可能需要同时考虑很多特征的复杂组合。

解决方案：把很多神经元连在一起，组成网络。

三、神经网络：把神经元组成层

3.1 全连接层

把多个神经元排成一层，每个神经元接收所有输入：

输入层 (3个值)          隐藏层 (4个神经元)          输出层 (2个神经元)
  x1 ─────┬──────→ h1 ─────┬──────→ y1 (猫的概率)
  x2 ─────┼──────→ h2 ─────┼──────→ y2 (狗的概率)
  x3 ─────┼──────→ h3 ─────┘
          └──────→ h4

每条线上都有一个权重。上面这个网络有：

• 输入→隐藏：3 × 4 = 12 个权重 + 4 个偏置
• 隐藏→输出：4 × 2 = 8 个权重 + 2 个偏置
• 总共 26 个参数

3.2 用矩阵运算表示

一个一个算太慢了。实际上，一整层的计算可以用矩阵乘法一步完成：

输入: X = [x1, x2, x3] = [0.8, 0.3, 0.6]     (1×3 向量)

权重矩阵: W = [[0.5,  0.2, -0.1, 0.3],        (3×4 矩阵)
               [-0.3,  0.4,  0.6, 0.1],
               [0.2, -0.1,  0.3, 0.5]]

偏置: b = [0.1, -0.2, 0.05, 0.0]               (1×4 向量)

计算:
  Z = X @ W + b     (矩阵乘法 + 偏置)
    = [0.8*0.5 + 0.3*(-0.3) + 0.6*0.2,          → z1
       0.8*0.2 + 0.3*0.4 + 0.6*(-0.1),          → z2
       0.8*(-0.1) + 0.3*0.6 + 0.6*0.3,          → z3
       0.8*0.3 + 0.3*0.1 + 0.6*0.5]             → z4
    = [0.43, 0.22, 0.28, 0.57]

  H = ReLU(Z) = [0.43, 0.22, 0.28, 0.57]       (全部为正，不变)

这就是神经网络的核心运算：矩阵乘法 + 激活函数。 后面你会看到，Transformer 里的每一步本质上都是这个。

3.3 为什么矩阵乘法这么重要

GPU（显卡）最擅长的就是并行做矩阵乘法。一个 4090 显卡每秒可以做约 83 万亿次浮点运算（83 TFLOPS）。这就是为什么深度学习需要 GPU——不是因为算法特别，而是核心运算就是矩阵乘法，而 GPU 天生擅长这个。

四、训练：网络如何学习

4.1 损失函数：衡量”答对没有”

网络输出了一个预测，我们需要一个数字来衡量”预测离正确答案有多远”。这个数字叫损失 (Loss)。

对于分类问题，最常用的是交叉熵损失：

真实答案: "猫" → one-hot 编码 [1, 0]  (100% 猫, 0% 狗)
模型预测:         [0.7, 0.3]         (70% 猫, 30% 狗)

交叉熵损失 = -sum(真实 * log(预测))
           = -(1 * log(0.7) + 0 * log(0.3))
           = -log(0.7)
           = 0.357

如果模型预测 [0.99, 0.01]:
  损失 = -log(0.99) = 0.01    ← 很好！

如果模型预测 [0.01, 0.99]:
  损失 = -log(0.01) = 4.61    ← 很差！

损失越小，预测越准。训练的目标就是让损失尽可能小。

4.2 梯度下降：往”下坡”方向走

想象你蒙着眼睛站在一座山上，要找到最低点。你的策略是：摸一下脚下的坡度，往下坡方向走一小步。

这就是梯度下降（Gradient Descent）：

参数更新公式:
  w_new = w_old - learning_rate * gradient

其中:
  gradient = ∂Loss/∂w    (损失对权重的偏导数——"坡度")
  learning_rate = 0.001  (步长，太大会跳过最低点，太小走得慢)

数值例子：

当前: w = 0.5,  Loss = 2.3
计算得: gradient = 0.8  (正数，说明 w 增大会让 Loss 增大)

更新: w_new = 0.5 - 0.001 * 0.8 = 0.4992

直觉: 因为 w 增大会让 Loss 增大（正梯度），所以应该减小 w

4.3 反向传播：高效计算梯度

一个网络可能有 1 亿个参数，每个都需要计算梯度。一个一个算不现实。

反向传播 (Backpropagation) 利用链式法则，从输出层往回，一层一层高效计算所有梯度。

链式法则:
  ∂Loss/∂w1 = ∂Loss/∂y * ∂y/∂h * ∂h/∂w1

直觉:
  "w1 的变化 → 影响了隐藏层 h → 影响了输出 y → 影响了损失"
  把这条链上每个环节的影响乘起来，就是 w1 对损失的总影响

你不需要手写反向传播——PyTorch 等框架会自动完成。但理解这个概念很重要：训练就是反复计算梯度、更新参数的过程。

4.4 一次完整的训练循环

# 伪代码
for epoch in range(100):           # 重复 100 轮
    for batch in training_data:     # 每次取一批数据
        predictions = model(batch.inputs)       # 前向传播
        loss = cross_entropy(predictions, batch.labels)  # 算损失
        gradients = backward(loss)               # 反向传播算梯度
        for param in model.parameters():
            param -= learning_rate * gradients[param]    # 更新参数

对于 GPT-3（1750 亿参数），一次训练跑了3000 亿个 token，在 1024 张 A100 GPU 上训练了几个月。

五、从神经网络到语言模型

5.1 语言模型在做什么

回到我们的主题。大语言模型（Large Language Model, LLM）做的事情其实只有一个：

给定前面的文字，预测下一个词（token）是什么

例子：

输入: "今天天气"
模型输出: 一个概率分布
  "真" → 25%
  "很" → 20%
  "不" → 15%
  "挺" → 10%
  ...
  (词汇表中每个词都有一个概率)

然后从中选一个（比如选了”真”），把它接到后面，继续预测：

输入: "今天天气真"
模型输出:
  "好" → 45%
  "不" → 20%
  "热" → 8%
  ...

一个一个地预测，直到生成出完整的回答。这就是所有 LLM 的核心机制。

5.2 为什么这么简单的机制能产生”智能”

你可能会想：只是预测下一个词，怎么能回答复杂问题、写代码、做数学？

关键在于：要准确预测下一个词，模型必须理解前面的内容。

输入: "法国的首都是"
→ 要预测出 "巴黎"，模型必须知道地理知识

输入: "def fibonacci(n):\n    if n <= 1:\n        return"
→ 要预测出 " n"，模型必须理解递归和函数逻辑

输入: "2 + 3 * 4 ="
→ 要预测出 "14"，模型必须理解运算优先级

当你在万亿级别的文本数据上训练”预测下一个词”，模型被迫学会了语言中蕴含的知识、逻辑和推理能力。这不是设计出来的智能——是从”预测下一个词”这个看似简单的任务中涌现出来的。

5.3 为什么叫”大”语言模型

“大”指的是参数量：

参数越多，能存储的知识和模式就越多。但参数量不是唯一因素——训练数据的质量和数量同样关键。

5.4 LLM 的核心架构：Transformer

2017 年，Google 发表了论文 “Attention Is All You Need”，提出了 Transformer 架构。从那以后，几乎所有主流 LLM 都基于 Transformer。

Transformer 的核心思想：让每个词都能直接关注到序列中的任意其他词。

传统的 RNN（循环神经网络）像读书一样一个字一个字往后读，想回忆前面的内容就很困难。Transformer 像是把所有字摊在桌面上，可以同时看到所有字，想关注哪个就关注哪个。

后面的章节会详细拆解 Transformer 的每个组件：

• 第 2 章：Token 化——文本怎么变成模型能处理的数字
• 第 3 章：Embedding——数字怎么变成有意义的向量
• 第 4 章：Self-Attention——Transformer 的核心计算
• 第 5 章：Multi-Head Attention 和 FFN
• 第 6 章：完整的 Transformer 架构
• 第 7 章：MoE——怎么用更少的计算做更大的模型

六、关键术语速查

本章总结

1. 神经网络的核心运算 = 矩阵乘法 + 激活函数
2. 训练 = 前向传播 → 算损失 → 反向传播 → 更新参数，重复几百万次
3. 语言模型 = 预测下一个 token 的神经网络
4. “智能”是在海量数据上训练”预测下一个词”时涌现出来的
5. Transformer 是当前所有主流 LLM 的底层架构

下一篇：02. Token 化：文本如何变成数字 — 模型看到的不是文字，而是 token