AI Agent 工程实践教程 · 第 02 章

从 AIGC 现象切入，补齐神经网络、Transformer 与大模型调用的基础概念。

返回系列目录

第二天：从 AIGC 到大模型：神经网络与必要原理

这一天会从 AIGC 现象出发，逐步走到大模型的核心原理。

先看整体路线：

这一节课不要求记住复杂公式。

更重要的是先建立一条清晰的理解路径：

AIGC 为什么能生成内容
  ↓
大模型为什么有这种能力
  ↓
神经网络和参数是什么
  ↓
参数是怎么训练出来的
  ↓
文字如何变成 Token 和 Embedding
  ↓
Transformer 如何理解上下文
  ↓
这些能力如何接入真实项目

1. 从 AIGC 开始：AI 生成内容到底改变了什么

程序可以通过 API 把问题发送给大模型，再接收模型返回的内容。

在继续开发之前，需要先理解一个基础问题：

为什么现在 AI 可以生成文章、代码、SQL、图片和分析结论？

这类能力通常叫做 AIGC。

1.1 AIGC 不是一个工具，而是一类能力

AIGC 是 AI Generated Content 的缩写，意思是 AI 生成内容。

这里的“内容”不要只理解成文章。

在软件项目里，AI 能生成的东西非常多：

所以 AIGC 的重点不是“AI 会写作文”。

更准确地说：

AIGC 是让 AI 根据输入要求，生成一段可被人或系统继续使用的内容。

这句话很重要。

因为在真实项目里，AI 生成的内容不一定是给人看的，也可能是给程序继续执行的。

例如：

• 生成一段 SQL，让数据库执行
• 生成一段 JSON，让后端解析
• 生成一个工具调用参数，让 Agent 去执行
• 生成一段回答，让前端展示给用户

1.2 用 Text-to-SQL 理解 AIGC

如果只把 AIGC 理解成“AI 写文章”，会低估它在软件系统里的价值。

但在开发项目里，AIGC 更有价值的地方是：

把人的自然语言，转换成系统能执行的内容。

比如 Text-to-SQL。

用户说一句话：

帮我查一下最近 7 天每个课程的报名人数。

系统不能直接拿这句话去查数据库。

数据库能执行的是 SQL。

所以 AI 要生成的内容不是文章，而是一段 SQL：

SELECT
    course_id,
    COUNT(*) AS signup_count
FROM student_order
WHERE created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
GROUP BY course_id;

这就是一个很典型的 AIGC 场景：

输入是自然语言，输出是可执行的 SQL。

再往前走一步，系统还可以继续做：

1. 检查 SQL 是否安全
2. 执行 SQL 查询数据
3. 把查询结果交给大模型
4. 生成一段业务解释

例如最后给用户返回：

最近 7 天报名人数最多的是 Python AI 入门课，共 126 人报名。
其次是 Java 项目实战课，共 83 人报名。
整体报名量比上周同期增长约 18%。

这个例子里，AIGC 出现了两次：

所以，AIGC 不只是“生成文字”。

它可以参与完整业务流程：

自然语言问题
  ↓
生成 SQL
  ↓
查询数据库
  ↓
生成分析结论
  ↓
返回给用户

这也是后面学习 Prompt、RAG、Tools、Agent 的基础。

1.3 生成内容之后，系统还要做什么

AIGC 能生成内容，但生成内容不等于功能已经完成。

在 Text-to-SQL 里，模型生成 SQL 之后，系统还需要继续处理：

这里有一个很重要的工程判断：

生成出来的内容不一定永远正确。

比如 Text-to-SQL 里，模型可能生成错误字段、错误表名，甚至生成危险 SQL。

所以 AI 应用开发不能只停留在“调用模型”。

还需要继续解决：

• 模型为什么能生成
• 模型为什么会生成错
• 怎么限制模型输出格式
• 怎么校验模型生成的内容
• 怎么让模型结合业务资料和数据库结构

这些就是第二天要讲“大模型必要原理”的原因。

1.4 从 Text-to-SQL 反推大模型需要哪些能力

Text-to-SQL 看起来只是“让 AI 写一段 SQL”。

但把这个过程拆开，会发现模型至少要完成几件事：

这说明 AIGC 背后不只是“会写字”。

模型需要先把输入内容变成可以计算的表示，再根据训练得到的规律，生成符合上下文的内容。

所以要继续理解大模型，需要顺着 Text-to-SQL 的过程问几个问题。

1.5 从一句话生成 SQL，需要哪些底层能力

继续看刚才的问题：

帮我查一下最近 7 天每个课程的报名人数。

表面上看，AI 只是生成了一段 SQL；实际上，中间至少发生了三件事。

第一，模型要把文字变成可以计算的东西。

一句中文问题不能直接被模型计算，所以要先切成 Token，再变成向量表示，也就是 Embedding。

第二，模型要根据学过的规律判断用户想要什么。

例如“最近 7 天”是时间范围，“每个课程”表示分组，“报名人数”通常对应统计数量。模型能做这种判断，是因为它在训练中学过大量文本、代码、SQL 和问答数据。

第三，模型要结合上下文生成结果。

Text-to-SQL 不能只看用户问题，还要看表结构、字段说明、输出要求和安全限制。模型需要在这些信息里判断当前该参考什么，再一步一步生成 SQL。

这三个动作会对应后面几个必要概念：

所以，从 AIGC 进入大模型原理，不是为了研究公式，而是为了理解一件事：

AI 生成内容的过程，本质上是把输入变成数字表示，再根据训练得到的参数和当前上下文，一步一步生成输出。

这条主线可以先记成：

文字问题
  ↓
切成 Token
  ↓
变成向量
  ↓
神经网络处理
  ↓
结合上下文
  ↓
生成 SQL / 回答 / 工具参数
  ↓
系统校验后再使用

2. 大模型到底是什么

可以先用一句话理解：

大模型是一个经过大量数据训练的神经网络，能够根据输入内容和上下文生成后续内容。

这句话里有三个重点：

2.1 大模型不是数据库

数据库的核心能力是“存储和查询”。

例如数据库里可以存一条订单记录：

订单号：10001
学生：张三
课程：Python AI 入门
状态：已支付

查询数据库时，系统是在找已经存在的数据；大模型则是根据输入和上下文生成内容。

大模型不是把每一句答案都原封不动存起来，再按问题取出来。它更像是学到了大量语言、代码和知识表达的规律，然后根据当前输入组织一个结果。

也正因为它是在“生成”，所以它可能生成看起来合理但实际不正确的内容，这就是后面会讲到的 幻觉。

2.2 大模型也不是搜索引擎

搜索引擎的核心能力是“找资料”。

用户输入关键词后，搜索引擎会从网页里找相关页面，再返回链接和摘要。

大模型的核心能力是“生成内容”。

用户输入问题后，大模型会根据上下文直接组织一段回答。

三者区别可以先这样理解：

在真实项目里，这几种能力经常会组合使用。

例如知识库问答系统通常不是只靠大模型回答，而是：

先检索资料
  ↓
把资料放进上下文
  ↓
再让大模型基于资料生成回答

这就是后面要学的 RAG。

2.3 大模型为什么叫“大”

它主要体现在几个方面：

参数可以先理解成模型内部的“调节旋钮”。训练过程会不断调整这些参数，让模型在看到输入时，更容易生成合适的输出。

参数越多，模型可以表达的规律通常越复杂；但模型是否好用，还和数据质量、训练方法、架构设计有关。

模型参数规模可以差很多。

可以先有一个大概印象：

公开资料里能看到一些例子：

这里的 B 是 Billion，表示“十亿”。

例如：

8B = 80 亿参数
70B = 700 亿参数
405B = 4050 亿参数

不过，现在很多商业大模型不一定公开具体参数量。

比如很多闭源模型只公布能力、上下文长度、价格和使用方式，不一定公布内部到底有多少参数。

所以看一个模型时，不能只问“参数有多少”，还要看：

• 训练数据质量
• 模型结构
• 推理速度
• 上下文长度
• 是否支持多模态
• 是否支持工具调用
• 在具体任务上的效果

可以先记住：

参数量能反映模型规模，但不能单独决定模型能力。

2.4 LLM 是什么

LLM 是 Large Language Model 的缩写，意思是 大语言模型。

它的核心能力是处理和生成文本。

这里的“语言”不只包括中文、英文，也包括很多文本形式的内容：

• 用户问题
• 文章
• 代码
• SQL
• JSON
• 日志
• 文档
• 表结构说明

用户问题是文本，表结构是文本，SQL 也是文本。大语言模型擅长在这些文本之间建立关系并生成新的文本。

不过，现在很多大模型已经不只处理文本，也可以接收图片、音频、视频等信息。这类模型通常会被称为 多模态大模型。

可以先这样区分：

本课程前期主要围绕文本类能力展开，因为 AI 问答、Text-to-SQL、Prompt、RAG 和 Agent 的基础都离不开文本理解与生成。

2.5 大模型是怎么生成回答的

大模型生成内容时，不是一次性把整段答案吐出来，而是一步一步往后写。

例如输入：

什么是 AIGC？

模型会根据前面的内容不断生成下一个更可能出现的 Token，最后组合成完整回答：

AIGC 是人工智能生成内容的意思，常见形式包括文本、图片、音频、视频和代码生成。

可以先把它理解成“边看上下文，边往后写”。

大模型每生成一点新内容，新的内容又会变成后续生成的上下文。

所以 Prompt 写得清不清楚、上下文放得对不对，会直接影响模型生成什么。

下一节先继续往下看：

神经网络是什么？

因为大模型本质上是神经网络，先认识神经网络的结构，后面再理解 Token、Embedding 和训练过程会更顺。

3. 神经网络先认识：神经元、层和参数

前面说过，大模型不是人工写死规则，而是由大量参数组成的神经网络。

这一章先不讲复杂公式，只先看懂三个问题：

• 神经元是什么
• 神经网络的层是什么
• 参数和权重为什么重要

3.1 神经网络可以先怎么理解

神经网络可以先理解成一个 由很多小计算单元组成的判断系统。

它接收输入，经过多层计算，最后输出结果。

例如判断今天适不适合打篮球，可以参考几个因素：

最后输出一个结果：

适合打篮球 / 不适合打篮球

这个例子不是说神经网络真的只会判断打篮球，而是用一个生活场景理解：

神经网络会把多个输入因素综合起来，经过计算后给出一个结果。

3.2 神经元是什么

在上面的结构图里，每一个圆点都可以先理解成一个神经元。

神经元可以先理解成一个小计算单元。

它会接收一些输入，然后给不同输入分配不同的重要程度，再算出一个结果。

比如判断是否适合打篮球时：

天气好不好
有没有时间
有没有朋友
球场远不远

这些因素的重要程度不一定一样。

对有的人来说，“有没有朋友一起”很重要；对另一些人来说，“有没有时间”更重要。

在神经网络里，这种“重要程度”通常叫做 权重。

图中圆点之间的连线，可以先理解成信息传递的连接；每条连接背后都有一个权重，用来表示这一路输入有多重要。

可以先这样理解：

从底层计算看，一个神经元通常会做三步：

输入 × 权重 → 求和 → 激活函数

可以写成：

z = x1w1 + x2w2 + x3w3 + b
输出 = 激活函数(z)

这里可以先这样理解：

为什么还要加一个 b？

因为只做 x1w1 + x2w2 + x3w3 时，神经元只能根据输入加权计算。

但真实判断里，模型往往还需要一个基础倾向。

比如即使天气、时间、朋友这些输入都差不多，不同人也可能有不同默认倾向：

有的人本来就很想运动
有的人本来就不太想出门

b 就可以先理解成这种“基础偏移”。

它能让神经元的输出整体往上或往下调整，而不是完全被输入和权重限制住。

比如：

x1：天气是否适合
x2：有没有时间
x3：有没有朋友

如果 w2 很大，说明“有没有时间”对这个神经元影响很大。

如果 w3 很大，说明“有没有朋友”对这个神经元影响很大。

所以神经元不是简单把输入加起来，而是会根据权重判断哪些输入更重要。

3.3 神经网络的层

一个神经元能做的判断很有限。

真实任务通常需要分步骤处理，所以神经网络会把很多神经元组织成多层。

可以把它理解成一个逐步加工的过程：

先接收信息
  ↓
再组合信息
  ↓
最后输出结果

以打篮球为例。

输入层接收的是原始因素：

天气、时间、朋友、距离

隐藏层不会直接输出“适合”或“不适合”，而是先做中间判断。

例如：

天气 + 距离  → 外部条件怎么样
时间 + 朋友  → 个人意愿怎么样
外部条件 + 个人意愿 → 综合判断

输出层再根据这些中间结果，给出最后判断：

适合打篮球 / 不适合打篮球

所以“层”的作用不是把内容简单传下去，而是让信息被一步一步加工。

放到大模型里也是类似的思想。

只不过大模型处理的不是“天气、时间”这种简单因素，而是大量文字、代码、上下文和语义关系。层数越多，模型越有机会逐步提取更复杂的关系。

3.4 参数和权重是什么

权重是参数的一种。

参数可以先理解成模型内部的“调节旋钮”。

在刚才的公式里：

z = x1w1 + x2w2 + x3w3 + b

w1、w2、w3 是权重，b 是偏置。

它们都属于模型参数。

权重主要控制“每个输入有多重要”。

偏置主要控制“整体判断的基础位置”。

神经网络的判断结果，很大程度上取决于这些参数怎么设置。

例如：

如果“有没有时间”的权重很高，
模型就会更重视时间这个因素。

如果“球场远不远”的权重很高，
模型就会更容易因为距离远而判断不适合打球。

大模型之所以叫“大”，一个重要原因就是内部有大量参数。

这些参数不是人工一个个手动设置的，而是在训练过程中不断调整出来的。

3.5 从这个例子抽象出来

打篮球例子里，神经网络做的是：

天气、时间、朋友、距离
        ↓
多层处理
        ↓
适合 / 不适合

把具体例子拿掉，就可以抽象成：

输入信息
   ↓
神经网络多层处理
   ↓
输出结果

大模型也是类似的思想。

只不过大模型处理的输入更复杂，可能是一段问题、一段对话、一份资料，或者一个任务要求。

它输出的也不只是“适合 / 不适合”，而可能是一段解释、一段回答，或者下一步要执行的内容。

所以可以先记住一句话：

神经网络的核心思想，是用很多神经元和参数，把输入一步一步处理成输出。

4. 参数是怎么学出来的

前面说过，参数可以理解成模型内部的“调节旋钮”。

那这些旋钮一开始应该怎么调？

答案不是人工一个个设置，而是通过 训练 调出来。

4.1 训练不是直接写规则

如果用传统程序判断要不要打篮球，我们可能会写规则：

如果天气好，并且有时间，并且有朋友，就适合打篮球。

但神经网络不是这样工作的。

它不会要求人把每一条规则都写死，而是从大量例子里慢慢调整参数。

比如训练数据可以长这样：

模型一开始并不知道哪些因素更重要。

训练的目的，就是让模型逐渐学会：

什么样的输入，更可能对应什么样的输出。

4.2 训练的基本过程

训练可以先理解成一个反复循环的过程。

每一轮训练大致做五件事：

这个过程会重复非常多次。

一次调整通常很小，但重复很多轮以后，模型的参数就会逐渐变得有用。

4.3 前向传播：先让模型算一遍

前向传播可以先理解成：

输入从前往后经过神经网络，最后得到一个预测结果。

比如输入是：

天气好，有时间，有朋友，但是球场很远

模型会根据当前参数算出一个结果：

适合打篮球

这一步只是“先做一次判断”。

判断对不对，还要看下一步。

4.4 损失函数：算一算错了多少

损失函数可以先理解成一个“打分器”。

它专门用来衡量：

模型预测结果和标准答案之间差了多少。

比如同一条训练样本：

天气好，有时间，有朋友，但是球场很远

标准答案是：

不适合打篮球

但模型预测成：

适合打篮球

这就说明预测和标准答案不一致，损失会比较大。

训练时，模型要做的事情就是不断让损失变小。

损失越小，说明模型的判断越接近训练数据里的答案。

常见的损失函数可以先了解几种：

不同任务会选择不同的损失函数。

比如预测房价、气温、销量这类连续数值时，经常会用 均方误差 MSE。

假设真实房价是：

100 万

模型预测是：

90 万

差距就是：

10 万

MSE 会把这个差距平方：

10 × 10 = 100

如果模型预测成：

60 万

差距就变成：

40 万

MSE 的惩罚会变成：

40 × 40 = 1600

所以 MSE 的特点是：

预测值离真实值越远，损失会变得更大，而且远离得越多，惩罚越明显。

但大语言模型生成文字时，不是在预测一个连续数值，而是在很多 Token 里选择下一个更可能出现的 Token。

所以在大语言模型里，更常见的是 交叉熵损失。

因为大模型生成文字时，本质上是在很多 Token 里预测“下一个更可能是谁”。

如果正确 Token 的概率很低，损失就会变大；如果正确 Token 的概率很高，损失就会变小。

例如输入是：

人工智能生成内容通常被称为

正确答案是：

AIGC

模型可能会给不同候选 Token 一个概率：

因为正确答案 AIGC 的概率比较高，所以损失比较小。

如果模型预测成这样：

正确答案 AIGC 的概率很低，说明模型没有把正确答案排到前面，损失就会变大。

所以交叉熵损失可以先这样理解：

正确答案的概率越高，损失越小；正确答案的概率越低，损失越大。

4.5 反向传播：从错误往回找原因

反向传播解决的问题是：

这次错了，主要和哪些参数有关？

可以继续用打篮球例子理解。

如果模型总是把“球场很远”也判断成适合打篮球，说明它可能没有足够重视距离。

反向传播会把损失从输出层往前传，逐层分析哪些参数对这次错误影响更大。

它不是直接修改参数，而是先告诉模型：

哪些地方可能需要改
往哪个方向改可能更好

4.6 梯度下降：按正确方向微调参数

梯度下降解决的问题是：

已经知道哪里需要改，具体怎么改？

先用一个具体问题把它串起来。

假设我们要根据房屋面积预测房价。

最简单的模型可以是一条直线：

预测价格 = k × 面积 + b

这里的 k 和 b 就是模型要学习的参数。

其中：

k：斜率，控制面积增加时价格涨得有多快
b：截距，控制整条预测线的基础高度

如果没有 b，这条线就会被限制得很死，通常必须从原点附近开始。

有了 b，模型就可以把整条线整体往上或往下移动，更容易贴近真实数据。

对每一套房子来说，都会有：

真实价格：y
预测价格：ŷ

预测价格由模型算出来：

ŷ = kx + b

如果预测价格和真实价格不一样，就会产生误差：

误差 = y - ŷ

但是误差有正有负。

有的房子预测高了，误差可能是正数；有的房子预测低了，误差可能是负数。

如果直接相加，正负可能会互相抵消。

所以 MSE 会把每个误差平方，再求平均：

MSE = 1/n × [(y1 - ŷ1)² + (y2 - ŷ2)² + ... + (yn - ŷn)²]

这样做有两个好处：

1. 平方以后，正负误差不会互相抵消
2. 误差越大的点，惩罚会更明显

现在问题变成：

到底选哪一组 k 和 b，能让 MSE 最小？

不同的 k 和 b 会得到不同的直线，也会得到不同的 MSE。

可以想象成这样：

哪一条线的 MSE 更小，说明它整体上离真实数据点更近。

到这里，梯度下降要解决的问题就清楚了：

怎么不断调整 k 和 b，让 MSE 越来越小？

如果把 k、b 和 MSE 画成一个图，就会像一个高低起伏的地形：

横轴：k
纵轴：b
高度：MSE

梯度下降要找的，就是这个地形里比较低的位置。

4.6.1 导数：一个参数时怎么看方向

先从只有一个参数的情况理解。

如果模型只有一个参数 x，损失可以写成一个函数：

Loss = f(x)

这时可以看普通导数：

f'(x)

导数可以理解成当前这个点的斜率。

它会告诉我们：

参数往右一点，损失会变大还是变小？
参数往左一点，损失会变大还是变小？

如果导数是正的，说明往右走损失会上升，那就应该往左调。

如果导数是负的，说明往右走损失会下降，那就可以往右调。

所以导数的作用是：

告诉我们当前参数应该往哪个方向移动，损失才可能变小。

4.6.2 偏导数：多个参数时分别看

线性回归里有两个参数：

预测价格 = k × 面积 + b

这时不能只看一个方向。

我们要分别看：

k 变化时，MSE 怎么变
b 变化时，MSE 怎么变

这就叫 偏导数：

∂Loss/∂k
∂Loss/∂b

可以先这样理解：

∂Loss/∂k：只看 k 变化时，损失怎么变
∂Loss/∂b：只看 b 变化时，损失怎么变

如果参数更多，也一样。

每个参数都有一个对应的偏导数，用来判断这个参数应该往哪个方向调。

4.6.3 梯度下降的更新公式

梯度下降的核心公式是：

新参数 = 旧参数 - 学习率 × 梯度

这里有三个关键词：

为什么是“减去”梯度？

因为梯度指向的是损失上升最快的方向。

我们要让损失下降，所以要往相反方向走。

对于线性回归来说，就是同时调整 k 和 b：

新 k = 旧 k - 学习率 × ∂Loss/∂k
新 b = 旧 b - 学习率 × ∂Loss/∂b

这里的“k 方向的梯度”和“b 方向的梯度”，可以先理解成：

∂Loss/∂k 告诉我们：k 往哪个方向调，MSE 会下降
∂Loss/∂b 告诉我们：b 往哪个方向调，MSE 会下降

每调整一次，直线的位置和倾斜程度就会变化一点。

如果调整方向是对的，MSE 就会下降：

原来的 MSE 比较大
调整 k、b
新的 MSE 变小

这就是梯度下降在做的事情：

不是一次找到完美直线，而是不断调整参数，让整体误差一步一步变小。

4.6.4 局部最优：不一定走到全局最低

实际训练里，损失地形可能并不是一个光滑的碗。

有时它会有很多高低起伏，模型可能走到某个小坑里就不容易出来。

这个小坑附近已经比较低，但不一定是全局最低，这种情况可以先理解成 局部最优。

所以训练模型时，梯度下降不一定保证找到世界上最完美的参数，但它会不断尝试让损失下降，找到一组足够好的参数。

比如模型总是把“球场很远”判断成适合打篮球。

当前参数可能是：

损失函数会告诉模型：这次判断错了。

反向传播会找出：和“距离远”相关的参数需要调整。

梯度下降会真正执行这次调整：

这样下一次模型再看到“球场很远”时，就更不容易判断成“适合”。

每次调整都不会特别大，只是按照学习率走一小步。

下一轮训练再来一遍：

前向传播 → 计算损失 → 反向传播 → 梯度下降

重复很多轮以后，模型就会逐渐学会更合理的参数。

4.7 学习率：每次参数改多大

学习率可以理解成：

每次调整参数时，步子迈多大。

如果学习率太大，参数变化太猛，可能一下子越过更好的位置。

如果学习率太小，每次只挪一点点，训练会非常慢。

可以这样理解：

所以训练模型时，学习率是一个很重要的设置。

4.8 过拟合：不能只会背训练题

训练并不是让模型把训练数据死记硬背。

如果一个模型只是在训练数据上表现很好，但换一批新数据就表现很差，这种情况通常叫 过拟合。

可以用考试来理解：

只背熟了练习册原题
考试换一种问法就不会了

这就不是好的学习。

好的模型应该学到更通用的规律，而不是只记住训练样本本身。

所以训练时通常还会用没见过的数据来检查模型，看看它是不是真的学会了规律。

4.9 放到大模型里也是一样

大模型的训练任务更复杂。

它看到的不是几行“天气、时间、朋友、距离”，而是大量文本、代码、问答、网页和资料。

训练时，模型会不断练习一件事：

根据前面的内容，预测后面更可能出现什么

比如看到：

人工智能生成内容通常被称为

模型要学会后面更可能接：

AIGC

如果预测错了，就通过损失函数计算差距，再通过反向传播和梯度下降调整参数。

所以可以先这样记：

训练就是让模型反复预测、计算损失、往回找原因、微调参数。参数就是在这个过程中学出来的。

训练完成后，参数基本固定下来。

我们平时使用大模型提问时，通常不是在训练模型，而是在使用已经训练好的参数进行推理。

5. 模型是怎么学习的：监督学习、无监督学习、强化学习

前面已经知道，模型训练时会不断调整参数。

但还要继续问一个问题：

模型到底是从什么样的数据里学会能力的？

不同训练任务里，数据的形式不一样。

有的数据会直接给出标准答案，有的数据没有明确答案，有的任务则靠反馈告诉模型做得好不好。

这些不同的学习方式，通常可以先分成三类：

监督学习
无监督学习
强化学习

它们不是三种完全割裂的技术，而是理解模型训练时非常重要的三个角度。

5.1 监督学习：有标准答案的学习

监督学习可以先理解成：

给模型输入，也给模型标准答案，让模型对照答案学习。

比如：

监督学习里，模型会先预测一个结果。

然后把预测结果和标准答案比较，计算损失，再调整参数。

例如房价预测：

输入：面积 100 平方米
标准答案：房价 200 万
模型预测：房价 180 万

模型就能知道自己预测低了，后面通过损失函数和梯度下降调整参数。

监督学习适合用来教模型：

看到什么输入，应该给出什么输出。

5.2 无监督学习：没有标准答案，也能找规律

无监督学习可以先理解成：

只给模型大量数据，不直接告诉它标准答案，让模型自己发现数据里的规律。

比如给模型大量文章，但不告诉它每篇文章的标准分类。

模型可能会慢慢发现：

有些文章都在讲体育
有些文章都在讲金融
有些文章都在讲编程

再比如词语之间的关系。

模型看过大量文本后，会发现：

篮球、足球、网球 经常出现在相近语境里
银行、贷款、利率 经常出现在相近语境里

它不一定需要人给每个词贴标签，也能从数据分布里学到规律。

无监督学习适合用来让模型：

从大量数据中自己发现结构、相似性和规律。

5.3 强化学习：通过反馈学习

强化学习可以先理解成：

模型先做动作，再根据反馈调整以后怎么做。

它不像监督学习那样每一步都有标准答案。

它更像是在一个环境里不断尝试：

做得好 → 奖励更高
做得差 → 奖励更低

比如训练一个游戏 AI：

赢了比赛 → 奖励高
输了比赛 → 奖励低

比如训练一个回答问题的模型：

回答清楚、有帮助、安全 → 反馈更好
回答混乱、跑题、不安全 → 反馈更差

强化学习的重点不是死记答案，而是让模型学会：

什么行为更容易得到好的反馈。

5.4 三种学习方式的区别

可以用一张表先记住：

举个生活化例子：

监督学习：老师给题目和标准答案
无监督学习：自己看大量资料，总结规律
强化学习：做完事情后，根据反馈慢慢改进

5.5 大模型训练里怎么用

大模型训练通常不是只用一种方式。

更常见的是多个阶段组合起来。

可以先这样理解：

这里有一个容易混淆的点：

大模型预训练时，经常会让模型预测下一个 Token。

表面上看，好像有“标准答案”。

比如：

人工智能生成内容通常被称为 __

后面的真实文本里出现的是：

AIGC

模型就可以拿 AIGC 当答案来计算损失。

但这个答案不是人工一个个标注出来的，而是从文本本身自动构造出来的。

这种方式通常叫 自监督学习。

可以先把它理解成：

从没有人工标注的大量文本里，自动构造训练任务，让模型学习语言规律。

所以预训练虽然不是人工给答案，但仍然会走训练流程：

输入前面的文本
  ↓
预测下一个 Token
  ↓
和真实下一个 Token 比较
  ↓
计算损失
  ↓
反向传播 + 梯度下降
  ↓
更新参数

也就是说，预训练不是没有答案，而是答案来自文本本身。

5.6 小结

这一章可以先记住三句话：

监督学习：有输入，也有标准答案。

无监督学习：没有标准答案，模型自己找规律。

强化学习：模型根据奖励或反馈改进行为。

放到大模型里，可以再记住一句：

大模型训练通常会组合多种学习方式：先从海量数据里学规律，再用高质量数据教它怎么回答，最后通过反馈让回答更符合人类偏好。

6. Token 和 Embedding：大模型怎样把文字变成数字

前面一直在说，大模型会处理文本、预测下一个 Token。

但模型本身不能直接计算一段中文或英文。

计算机真正擅长处理的是数字。

所以文字进入大模型之前，通常会经历几步转换：

文字
  ↓
Token
  ↓
Token ID
  ↓
Embedding 向量
  ↓
送进 Transformer 继续处理

这一章先解决一个问题：

大模型看到的文字，最后是怎样变成可以计算的数字的？

6.1 Token：文字先被切成小块

Token 可以先理解成：

模型处理文字时使用的基本小块。

一段文字不会直接整段丢给模型，而是先被切开。

例如：

我喜欢人工智能

可能会被切成类似这样的 Token：

我 / 喜欢 / 人工智能

但要注意，Token 不一定等于一个汉字，也不一定等于一个完整单词。

有时一个中文词会被切成一个 Token，有时会被切成多个 Token。

英文也是一样。

比如英文单词很长时，可能会被切成几个片段。

所以可以先记住：

Token 是模型使用的文字小块，不要简单理解成“一个字”或“一个词”。

6.2 为什么需要 Token

可以先用一个生活里的例子理解。

如果要让机器处理一整篇文章，直接把整篇文章当成一个整体，会很难。

就像做菜时，不会把一整棵菜直接下锅，而是会先切成一小段一小段。

文字也是类似的。

模型会先把一段文字切成很多小块：

我喜欢人工智能
  ↓
我 / 喜欢 / 人工智能

这样做的好处是，模型可以按顺序处理每一个小块：

先看第 1 个 Token
再看第 2 个 Token
再看第 3 个 Token

所以 Token 的作用可以先理解成：

把连续的文字切成模型能一步一步处理的小块。

这也能解释大模型为什么经常说是：

一个 Token 一个 Token 地生成内容。

比如模型要生成：

人工智能可以帮助我们学习

它不是一下子把整句话全部吐出来，而是更像这样：

人工智能
人工智能 可以
人工智能 可以 帮助
人工智能 可以 帮助 我们
人工智能 可以 帮助 我们 学习

每生成一个新的 Token，它都会把前面已经生成的内容一起作为上下文，再继续预测下一个 Token。

6.3 Token ID：Token 会变成编号

Token 只是文字小块。

但模型内部还不能直接计算文字。

所以每个 Token 会在词表里对应一个编号，这个编号通常叫 Token ID。

可以把词表理解成一本字典：

这里的编号只是示意，不需要记具体数字。

重要的是理解：

Token ID 只是把文字小块变成编号，方便模型继续处理。

不过，只有编号还不够。

因为编号本身没有语义。

比如：

篮球 = 102
足球 = 381
利率 = 9284

这些数字大小并不能说明“篮球”和“足球”更相近。

所以还需要下一步：Embedding。

6.4 Embedding：把编号变成有语义的向量

Embedding 可以先理解成：

把 Token 变成一组能表达语义关系的数字。

例如一个 Token 进入模型后，可能会变成类似这样的向量：

篮球 → [0.21, -0.08, 0.64, 0.12, ...]
足球 → [0.19, -0.05, 0.61, 0.10, ...]
利率 → [-0.44, 0.72, 0.03, -0.18, ...]

这些数字不是随便写出来的。

它们是在训练过程中学出来的。

如果两个 Token 经常出现在相似语境里，它们的向量就可能更接近。

比如：

篮球、足球、网球

它们都和运动有关，所以向量可能比较接近。

而：

银行、贷款、利率

更偏金融语境，所以会在另一个位置附近。

所以 Embedding 不是简单编号。

它更像是给每个 Token 一个“语义位置”。

6.5 Embedding 为什么重要

Embedding 重要，是因为它让模型可以用数学方式处理语言。

原来的文字是：

我喜欢人工智能

进入模型后，会变成很多向量。

模型后面的神经网络和 Transformer，就可以对这些向量做计算。

比如判断：

哪些 Token 语义接近
哪些 Token 关系更强
当前 Token 应该重点看前面的哪些 Token
下一个 Token 更可能是什么

如果没有 Embedding，模型只能看到一串编号。

有了 Embedding，模型才能在数字里保留一部分语义信息。

6.6 上下文窗口也和 Token 有关

平时会听到一个说法：

这个模型支持多少多少 Token 的上下文窗口。

这里的上下文窗口，指的是模型一次请求里最多能看到多少 Token。

它不是按“多少个字”精确计算，也不是按“多少句话”计算。

而是按 Token 数量计算。

所以一段很长的资料放进模型时，本质上是在占用上下文窗口里的 Token 位置。

可以先这样理解：

上下文窗口越大，模型一次能看到的 Token 越多。

6.7 小结

这一章先记住一条主线：

文字 → Token → Token ID → Embedding 向量 → Transformer

其中：

可以先记住一句话：

大模型不是直接读文字，而是先把文字切成 Token，再变成向量，最后用神经网络继续计算。

7. Transformer：大模型怎样理解上下文

上一章讲到，文字会先变成 Token，再变成 Embedding 向量。

但到这里还不够。

因为每个 Token 如果只看自己，还是很难真正理解一句话。

比如：

小明把书放进书包，因为它太重了。

这里的“它”指的是谁？

更可能是“书”，不是“书包”。

人能判断出来，是因为我们会看上下文。

大模型也需要做类似的事情：

让每个 Token 都去看上下文里的其他 Token，判断谁和自己关系更大。

这就是理解 Transformer 的入口。

7.1 为什么需要 Transformer

Token 变成向量后，模型已经可以计算它们了。

但问题是：

每个 Token 不是孤立存在的。

同一个词放在不同句子里，意思可能不一样。

比如：

苹果很好吃。
苹果发布了新手机。

第一句里的“苹果”更像水果。

第二句里的“苹果”更像公司。

如果模型只看“苹果”这一个 Token，就很难判断它到底是什么意思。

所以模型必须看上下文：

它前后出现了哪些词？
这些词和它有什么关系？
当前应该重点关注谁？

Transformer 就是为了解决这类问题而变得非常重要。

7.2 注意力机制：不是每个词都一样重要

注意力机制可以先理解成：

当前 Token 会给上下文里的其他 Token 分配不同的重要程度。

还是看这个句子：

小明把书放进书包，因为它太重了。

当模型处理“它”这个 Token 时，它会去看前面的内容。

但不是所有 Token 都同样重要。

比如：

小明：关系较弱
书：关系很强
书包：也有关系，但可能弱一些
太重了：帮助判断“它”更像书

可以把注意力想象成一支手电筒。

句子里有很多 Token，但当前 Token 会把光更多打在和自己关系最强的 Token 上。

所以注意力机制不是“把所有词平均看一遍”，而是：

谁更相关，就多看谁。

7.3 Self-Attention：一句话里的 Token 互相看

Self-Attention 可以翻译成“自注意力”。

它的意思是：

同一句话里的每个 Token，都会去看这句话里的其他 Token。

不是只有“它”会看“书”。

每个 Token 都会重新判断：

我和哪些 Token 关系更大？
哪些信息应该被我吸收进来？

例如一句话：

苹果发布了新手机，它的价格很高。

模型处理“它”时，会更关注“新手机”。

模型处理“价格”时，也会更关注“新手机”。

模型处理“苹果”时，会结合“发布”“新手机”，判断这里的苹果不是水果。

所以 Self-Attention 的关键不是记住公式，而是理解一句话：

每个 Token 都不是单独理解的，而是在和其他 Token 的关系里被理解。

7.4 Transformer 是什么

Transformer 可以先简单理解成：

一种特别擅长处理 Token 之间关系的神经网络结构。

它里面最重要的部分之一，就是 Self-Attention。

一个 Transformer 层大致可以理解成两步：

第一步：注意力机制
判断 Token 之间谁和谁关系更强。

第二步：神经网络处理
把这些关系继续加工，得到新的表示。

然后很多层叠在一起。

每一层都会让 Token 的表示变得更“懂上下文”一点。

可以把它想象成反复修改一篇阅读理解答案：

第一遍：先看大概意思
第二遍：发现词和词之间的关系
第三遍：理解更深的语义

大模型就是把这种处理重复很多层。

层数越多、参数越多、训练数据越多，模型就越有机会学到更复杂的语言关系。

7.5 为什么 Transformer 适合大模型

Transformer 之所以重要，是因为它很适合处理文本。

原因可以先记住三个：

这也是为什么今天很多大语言模型都以 Transformer 为基础。

但要注意：

Transformer 本身只是结构。

它要变成真正好用的大模型，还需要：

大量数据
大量参数
大量训练
合适的对齐方式

所以不能简单说“Transformer 等于大模型”。

更准确地说：

很多大模型是以 Transformer 为核心结构训练出来的。

7.6 Transformer 和前面内容的关系

到这里，可以把前面的知识串起来：

文字
  ↓
Token
  ↓
Embedding 向量
  ↓
Transformer 理解上下文关系
  ↓
预测下一个 Token
  ↓
生成回答

比如用户问：

苹果最新手机有什么特点？

模型不会直接“读懂整句话”。

它会经历类似过程：

先切成 Token
再变成向量
再用 Transformer 判断这些 Token 的关系
最后预测接下来应该生成什么内容

所以可以先记住：

Token 解决“怎么切文字”，Embedding 解决“怎么变成数字”，Transformer 解决“这些数字之间怎么理解上下文关系”。

7.7 小结

这一章先记住三句话：

Transformer 的核心作用，是帮助模型理解 Token 之间的上下文关系。

注意力机制的意思是：当前 Token 会重点关注和自己更相关的 Token。

大模型通常是很多层 Transformer 叠起来，再经过大量数据训练出来的。

8. 最后把整条链路串起来

到这里，第二天的核心概念已经基本连起来了。

可以用一张图看完整流程：

当用户输入一个问题时，大模型大致会经历这样的过程：

用户输入问题
  ↓
切成 Token
  ↓
变成 Embedding 向量
  ↓
经过 Transformer 理解上下文
  ↓
预测下一个 Token
  ↓
不断重复预测
  ↓
形成完整回答

这里有一个关键点：

大模型不是一次性把整段答案写出来，而是不断预测下一个 Token，再把生成出来的内容接到前面。

所以前面讲过的概念，其实都在这条链路里：

8.1 和真实项目有什么关系

学习这些概念，不是为了背术语。

在真实项目里，我们通常不会自己从零训练一个大模型。

更多时候，是把已经训练好的大模型能力接入系统。

例如 AI 问答、Text-to-SQL、智能助教、资料总结，本质上都可以理解成：

业务系统准备输入
  ↓
通过 API 调用大模型
  ↓
大模型生成内容
  ↓
系统检查、保存、展示或继续执行

对应到项目开发里：

所以后面真正做项目时，要关注的不只是“模型会不会回答”。

还要考虑：

给模型什么输入？
模型输出什么格式？
输出结果能不能直接用？
需要不要做校验？
要不要保存对话和结果？
出错时系统怎么处理？

8.2 这一节课最终要带走什么

第二天可以先带走三句话：

AIGC 是现象，大模型是能力来源。

大模型内部依靠神经网络、参数、训练、Token、Embedding 和 Transformer 来处理语言。

做项目时，我们要把大模型能力接入真实系统，让它围绕业务问题完成任务。

学完这些概念后，后面再学习 Prompt、API 调用、RAG、Tools、Agent，就会更容易理解它们为什么需要、解决什么问题。