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

AI 自学手册
零基础版

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

遇到 绿色术语,悬停或点按即可查看解释。

怎么学

推荐学习路径 · 约 20 小时

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

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

板块 01

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

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

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

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

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

📖 分步讲解

第一步 · 什么是"向量"
一个 向量就是一排数字。比如"苹果"这个词,在模型内部不是文字,而是变成了一排数字(通常是 768 个)。这排数字就是这个词的"身份证"。在 AI 圈,这排数字叫这个词的 嵌入
第二步 · 什么是"矩阵乘法"
模型把一排数字和一张数字表做乘法加法,得到新的一排数字。这张表就是 权重。这是网络中的一次线性变换;真实大模型还会穿插注意力、非线性变换、归一化和残差连接。
第三步 · "参数量"是什么
把模型里可学习数字数一遍,总数就是参数量。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 行向量写法:先算第 1 列,再算第 2 列
▶ 点「播放」:行向量 x 分别与 W 的每一列做点积,得到输出 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 工程师的日常玄学。
⛷️ 人话版:梯度下降 = 蒙眼下山找谷底 你在这 谷底(最优) 梯度指方向,学习率定步幅;步子过大可能越过谷底
动态演示:小球是怎么"滚"到谷底的
起点(损失高) 谷底(损失最低) 步长(学习率)越大 → 滚得越快,但容易滚过头
▶ 点击「播放」,看一维二次损失函数上的梯度下降如何更新参数

📌 先认识这 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。现代分词器通常按子词或字节模式切分;中文可能一字一块、几字一块,也可能拆成字节,具体取决于模型的词表和算法。
第二步 · 每块领一个"编号"
每个 token 在分词器的 词表里有编号。句子会先变成一串 token ID,再查表得到向量供网络计算;示例编号只是示意,并非固定值。
第三步 · 中文为什么更贵
不同模型的分词器差异很大。偏英文的词表常把中文切得更碎,多语言新模型可能高效得多。API 按 token 计费、上下文也按 token 计算,所以应使用目标模型自己的 tokenizer 实测,不要用固定倍数估算。
🧱 人话版:分词 = 把一句话拆成乐高积木 "我爱学大模型" 大模型 ID:123 ID:87 ID:904 ID:441 每块积木编个号,模型就读得懂了。中文拆得碎 → token 多 → 更烧钱

📌 先认识这 3 个词

token:模型读文字的最小单位(词/子词/汉字)。
词表:token 与编号的清单;不同模型通常是数万到二十万以上。
上下文窗口:模型一次最多能"记住"的 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)))
你会看到:这两句在 cl100k_base 下的 token 数;它只说明该分词器如何切这两个例句,不能外推所有中英文或所有模型。
为什么有用:估算成本或上下文前,用目标模型的 tokenizer 计算实际 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

预训练 → 指令微调 → 偏好对齐:模型怎么炼成

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

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

📖 分步讲解

第一阶段 · 预训练:读万卷书
把互联网上几乎所有文字喂给模型,让它反复练习"猜下一个词"。几个月后,模型学会了语言规律和大量知识。但此时它的训练目标主要是续写,没有被专门训练为稳定遵循对话指令。你说“你好”,它可能继续写成网页或文章。这一步成本最高,通常由资金和算力充足的组织完成。
第二阶段 · SFT:学答题格式
用几十万条"问-答"例子教模型:人家问你,你要回答,不是接着写。从此模型会"聊天"了。
第三阶段 · RLHF:学讨人喜欢
用人类偏好改善回答的有用性与安全性。现代助手还常用 DPO、RLAIF 等方法;更准确的总括是“预训练 → 指令微调 → 偏好与安全对齐”。
🎓 人话版:像培养一个大学生 ① 读万卷书 ② 上培训班 ③ 家教打分 你的工作: 在成品上微调/接应用 预训练学语言与知识,SFT学指令,偏好对齐改善有用性与安全性

📌 先认识这 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:给示例让模型照着模仿。
任务分解:把复杂任务拆成可检查的步骤,并要求给出简洁依据。

🧪 实验 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 说"我想调用",你执行
用户问“深圳天气如何?”模型返回结构化调用请求:get_weather({city: 深圳})。你的应用校验参数、决定是否执行,再调用真实天气接口。一次回复也可能包含零个、一个或多个调用。
第三步 · 把结果还给 AI,AI 组织答案
你把工具结果与对应的调用 ID 回传给模型,模型再组织答案。关键:模型提出调用,应用负责授权、校验和执行——这才是安全边界。
📞 人话版:模型是老板,你的代码是员工——老板只会打电话 老板(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
把检索到的段落和问题一起发给模型,让它基于材料回答。这能提供可引用依据并随文档更新,但检索错、材料缺失或模型误读时仍可能出错——这就是 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 分钟这一课讲什么:想让 AI 说话像你、懂你的业务,有两个办法:一是写提示词(改"说明书"),二是微调(改"大脑")。这一课讲微调里最省钱的办法——LoRA。

📖 分步讲解

第一步 · 微调 = 继续训练模型
在成品模型上,用你自己的数据(比如 1000 条你写的对话)继续训练,让模型学会你的风格。这没问题,但全量微调很贵:改全部参数,显存不够、时间漫长。
第二步 · LoRA 的聪明主意:只改"小补丁"
LoRA 冻结基础模型,用两个低秩矩阵表示权重更新。可训练参数比例常低于几个百分点;效果取决于任务、数据、秩和注入层,不能一概等同全量微调。
第三步 · 好处不止省钱
适配器通常远小于基础模型,可以为同一基础模型保存多个适配器,按任务加载或切换。文件大小、切换方式和能否同时组合取决于框架与配置。
📌 人话版: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 通常显著减少可训练参数和优化器显存;实际速度、显存与成本取决于秩、目标层、序列长度和训练框架。
4.2

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

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

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

📖 分步讲解

第一步 · 为什么需要"量化"
模型常以 FP16/BF16 权重发布,7B 仅权重约 14GB,运行时还需 KV 缓存和框架开销。量化可把 4-bit 7B 权重压到约 4–5GB,但实际内存更高,质量损失也因模型与方案而异。
第二步 · 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 个词

量化:用更低位宽表示权重或激活;占用和质量变化取决于方案。
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 提供依据并展示引用;② 允许模型明确表达不确定;③ 高风险事实调用可信来源或人工复核。另一个 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 定义了标准协议:服务端暴露能力,宿主内的客户端连接。支持相应 MCP 版本与传输方式的客户端可以发现并使用;宿主仍需处理授权与安全控制。
第三步 · 一个工具能暴露三种能力
MCP 服务器可提供:工具资源提示词。生态已有许多社区和官方服务器;安装前应核对来源、权限范围、传输方式和维护状态。
🔌 人话版: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,
# 支持该 MCP 能力的客户端在用户授权后可调用 add
你会看到:一个不到 20 行的"工具服务器"——这就是 MCP 生态里每个工具的长相。
为什么有用:把 add 换成“读 CSV 文件”或“查天气”,支持相应 MCP 版本的客户端可在用户授权后复用这项能力。

小抄

全站词汇表

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

token模型读文字的最小单位(词/子词/汉字),API 按它计费
词表token 与编号的清单;规模随模型而异,常见为数万到二十万以上
嵌入把一个词/一段文字变成一排数字,意思相近数字也相近
权重训练学到的数字参数,共同决定信息如何在网络中变换
参数量权重里数字的总个数;7B=70 亿个
损失模型答错程度的分数,训练就是把它降下来
梯度告诉"往哪改数字损失降得快"的方向箭头
学习率每次改数字的步子大小;太大震荡、太小龟速
logits模型给每个候选词的原始打分
softmax把打分变成百分比(加起来=100%)的公式
温度控制"敢不敢冒险"的旋钮;低=稳,高=有创意也爱乱说
上下文窗口模型一次最多能记住的 token 数(如 128K)
注意力让词与词按相关度互相影响,是"理解语境"的机制
Q/K/V注意力里三个角色:找谁/是谁/给啥
多头注意力多组 Q/K/V 同时看,各管一类关系
预训练读海量文字学"猜下一个词",获得知识(大公司才做)
SFT用问答例子教模型"答题格式",让它会聊天
RLHF利用人类偏好反馈训练奖励信号,再优化模型行为
Prompt你发给 AI 的那段话(提问/指令)
Few-shot给示例让模型照着模仿输出格式
任务分解把复杂任务拆成可检查的步骤;效果需用评测验证
Function CallingAI 输出"调用工具的请求",你的代码执行
Schema工具的说明书(名字+参数)
幻觉模型生成看似合理、实际无依据或错误的信息
RAG先检索材料再生成回答,可提供依据但不能保证正确
向量数据库存"文字的数字版"并支持快速找相似的库
微调用自己的数据继续训练成品模型
LoRA冻结基础权重,训练低秩更新矩阵的参数高效微调方法
量化用更低位宽近似表示权重或激活,以降低占用或提升效率
Ollama本地跑开源模型的免费工具,一条命令
Agent能自己循环调用工具完成任务的 AI
ReAct思考-行动-观察 循环;Agent 的最小形态
LangGraph把 Agent 画成流程图的框架,可控可恢复
MCPAI 与工具之间的统一"USB-C"协议