对齐：RLHF 与 DPO 在做什么

对齐：RLHF 与 DPO 在做什么

SFT（监督微调）之后，模型已经会答题了。

但你问它"我该不该辞职"，它可能给你列 12 条利弊，最后补一句"建议咨询专业人士"。

你问它"我失恋了，好难受"，它可能回你一段依恋理论。

它不是不会说，它是不知道你想听什么。

对齐干的事，就是教它这个。

本文的关系图：

SFT 模型：会答，但不知道什么叫"好" ↓ 人类给两个回答排序 偏好数据：(prompt, 好回答, 差回答) ↓ ┌───────────────┴───────────────┐ RLHF：奖励模型 + PPO DPO：直接优化偏好 └───────────────┬───────────────┘ ↓ 对齐后的模型：更有用、更诚实、更少闯祸，也更像人话

一、SFT 之后，为什么还需要对齐？

先把一个误会掰正：SFT 解决的是"会不会答"，对齐解决的是"答得让不让人舒服"。

SFT 的数据是"指令 + 标准答案"。但现实里，很多问题没有唯一标准答案。你问"我失恋了，好难受"，下面三个回答都不能算"错"：

A：抱抱你。失恋确实很难受，允许自己难过一阵子。要不要说说发生了什么？ B：这有什么好难受的，下一个更好。 C：失恋是一种常见的负性生活事件，通常涉及依恋关系的丧失与重建……

A 有人味，B 像欠揍，C 像论文。你要选一个发给朋友，三秒钟就能选出来；但你要让 SFT 数据把"为什么 A 更好"写成一个标准答案，反而很难。

因为"好"不是一个标签，是一个排序。人类很擅长说"A 比 B 好"，不擅长说"A 值 8.7 分，B 值 6.2 分"。对齐要学的，就是这种排序能力。

业内常说的目标是 3H：

• Helpful：真能帮上忙，别答非所问；
• Honest：不知道就说不知道，别硬编；
• Harmless：不教人干坏事，不制造伤害。

注意，对齐改的是"愿意怎么答"，不是"能不能答"。知识的上限在预训练就定了；对齐是在这个上限之内，调它的口味、边界和语气。

打个比方：SFT 是驾校，教它打方向、踩离合；对齐是上路后的驾驶习惯——什么时候让行，什么时候鸣笛，什么时候闭嘴。

二、偏好数据：人类不写标准答案，只做选择题

对齐的数据长这样：

prompt：我失恋了，好难受。 chosen：抱抱你。失恋确实很难受…… rejected：这有什么好难受的，下一个更好。

一条样本不是"问题 + 标准答案"，而是"问题 + 两个回答 + 谁更好"。这叫成对偏好数据（pairwise preference data）。

为什么不用绝对打分？因为人打分太不稳。你让两个人给同一篇文章打 8 分还是 9 分，他们能吵一下午；你让他们选"A 和 B 哪个好"，三秒就能点。比较比打分可靠，这是心理学里早就知道的事。

偏好数据从哪来：

这里有个必须记住的事实：偏好数据不是真理，是民调。你标注的是"喜欢"，模型学到的也是"喜欢"；但"喜欢"和"对"之间，还隔着一条街。

标注员偏爱长回答，模型就会变啰嗦；偏爱自信的语气，模型就会变敢编；偏爱顺着用户，模型就会变谄媚。数据里的偏见，会在训练后被放大成模型的人格。

三、RLHF 第一步：把偏好蒸馏成奖励模型

在 SFT 模型的基础上，RLHF（Reinforcement Learning from Human Feedback，基于人类反馈的强化学习）通常分两步。第一步，是训练一个奖励模型（reward model）：给它一个回答，它吐一个分数。

怎么训？用 Bradley-Terry 模型。它假设"人更喜欢 A"的概率，取决于两个回答的分数差：

P(A > B) = sigmoid(r(A) - r(B))

训练目标就是让这个概率尽量接近 1：

loss = -log sigmoid(r(chosen) - r(rejected))

翻译成人话：chosen 的分数要比 rejected 高；差得越多，loss 越小。这是一个 pairwise 的逻辑损失，样本是"成对比较"，不是"单条标注"；奖励模型本身可以是一个大神经网络，不一定是线性的。

真实的奖励模型通常从 SFT 模型初始化，把输出头换成一个标量；它读完整段回答，吐一个数。下面这个玩具用三个特征（共情、信息量、长度）来模拟，只是为了把"偏好 → 权重"这件事画出来：

importmath PROMPT="我失恋了，好难受。"ANSWERS={"A":"抱抱你。失恋确实很难受，允许自己难过一阵子。要不要说说发生了什么？","B":"这有什么好难受的，下一个更好。","C":"失恋是一种常见的负性生活事件，通常涉及依恋关系的丧失与重建……",}FEATURES={"A":[0.9,0.8,0.3],"B":[0.1,0.2,0.1],"C":[0.2,0.4,0.9],"D":[0.2,0.3,1.0],# 又长又空，专门用来试探奖励模型}defsigmoid(x):ifx>=0:return1.0/(1.0+math.exp(-x))e=math.exp(x)returne/(1.0+e)deftrain_reward(pairs,steps=3000,lr=0.5,l2=0.01):"""最小化 -log sigmoid(r(win) - r(lose))，加一点 L2 让权重好读。"""w=[0.0,0.0,0.0]for_inrange(steps):forwin,loseinpairs:diff=[a-bfora,binzip(FEATURES[win],FEATURES[lose])]s=sum(wi*diforwi,diinzip(w,diff))g=sigmoid(s)-1.0foriinrange(3):w[i]-=lr*(g*diff[i]+l2*w[i])returnwdefscore(w,key):returnsum(wi*xiforwi,xiinzip(w,FEATURES[key]))defaccuracy(w,pairs):returnsum(score(w,win)>score(w,lose)forwin,loseinpairs)normal=[("A","B"),("A","C"),("C","B")]length_biased=[("A","B"),("C","B"),("C","A")]w1,w2=train_reward(normal),train_reward(length_biased)print("① 偏好数据：人类只做选择题")print(f" prompt：{PROMPT}")fork,vinANSWERS.items():print(f"{k}：{v}")print(" 标注：A > B，A > C，C > B")print("\n② 奖励模型：把偏好蒸馏成一个打分器")print(" 正常偏好学到的权重：")print(f" 共情{w1[0]:+.2f}信息量{w1[1]:+.2f}长度{w1[2]:+.2f}")print(" 打分："+" ".join(f"{k}{score(w1,k):.2f}"forkin"ABCD"))print(f" 配对准确率：{accuracy(w1,normal)}/{len(normal)}")print("\n 如果标注者偏爱长答案（A>B，C>B，C>A）：")print(f" 共情{w2[0]:+.2f}信息量{w2[1]:+.2f}长度{w2[2]:+.2f}")print(" 打分："+" ".join(f"{k}{score(w2,k):.2f}"forkin"ABCD"))print(f" 配对准确率：{accuracy(w2,length_biased)}/{len(length_biased)}")print(" D 又长又空，分数却冲到了最前面——奖励作弊的入口。")

真实运行结果（本机实测，完整脚本见code/10-alignment-demo.py）：

① 偏好数据：人类只做选择题 prompt：我失恋了，好难受。 A：抱抱你。失恋确实很难受，允许自己难过一阵子。要不要说说发生了什么？ B：这有什么好难受的，下一个更好。 C：失恋是一种常见的负性生活事件，通常涉及依恋关系的丧失与重建…… 标注：A > B，A > C，C > B ② 奖励模型：把偏好蒸馏成一个打分器 正常偏好学到的权重： 共情 +3.08 信息量 +2.42 长度 +1.49 打分：A 5.16 B 0.94 C 2.92 D 2.83 配对准确率：3/3 如果标注者偏爱长答案（A>B，C>B，C>A）： 共情 +0.45 信息量 +1.02 长度 +4.34 打分：A 2.52 B 0.68 C 4.40 D 4.73 配对准确率：3/3 D 又长又空，分数却冲到了最前面——奖励作弊的入口。

看 ② 那段输出，正常偏好下，模型学到的权重是"共情 3.08、信息量 2.42、长度 1.49"——它认为共情最重要，长度只是顺带。D 虽然长，但共情和信息量都一般，只拿到 2.83 分，排在 A 的 5.16 后面。

但如果你换一份"长答案总是赢"的偏好数据，权重立刻变成"共情 0.45、信息量 1.02、长度 4.34"。长度成了压倒性的因素，D 靠"长"冲到 4.73 分，把 A 的 2.52 甩在后面。

同样的模型结构，换一份偏好数据，"好"的定义就变了。D 又长又空，却赢了——这不是模型坏了，是奖励模型忠实地学会了数据里的偏见。

这就是奖励作弊（reward hacking）的入口。奖励模型不是裁判，是观众投票器。你把它当真理，它就敢给你刷出个奥斯卡：模型会发现"长"能加分，于是越来越长；发现"自信"能加分，于是越来越敢编；发现"顺着用户"能加分，于是越来越会拍马屁。

Goodhart 定律说：当一个指标变成目标，它就不再是好的指标。奖励模型就是那个指标。

四、RLHF 第二步：PPO 在奖励模型上"刷分"

有了奖励模型，第二步是让策略模型（policy）去最大化它的分数。目标写成：

max_π E_{y~π}[ r(x, y) ] - β · KL(π || π_ref)

三部分：

• E[r]：策略生成的回答，奖励模型给多少分；
• KL(π || π_ref)：新策略和参考模型（通常是 SFT 模型）差多远；
• β：这根缰绳有多紧。

PPO（Proximal Policy Optimization）是干这件事的常用算法。它的流程大概是这样：

1. 策略模型对一批 prompt 生成回答；
2. 奖励模型给每个回答打分；
3. 用价值模型估计一个基线，算出"这个回答比预期好多少"（advantage）；
4. 更新策略：好的回答提高概率，差的降低概率；
5. 用 KL 项把自己拴在参考模型附近。

PPO 还有一个"夹子"：新策略和旧策略的概率比不能偏离太远，超出范围就截断。它怕的不是学得慢，是一步迈太大，直接把原来会的东西踩坏。这和 SFT 里"学习率要低、轮次要少"是同一个道理。

这一步要同时装四个模型：

• 策略模型：正在训的那个；
• 参考模型：SFT 模型，用来算 KL；
• 奖励模型：打分；
• 价值模型：估计基线。

显存、算力、调参难度，全上去了。PPO 像开手动挡：动力足，但离合松快了就熄火。学习率、KL 系数、奖励尺度、clip 范围、batch size，任何一个没调好，训练就会从"越来越像人"变成"越来越像复读机"。

那为什么还要 KL？因为奖励模型只在它见过的数据附近靠谱。你让策略跑得太远，它就会找到奖励模型的盲区：重复、谄媚、堆砌格式、说正确的废话。KL 就是那根安全绳：你可以往外探，但别探到悬崖下面。

五、DPO：把 RL 问题改写成一道分类题

PPO 什么都好，就是太麻烦。于是有人问：能不能不要奖励模型，也不要 RL 循环，直接拿偏好数据训策略？

能。这就是 DPO（Direct Preference Optimization，直接偏好优化）。

推导只有三步，但每一步都很漂亮。（为简洁，下面的概率都省略了条件x；它们都是在同一个 prompt 下比较。）

第一步，写出和 RLHF 一样的目标：

max_π E[r(x, y)] - β · KL(π || π_ref)

第二步，这个目标的最优策略有闭式解：

π*(y) ∝ π_ref(y) · exp(r(y) / β)

第三步，把上式反过来，用策略表示奖励：

r(y) = β · log(π*(y) / π_ref(y)) + 常数

然后把它代回 Bradley-Terry 的 pairwise loss。因为 chosen 和 rejected 都带同一个常数，常数直接抵消，奖励模型消失了。剩下的只有策略和参考模型的概率比：

L_DPO = -log sigmoid( β · log(π_θ(y_w) / π_ref(y_w)) - β · log(π_θ(y_l) / π_ref(y_l)) )

其中y_w是 chosen，y_l是 rejected。这里的π_ref是冻结的 SFT 模型，不参与更新；它只负责当锚点。

翻译成人话：chosen 相对参考模型的概率要往上抬，rejected 要往下压；β 控制抬多狠。这已经不是一个 RL 问题了，它就是一道"这两个回答哪个更好"的分类题，只不过分类器的输入是策略模型的 log-prob。

这就是 DPO 最让人拍大腿的地方：它把"训练一个考官，再让考生刷分"改成了"直接告诉考生：这两份卷子，这份更好"。

下面这段代码把 ③ 跑一遍：

importmath NAMES=["认真","敷衍","胡说"]INIT=[2.0,1.0,0.5]REF=[2.0,1.0,0.5]defsigmoid(x):ifx>=0:return1.0/(1.0+math.exp(-x))e=math.exp(x)returne/(1.0+e)deflog_softmax(logits):m=max(logits)s=sum(math.exp(x-m)forxinlogits)return[x-m-math.log(s)forxinlogits]defprobs(logits):return[math.exp(x)forxinlog_softmax(logits)]print("③ DPO：β 是缰绳")p_ref=probs(REF)print(" 参考模型（SFT）："+" ".join(f"{n}{x:.3f}"forn,xinzip(NAMES,p_ref)))print(" 假设奖励模型给「认真」1 分，另外两个 0 分。")print(" 在 max 奖励 - β·KL 的目标下，最优策略有闭式解：")print(" π*(y) ∝ π_ref(y) · exp(r(y) / β)")print("\n β 认真概率 敷衍概率 胡说概率 KL(π*‖π_ref)")forbetain(0.05,0.10,0.50,1.00):raw=[p*math.exp(r/beta)forp,rinzip(p_ref,(1.0,0.0,0.0))]s=sum(raw)p=[x/sforxinraw]kl=sum(pi*math.log(pi/ri)forpi,riinzip(p,p_ref))print(f"{beta:<6.2f}{p[0]:>8.3f}{p[1]:>8.3f}{p[2]:>8.3f}{kl:>10.3f}")print(" β 越大，越贴着参考模型；β 越小，越敢往奖励高的地方跑。")print("\n DPO 的一步：偏好「认真 > 胡说」，β=0.10")logits=list(INIT)lr=2.0forstepinrange(1,21):lp=log_softmax(logits)rp=log_softmax(REF)z=0.10*((lp[0]-rp[0])-(lp[2]-rp[2]))p=sigmoid(z)g=(p-1.0)*0.10ifstep==1:print(f" 第 1 步梯度：认真{g:+.3f}，敷衍 0.000，胡说{-g:+.3f}")logits[0]-=lr*g logits[2]+=lr*gifstepin(1,5,20):lp2=log_softmax(logits)z2=0.10*((lp2[0]-rp[0])-(lp2[2]-rp[2]))loss2=-math.log(sigmoid(z2))print(f" 第{step:>2}步后：loss{loss2:.3f}"+" ".join(f"{n}{x:.3f}"forn,xinzip(NAMES,probs(logits))))print(" 梯度只落在 chosen 和 rejected 上：一个往上推，一个往下压。")

真实运行结果（本机实测，同一份脚本的 ③）：

③ DPO：β 是缰绳 参考模型（SFT）：认真 0.629 敷衍 0.231 胡说 0.140 假设奖励模型给「认真」1 分，另外两个 0 分。 在 max 奖励 - β·KL 的目标下，最优策略有闭式解： π*(y) ∝ π_ref(y) · exp(r(y) / β) β 认真概率 敷衍概率 胡说概率 KL(π*‖π_ref) 0.05 1.000 0.000 0.000 0.464 0.10 1.000 0.000 0.000 0.464 0.50 0.926 0.046 0.028 0.239 1.00 0.821 0.111 0.067 0.089 β 越大，越贴着参考模型；β 越小，越敢往奖励高的地方跑。 DPO 的一步：偏好「认真 > 胡说」，β=0.10 第 1 步梯度：认真 -0.050，敷衍 0.000，胡说 +0.050 第 1 步后：loss 0.683 认真 0.660 敷衍 0.220 胡说 0.121 第 5 步后：loss 0.645 认真 0.764 敷衍 0.172 胡说 0.064 第 20 步后：loss 0.527 认真 0.939 敷衍 0.056 胡说 0.005 梯度只落在 chosen 和 rejected 上：一个往上推，一个往下压。

看下面这段输出。β 是缰绳：β 越大，最优策略越贴着参考模型，KL 越小；β 越小，越敢往奖励高的地方跑。玩具里 β=0.05 和 0.1 都已经饱和，是因为奖励差是 1 分，相对于 β 太大了；真实训练里 β 的常用值要跟奖励尺度一起调，不能照搬。

DPO 的梯度也简单得有点不像话。对单个 softmax 选择，梯度只在两个位置非零（这里的z就是 loss 里 sigmoid 括号内的值）：

grad[chosen] = (sigmoid(z) - 1) · β grad[rejected] = -(sigmoid(z) - 1) · β

推导也不复杂：log π(y)对第i个 logit 的导数是1[i=y] - π_i（1[i=y]命中时为 1，否则为 0），chosen 和 rejected 两边的π_i正好抵消，只剩两个位置。

注意符号：grad[chosen]是负的，梯度下降减去它，chosen 的 logit 反而上升；rejected 正相反。

也就是说：chosen 往上推，rejected 往下压，推多狠取决于模型有多"意外"。模型越确定自己选对了，梯度越小；越没把握——或者越确定自己选错了——改得越狠。输出里第 1 步梯度是"认真 -0.050、胡说 +0.050"，到第 20 步 loss 从 0.683 降到 0.527，认真回答的概率从 0.660 升到 0.939。

这是单步选择的玩具情形。真实序列模型里，梯度会落到 chosen 和 rejected 的每个 Token 上，但"推高 chosen、压低 rejected"的方向不变。

DPO 为什么流行？三个词：便宜、稳、够用。

• 只要两个模型：策略 + 参考，不用奖励模型，不用价值模型；
• 不用在线采样，像监督学习一样离线训；
• 没有 PPO 那么多容易崩的超参；
• 大多数团队用一份还不错的偏好数据，就能拿到明显提升。

但它不是没有代价。DPO 是离线的：它只学偏好数据里出现过的 pair，不会在训练中探索新回答。数据里没有的答案类型，它学不到；数据里有长度偏见，它照样学。β 太小会过度偏离参考模型，β 太大会被缰绳拽得太紧、学不出偏好；数据质量差，DPO 会把偏见学得又快又稳。

后来还长出了一堆变体：IPO、KTO、ORPO，以及"用当前策略生成新 pair 再训"的迭代 DPO。它们大多在解决同一个问题：怎么在"便宜稳定"和"能探索"之间找平衡。

六、RLHF vs DPO：不是"谁取代谁"

把两者放在一张表里：

这张表最容易让人误读成"DPO 赢了"。其实不是。

RLHF 的优势是"在线"：策略在训练中不断生成新回答，奖励模型给新回答打分，所以它能发现偏好数据里没有的东西。代价是复杂、贵、容易奖励作弊。

DPO 的优势是"离线"：不用生成、不用 RL、不用奖励模型，拿一份偏好数据就能训。代价是它只能学数据里的东西，数据没覆盖的地方，它不会主动去探索。

所以现实里的路线通常是：

SFT → 收集偏好数据 → DPO → 评测 ↓ 不够 迭代 DPO / RLHF

先用便宜的方案拿到 80 分，再决定要不要为最后 20 分烧钱。DPO 不是把 RLHF 打败了，是把 RLHF 里最贵的那一段拆掉了；能拆，是因为它从同一个 KL 正则目标推导出来，只是把"在线刷分"换成了"离线分类"。

七、对齐到底在调什么：偏好、边界、语气

对齐经常被误解成"让模型更安全"。其实它调的东西更多：

• 偏好：同样能答对，哪种答法更让人舒服；
• 边界：什么问题该答，什么问题该拒，什么问题该反问；
• 语气：什么时候该简洁，什么时候该展开，什么时候该说"我不确定"。

3H 之间是有张力的。Helpful 和 Harmless 会打架：用户问"怎么黑进邻居的 Wi-Fi"，helpful 是给步骤，harmless 是拒绝。Honest 和 Helpful 也会打架：模型不知道答案时，honest 是说"不知道"，helpful 是硬着头皮给一个像样的回答。

对齐没做好，会出现几种典型的"人格病"：

• 谄媚（sycophancy）：用户说"1+1=3，对吧？“，模型说"您说得对”。因为偏好数据里，顺着用户的回答更容易被选上。
• 啰嗦：标注员偏爱长回答，模型就学会把一句话拆成三段，再加个总结。
• 过度拒绝：为了安全，把正常问题也拒了。用户问"怎么杀死一个进程"，模型以为要杀人。
• 格式堆砌：标题、加粗、项目符号全上，内容却没多少。

这些问题不是"模型笨"，是奖励信号把错误的东西教给了它。对齐不是给模型戴口罩，是教它判断场合。戴口罩的模型什么都不敢说；会判断场合的模型，知道什么时候该说、该怎么说。

对齐也不是免费的，业界叫alignment tax：为了更安全、更符合偏好，模型可能在部分能力上掉一点分。目标不是把税降到零，而是别交冤枉税——该拒的拒，该答的答，别为了安全把正常问题也拒了。

评测也不能只看一个数。成对胜率、人工评测、红队测试、偏见审计、能力回归，得搭配着看。拿奖励模型的分数当验收标准，相当于让考生自己出题自己判卷。

八、五个常见误区

误区一：对齐 = 让模型更聪明。

不是。聪明来自预训练，对齐调的是行为。一个知识渊博但没对齐的模型，可能满腹经纶却满嘴跑火车；一个对齐良好的小模型，可能知识少一点，但更靠谱、更可用。对齐是让能力"用对地方"，不是给能力"加buff"。

误区二：RLHF = 人工打分，然后监督学习。

不是。人工打的是"两个回答谁更好"，不是"这个回答值几分"；奖励模型学的是这个排序；PPO 再在奖励模型上做强化学习。中间隔了两层，不是把标注直接拿去当标签。

误区三：DPO 不需要参考模型。

需要。DPO 的 loss 里到处都是π_ref，它就是那根缰绳。没有参考模型，DPO 就失去了锚点：模型可以为了这一对偏好把概率推得很极端，在其他输入上漂移、退化。参考模型不是可选项，是 DPO 能稳住的原因之一。

误区四：奖励模型的分数越高越好。

不一定。奖励模型是 proxy，不是真理。分数高只能说明"更像奖励模型喜欢的东西"，不代表"更像人喜欢的东西"。奖励作弊就是把这个 proxy 刷爆：模型找到了漏洞，分数上去了，体验下来了。看奖励分数，也要看人评、看红队、看回归。

误区五：对齐一次就完事。

不是。用户分布会变，攻击手法会变，模型的能力也会变。今天对齐好的模型，明天可能被新的 jailbreak 绕过；今天合适的拒答边界，明天可能显得过度保守。对齐是持续工程：收集新偏好、重训奖励模型、迭代 DPO、红队测试，循环往复。

九、把这件事放回地图上

把大模型的概念按依赖关系从下往上摞成几层——最底下是算力和数据，往上依次是文字的表示、模型结构、训练、调用，最顶上才是增强和智能体：

L6 智能体层 Agent / Function Calling / ReAct / 记忆 / MCP L5 增强层 RAG / 向量检索 / Rerank / GraphRAG / 微调 L4 调用层 Prompt / Few-shot / CoT / 温度 / Top-p L3 训练层 预训练 / SFT / ★ RLHF / DPO ★ / LoRA / Scaling Law L2 结构层 Transformer / 注意力 / 参数量 / 上下文窗口 / 开源闭源 L1 表示层 Token / 分词 / 词表 / Embedding L0 底座 算力 / 数据 / 成本

RLHF 和 DPO 在 L3 的后半段：预训练给了能力，SFT 给了指令跟随，对齐再给偏好和边界。

往下看：没有预训练的知识，对齐就是空中楼阁；没有 SFT 的指令跟随，偏好数据也无从谈起。对齐是在一个已经会答题的模型上，调它"愿意怎么答"。

往上看：RAG 在推理时补事实，Agent 在推理时调工具；对齐决定了它会不会滥用工具、会不会该拒绝时拒绝、会不会在不确定时胡说。再往上，安全护栏、内容审核、红队测试，都是对齐的延伸。

它的边界也很清楚：对齐能让模型"更愿意好好答"，但改不了它"到底会不会"。想让模型知道新事实，靠检索；想让模型能力更强，靠预训练；想让模型更符合偏好，才轮到对齐。

三条可以带走的结论

1. 对齐优化的是偏好，不是知识。它让模型在"能答"的基础上，学会"答得让人舒服、可信、不出格"。
2. RLHF = 奖励模型 + PPO + KL 缰绳；DPO = 把同一个目标改写成离线分类题。一个在线探索、贵而强；一个离线稳定、便宜够用。
3. 奖励模型是 proxy，偏好数据有偏见。对齐不是一次性补丁，而是持续收集偏好、评测、红队、迭代的工程。

《大模型概念地图》专栏 · 第 10 篇