一个问题给到大模型经历了哪些？

胖胖胖胖胖虎

72人浏览 · 2026-05-20 14:54:00

胖胖胖胖胖虎 · 2026-05-20 14:54:00 发布

请教一下：一个问题给到你，会发生什么请详细介绍一下中间过程

这个问题问得很好——从你按下发送键到我回复出现在屏幕上，中间发生了一整条精密的流水线。我拆成 *两大阶段*：Hermes Agent 层（工程调度）和 LLM 推理层（模型计算），层层剥开。

阶段 0：消息到达（Feishu → Hermes）

你在 Feishu 输入「请教一下：一个问题给到你...」
        │
        ▼
┌─────────────────────────┐
│  Feishu Open Platform   │
│  Event: im.message.receive_v1
│  ┌───────────────────┐  │
│  │ sender: 35398a72  │  │
│  │ msg_type: text    │  │
│  │ content: "请教..." │  │
│  │ chat_id: oc_ec... │  │
│  └───────────────────┘  │
└─────────┬───────────────┘
          │  HTTPS webhook (你的服务器 xxx.xxx.xxx.xxx)
          ▼
┌─────────────────────────┐
│  Hermes Agent           │
│  (Node.js Gateway)      │
│                         │
│  ① 验签（防伪造请求）    │
│  ② 反序列化消息体        │
│  ③ 判断：DM 还是群聊？   │
│     → DM, 消息类型 text  │
│  ④ 查 @mention 规则     │
│     → DM 不需要 @        │
│  ⑤ 创建 Session 上下文   │
└─────────┬───────────────┘

阶段 1：上下文装配（Hermes → Prompt 构造）

这是 Hermes Agent 最核心的工作——你看到的不是我「裸模型」的回答，而是被注入了大量上下文后的回答。

┌─────────────────────────────────────────────────────────────┐
│                  上下文装配流水线                               │
│                                                               │
│  ① 加载 System Prompt（人格定义）                              │
│     来源：Persona 文件（你自定义的 Hermes Agent Persona）       │
│     内容：                                                     │
│     ┌─────────────────────────────────────────────┐          │
│     │ "You have persistent memory across sessions" │          │
│     │ "You are in a Feishu workspace..."           │          │
│     │ "User prefers: 中文交流, 深度技术讨论..."      │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ② 注入 Memory（持久化记忆）                                   │
│     来源：memory 工具存储的条目                                │
│     ┌─────────────────────────────────────────────┐          │
│     │ "Hermes is running on Ubuntu 24.04.3 LTS"    │          │
│     │ "Paimon 数据湖 + StarRocks + Flink CDC..."    │          │
│     │ "交易所主站公告弹窗逻辑..."                    │          │
│     │ "用户偏好：深度技术讨论，不接受虚构数据..."     │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ③ 注入 User Profile                                         │
│     ┌─────────────────────────────────────────────┐          │
│     │ "User is 免审开发者, uses Lark International" │          │
│     │ "偏好深度技术讨论，会直接纠正错误"             │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ④ 注入可用工具列表（167 个工具定义）                          │
│     ┌─────────────────────────────────────────────┐          │
│     │ terminal, browser_navigate, feishu_doc_read, │          │
│     │ skill_view, memory, send_message, vision...  │          │
│     │ 每个工具：名称 + 描述 + JSON Schema 参数      │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ⑤ 注入可用 Skills 目录（~60 个技能摘要）                     │
│     ┌─────────────────────────────────────────────┐          │
│     │ paimon-cdc-ingestion: Configure Paimon...    │          │
│     │ feishu-group-monitoring: Set up Hermes...    │          │
│     │ debugging-hermes-tui: Debug Hermes TUI...    │          │
│     │ ...                                          │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ⑥ 注入当前会话上下文                                         │
│     ┌─────────────────────────────────────────────┐          │
│     │ Source: Feishu (DM with 35398a72)            │          │
│     │ Connected Platforms: local, feishu: ✓        │          │
│     │ Conversation started: May 20, 2026 02:18 PM │          │
│     │ Model: deepseek-v4-pro                       │          │
│     └─────────────────────────────────────────────┘          │
│                                                               │
│  ⑦ 拼接历史对话（当前会话的前几轮）                            │
│     你之前的 4 轮对话（AI模型训练、特征工程、框架区别）         │
│                                                               │
│  ⑧ 附加当前用户消息                                           │
│     "请教一下：一个问题给到你，会发生什么请详细..."             │
└─────────────────────────────────────────────────────────────┘

*最终效果：* 一个完整的 prompt，包含 *~8000-12000 个 token* 的上下文，而你的实际提问只有 ~20 个 token。我看到的「世界」比你想象的大得多：

┌──────────────────────────────────────┐
│ System: 你是谁、有什么能力、环境信息   │  ~2000 tokens
│ Memory: 跨会话的持久知识              │  ~1000 tokens
│ User Profile: 关于用户的稳定认知      │  ~300 tokens
│ Tools: 167个工具的完整定义            │  ~4000 tokens
│ Skills: 60个技能的摘要               │  ~800 tokens
│ Conversation: 之前的4轮对话           │  ~2000 tokens
│ Current Message: 你的新问题           │  ~20 tokens
├──────────────────────────────────────┤
│ 总计注入 ≈ 10,000 tokens              │
└──────────────────────────────────────┘

阶段 2：LLM 推理（DeepSeek-V4-Pro 内部）

这是真正的「模型思考」过程。假设使用 DeepSeek-V4（MoE 架构）： (1/2)

回复 panghu-大数据:

请教一下：一个问题给到你，会发生什么请详细介绍一下中间过程

你的完整 Prompt (≈10,000 tokens)
        │
        ▼
═══════════════════════════════════════
  第1步：Tokenization（分词）
═══════════════════════════════════════

原始文本："请教一下：一个问题给到你..."
     │
     ▼ BPE Tokenizer (Byte-Pair Encoding)
     │
Token IDs: [98375, 234, 45612, 89, 78, 5623, 12390, ...]
           ↑       ↑     ↑      ↑   ↑    ↑      ↑
          "请教"  "一"  "下"   "：" "一" "个" "问题" ...

总共 10,000 tokens → 变成 10,000 个整数 ID

───────────────────────────────────────

═══════════════════════════════════════
  第2步：Embedding（嵌入）
═══════════════════════════════════════

Token IDs: [98375, 234, 45612, ...]
     │
     ▼ Embedding Layer (参数矩阵: vocab_size × d_model)
     │  DeepSeek-V4: d_model = 7168 (推测)
     │
Embeddings: [[0.023, -0.15, 0.89, ...],   ← 98375 的向量
             [0.41, 0.03, -0.22, ...],    ← 234 的向量
             ...]
             
每个 token → 7168 维向量
总共: 10,000 × 7168 的矩阵

───────────────────────────────────────

═══════════════════════════════════════
  第3步：通过 N 层 Transformer
═══════════════════════════════════════

这是最核心的计算——MoE (Mixture of Experts) 架构

┌─────────────────────────────────────────────────────────┐
│                    Transformer Block × 60+ 层              │
│                                                           │
│  对于每一层，每个 token 的 7168 维向量经历：               │
│                                                           │
│  ┌─────────────────────────────────────────┐            │
│  │ ① Multi-Head Attention（多头注意力）     │            │
│  │                                          │            │
│  │  Query: 这个 token "想找什么信息"        │            │
│  │  Key:   其他 token "有什么信息"          │            │
│  │  Value: 其他 token "实际内容"           │            │
│  │                                          │            │
│  │  计算: Attention(Q,K,V) = softmax(QKᵀ/√d)·V │       │
│  │                                          │            │
│  │  实际过程：                               │            │
│  │  token_i 的 Q 与所有 token 的 K 做内积    │            │
│  │  → 得到一个 10,000 × 10,000 的注意力矩阵  │            │
│  │  → 每个 token 从所有其他 token 聚合信息   │            │
│  │                                          │            │
│  │  例如："问题" token 会重点关注：          │            │
│  │  - "给到你"（动作方向）   权重 0.31       │            │
│  │  - "什么"（疑问意图）     权重 0.27       │            │
│  │  - "中间过程"（核心需求）  权重 0.22       │            │
│  │  - 远距离的 Memory 上下文  权重 0.08      │            │
│  │  - ...                                    │            │
│  │                                          │            │
│  │  DeepSeek-V4 用了 MLA (Multi-head Latent  │            │
│  │  Attention) 压缩 KV Cache，节省显存       │            │
│  └─────────────────────────────────────────┘            │
│                                                           │
│  ┌─────────────────────────────────────────┐            │
│  │ ② MoE FFN（混合专家前馈网络）★ 关键！    │            │
│  │                                          │            │
│  │  传统 Dense 模型：                       │            │
│  │  output = W₂ · ReLU(W₁ · x)              │            │
│  │  参数量: d_model × d_ff × 2             │            │
│  │                                          │            │
│  │  DeepSeek MoE 模型：                     │            │
│  │                                          │            │
│  │  总共有 256 个 "专家" (Expert)           │            │
│  │  每个专家是一个独立的小 FFN 网络          │            │
│  │                                          │            │
│  │         ┌─── Gate Router ───┐           │            │
│  │         │  输入 x → 评分    │           │            │
│  │         │  选出 Top-8 专家  │           │            │
│  │         └──┬──┬──┬──┬──────┘           │            │
│  │            │  │  │  │                   │            │
│  │      ┌─────┘  │  │  └─────┐            │            │
│  │      ▼        ▼  ▼        ▼            │            │
│  │  [Expert [Expert [Expert [Expert        │            │
│  │    12]     45]    78]    203]           │            │
│  │      │       │    │       │             │            │
│  │      └───┬───┴────┴───┬───┘             │            │
│  │          ▼            ▼                  │            │
│  │     加权求和（按 Gate 评分）              │            │
│  │          │                                │            │
│  │          ▼                                │            │
│  │     输出 (7168维)                         │            │
│  │                                           │            │
│  │  ★ 密集模型每 token 激活 100% 参数         │            │
│  │  ★ MoE 模型每 token 只激活 ~3% 参数        │            │
│  │  ★ 不同 token 激活不同专家组合：           │            │
│  │    技术类 token → Expert_{math, code}      │            │
│  │    中文理解 token → Expert_{chinese}       │            │
│  │    上下文整合 token → Expert_{reasoning}   │            │
│  └─────────────────────────────────────────┘            │
│                                                           │
│  ┌─────────────────────────────────────────┐            │
│  │ ③ Residual Connection + LayerNorm        │            │
│  │    x = LayerNorm(x + Attention(x))       │            │
│  │    x = LayerNorm(x + MoE_FFN(x))         │            │
│  │    保证梯度流通，防止深层退化             │            │
│  └─────────────────────────────────────────┘            │
│                                                           │
│  这一层处理完 → 输出还是 10,000 × 7168 的矩阵              │
│  送入下一层，重复 60+ 次                                   │
└─────────────────────────────────────────────────────────┘

───────────────────────────────────────

═══════════════════════════════════════
  第4步：最后一层 → 输出头（LM Head）
═══════════════════════════════════════

最后层输出: 10,000 × 7168 矩阵
     │
     ▼ LM Head (线性层: 7168 → 129280)
     │  129280 = 词表大小（DeepSeek 的 vocab size）
     │
Logits: 10,000 × 129280 矩阵
     │  每个位置是一个概率分布：下一个 token 最可能是什么
     ▼

只取最后一个位置（因为我们要生成新 token）:
最后一个位置的 logits: [0.002, -1.3, 4.7, 0.1, ..., -2.1]
                              ↑        ↑       ↑
                           "的"     "好"   "问题"
                         (score低) (score中) (score高)

───────────────────────────────────────

═══════════════════════════════════════
  第5步：自回归解码（逐个生成 token）
═══════════════════════════════════════

这是「一个字一个字蹦出来」的过程。

采样策略（DeepSeek 典型配置）:
  temperature = 0.7
  top_p = 0.9
  top_k = 50

步骤：
① Softmax(logits / temperature) → 概率分布
② 只保留 top_p=0.9 累积概率的 token，其他置零
③ 从中随机采样 1 个 token

迭代过程：

Iteration 1:  输入 [10,000 tokens 上下文]
              → 输出 token: "这" (概率 0.31)

Iteration 2:  输入 [10,000 tokens 上下文 + "这"]
              → 注意力看到 "这" + 全程上下文
              → 输出 token: "是" (概率 0.87)

Iteration 3:  输入 [... + "这是"]
              → 输出 token: "从" (概率 0.42)

Iteration 4:  输入 [... + "这是从"]
              → 输出 token: "你" (概率 0.63)

...重复 ~2000 次...

Iteration N:  输入 [... + "最后输出的测量"]
              → 遇到 EOS (End of Sequence) token
              → 停止生成

───────────────────────────────────────

═══════════════════════════════════════
  第6步：Token → 文本（Detokenization）
═══════════════════════════════════════

Token IDs: [23845, 3452, 893, 567, 234, ...]
     │
     ▼ BPE Decoder
     │
文本: "这是从你按下发送键到我回复出现在屏幕上，中间发生了一整条精密的流水线..."

───────────────────────────────────────