鱼皮AI导航
鱼皮AI导航
  • 主页
  • 社区
  • AI工具
  • AI知识库
  • AI提示词
  • MCP
  • Skills
  • AI学习资源
  • AI资讯
  • GitHub开源
登录/注册
站长：程序员鱼皮 老鱼简历 商务合作 增值电信业务经营许可证
2026 鱼皮AI导航 | 沪ICP备19026706号-6
5
1

AI 基础知识从 0.5 到 0.6—— Transformer 架构为何能统治AI领域？ - 学习笔记

反正没人会看
反正没人会看
2025-09-01 15:50
阅读 1216
反正没人会看
2025-09-01 15:50
阅读 1216

原文链接：AI 基础知识从 0.5 到 0.6—— Transformer 架构为何能统治AI领域？

AI 基础知识从 0.5 到 0.6—— Transformer 架构为何能统治AI领域？

seq2seq 任务

  1. seq2seq 任务是指将一个输入序列数据转换为另一个输出序列数据，不需要两个序列具有相同的长度或结构，是 自然语言处理（NLP） 的核心；
    1. 序列数据是指有顺序的数据集合，比如一句话中的文字、一段语音信号等。
    2. 典型的 Seq2Seq 问题包括：
      1. 机器翻译：输入中文句子 "非常感谢"，输出英文句子 "Thank you very much"
      2. 文本摘要：输入一篇长文章，输出简短摘要
      3. 问答系统：输入一个问题，输出一个答案
      4. 聊天机器人：输入用户消息，输出回复消息
  2. Seq2Seq 模型由两个主要组件组成：编码器（Encoder）和解码器（Decoder），其核心思想是“编码全局信息→解码逐步生成”；
    1. 编码器：负责处理输入序列，将其压缩成一个固定维度的上下文向量（context vector），该向量包含了输入序列的语义信息。
    2. 解码器：接收编码器产生的上下文向量，并基于此逐步生成目标序列。解码器通常是自回归（Autoregressive）的，即每一步的输出依赖于前面所有步骤的输出。
    3. afddfa2e76f1b90a4a67e556985da635.png
  3. 自回归是指模型在生成序列时候，每一步都依赖于之前已经生成的内容。
    1. 比如我们要生成一个序列： image.png 自回归模型的目标是根据前面的词预测下一个词的概率分布： image.png 因此自回归模型都是逐词生成、输出。

RNN 和 LSTM 的困境

在 Transformer 出现之前，Seq2Seq 编码器和解码器的实现主流方法是循环神经网络（RNN）和长短期记忆网络（LSTM）。

有记忆的序列处理 RNN

  1. 循环神经网络（Recurrent Neural Network，RNN）是一种专门设计用于处理序列数据的神经网络结构。与传统的前馈神经网络不同，RNN 引入记忆的概念，能够"记住"之前的信息，并利用这些信息影响下一步的输出。

RNN 工作流程

  1. RNN 在普通神经网络的基础上，引入了循环隐藏层（下图中间的圆），其核心特点是通过对序列数据进行逐步处理 。具体来说：
    1. 逐 token 处理：输入序列按时间步依次处理（如文本中的每个词），每个时间步的输入会与前一时刻的隐藏状态共同计算当前隐藏状态；
    2. 隐藏状态的记忆功能：隐藏层存储历史信息，每步的隐藏层不仅包含当前输入的特征，还整合了前一步的隐藏状态，形成对序列上下文的动态记忆；
    3. 输出生成：当前步的输出基于当前隐藏状态计算得出，因此输出结果既依赖于当前输入，也依赖于之前所有输入的历史信息；
    4. image.png

RNN 数学原理

  1. image.png RNN 中输出的计算依赖一个中间过程，称之为隐藏层，就是图中的 h
    1. RNN 中需要逐步计算输出，每一次输出的计算依赖上一步的输出。

在 seq2seq 中使用 RNN

  1. 08210fd15f4844d1129add60794741c5.jpg
    1. 在 seq2seq 架构中把 RNN 分别应用到编码器和解码器，如果是翻译任务
      1. 编码器是一个完整的 RNN 流程。
      2. 解码器同样是一个完整的 RNN 流程。
    2. 注意：编码器和解码器是两个独立的 RNN，单个 RNN 的输入输出过程并不是翻译的过程

RNN 的问题

  1. RNN 几个严重问题：
    1. 梯度消失和梯度爆炸
      1. RNN 使用链式法则反向传播误差，每一步都乘以权重矩阵的导数，导致梯度随着序列长度迅速衰减或激增。
        1. 如果权重矩阵的特征值小于 1，梯度会指数级减小 → 梯度消失；
        2. 如果特征值大于 1，梯度会指数级增长 → 梯度爆炸；
    2. 长距离依赖丢失
      1. RNN 只能记住短期依赖（Short-term Memory），对长序列中的早期信息几乎“记不住”
    3. 训练效率低
      1. RNN 是顺序处理的，每个时间步必须等前一个完成才能进行下一步计算，这样训练速度慢，难以利用 GPU 的并行计算优势，不适合大规模数据训练和实时应用。

LSTM & GRU 的优化

  1. 61553387f8ba5aa1ef254bb396014dc2.jpg
  2. LSTM（Long Short-Term Memory，长短时记忆）是 RNN 变体，专门设计用来解决传统 RNN 的长期依赖问题，LSTM 的核心是一个记忆单元（Cell State），通过精心设计的门控机制来控制信息的流动，这种设计使 LSTM 能够在长序列中保持重要信息，同时丢弃不相关信息，有效解决了梯度消失问题。
    1. 遗忘门：决定从细胞状态中丢弃哪些信息；
    2. 输入门：决定哪些新信息将被存储到细胞状态中；
    3. 输出门：决定基于细胞状态输出哪些信息；
  3. GRU（Gated Recurrent Unit）是 LSTM 的简化版本，合并了 LSTM 的遗忘门和输入门为一个更新门，并引入了重置门，使结构更加简洁，与 LSTM 相比，GRU 参数更少，训练速度更快，在某些任务上表现相当甚至更好。GRU的两个门控机制：
    1. 更新门：决定保留多少前一状态的信息和添加多少当前信息；
    2. 重置门：决定如何将新输入与前一记忆结合；
  4. 虽然 LSTM 和 GRU 在很大程度上缓解了 RNN 的梯度消失和短时记忆问题，但依然是串行处理模式，每一步的计算都依赖于上一步的结果，无法利用 GPU 的并行计算能力加速训练。而且在处理超长序列时，效率和性能仍然受限。

Transformer 工作流程

  1. 2017 年 Google 的研究团队提出了一个大胆的想法：能否完全抛弃循环结构，让模型直接关注序列中任意两个位置之间的关系？这就是 Transformer 的核心创新——自注意力机制（Self-Attention）；
    1. 出自 Attention is all you need 论文的 Transformer 架构图 e2e8708b8abe3115156e2cbd0d79ba38.jpg
    2. 简化的图 28d3aadb3a7c3106ad1702854370222b.jpg
  2. Transformer 和经典 seq2seq 架构一样使用了 Encoder-Decoder 模式，编码器负责理解输入序列，解码器把编码器的输出作为上下文，自回归输出目标序列，同样是一次编码、多次解码生成。
    1. 编码器一次编码：
      1. 输入序列会被转换成对应的词嵌入表示，每个 token 会被映射到一个连续的向量。然后，需要通过添加位置编码来保留输入序列的先后顺序信息，这样模型就能区分 A B 和 B A 的不同含义。
      2. 输入序列的词嵌入矩阵被送入模型，通过自注意力机制生成 Query（Q）、Key（K）和 Value（V）三个矩阵，这些矩阵是输入序列中各个 token 的特征表示。
        1. Q 矩阵负责提出问题（查询），K 矩阵负责提供信息（匹配），V 矩阵包含实际内容。自注意力机制会计算每个 token 对其他 token 的重要性，也就是注意力权重（Attention Weights），用这些权重对 V 矩阵进行加权求和，生成包含输入序列中每个 token 语义的上下文表示。
        2. 因为只编码一次，编码器生成的语义矩阵在结果过程中不再变化（KV 也不会变化）。
    2. 解码器逐 token 解码：
      1. 解码器会对历史生成的目标序列进行嵌入映射，将历史生成结果转化为向量表示。为了保留生成序列的顺序信息，还需要加上位置编码。如果是首次解码（没有历史目标序列），则会使用特殊的起始标记 <SOS>。
      2. 经过嵌入和位置编码后，目标序列被送入掩码自注意力模块。掩码的作用是确保当前时间步只能看到已生成的历史序列，而不能访问未来的 token，严格遵守自回归生成的规则。
      3. 掩码自注意力会生成一组新的上下文表示矩阵，描述了解码器目前所有生成序列的内部关系，并作为对目标序列的特征提取结果。
      4. 解码器进一步通过跨注意力模块，与编码器生成的语义矩阵关联以获取来自输入序列的上下文信息；
        1. 解码器使用掩码自注意力的结果，生成用于与编码器交互的查询表示（Query）。这个 Query 表示当前生成序列的需求或问题。
        2. 编码器的语义矩阵则通过固定的变换生成 Key（键）和 Value（值），表示输入序列中的全局信息。
        3. 解码器的 Query 会从编码器输出的 Key 中查询相关的信息，同时结合 Value 形成新的跨序列上下文信息。因为信息来自不同序列，这个操作被称为跨注意力。
      5. 跨注意力模块的输出被进一步处理，生成解码器最终的语义矩阵，这个矩阵用于预测当前时间步目标 token 的分布，通过采样或搜索方法解码器生成下一个单词。
      6. 最后，生成的新 token 会添加到历史生成序列中，更新为解码器的输入序列。解码器重复以上步骤，直到遇到特殊结束标记 <EOS>，整个目标序列生成完成。

Transformer 实现

Embeding 与位置编码

  1. Transformer 架构本身不包含序列位置信息，因为自注意力机制对输入序列的顺序是不敏感的，这在很多时候会导致歧义；
    1. 为了让模型能够利用序列的顺序信息，Transformer 引入了位置编码。位置编码通过为每个位置生成唯一的编码，并与词嵌入（Word Embedding）结合，使模型能够区分相同 token 在不同位置的语义差异。

什么是注意力

  1. 注意力机制的本质：在理解当前词时，关注与其相关的其他词；
    1. 想象你在阅读这样一个句子："那只猫坐在垫子上，它看起来很舒服"，当你读到"它"时，你的大脑会自动回到前面找到"它"指代的对象——"猫"，这种能力就是注意力机制的本质；
    2. 最早由 Bahdanau 等人于2014年提出，用于解决 RNN 在编码器-解码器架构中的长期依赖问题；但传统注意力机制通过逐步传递信息，但受限于距离和计算效率，难以有效捕捉远距离关联；
  2. Transformer 摒弃了 RNN 和 CNN，提出了自注意力机制，对序列中的每个元素（token）与序列中所有其他元素之间的关系进行建模，用于捕获序列内元素之间的依赖关系。

    1. 换句话说，它让模型在处理某个 token 时，可以动态关注同一序列中其他对其有重要影响的 token；

    2. 8d155833ca93f9faba27b98aaac34ef3.png

      有点像是句子中的每个 token 是一个神经元节点，重复一遍形成两层，中间做了全连接，连线就是两个token 之间的影响。

注意力的实现 QKV

  1. 自注意力机制使模型能够关注输入序列 token 之间的相关性，从而使其能够捕捉数据中的复杂关系和依赖。现在我们知道了什么是注意力，但具体是怎么计算的呢？这就要引入 Transformer 的核心创新：QKV 机制。
    1. 上文中的嵌入矩阵 H 通过和权重矩阵（图片）线性变换得到三个矩阵：Query (Q)、Key (K)、Value (V) 1fb26b778d51997aa1a44f17439ac3ae.png
    2. QKV 有什么作用？
      1. Query：是每个 token 提出的“问题”向量，比如一个单词想知道序列中其他单词对其影响。
      2. Key：是每个单词的“标签”向量，告诉其他位置，它和哪些 token 是相关的。
      3. Value：是每个单词的语义内容，它是最终被注意力加权取回的信息。
    3. 想象一下在一个图书馆找一本书：
      1. 你要找一本书，你的问题是 Query：你会问图书管理员一个关于书的信息，比如：“哪一本书讲关于人工智能的基础知识？”
      2. 图书馆的目录卡片是 Key：图书馆里每本书会有一个目录卡片（对应于 Key），这张卡片告诉你这本书包含什么内容。
      3. 图书内容是 Value：图书的 Key 告诉你是它关于什么的，而书的内容 Value 是它实际含有的信息。
    4. 注意力的匹配过程：
      1. 你的问题 (Query) 会与所有书的目录卡片 (Key) 匹配（通过点积计算相关性）。
      2. 找到最符合你问题的 Key，图书管理员会把相应的图书 (Value) 借给你。

从 QKV 到语义表示

  1. QKV 矩阵并不能表示 Token 和其他 Token 的相关性，从 QKV 矩阵到最终语义表示有一个计算过程。
    1. 计算 Query 和 Key 的相关性
      1. 每个 token 的 Query 和所有 token 的 Key 做矩阵乘法运算，计算出它对其他 token 的相关性。这会生成一个二维矩阵，即注意力分数矩阵（Attention Scores）；
    2. 缩放和归一化
    3. 加权求和获得最终语义矩阵

跨注意力与掩码自注意力

  1. 自注意力用于计算序列中每个 token 与其他 token 的关系——即实现序列内部的依赖关系建模。简单来说，每个 token 都可以“关注”同一输入序列的其他 token，从所有 token 中提取有用的信息并重新生成上下文敏感特征。
  2. 掩码自注意力是一种限制版的自注意力机制，用来解决目标序列的因果性（causality）问题。在解码器生成目标序列时，模型需要严格遵循时间步的自回归逻辑，确保生成当前 token图片时，只能访问之前的 token，而不能看到未来 token。

多头注意力

  1. 多头注意力（Multi-Head Attention）——输入序列被分到多个子空间，每个子空间独立计算自己的注意力表示；
    1. 多头注意力的核心思想是并行地在多个子空间中计算注意力表示，每个头独立学习特定的关系模式，并在最后通过拼接融合生成最终的上下文特征；
      1. 每个头分别计算自己的注意力
      2. 拼接这些注意力输出
      3. 最后通过线性变换
    2. 模式使用多头注意力后有几个明显的优点：
      1. 丰富表征能力：不同的注意力头独立计算，捕获多样化的语义、语法关系。
      2. 高效的计算：并行化支持多头计算，同时降低复杂度。
      3. 增强模型稳定性：通过冗余和分散化处理，降低单点故障的影响。

遗漏的关键步骤

  1. 前馈网络：对每个 token 的特征表示进行进一步的非线性变换和特征提取；
  2. 残差连接与归一化：稳定梯度流并加速模型收敛；
    1. 残差连接：将模块的输入和输出相加，形成新的表示；
    2. 归一化：对每层的输出进行归一化处理，使得数据分布更加稳定，便于后续层的处理；
  3. 多层堆叠：编码器堆叠多层（6 层或 12 层），每一层包括自注意力机制、前馈网络和残差连接与归一化。每一层的输出作为下一层的输入，经过逐层处理最终得到编码器的全局语义表示。
    1. 编码器堆叠 N 层：多层次处理输入序列，通过堆叠逐步捕获更深的上下文信息，使得输入序列的特征向量更表达语义和语法。
    2. 解码器堆叠 N 层：在生成序列时，每层逐渐从已生成的序列中综合更多的上下文信息，同时将目标序列与编码器输出对齐，真正实现高质量的跨语言/跨序列建模。

Transformer 的优势

  1. Transformer 相较于传统的 RNN（包括 LSTM 和 GRU）为基础的 Seq2Seq 模型，在多个方面具有显著的优势：
    1. 并行运算
      1. RNN 的设计是循环递归的，每个时间步的计算依赖于前一个时间步的输出。这种顺序计算方式阻碍了模型在长序列上的并行化处理，导致训练和推理过程速度较慢。
      2. Transformer 完全摒弃了递归计算，使用掩码自注意力机制在训练阶段能够同时对整个序列进行处理，加速模型训练过程。
    2. 长距离依赖
      1. RNN 越往后传播，模型的隐藏状态可能丢失早期输入的信息，尽管 LSTM、GRU 等通过“门控机制”稍微缓解了这个问题，但在捕获长距离依赖时仍显乏力。
      2. Transformer 通过自注意力机制，每个 token 都能直接与整个序列中的所有 token 建立联系，全局感知能力极大提高了对长序列上下文的理解能力。
    3. 丰富的特征表示
      1. RNN 的隐藏状态是单一维度的时间步相关表示，难以建模复杂的句法和语义模式。
      2. 多头注意力机制让 Transformer 可以从多角度捕获语义特征，更全面地表示复杂的信息依赖。
  2. Transformer 在计算效率、长距离依赖建模、特征表示能力和任务泛化性等方面全面优于 RNN Seq2Seq，彻底颠覆了序列建模的传统方式，成为现代 NLP 和更广泛任务中的核心架构。

常见 Transformer 架构模型

T5：Transformer 正统

  1. T5（Text-to-Text Transfer Transformer）是由谷歌提出的一种采用 Encoder-Decoder 结构的 Transformer 模型。其核心思想是通过将所有 NLP 任务统一建模为“文本到文本（text-to-text）”问题，将输入视为自然语言文本，将输出作为目标文本序列。
    1. T5 使用经典的 Transformer 架构：输入 → [Encoder] → 语义表示 → [Decoder] → 输出。由于其架构严格遵循 Transformer 的标准设计逻辑，因此可以称之为“Transformer 正统”模型。
    2. T5 能适配翻译、摘要、问答和分类等多种任务类型，尤其擅长处理输入与输出存在明确语义映射关系的任务。

GPT：Decoder-Only

  1. GPT（Generative Pre-trained Transformer）任务核心是从给定的上下文中预测下一步的内容，并不涉及对额外输入的深度理解。因此 GPT 只使用了 Transformer 的 Decoder 部分，输入的序列会直接进入 Decoder，作为“历史输出”的一部分（标准 Transformer Decoder 初始输入序列是 <SOS>），参与注意力计算和生成下一步 Token，通过多头注意力机制对输入序列解析和建模上下文，然后自回归生成，这使得 GPT 架构极其简单、高效。
    1. 在 GPT 中没有了编码器，首先会把用户输入当做初始化的历史输出，使用掩码注意力机制生成 QKV 矩阵，然后预测下一个 token，直到遇到结束符 <EOS>，这就是 GPT 的单向注意力。这个机制也正是 GPT 类模型幻觉相对严重，擅长生成而不擅长理解的原因。
  2. 如果我们要求 GPT 根据 "Once upon a time, in a magical forest, there lived a brave little rabbit." 生成一个童话故事，简化版的工作流程是这样的：
    1. 输入准备：将输入序列分词为小单位（Token），转化为向量表示，并加入位置信息。
    2. 初始化上下文：模型将开头提示作为上下文，视为“历史输出”，用于开始生成后续内容。
    3. 单向注意力处理：模型通过自注意力机制分析输入，并使用遮掩机制仅关注当前和之前的内容，确保生成过程是从左到右的。
    4. 前馈网络计算：注意力处理后的结果通过前馈神经网络进行进一步特征提炼，输出更新后的上下文表示。
    5. 预测下一个词：
      1. 模型基于上下文预测下一个词的概率分布，例如可能是 "The", "rabbit", "explored", "a", 等选项。
      2. 根据生成规则（如 Greedy Search 或采样），选择最优词，例如 "explored"。
    6. 循环生成：将生成的词 "explored" 添加到上下文，重复上述过程，生成后续内容；
    7. 结束生成：模型会继续生成，直到遇到结束符 <EOS>，或达到最大生成长度；
    8. 输出完整故事：最终生成的词序列被解码为自然语言；
  3. 这是 GPT 的完整架构，相对于经典的 Transformer 确实比较简单 9533612f85f6459f3c3d834ab3ec86e9.png
  4. Decoder-only 模型的核心是单向注意力机制（Causal Attention）。这意味着模型在生成序列中的当前词时，只能关注其前面的词，而不能看到其后面的词。这种设计非常适合生成任务，因为生成文本本质上是一个从左到右、逐步预测下一个词的过程。模型通过学习前面词的模式来预测后续词，从而连贯地生成文本。 然而，这种单向性限制了模型对文本整体语境的理解。在理解任务（如情感分析、问答、文本摘要等）中，通常需要模型能够同时考虑文本的上下文信息，包括当前词前后的所有词。
    1. 例如，要理解一句话的情感，模型需要同时分析正向和负向的关键词，以及它们在句子中的排列方式。单向注意力机制使得模型难以像人类一样“通读”并全面把握文本的含义。

BERT：Encoder-Only

  1. **BERT（Bidirectional Encoder Representations from Transformers）是由谷歌提出的一种专注于自然语言理解（NLU）**的 Encoder-Only 架构的 Transformer 模型；
    1. BERT 的核心目标是：将输入文本通过双向编码器形成深层语义表示，用于丰富地捕捉上下文依赖关系。
    2. BERT 的双向注意力在计算每个单词的表示时，同时结合了句子中左侧和右侧的上下文信息，对比单向模型（如 GPT），BERT 能理解更加全面的语义关系。
    3. BERT 只使用了 Transformer 的 Encoder 部分，摒弃了生成式任务相关的 Decoder。其参数通过大规模预训练进行优化，输入 → [双向 Encoder] → 深层语义表示。
  2. BERT 特别强调“双向注意力” 的原因，并不仅仅是使用 Encoder 部分的自注意力机制，而是它对模型的训练方式和设计目标进行了特殊优化。BERT 在大规模无标签语料上进行预训练，采用了两个创新的预训练目标：
    1. Masked Language Modeling（MLM）：掩码语言模型
      1. 在训练阶段，随机遮掩（Mask）输入序列中的部分单词（用 [MASK] 替换），然后让模型同时关注该词的左侧上下文和右侧上下文来预测掩码的词，这种方式使 BERT 学会结合双向建模。
    2. Next Sentence Prediction（NSP）：下一句预测
      1. 给定两个句子 A 和 B，让模型判断 B 是否是 A 的下一句。这有助于学习句子之间的逻辑关系。
  3. 由于 BERT Encoder-Only 架构 和强大的语义建模能力，BERT 特别擅长理解类任务，主要应用于以下领域：
    1. 自然语言理解任务
      1. 文本分类：情感分析、主题分类等。
      2. 文本相似性：句子对分类任务（如自然语言推断NLI、问句匹配）。
      3. 问答系统：基于上下文提取答案（机器阅读理解任务，例如 SQuAD）。
      4. 信息检索（IR）：根据用户查询从文档中提取相关内容。
    2. 语言学相关任务
      1. 核心语义分析：例如语法关系解析、命名实体识别（NER）。
      2. 样本不足任务：通过预训练语义表示在小数据集下迁移学习。

ViT：无 CNN 视觉任务处理

  1. ViT（Vision Transformer） 是一个将 Transformer 架构成功应用于图像处理的模型，由谷歌研究团队在论文“An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale”中提出。
    1. 传统的 CNN 在图像处理上采用卷积操作（Convolution）来提取局部特征。而 ViT 则完全摆脱了卷积操作，通过使用 Transformer 的 自注意力机制（Self-Attention），直接对图像进行全局建模。
    2. ViT 的核心想法是将图像处理任务（如分类）转化为像文本处理一样的“序列任务”，即通过将图像分成小块（patches）并线性展平，作为序列输入到经典的 Transformer 中进行处理。它颠覆了传统的卷积神经网络（CNN）在图像领域占主导地位的局面，是视觉任务的重要突破。
AI
学习笔记
5
1
分享
操作
评论
相关内容
0个评论
全部评论
点击登录，快来和大家讨论吧～
表情
图片
🔥热门工具
朱雀AI检测朱雀AI检测
朱雀AI检测助手朱雀AI检测助手
LovartLovart
老鱼简历老鱼简历
WritePass官网WritePass官网
面多多面多多
CursorCursor
星月写作星月写作
零感AI零感AI
墨得问题墨得问题

目录

🔥 热门文章
1
手把手教你设计一个成熟的 Agent Harness
2510
2
我用 REA 逆向了付费颜色 APP，结果很意外！
570
3
离谱，DeepSeek 崩了 5 小时，大家却喊：梁圣恩情还不完？？
420
4
DeepSeek 全新模型发布，性价比最高的一集！
380
5
B 站上 DeepSeek 闹鱼灾了，我发起《大肥鱼清除计划》！
370
6
自己学习ai，直接买cursor 的套餐，还是买gpt 或者claude 的套餐?
360
7
又一个国产版 Codex 神器，也来卷办公了！
330
8
day3-如何写出一个高质量的 Skill（组内分享） 高质量 Skill 不是“一个调得很顺的巨型 Prompt”，而是一个可验证、可回归、可维护的能力包。 先定义“什么算好”，再实现“怎么做好”。评估体系先于 Skill 本身成型。 下面用“故障诊断 Markdown 转 YAML”作为例子，但方法是通用的。 --- 一、先想清楚：Skill 到底是什么 一个 Skill 至少包含四部分： 部分 作用 接口 输入什么、输出什么、边界在哪 流程 分几步做，每步的产物是什么 规则 硬约束、经验规则、失败模式 降级策略 不确定时怎么办，而不是硬编一个看似合理的结果 高质量 Skill 的共同点：职责单一、接口清晰、规则可定位、输出可验证。 反例：把几十条经验全塞进一个主 Prompt，改一条规则要重调整个 Prompt，评估时也不知道是哪条规则退化。 --- 二、核心方法：先建评估，再写 Skill 不要先写转换器再补测试。正确顺序是： 1. 定义输出契约：什么算合法、什么算合格； 2. 建金标准集：一小批人工认可“可放行”的样本； 3. 先写评估 Skill：让它在金标准集上跑出基线； 4. 再迭代生成 Skill：每次修改跑同一套评估，无退化且目标维度提升才算正向。 这就是评估驱动开发：评估是 Skill 的单元测试，金标准集是回归锚点。 --- 三、评估 Skill：三层门禁，逐层递进 前一层不过，后一层不跑。每层留可追溯证据。 第 1 层：确定性硬门禁 用解析器、Schema、校验器完成，不消耗模型成本。 · 输出可解析； · 必填字段齐全，类型/枚举合法； · 引用目标存在，无悬空引用、无不可达节点； · 关键路径至少有一条能到达预期出口。 不通过直接打回。 第 2 层：语义断言 用脚本 + 结构遍历检查“逻辑对不对”，仍然保持确定性。 通用检查项： · 覆盖率：源材料里的关键步骤、分支、条件，输出里是否都有对应？ · 完整性：每个判断节点是否都有明确出口？有没有死胡同？ · 可达性：每条路径是否都能到达预期终点？有没有无出口循环？ · 顺序与依赖：有先后依赖的操作，是否保留了顺序？有没有被拍平成无序列表？ 例子：故障诊断转换中，检查“每个判断项是否有是/否/异常出口”“每条路径是否能到根因”。 第 3 层：LLM-as-Judge 只处理解析器表达不了的维度：忠实度、完整性、可执行性。 但 Judge 会漂移，不能单独放行，必须建立在第 1、2 层之上。Judge 的 Prompt、rubric、模型版本都要版本化，换模型必须用金标准集重新校准。 通用 Judge 维度： 维度 问什么 忠实度 输出是否忠实源材料意图？有没有自行发明内容？ 完整性 关键步骤、条件、证据是否保留？隐式知识有没有被压成空话？ 收敛性 输出是否仍指向原目标，而不是发散？ 可执行性 下游不依赖源材料能否直接使用？ --- 四、金标准集：回归测试的锚点 不需要一开始就标注几百份。用已认可的样本当种子，扩到 15～30 份，覆盖失败模式而非随机抽样： · 完整正例：典型流程； · 边界/异常分支：异常路径、循环、前置失败回退； · 已知易错模式：实际踩过的坑； · 留出集：不参与调优，只用于最终验收，防过拟合。 金标准不需要完美，只需要当前标准下认可可放行。 回归指标：关键路径用 pass^k（k 次全过），稳定性用 pass@k。 --- 五、工程约束：让批量产出可重放 · 幂等：同输入 + 同 Skill 版本 + 同规则 → 输出一致，否则无法判断变好是 Skill 改了还是随机波动； · 隔离不阻断：单份失败进隔离队列，记录失败层和原因，不阻塞其余； · 版本绑定：规则、rubric、金标准集进 Git；每份报告绑定“源版本 + 生成 Skill 版本 + 评估 Skill 版本 + Judge 模型版本”； · 抽样人工复核：Judge 临界样本 + 易错模式，人工抽检结果反过来校准 rubric。 --- 六、Skill 本身怎么写 · SKILL.md 控制篇幅，写清：输入约定、输出契约、分步流程、硬规则、降级策略； · 经验规则放 references/ 或 rules/，按失败模式分类，不要全塞进主 Prompt； · 不确定时标 needs_review: true，不要硬编看似合理的结果； · 迭代由评估报告驱动：报告告诉你哪层挂了、哪类失败模式，你改对应规则文件，而不是漫无目的调 Prompt。 --- 七、落地顺序（不要反过来） 1. 固化输出契约：Schema + 结构约束； 2. 建金标准集：从已认可的 + 最易出错的样本开始； 3. 先写评估 Skill：跑出基线报告； 4. 再迭代生成 Skill：每次修改对比逐项通过率，无退化且目标提升才算正向； 5. 批量运行 + 隔离回放：失败进队列，结束后人工抽检； 6. 评估 Skill 自身版本化：换 Judge 模型必须重新校准。 --- 八、给组员的三条硬要求 1. 不许凭感觉说“变好了”：每次修改必须附评估报告对比，逐项通过率说话。 2. 不许跳过确定性门禁直接看 Judge 分数：前两层挂了，Judge 分数没有意义。 3. 不许把规则堆进主 Prompt：规则按失败模式分文件，评估报告要能定位到具体文件。 --- 一句话收尾 生成 Skill 决定“能不能做”，评估 Skill 决定“敢不敢用”。 先让评估体系站稳，再让生成器迭代。这样交付的不是一堆“看起来还行”的产出，而是一套可证明、可回归、可交接的 Skill 质量体系。
310
9
AI 越强，被它拒绝的代价就越大 我有时候会想：AI 越来越厉害之后，有些事情，会不会反而越来越难做？ 这个想法看起来有点矛盾。AI 明明在降低门槛，让不会写代码的人做出软件，让不会画画的人生成图片，让一个人完成过去需要整支团队才能完成的工作。但今天用 Codex 的时候，AI 拒绝帮我编写 SQL 注入的请求体，而那还是我有源码、在本地跑测试的情况。那么，往后是否只会更难？ 我们假设某一天，AI 说：「这个请求违规，我不能帮助你。」到那个时候，你还有多少能力，能绕过它，把事情做完？ 这里的「违规」需要打个引号。平台的规则、模型的判断、法律的要求，以及一件事实际有没有造成伤害，彼此之间并不总是画得上等号。一个请求可能确实危险，也可能只是缺少上下文被误判，或者恰好落在某家公司的限制范围里。 无论是哪种情况，随着我们越来越依赖 AI，这句拒绝都可能变得越来越贵。 今天，一个程序员让 AI 帮忙写代码，AI 拒绝了，他大概率还有别的办法：查文档、找开源项目、问同行，或者自己写。麻烦一点，慢一点，但路还在。 可如果十年之后，大部分程序都由 AI 完成，情况就不一样了。 很多人从接触编程的第一天起，就习惯了描述需求、等待生成、运行结果、继续迭代。他们能做出相当复杂的产品，却未必经历过独立处理底层问题的训练。平时，这种能力结构完全够用，效率甚至更高。只有 AI 拒绝的时候，他们才会发现：平常被省掉的那段学习过程，恰好是此刻最需要的东西。 到那时，一次拒绝的成本，可能就从「今晚多花两个小时」，变成「先花半年学会这门技术」。 拿 SQL 注入举个稍显极端的例子：往后，连真正理解这类攻击如何发生、能够独立构造测试的人，会不会也越来越少？ 这里也包括那些有正当需求的人。一个开发者想检查自己的旧系统，一个经过授权的安全研究员想复现漏洞，假如 AI 识别到危险模式就拒绝，而使用者又只熟悉「让 AI 帮我检查」，这项原本可以独立完成的工作，就这样卡住了。 但是安全专家不会因此消失，但这类技能可能越来越集中在少数人手里。你仍然可以找专家，只是要付出更多的钱、更多的时间，以及更高的沟通成本。 类似的困境，未必只发生在网络安全领域。 你想从一个停止维护的软件里取回自己的数据，需要解析它的旧文件格式。AI 判断这涉及规避保护措施，拒绝继续。你拥有这些数据，却没有能力把它们读出来。 你买了一台设备，厂商停止提供服务。你想修改程序让它继续运转，过程中需要处理某种访问限制。AI 不愿协助，而你所掌握的维修方式，早已只剩下「把报错发给 AI」。 你想给常用的网站写一个辅助工具，减少重复操作。平台将此归入自动化限制，AI 也据此拒绝。过去会写脚本的人可以自己判断、自己处理；未来的使用者，可能连从哪里开始都不知道。 这些例子有一个共同点：当工具同时承担了「执行工作」和「传授知识」的角色，它的拒绝就不只是挡住了一次任务，也挡住了获得这种能力的机会。 更麻烦的是，这种依赖往往是我们主动选择的，而且每一步都很合理。 既然 AI 几秒钟就能做好，为什么还要花几个月学习？既然公司可以采购成熟的 AI 服务，为什么还要养一支负责基础工作的团队？既然市场上已经很少有人手写这些东西，学校为什么还要花大量时间教？ 对个人、公司和学校来说，这些选择都有现实依据。但叠加起来，整个社会保留的独立能力就可能越来越少。等到某项能力突然受到限制，我们才发现，备用方案早已在追求效率的过程中被一点点削掉了。 所以，「AI 越强，做事越便宜」可能只描述了未来的一半。 另一半是：被允许的事情越来越便宜，被拒绝的事情依然需要人工完成，却要面对更少的人才、更高的报价，以及越来越难获得的知识。两边的成本差距，会越拉越大。 有人会说，可以换一个模型，或者用本地模型。这确实是重要的选项。只要工具之间还有充分竞争，开放模型还足够可用，限制就未必能形成真正的门槛。 但备用方案也需要维护。它需要硬件、知识、软件生态，以及一群仍然理解这些系统的人。如果大多数人已经习惯了最方便的商业服务，那么「理论上还有别的办法」和「普通人实际用得起、用得明白」，之间仍然可能隔着很远。 我担心的，正是这段距离。 我不指望 AI 对任何请求都照单全收。对明显会伤害他人的行为设置限制，有充分的理由。但我们也需要关心：限制由谁定义，误判有没有申诉渠道，用户能不能换工具，以及脱离这个工具之后，还剩下多少独立行动的能力。 保留这些能力，平时看起来甚至有点低效，明明可以自动生成，还要理解原理；明明可以一键完成，还要知道手动怎么做。 但这些看似多余的知识，会在工具拒绝、失效、涨价或改变规则的那一刻，成为真正的选择权。 AI 越强，我们可能越需要留意它说「不」的那一刻。 因为那句话的分量，最终取决于：它拒绝之后，我们还能做什么。
310
10
什么是LLM
300