写给零基础 · 每个词都有解释 · 无需注册

AI 自学手册
零基础版

完全不懂 AI?没关系。这里有 15 节课:每节课先讲人话、配漫画、遇到的每个生词都能点开看解释,最后动手跑一个实验。跟着顺序学就行。

📌 遇到 绿色的词,悬停/点按就能看到解释。

怎么学

推荐学习路径 · 约 20 小时

完全零基础就按数字顺序学。第 4、5 板块用到前面的知识,建议不要跳。每个单元 60-90 分钟:看讲解 → 看漫画 → 记要点 → 跑实验。

1.1矩阵乘法:模型怎么算数
1.2梯度下降:模型怎么学会
1.3概率与温度:模型怎么选词
2.1分词:文字怎么变数字
2.2注意力:模型怎么理解语境
2.3三阶段训练:模型怎么炼成
3.1写 Prompt:怎么让模型听话
3.2Function Calling:给模型装手脚
3.3RAG:给模型接个知识库
4.1LoRA:只改 1% 微调模型
4.2量化部署:自己电脑跑模型
4.3评测:怎么知道模型行不行
5.1ReAct:Agent 怎么思考干活
5.2LangGraph:把 Agent 画成图
5.3MCP:工具的统一接口
🏁毕业能看懂 AI 圈 80% 的新闻和教程

板块 01

数学基础 · 只要会用计算器

先修要求:会加减乘除就行。不考你做题,只要求"看懂这个数字在干嘛"。
学完你能:看懂"7B 参数""学习率 1e-4""温度 0.7"这些 AI 圈黑话,知道它们背后是什么感觉。
1.1

矩阵乘法:模型靠什么"算数"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:大模型本质上是一台只会做"乘法加法"的机器。这一课让你亲眼看到这台机器长什么样,为什么它"记住的知识"其实是一堆数字。

📖 分步讲解

第一步 · 什么是"向量"
一个 向量就是一排数字。比如"苹果"这个词,在模型内部不是文字,而是变成了一排数字(通常是 768 个)。这排数字就是这个词的"身份证"。在 AI 圈,这排数字叫这个词的 嵌入
第二步 · 什么是"矩阵乘法"
模型把一排数字(1 行)和一整张数字表(几行几列)做乘法加法,得到新的一排数字。这张"数字表"就是 权重模型每"想"一步,就是做一次这样的运算,来回做几万次,就"想"完了。
第三步 · "参数量"是什么
把模型里所有数字表的数字数一遍,这个总数就是"参数量"。7B 模型 = 有 70 亿个数字,70B = 700 亿个。数字越多,模型"记得"的东西越多,但也越费电、越贵。
🍳 人话版:矩阵乘法 = 按食谱配菜 鸡蛋 [1×3] 面粉 [1×3] 牛奶 [1×3] 食谱 W [3×3] (配方表) 蛋糕 [1×3] 原料×配方=成品:把输入按权重混合成输出
动态演示:向量 × 矩阵 = 模型的一次"思考"
输入 x 1 2 [1×2] 权重矩阵 W(模型的记忆) 2 0 1 3 [2×2] 输出 y ? ? [1×2] x · W = y 点击播放,看每一步怎么算
▶ 点「播放」:输入向量 x 逐个格子与权重矩阵相乘,得到输出 y

📌 先认识这 3 个词

向量:一排数字,代表一个词/一个东西。
权重:模型的"记忆",一张很大的数字表。
参数量:权重里数字的总个数(7B=70 亿个)。

🧪 实验 1.1:亲眼看看"模型算数"

# 复制到任意 Python 环境跑(https://colab.research.google.com 免安装)
import numpy as np
np.random.seed(42)
x = np.array([0.2, 0.9, -0.4])   # 一个"词"的嵌入(3 个数字)
W = np.random.randn(3, 3) * 0.5  # 一张"权重表"(3×3 共9个数字)
y = x @ W + 0                    # 乘法加法,得到新的 3 个数字
print("词变成:", y.round(3))
你会看到:输入 3 个数字,出来 3 个不同的数字。模型就是这么"处理"每个词的——把一排数字变成另一排数字。
为什么有用:以后看到"embedding 768 维"这种话,你就知道——哦,就是一个词变成了 768 个数字。
1.2

梯度下降:模型怎么"学会"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:模型不是天生会答题,是"练"出来的。这一课讲清"练"的机制——为什么改一改数字,模型就变聪明了。

📖 分步讲解

第一步 · 模型怎么知道自己错了
模型答错题时,有个"打分器"算出它错得多离谱,这个分数叫 损失。损失越低 = 答得越好。训练 = 想办法把损失降下来。
第二步 · 往哪改?看"梯度"
梯度就是数学给的"方向箭头":它告诉你每个数字该往大改还是往小改,损失才会降。模型顺着箭头反方向调数字,损失就小了——这一步叫梯度下降
第三步 · 一次改多少?看"学习率"
学习率决定每次改动的幅度。步子太大:跳过头、越改越差;步子太小:进步龟速。调学习率是 AI 工程师的日常玄学。
⛷️ 人话版:梯度下降 = 蒙眼下山找谷底 你在这 谷底(最优) 脚感(loss)知道坡向哪边斜,就朝斜的反方向迈步。步长(lr)太大就滚过头
动态演示:小球是怎么"滚"到谷底的
起点(损失高) 谷底(损失最低) 步长(学习率)越大 → 滚得越快,但容易滚过头
▶ 点击「播放」,看小球一步步滚向谷底(每个点 = 一次参数更新)

📌 先认识这 3 个词

损失:答错程度的分数,越低越好。
梯度:告诉"往哪改"的方向箭头。
学习率:每次改动的步子大小。

🧪 实验 1.2:亲眼看着模型"学会"

# 让模型自己找出 y = 3x + 2 里的 3 和 2
import numpy as np
x = np.linspace(-1, 1, 50)
y_true = 3 * x + 2 + np.random.normal(0, 0.1, 50)
w, b, lr = 0.0, 0.0, 0.5        # 从"啥都不会"开始
for step in range(100):
    y_pred = w * x + b
    loss = np.mean((y_pred - y_true) ** 2)
    dw = 2 * np.mean((y_pred - y_true) * x)
    db = 2 * np.mean(y_pred - y_true)
    w -= lr * dw; b -= lr * db   # 顺着箭头反方向改
    if step % 20 == 0: print(f"第{step:3d}步 loss {loss:.4f} w {w:.3f} b {b:.3f}")
print("找到答案: w=%.3f b=%.3f(真值是 3 和 2)" % (w, b))
你会看到:loss 从几十一路掉到接近 0,w、b 从 0 慢慢爬到 3 和 2——这就是"学习"的全过程。
为什么有用:把 lr 改成 3.0 再跑,你会看到 loss 疯狂上下跳——这就解释了为什么"学习率调不好,模型训不乖"。
1.3

概率与温度:模型怎么"选词"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:写文章时,模型其实是在"猜下一个词"。这一课讲清它怎么猜、以及为什么有时候它"一本正经地胡说八道"。

📖 分步讲解

第一步 · 每个词都是"抽奖"
模型算完一轮后,会给词表里每个候选词打一个"推荐分",这叫 logits。但这些分数加起来不等于 1,不能直接用。
第二步 · softmax 把分数变成概率
softmax 把这些分数变成一组"百分比"(加起来正好 100%),也就是 概率分布。分数最高的词,被选中的概率最大。
第三步 · "温度"控制随机程度
温度(temperature)是一个旋钮:调低 → 模型几乎只选最稳的词(回答更保守);调高 → 冷门词也有机会被选(回答更有创意、也更爱乱说)。
🎰 人话版:温度 = 抽奖机的手劲 乱分数 logits softmax (归一化成概率) 概率 总和=1 抽一个 采样 温度旋钮 手劲小(低温)=几乎总抽中大奖;手劲大(高温)=谁都可能中。熵=抽奖的"乱的程度"
动态演示:拖动温度,看"抽奖概率"怎么变
"好" "行" "好棒" "可以" "无语" -- -- -- -- -- 温度 T = 1.0
▶ 拖动下方的温度滑块,看 5 个候选词的中奖概率怎么变化

📌 先认识这 3 个词

logits:模型给每个候选词的原始打分。
softmax:把打分变成百分比(加起来=100%)。
温度:控制"敢不敢冒险"的旋钮,0.7 是常见默认值。

🧪 实验 1.3:转动温度旋钮看变化

import numpy as np
logits = np.array([2.1, 1.4, 0.6, 0.1, -1.2])  # 5 个候选词的分数
def softmax_with_t(z, T):
    z = z / T
    e = np.exp(z - z.max())
    return e / e.sum()
for T in [0.2, 1.0, 3.0]:
    p = softmax_with_t(logits, T)
    print(f"温度 T={T}: " + " ".join(f"{v:.2f}" for v in p))
你会看到:T=0.2 时第一个词概率冲到 0.9+(稳如老狗);T=3.0 时五个词概率接近平均(掷骰子)。
为什么有用:写代码让 AI 输出要低温(稳定),写小说要高温(有创意)。现在你知道为什么了。

板块 02

大模型原理 · 拆开黑盒

先修要求:板块 1 的 1.1(矩阵)和 1.3(概率)。这一板块把"黑盒"拆成三块:怎么读进文字、怎么理解文字、怎么炼出来。
学完你能:看懂"token 数""上下文 128K""RLHF"这些词,知道大模型为什么"懂"中文、为什么答非所问。
2.1

分词(Tokenizer):文字怎么变成数字

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:模型只认识数字。你打的中文怎么变成它认识的数字?答案是一个叫"分词器"的切菜工具。顺带解开一个谜:为什么中文对话总是"更烧钱"。

📖 分步讲解

第一步 · 文字先被"切块"
你输入"我爱学大模型",模型的第一步不是读,而是把这句话切成小块,每块叫一个 token。中文常按"词"切(我/爱/学/大模型),英文按"子词"切(unbelievable → un/believ/able)。
第二步 · 每块领一个"编号"
每个 token 在模型内置的 词表里有一个唯一编号(比如"我"=123 号)。于是句子变成一串数字:[123, 87, 904, 441]。模型从此"看得懂"了。
第三步 · 中文为什么更贵
英文一个词 ≈ 1 个 token;中文一个词往往要切得更碎。同样一段话,中文的 token 数量大约是英文的 2-4 倍。而 API 按 token 收费、上下文窗口也按 token 计算——所以中文对话更快"烧钱"、更容易"装满"。
🧱 人话版:分词 = 把一句话拆成乐高积木 "我爱学大模型" 大模型 ID:123 ID:87 ID:904 ID:441 每块积木编个号,模型就读得懂了。中文拆得碎 → token 多 → 更烧钱

📌 先认识这 3 个词

token:模型读文字的最小单位(词/子词/汉字)。
词表:模型认识的所有 token 的编号清单(约 5 万个)。
上下文窗口:模型一次最多能"记住"的 token 数(如 128K)。

🧪 实验 2.1:数一数中文有多"贵"

# pip install tiktoken
import tiktoken
enc = tiktoken.get_encoding("cl100k_base")
zh = "人工智能正在改变世界"
en = "AI is changing the world"
print("中文 token 数:", len(enc.encode(zh)))
print("英文 token 数:", len(enc.encode(en)))
你会看到:中文的 token 数明显比英文多(通常 8-10 vs 5-6)——相同信息量,中文更费 token。
为什么有用:以后写长文发给 AI,先想想"这段值不值这么多 token";选模型时留意它的"上下文窗口"多大。
2.2

注意力:模型怎么"理解"一句话

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:"苹果"是指水果还是手机?模型靠一个叫"注意力"的机制搞明白。这也是"Attention Is All You Need"那篇论文的核心。

📖 分步讲解

第一步 · 每个词都要"看别人"
理解"苹果"需要看旁边的词。注意力机制让每个 token 跟句子里其他所有 token 互相"打招呼",判断谁和自己相关。相关度高的,影响力就大。
第二步 · 三个角色:Q、K、V
每个 token 变身成三个角色:Q/K/V。"苹果"用 Q 问"我在说什么?","手机"用 K 答"我是电子产品",配对成功 → 从 V 里取内容。Q、K、V 就是"找谁、是谁、给啥"。
第三步 · 每层都看一遍,就是"多头"
模型不止看一轮,而是用很多组 Q/K/V 同时看(多头注意力):一组管语法,一组管指代,一组管主题…… 综合起来,模型就"理解"了整句话。
👀 人话版:注意力 = 教室里找"最相关"的同学问答案 问: "苹果" 哪个意思? 水果 🍎 手机 📱 谁相关谁 权重就大 上下文里每个词都"看"其他词,相关度高 → 贡献大。这就是"理解语境"
动态演示:"苹果"是怎么看别的词的
"苹果" 🍎 水果 📱 手机 🍏 青苹果 💊 药丸 0.52 0.28 0.17 0.03 相关度越高 → 线越粗 → 权重越大
▶ 点击「播放」,看"苹果"依次看向每个词,按相关度分配注意力

📌 先认识这 3 个词

注意力:让词与词按相关度互相影响。
Q/K/V:找谁 / 是谁 / 给啥 三个角色。
多头注意力:多组 Q/K/V 同时看,各管一类关系。

🧪 实验 2.2:30 行写出"注意力"

import numpy as np
def attention(Q, K, V):
    d = Q.shape[-1]
    scores = Q @ K.T / np.sqrt(d)      # Q 找 K 配对打分
    w = np.exp(scores - scores.max(axis=-1, keepdims=True))
    w = w / w.sum(axis=-1, keepdims=True)  # softmax 归一
    return w @ V, w                    # 按权重取内容

np.random.seed(0)
X = np.random.randn(4, 8)              # 4 个词,各 8 个数字
Q = X @ np.random.randn(8, 8); K = X @ np.random.randn(8, 8); V = X @ np.random.randn(8, 8)
out, weights = attention(Q, K, V)
print("每个词对其他词的关注度(每行=一个词):")
print(weights.round(2))
你会看到:一个 4×4 的表格,每行是"这个词有多关注其他词",每行加起来=1。
为什么有用:这就是"模型理解语境"的物理本质。以后看到"注意力机制"四个字,你脑子里有画面了。
2.3

预训练 → SFT → RLHF:模型是怎么"炼"出来的

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:为什么 DeepSeek、ChatGPT 这么"会聊天"?因为它们经历了三个阶段的教育。这一课讲清三个阶段分别教了模型什么,以及——你处在哪一步。

📖 分步讲解

第一阶段 · 预训练:读万卷书
把互联网上几乎所有文字喂给模型,让它反复练习"猜下一个词"。几个月后,模型学会了语言规律和大量知识。但此时的它只会续写,不会聊天——你说"你好",它可能接"吗?今天天气真不错…"。这一步成本最高,只有大公司做。
第二阶段 · SFT:学答题格式
用几十万条"问-答"例子教模型:人家问你,你要回答,不是接着写。从此模型会"聊天"了。
第三阶段 · RLHF:学讨人喜欢
请人类给模型的回答打分(安全、有用、不胡说),模型据此调整自己。这一步让模型"更乖"。你现在用的每个助手模型,都走完了这三步。
🎓 人话版:像培养一个大学生 ① 读万卷书 ② 上培训班 ③ 家教打分 你的工作: 在成品上微调/接应用 预训练学知识,SFT学格式,RLHF学讨喜

📌 先认识这 3 个词

预训练:读海量文字学"猜下一个词",获得知识。
SFT:用问答例子学"答题格式"。
RLHF:靠人类打分学"讨人喜欢"。

🧪 实验 2.3:亲眼对比"会聊天"和"不会聊天"

# 装 ollama 后跑(免费本地)
# ollama pull qwen2.5:0.5b-instruct   # 走完三阶段的成品
# ollama pull qwen2.5:0.5b            # 只预训练过的"原始版"
# 分别运行 ollama run <模型名>,输入:你好,介绍一下你自己
# 你会发现:instruct 版正常聊天;原始版只会"接话续写"
你会看到:同一个公司、同一个大小,只差"SFT+RLHF",聊天体验天差地别。
为什么有用:下载开源模型时认准"instruct/chat"后缀——否则你会觉得"这模型好笨",其实只是没上过学。

板块 03

Prompt 与应用 · 让模型干活

先修要求:板块 2(知道模型是"猜下一个词"的机器)。这一板块是最实用的——学完你立刻能用。
学完你能:写出高质量的提问模板,让 AI 输出稳定;知道 Agent 怎么调用工具;会搭一个"问答自己文档"的 RAG。
3.1

结构化 Prompt:一句话说清,别让 AI 猜

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:AI 不是读心术。你问得越含糊,它答得越随缘。这一课教你一套万能提问模板,让 AI 的输出又稳又准。

📖 分步讲解

第一步 · 给 AI 一个"角色"
一句话开头:"你是一位资深编辑"。角色设定能让模型自动调用相关的表达方式和专业度——这是最简单也最有效的技巧。
第二步 · 说清任务 + 约束
任务:做什么("把下面文字压缩成 3 条要点")。约束:不许做什么("每条不超过 20 字""只输出列表,不要其他话")。约束越具体,输出越听话。
第三步 · 给 1-2 个示例(可选但很管用)
给一个"输入→输出"的例子,叫 few-shot。模型模仿示例,比听你描述格式靠谱得多。复杂任务再加一句"请一步步思考",准确率立刻提升。
🍜 人话版:写 Prompt = 给厨师下单,说清楚才不踩雷 下单: · 角色:川菜师傅 · 任务:回锅肉 · 约束:少辣多蒜 (示例:上次那样) 🌶️ 回锅肉 少辣·多蒜·色香味 符合预期 ✓ 只说"做道菜"随缘;角色+任务+约束+示例才稳定

📌 先认识这 3 个词

Prompt:你发给 AI 的那段话(提问/指令)。
Few-shot:给示例让模型照着模仿。
思维链(CoT):让模型先推理再回答。

🧪 实验 3.1:同题两种问法,差距立现

# 打开任意 AI 聊天工具(ChatGPT/DeepSeek/Kimi…)直接试:
# 问法 A(模糊):
#   "总结这段文字。"
# 问法 B(结构化):
#   "你是一位资深编辑。任务:把以下文字压缩成 3 条要点。
#    约束:每条不超过 20 字,按重要性排序,只输出列表。
#    文字:<粘贴你的内容>"
你会看到:问法 A 输出飘忽(可能长篇大论);问法 B 稳定给你 3 条清爽要点。
为什么有用:以后所有提问都套这个模板:角色 + 任务 + 约束 +(示例)。10 秒钟的事,输出质量翻倍。
3.2

Function Calling:AI 不会动手,但会"叫人干活"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:AI 只会生成文字,不会查天气、不会订票。但我们可以给 AI 一本"工具说明书",让它学会开口叫人干活——这就是 Agent 的起点。

📖 分步讲解

第一步 · 把"工具说明书"发给 AI
你写一个函数(比如查天气 get_weather),把它的"说明书"——名字、需要什么参数——发给 AI。这说明书叫 schema
第二步 · AI 说"我想调用",你执行
用户问"深圳天气如何?"AI 不直接编答案,而是输出一句:"我要调用 get_weather,参数 city=深圳"。你的代码收到这句话,调用真实的天气接口,拿到数据。
第三步 · 把结果还给 AI,AI 组织答案
你把天气数据回填给 AI,AI 基于真实数据回答:"深圳今天 31°C 有雷阵雨…"关键:AI 只"指挥"不"动手",执行权永远在你手里——这也是安全边界。
📞 人话版:模型是老板,你的代码是员工——老板只会打电话 老板(LLM) 员工(你的代码) 📋 工具名册 get_weather(...) 老板出嘴(参数),员工跑腿(执行),结果回报

📌 先认识这 3 个词

Function Calling:AI 输出"调用请求",你执行。
Schema:工具的说明书(名字+参数)。
回填:把工具结果还给 AI 组织答案。

🧪 实验 3.2:看 AI"叫人干活"

# 需要任意 OpenAI 兼容 API(你的 KEY)
import openai
client = openai.OpenAI(base_url="你的BASE_URL", api_key="你的KEY")
tools = [{"type": "function", "function": {
    "name": "get_weather",
    "description": "查询城市天气",
    "parameters": {"type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]}}}]
resp = client.chat.completions.create(
    model="gpt-4o-mini", tools=tools,
    messages=[{"role": "user", "content": "深圳今天适合跑步吗?"}])
msg = resp.choices[0].message
if msg.tool_calls:
    c = msg.tool_calls[0].function
    print("AI 请求调用:", c.name, "参数:", c.arguments)
你会看到:AI 没有直接编天气,而是输出"我要调用 get_weather,city=深圳"——它在叫人干活。
为什么有用:这就是 Agent 的雏形。后面 5.1 课你还会看到它怎么循环干活。
3.3

RAG:让 AI 读你的文档再回答

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:AI 的知识停在训练那天,还会一本正经地瞎编(幻觉)。RAG 的解法很朴素:先翻资料再回答——把你自己的文档变成 AI 的"参考书"。

📖 分步讲解

第一步 · 把文档"存进书架"(离线做一次)
把你的文档切成一段段(几百字一段),每段转成一排数字(还记得 1.1 课的嵌入吗),存进一个叫 向量数据库 的地方。这一步叫"建库"。
第二步 · 提问时"查书架"(每次提问都做)
用户提问后,把问题也变成数字,去库里找最相似的 3-5 段(这叫检索)。就像图书馆管理员按关键词帮你找出最相关的几页书。
第三步 · 把"书页"和问题一起给 AI
把检索到的段落 + 用户问题拼在一起发给 AI,AI 照着材料回答。这样答案有出处、不编造、还能随时更新——这就是 RAG(检索增强生成)。
📚 人话版:RAG = 图书馆管理员,先查书再回答 你(提问) 📖 书架 = 你的文档 切成块存向量库 模型(照着念) 先查书再照着念:答案有出处、不编造

📌 先认识这 3 个词

幻觉:AI 一本正经地编造不存在的"事实"。
向量数据库:存"文字的数字版"并支持找相似的库。
RAG:先检索材料,再让模型照材料回答。

🧪 实验 3.3:40 行搭一个迷你 RAG

# pip install chromadb sentence-transformers
import chromadb
from sentence_transformers import SentenceTransformer
emb = SentenceTransformer("BAAI/bge-small-zh-v1.5")
db = chromadb.Client().create_collection("kb")
docs = ["深圳康泰创新广场在南山科技园附近",
        "深圳地铁 1 号线经过深大站",
        "华为康泰创新广场楼下有肯德基"]
for i, d in enumerate(docs):
    db.add(ids=[str(i)], documents=[d], embeddings=[emb.encode(d).tolist()])
q = "肯德基在哪?"
hits = db.query(query_embeddings=[emb.encode(q).tolist()], n_results=1)
print("检索到:", hits["documents"][0][0])
你会看到:问"肯德基在哪?"命中第三条"华为康泰创新广场楼下有肯德基"——它真会找。
为什么有用:把 docs 换成你的公司文档、课程笔记,再让 AI 基于命中内容回答,就是你的私有知识问答机器人。

板块 04

微调与部署 · 把模型变成你的

先修要求:板块 2 的 2.3(三阶段训练)。这一板块讲"训练完的大模型,普通人怎么改造它、怎么在自己电脑上跑"。
学完你能:分清"微调"和"提示词"的区别;知道 LoRA 为什么省钱;会在自己电脑上跑一个开源大模型(你的 Mac 完全够用)。
4.1

LoRA:只改 1% 的参数,让模型"变性格"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:想让 AI 说话像你、懂你的业务,有两个办法:一是写提示词(改"说明书"),二是微调(改"大脑")。这一课讲微调里最省钱的办法——LoRA。

📖 分步讲解

第一步 · 微调 = 继续训练模型
在成品模型上,用你自己的数据(比如 1000 条你写的对话)继续训练,让模型学会你的风格。这没问题,但全量微调很贵:改全部参数,显存不够、时间漫长。
第二步 · LoRA 的聪明主意:只改"小补丁"
LoRA 的想法:原模型完全冻结不动,在旁边加两个很小的矩阵当"补丁",只训练补丁。原模型 100 亿参数纹丝不动,补丁可能只有 1000 万——但效果接近全量微调。
第三步 · 好处不止省钱
补丁很小(几 MB),可以一个模型挂多个补丁:同一个模型 + 补丁A = 客服风格,+ 补丁B = 小说风格,随时切换,互不干扰。这就是"模型超市"的玩法。
📌 人话版:LoRA = 不动整本字典,只贴便签改几页 整本大字典 (7B 参数,冻结不动) 重新印刷太贵 ✗ 贴便签改几页 A×B A×B 只训练便签(~1%) ✓ 只改1%小矩阵:显存省10倍,照样个性化

📌 先认识这 3 个词

微调:用自己的数据继续训练模型。
LoRA:只训练"补丁矩阵"的省钱微调法。
Adapter:微调产物,几 MB 的"风格补丁"文件。

🧪 实验 4.1:看 LoRA 到底省多少

# pip install peft transformers
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-0.5B-Instruct")
lora = LoraConfig(r=8, target_modules=["q_proj","k_proj","v_proj","o_proj"])
model = get_peft_model(model, lora)
model.print_trainable_parameters()
# 输出类似:trainable params: 1,572,864 / 501,432,960 → 只训练 0.31%
你会看到:5 亿参数里只训练 150 万——剩下 99.7% 冻结不动。
为什么有用:记住一个数字:LoRA 训练成本 ≈ 全量微调的 1/100。以后听到"微调很贵"你要知道有便宜的玩法。
4.2

量化与本地部署:在自己电脑上跑大模型

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:大模型一定要连网用吗?不。这一课教你在自己电脑上跑一个开源大模型——免费、离线、数据不外传。你的 Mac 完全跑得动。

📖 分步讲解

第一步 · 为什么需要"量化"
模型默认用"高精度数字"存储,占内存大(7B 模型 ≈ 14GB)。量化把数字压缩(像照片压成 JPEG),7B 模型降到 ~4GB,普通电脑就装得下了。质量损失通常很小。
第二步 · Ollama:一条命令搞定
Ollama 是免费工具,把"下载模型 + 量化 + 启动服务"打包成一条命令。装好后:ollama run qwen2.5:14b 就能聊天。
第三步 · 你的 Mac 能跑多大的?
你的 M2 Max 有 96GB 统一内存,跑 14B 模型(约 9GB)非常轻松,甚至 32B 也能跑。估算公式:模型要占的内存 ≈ 参数规模 × 每参数字节(Q4 量化 ≈ 0.5 字节)。
🧳 人话版:量化 = 真空压缩袋,衣服变小但能穿 原模型 FP16 7B = 14GB 显存 大箱子占地方 压! 量化 Q4 7B = 4GB 显存 小箱子塞得下 ✓ 💻 衣服皱了(精度略降)但能穿:ollama 一行命令跑

📌 先认识这 3 个词

量化:压缩模型数字精度,内存减到 1/4。
Ollama:本地跑模型的免费工具。
GGUF:量化后模型的常见文件格式。

🧪 实验 4.2:现在就在你 Mac 上跑起来

# 第 1 步:装 Ollama(官网 ollama.com 下载,或终端执行)
#   brew install ollama
# 第 2 步:下载并运行一个 14B 模型(约 9GB,等几分钟)
#   ollama run qwen2.5:14b
# 第 3 步:用 Python 调它(OpenAI 兼容接口)
import openai
client = openai.OpenAI(base_url="http://localhost:11434/v1",
                       api_key="ollama")
r = client.chat.completions.create(
    model="qwen2.5:14b",
    messages=[{"role": "user", "content": "用三句话解释 RAG"}])
print(r.choices[0].message.content)
你会看到:终端里出现一个能聊天的本地 AI,全程离线、数据不出你电脑。
为什么有用:隐私敏感场景(公司资料、个人笔记)用本地模型最安心;而且不花一分钱 API 费。
4.3

评测与幻觉:怎么知道 AI "行不行"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:"感觉答得不错"不算数。这一课教你用一套"考卷"客观给 AI 打分,还讲清 AI 为什么会"一本正经地胡说八道"(幻觉)以及怎么防。

📖 分步讲解

第一步 · 准备一张"考卷"
收集 50-200 条真实问题 + 标准答案,这就是你的 评测集。题目要覆盖:日常问题 80% + 刁钻问题 20%(空输入、超长、陷阱题)。
第二步 · 让模型"考试"并打分
把考卷跑一遍,按标准答案判分,得出一个通过率。改完提示词或模型后重跑同一张考卷,对比分数——这就是"回归测试":防止"修好一个坏十个"。
第三步 · 对付"幻觉"三板斧
幻觉是"猜词机器"的副作用,没法根除,只能防:① 用 RAG 给依据(3.3 课);② 提示词里写"不知道就说不知道";③ 让另一个 AI 交叉检查答案真假。
📝 人话版:评测 = 期末考,幻觉 = 瞎编答案被红笔叉掉 考官(评测集) 考卷 50~200 题 固定题目,改版就重考 学生(模型) ✗ 瞎编 (幻觉扣分) 固定考卷打分才能对比;不会的题教它说"不知道"

📌 先认识这 3 个词

评测集:固定的"题目+答案"考卷。
回归测试:改完重跑同一张考卷,对比分数。
LLM-as-judge:让一个 AI 给另一个 AI 打分。

🧪 实验 4.3:5 分钟给你的 AI 出张考卷

# 打开任意 AI 工具,做一件事:
# 1. 收集你日常问它的 10 个问题+理想答案
# 2. 每个问题问 3 遍,看回答稳不稳定
# 3. 统计:几次答对?几次胡说?
# 4. 把"胡说的题"挑出来,改提示词:
#    "不确定的信息,请明确说'我不确定'"
# 5. 再考一遍,对比正确率
你会看到:加一句"不知道就说不知道",胡编率肉眼可见下降。
为什么有用:你不需要懂代码就能评测 AI。这套"考卷思维"是 AI 从业者的基本功。

板块 05

多智能体 · 从工具到系统

先修要求:板块 3 的 3.2(Function Calling)。这一板块把"单个 AI 干活"升级成"AI 自己循环干活、多 AI 协作"。
学完你能:看懂 Agent / ReAct / LangGraph / MCP 这些热词;知道怎么让 AI 自动完成多步任务。
5.1

ReAct:AI 自己"想→查→看"循环干活

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:3.2 课里 AI 只会"调用一次工具"。这一课让它反复调用:查一下、想一下、再查、再想……直到任务完成。这就是 Agent(智能体)的最小形态。

📖 分步讲解

第一步 · 循环长这样
ReAct 循环三步:思考(我下一步该干什么)→ 行动(调用哪个工具、传什么参数)→ 观察(看工具返回的结果)→ 回到思考。像侦探查案:想→查→看→再想。
第二步 · 一定要有"刹车"
循环很危险:AI 可能卡在同一个工具上反复调用,直到把你的 token 烧光。工程上必须加三道刹车:最大步数(比如 10 步)、工具白名单(只准用允许的工具)、每步成本核算。
第三步 · "完成"也要教
在提示词里明确告诉 AI:任务做完就输出 Final Answer(最终答案)并停止。不给出口,它就会一直转圈。
🕵️ 人话版:ReAct = 侦探破案:想→查→看→再想 Thought 想 Action 查 Observe 看 查到线索(观察)再回到"想"——循环到结案。没步数上限就烧钱转圈

📌 先认识这 3 个词

Agent(智能体):能自己循环调用工具完成任务的 AI。
ReAct:思考-行动-观察 的循环模式。
步数上限:给循环装的"刹车",防止烧钱。

🧪 实验 5.1:亲手造一个会循环的 Agent

# 需要任意 OpenAI 兼容 API。看懂结构即可,不用全跑
def run_agent(task, max_steps=5):
    messages = [{"role": "system",
        "content": "你是 Agent。循环执行:思考→调工具→看结果→再思考。"
                   "完成时输出 Final Answer 并停止。"}]
    for step in range(max_steps):
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=tools)
        msg = r.choices[0].message
        print(f"[第{step}步]", msg.content or "(调用工具)")
        if msg.content and "Final Answer" in msg.content:
            return msg.content
        if msg.tool_calls:
            fn = msg.tool_calls[0].function
            result = my_tool(fn.name, fn.arguments)  # 执行工具
            messages += [msg, {"role": "tool",
                "tool_call_id": msg.tool_calls[0].id,
                "content": result}]
    return "达到步数上限,任务未完成"
你会看到:日志里 AI 一步步"想→查→看",直到给出 Final Answer。
为什么有用:把 max_steps 去掉跑一个注定失败的任务——你就亲眼看到"AI 失控烧钱"长什么样。这教训值回票价。
5.2

LangGraph:把 Agent 画成一张流程图

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:裸 ReAct 是"自由发挥",不可控。LangGraph 把它变成一张地铁线路图:每个站干什么、什么条件下走哪条线,一目了然,还能中途让人插手。

📖 分步讲解

第一步 · 节点:每个"站"干一件事
把流程拆成一个个节点:LLM 节点(思考)、工具节点(执行)、判断节点(要不要继续)。每个节点只干自己的事。
第二步 · 边:条件决定走哪条线
节点之间用连接。有些边是"条件边":比如"输出里含'答案'→ 去终点;否则 → 回去调工具"。这就是程序里的 if/else。
第三步 · 状态 + 检查点:中途能下车
所有中间结果存在一个叫 状态 的"记事本"里。检查点每步存快照,所以可以:中断恢复、人类中途审批(human-in-the-loop)。
🚇 人话版:LangGraph = 把 Agent 画成地铁线路图 起点站 LLM 站 (思考) 工具站 (查资料) 终点站 需要工具? 查完回来 每站干一件事,箭头定下一站;可中途下车

📌 先认识这 3 个词

节点/边:流程图的"站"和"线路"。
状态(state):各节点共用的"记事本"。
检查点:每步快照,可中断恢复、人工审批。

🧪 实验 5.2:搭一个"两站"流程图

# pip install langgraph
from typing import TypedDict
from langgraph.graph import StateGraph, END
class State(TypedDict):
    messages: list
def agent_node(state):
    return {"messages": [call_llm(state["messages"])]}  # LLM 站
def route(state):
    last = state["messages"][-1]
    return "finish" if "答案" in last else "agent"     # 条件边
g = StateGraph(State)
g.add_node("agent", agent_node)
g.set_entry_point("agent")
g.add_conditional_edges("agent", route, {"agent": "agent", "finish": END})
app = g.compile()
print(app.invoke({"messages": ["用一句话介绍 Agent"]}))
你会看到:图结构里"LLM 站"反复运行,直到输出含"答案"才到终点。
为什么有用:流程可视、可控、可恢复——这就是"生产级 Agent"和"玩具 ReAct"的分水岭。
5.3

MCP:给 AI 的工具装一个"USB-C 接口"

开场白 · 分步讲解 · 漫画 · 术语 · 实验

1 分钟这一课讲什么:每个 AI 都要给每个工具写一套接入代码,太痛苦了。MCP 统一了标准:工具做好一个"USB-C 口",任何 AI 插上就能用。

📖 分步讲解

第一步 · 没有标准时的混乱
以前:Claude 要接日历写一套代码,ChatGPT 要接日历再写一套。每家一个专用接口,重复劳动,维护地狱。
第二步 · MCP 统一"插座"
MCP 定义了一套标准协议:工具方做成一个"服务器"(server),AI 方用标准"客户端"(client)连接。写一次工具,所有支持 MCP 的 AI 都能用。
第三步 · 一个工具能暴露三种能力
MCP 服务器能提供:工具(能执行的动作)、资源(能读取的数据)、提示词(预设模板)。生态里已有几百个现成服务器:GitHub、日历、数据库、浏览器……
🔌 人话版:MCP = 工具的 USB-C 接口,一个口插所有 AI 助手 (手机/电脑) USB-C 口 日历 数据库 浏览器 不用 MCP 之前: 每家一根专用线 ✗ 标准口即插即用:写一个 server,所有客户端能用

📌 先认识这 3 个词

MCP:AI 与工具之间的统一通信协议。
Server:把工具包装成标准接口的服务。
工具/资源/提示词:Server 能提供的三种能力。

🧪 实验 5.3:50 行写一个 MCP 工具

# pip install "mcp[cli]"
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("demo")
@mcp.tool()
def add(a: int, b: int) -> int:
    """两数相加"""
    return a + b
if __name__ == "__main__":
    mcp.run()   # 启动服务器(stdio 模式)
# 之后:任何支持 MCP 的 AI 客户端连接这个 server,
# 模型就能自己调用 add —— 写一次,处处用
你会看到:一个不到 20 行的"工具服务器"——这就是 MCP 生态里每个工具的长相。
为什么有用:把 add 换成"读 CSV 文件""查天气",你的 AI 就多了一项技能,而且所有 AI 客户端通用。

小抄

全站词汇表

学完 15 课还记不住?把这一页存着。以后看到 AI 新闻里的生词,回来查。

token模型读文字的最小单位(词/子词/汉字),API 按它计费
词表模型认识的所有 token 的编号清单(GPT 约 5 万)
嵌入把一个词/一段文字变成一排数字,意思相近数字也相近
权重模型里的数字表,模型的所有"记忆"都藏在里面
参数量权重里数字的总个数;7B=70 亿个
损失模型答错程度的分数,训练就是把它降下来
梯度告诉"往哪改数字损失降得快"的方向箭头
学习率每次改数字的步子大小;太大震荡、太小龟速
logits模型给每个候选词的原始打分
softmax把打分变成百分比(加起来=100%)的公式
温度控制"敢不敢冒险"的旋钮;低=稳,高=有创意也爱乱说
上下文窗口模型一次最多能记住的 token 数(如 128K)
注意力让词与词按相关度互相影响,是"理解语境"的机制
Q/K/V注意力里三个角色:找谁/是谁/给啥
多头注意力多组 Q/K/V 同时看,各管一类关系
预训练读海量文字学"猜下一个词",获得知识(大公司才做)
SFT用问答例子教模型"答题格式",让它会聊天
RLHF靠人类打分教模型"讨人喜欢"
Prompt你发给 AI 的那段话(提问/指令)
Few-shot给示例让模型照着模仿输出格式
思维链 CoT让模型"先一步步想再给答案",推理题更准
Function CallingAI 输出"调用工具的请求",你的代码执行
Schema工具的说明书(名字+参数)
幻觉AI 一本正经地编造不存在的"事实"
RAG先检索你的文档,再让模型照材料回答
向量数据库存"文字的数字版"并支持快速找相似的库
微调用自己的数据继续训练成品模型
LoRA只训练"补丁矩阵"的省钱微调法(成本 1%)
量化压缩模型数字精度,内存减到 1/4
Ollama本地跑开源模型的免费工具,一条命令
Agent能自己循环调用工具完成任务的 AI
ReAct思考-行动-观察 循环;Agent 的最小形态
LangGraph把 Agent 画成流程图的框架,可控可恢复
MCPAI 与工具之间的统一"USB-C"协议