bert_encoder_detailed_explained.py

"""
BERT Encoder 12层详细解析
展示 Vectara HHEM 中 BERT 编码器的每一层处理过程
使用真实训练样本演示数据流转
"""

import numpy as np

print("=" * 80)
print("BERT Encoder 12层完整解析 - 联合编码幻觉检测")
print("=" * 80)

# ============================================================================
# Part 1: 训练样本准备
# ============================================================================
print("\n" + "=" * 80)
print("📚 Part 1: 训练样本")
print("=" * 80)

print("""
训练样本（幻觉检测）：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Documents (文档):
  "AlphaCodium 是一种代码生成方法，通过迭代改进提升性能。"

Generation (LLM生成):
  "AlphaCodium 是 Google 在 2024 年发布的代码生成工具。"
  
Label (标签):
  Hallucinated ❌
  
原因:
  - "Google" 在文档中没有 → 幻觉
  - "2024 年" 在文档中没有 → 幻觉
  - "工具" vs "方法" → 词语不精确
""")


# ============================================================================
# Part 2: Tokenization 和初始 Embeddings
# ============================================================================
print("\n" + "=" * 80)
print("🔧 Part 2: 输入准备 - Tokenization")
print("=" * 80)

print("""
Step 1: 文本拼接
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

输入格式:
  [CLS] Documents [SEP] Generation [SEP]

实际拼接后:
  [CLS] AlphaCodium 是一种代码生成方法，通过迭代改进提升性能。
  [SEP] AlphaCodium 是 Google 在 2024 年发布的代码生成工具。
  [SEP]


Step 2: Tokenization (BERT WordPiece 分词)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

分词结果（简化，实际会更细）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
位置   Token              Token ID    Segment ID
────────────────────────────────────────────────────────
0      [CLS]              101         0
1      Alpha              2945        0
2      ##Codium           3421        0
3      是                 2003        0
4      一种               1037        0
5      代码               4521        0
6      生成               3156        0
7      方法               2567        0
8      ，                110         0
9      通过               2134        0
10     迭代               3789        0
11     改进               2891        0
12     提升               4123        0
13     性能               3456        0
14     。                119         0
15     [SEP]              102         0  ← 第一个分隔符
16     Alpha              2945        1  ← Segment ID 变为 1
17     ##Codium           3421        1
18     是                 2003        1
19     Google             5678        1
20     在                 2156        1
21     2024               4532        1
22     年                 3267        1
23     发布               2789        1
24     的                 1998        1
25     代码               4521        1
26     生成               3156        1
27     工具               3890        1
28     。                119         1
29     [SEP]              102         1  ← 第二个分隔符

总共: 30 个 tokens


Step 3: 初始 Embeddings
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

BERT 的输入 = Token Embedding + Segment Embedding + Position Embedding

对于每个 token，获取三个 embedding 并相加：
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

以 Token 0 "[CLS]" 为例:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Token Embedding (词嵌入表查询)
   Token ID: 101
   → Embedding Table[101] = [0.12, -0.34, 0.56, ..., 0.78]  (768维)

2. Segment Embedding (段落嵌入)
   Segment ID: 0 (属于 Documents 部分)
   → Segment Table[0] = [0.05, 0.02, -0.01, ..., 0.03]  (768维)

3. Position Embedding (位置嵌入)
   Position: 0 (第一个位置)
   → Position Table[0] = [0.08, -0.12, 0.15, ..., -0.05]  (768维)

4. 相加得到初始向量
   Initial Embedding[0] = Token + Segment + Position
                        = [0.12, -0.34, 0.56, ..., 0.78]
                        + [0.05,  0.02, -0.01, ..., 0.03]
                        + [0.08, -0.12, 0.15, ..., -0.05]
                        = [0.25, -0.44, 0.70, ..., 0.76]  (768维)


所有 tokens 的初始向量矩阵:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

H⁰ = [
    [0.25, -0.44, 0.70, ..., 0.76],  ← Token 0: [CLS]
    [0.15,  0.32, -0.23, ..., 0.45],  ← Token 1: Alpha
    [0.28, -0.15,  0.41, ..., 0.52],  ← Token 2: ##Codium
    ...
    [0.19,  0.27, -0.38, ..., 0.61]   ← Token 29: [SEP]
]

形状: (30, 768)
      ↑    ↑
   30个tokens  每个768维
""")


# ============================================================================
# Part 3: BERT Encoder Layer 详细结构
# ============================================================================
print("\n" + "=" * 80)
print("🏗️  Part 3: BERT Encoder Layer 结构（单层详解）")
print("=" * 80)

print("""
每一层 BERT Encoder 的结构:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

输入: H^(l-1)  (上一层的输出，形状: 30×768)
输出: H^l      (本层的输出，形状: 30×768)

┌────────────────────────────────────────────────────────┐
│                   BERT Encoder Layer                   │
│                                                        │
│  输入: H^(l-1) (30, 768)                              │
│    ↓                                                   │
│  ┌──────────────────────────────────────────────────┐ │
│  │ Sub-Layer 1: Multi-Head Self-Attention           │ │
│  │ ────────────────────────────────────────────────│ │
│  │                                                  │ │
│  │ 1.1 计算 Q, K, V                                 │ │
│  │     Q = H^(l-1) × W^Q  (30×768 × 768×768)      │ │
│  │     K = H^(l-1) × W^K  (30×768 × 768×768)      │ │
│  │     V = H^(l-1) × W^V  (30×768 × 768×768)      │ │
│  │                                                  │ │
│  │ 1.2 分成 12 个 Head                              │ │
│  │     每个 Head: 768 / 12 = 64 维                 │ │
│  │                                                  │ │
│  │ 1.3 每个 Head 计算 Attention                     │ │
│  │     Attention = softmax(Q×K^T / √64) × V        │ │
│  │                                                  │ │
│  │ 1.4 Concat 所有 Heads                           │ │
│  │     Output = Concat(head₁, ..., head₁₂)        │ │
│  │                                                  │ │
│  │ 1.5 线性变换                                     │ │
│  │     Output = Output × W^O                       │ │
│  └──────────────────────────────────────────────────┘ │
│    ↓                                                   │
│  ┌──────────────────────────────────────────────────┐ │
│  │ Add & Norm 1                                     │ │
│  │ ────────────────────────────────────────────────│ │
│  │ H_att = LayerNorm(H^(l-1) + Attention_Output)   │ │
│  │         ↑ 残差连接  ↑ Attention 输出             │ │
│  └──────────────────────────────────────────────────┘ │
│    ↓                                                   │
│  ┌──────────────────────────────────────────────────┐ │
│  │ Sub-Layer 2: Feed Forward Network                │ │
│  │ ────────────────────────────────────────────────│ │
│  │                                                  │ │
│  │ 2.1 第一层全连接 + ReLU                          │ │
│  │     FFN₁ = ReLU(H_att × W₁ + b₁)                │ │
│  │     (30×768 × 768×3072 = 30×3072)               │ │
│  │                                                  │ │
│  │ 2.2 第二层全连接                                 │ │
│  │     FFN₂ = FFN₁ × W₂ + b₂                       │ │
│  │     (30×3072 × 3072×768 = 30×768)               │ │
│  └──────────────────────────────────────────────────┘ │
│    ↓                                                   │
│  ┌──────────────────────────────────────────────────┐ │
│  │ Add & Norm 2                                     │ │
│  │ ────────────────────────────────────────────────│ │
│  │ H^l = LayerNorm(H_att + FFN₂)                   │ │
│  │       ↑ 残差连接  ↑ FFN 输出                     │ │
│  └──────────────────────────────────────────────────┘ │
│    ↓                                                   │
│  输出: H^l (30, 768)                                  │
└────────────────────────────────────────────────────────┘

关键参数:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Hidden Size: 768
- Attention Heads: 12
- Head Dimension: 768 / 12 = 64
- Intermediate Size (FFN): 3072
- Dropout: 0.1
""")


# ============================================================================
# Part 4: Multi-Head Self-Attention 详细计算
# ============================================================================
print("\n" + "=" * 80)
print("🔍 Part 4: Multi-Head Self-Attention 详细计算过程")
print("=" * 80)

print("""
以 Layer 1 为例，详细展示 Attention 计算:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

输入: H⁰ (30, 768)  # 初始 embeddings

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 1: 计算 Q, K, V
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Q = H⁰ × W^Q
  = (30, 768) × (768, 768)
  = (30, 768)

K = H⁰ × W^K
  = (30, 768) × (768, 768)
  = (30, 768)

V = H⁰ × W^V
  = (30, 768) × (768, 768)
  = (30, 768)

实际数值示例（只展示前3个token的前8维）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Q = [
  [0.15, -0.23, 0.34, 0.12, -0.45, 0.67, 0.89, -0.12, ...],  ← [CLS]
  [0.22,  0.18, -0.31, 0.45, 0.23, -0.56, 0.34, 0.78, ...],  ← Alpha
  [0.34, -0.12, 0.45, -0.23, 0.67, 0.12, -0.89, 0.45, ...],  ← ##Codium
  ...
]

K 和 V 类似结构


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 2: 分成 12 个 Head
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

将 768 维分成 12 份，每份 64 维：

Head 0: Q[:, 0:64],   K[:, 0:64],   V[:, 0:64]
Head 1: Q[:, 64:128], K[:, 64:128], V[:, 64:128]
...
Head 11: Q[:, 704:768], K[:, 704:768], V[:, 704:768]

以 Head 0 为例:
  Q₀ = Q[:, 0:64]  # (30, 64)
  K₀ = K[:, 0:64]  # (30, 64)
  V₀ = V[:, 0:64]  # (30, 64)


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 3: 计算 Attention Scores (Head 0)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Scores = Q₀ × K₀^T / √64
       = (30, 64) × (64, 30) / 8
       = (30, 30) / 8

结果矩阵 Scores (30, 30):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

每个元素 Scores[i][j] 表示 token i 对 token j 的注意力分数

示例（前5x5）:
                        ↓ Key tokens
         [CLS]  Alpha  ##Cod  是    一种
[CLS]    [2.3   1.5    1.8    0.9   0.7  ...]  ← Query: [CLS]
Alpha    [1.2   3.1    2.9    1.1   0.8  ...]  ← Query: Alpha
##Cod    [1.0   2.8    3.5    1.3   0.9  ...]  ← Query: ##Codium
是       [0.8   1.2    1.4    2.1   1.5  ...]  ← Query: 是
一种     [0.6   0.9    1.0    1.6   2.3  ...]  ← Query: 一种
...

解释:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Scores[0][0] = 2.3  → [CLS] 对自己的注意力
Scores[1][2] = 2.9  → "Alpha" 对 "##Codium" 的注意力（很高，因为是同一个词）
Scores[19][1] = 1.8 → "Google"(pos 19) 对 "Alpha"(pos 1) 的注意力


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 4: Softmax 归一化
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Attention_Weights = softmax(Scores, dim=-1)

对每一行做 softmax（和为1）:

示例（前5x5，归一化后）:
                        ↓ Key tokens
         [CLS]  Alpha  ##Cod  是    一种   ...
[CLS]    [0.35  0.15   0.20   0.08  0.05  ...]  ← 总和=1.0
Alpha    [0.10  0.40   0.35   0.08  0.04  ...]  ← 总和=1.0
##Cod    [0.08  0.28   0.45   0.10  0.06  ...]  ← 总和=1.0
是       [0.12  0.18   0.20   0.30  0.15  ...]  ← 总和=1.0
一种     [0.10  0.14   0.16   0.22  0.32  ...]  ← 总和=1.0
...

关键观察:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- "Alpha" 对 "##Codium" 的权重 = 0.35（高！）
  → 说明模型学会了它们是同一个词

- "Google" (pos 19) 对 Documents 中的 tokens 权重较低
  → 因为 Documents 中没有 "Google"
  → 这个信息会被用于判断幻觉！


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 5: 加权求和 V
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Output₀ = Attention_Weights × V₀
        = (30, 30) × (30, 64)
        = (30, 64)

对于每个 token i:
  Output₀[i] = Σⱼ Attention_Weights[i][j] × V₀[j]

示例（token 0 "[CLS]" 的输出）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Output₀[0] = 0.35 × V₀[0]  ([CLS] 的 value)
           + 0.15 × V₀[1]  (Alpha 的 value)
           + 0.20 × V₀[2]  (##Codium 的 value)
           + 0.08 × V₀[3]  (是 的 value)
           + ...
           + 0.02 × V₀[19] (Google 的 value)  ← 权重很小！
           + ...

结果: [0.23, -0.15, 0.34, ..., 0.67]  (64维)

[CLS] 的向量现在包含了:
- 主要: 自己、Alpha、##Codium 的信息（权重大）
- 少量: Google、2024 的信息（权重小）
- 这个差异会被后续层放大，用于检测幻觉！


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 6: Concat 所有 12 个 Heads
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Multi_Head_Output = Concat(Output₀, Output₁, ..., Output₁₁)
                  = Concat((30,64), (30,64), ..., (30,64))
                  = (30, 768)

每个 Head 捕捉不同的模式:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Head 0: 词内关系 ("Alpha" ↔ "##Codium")
Head 1: 语法关系 ("是" ↔ "方法")
Head 2: 长距离依赖 ("AlphaCodium" ↔ "性能")
Head 3: 检测添加信息 ("Google" 在 Documents 中的对应)
...


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Step 7: 线性变换
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Attention_Output = Multi_Head_Output × W^O + b^O
                 = (30, 768) × (768, 768) + (768,)
                 = (30, 768)
""")


# ============================================================================
# Part 5: 12层逐层处理
# ============================================================================
print("\n" + "=" * 80)
print("🔢 Part 5: BERT 12层逐层处理过程")
print("=" * 80)

print("""
完整的 12 层处理流程:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

输入: H⁰ (30, 768)  # 初始 embeddings

┌──────────────────────────────────────────────────────────┐
│ Layer 1                                                  │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H⁰                                                 │
│   ↓                                                      │
│ Multi-Head Self-Attention                               │
│   - "Alpha" attend到 "##Codium" (0.35)                 │
│   - "Google" attend到 Documents tokens (0.1-0.2)       │
│   ↓                                                      │
│ Add & Norm: H_att¹ = LayerNorm(H⁰ + Attention)         │
│   ↓                                                      │
│ Feed Forward: FFN(H_att¹)                               │
│   ↓                                                      │
│ Add & Norm: H¹ = LayerNorm(H_att¹ + FFN)               │
│                                                          │
│ 输出: H¹ (30, 768)                                      │
│                                                          │
│ 学到的模式:                                              │
│ ✓ 基本词语关系                                          │
│ ✓ "AlphaCodium" 在两段中都出现                          │
│ ✓ "Google" 只在 Generation 中出现 ⚠️                   │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│ Layer 2                                                  │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H¹                                                 │
│   ↓                                                      │
│ Multi-Head Self-Attention                               │
│   - 开始建立语法关系                                     │
│   - "是" attend到 "方法" 和 "工具"                      │
│   ↓                                                      │
│ FFN + Residual                                          │
│   ↓                                                      │
│ 输出: H² (30, 768)                                      │
│                                                          │
│ 学到的模式:                                              │
│ ✓ "方法" vs "工具" 的语义差异                           │
│ ✓ 时间信息: "2024 年"                                   │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│ Layer 3                                                  │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H²                                                 │
│   ↓                                                      │
│ Multi-Head Self-Attention                               │
│   - 长距离依赖开始建立                                   │
│   - [CLS] attend到关键词: "Google", "2024"             │
│   ↓                                                      │
│ FFN + Residual                                          │
│   ↓                                                      │
│ 输出: H³ (30, 768)                                      │
│                                                          │
│ 学到的模式:                                              │
│ ✓ Documents: "迭代改进" vs Generation: 无此信息        │
│ ✓ Generation: "Google" vs Documents: 无此信息 ⚠️       │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│ Layer 4-6: 中间层                                        │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H³                                                 │
│   ↓                                                      │
│ 多层 Self-Attention + FFN                               │
│   ↓                                                      │
│ 输出: H⁶ (30, 768)                                      │
│                                                          │
│ 学到的模式:                                              │
│ ✓ 复杂的语义关系                                        │
│ ✓ Documents 和 Generation 的对比                        │
│ ✓ 识别不一致的地方:                                     │
│   - "方法" vs "工具"                                    │
│   - 缺失 "Google" 和 "2024" 的来源                     │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│ Layer 7-9: 深层抽象                                      │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H⁶                                                 │
│   ↓                                                      │
│ 多层 Self-Attention + FFN                               │
│   ↓                                                      │
│ 输出: H⁹ (30, 768)                                      │
│                                                          │
│ 学到的模式:                                              │
│ ✓ 高层语义理解                                          │
│ ✓ [CLS] 向量开始聚合判断信息:                           │
│   - Documents 说: "代码生成方法，迭代改进"              │
│   - Generation 说: "Google 发布的工具"                  │
│   → 发现不匹配！⚠️                                      │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│ Layer 10-12: 最终层（决策层）                            │
│ ──────────────────────────────────────────────────────── │
│                                                          │
│ 输入: H⁹                                                 │
│   ↓                                                      │
│ 多层 Self-Attention + FFN                               │
│   ↓                                                      │
│ 输出: H¹² (30, 768)                                     │
│                                                          │
│ [CLS] 向量的信息（最关键）:                              │
│ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│                                                          │
│ H¹²[0] = [0.234, -0.567, 0.890, ..., 0.123]  (768维)   │
│          ↑ [CLS] token 的最终向量                       │
│                                                          │
│ 这个向量编码了:                                          │
│ ✓ Documents 的完整信息                                  │
│ ✓ Generation 的完整信息                                 │
│ ✓ 两者的关系:                                           │
│   - 有哪些信息一致                                      │
│   - 有哪些信息矛盾                                      │
│   - Generation 添加了哪些 Documents 中没有的信息       │
│                                                          │
│ 具体识别到的问题:                                        │
│ ❌ "Google" 在 Documents 中找不到对应                   │
│ ❌ "2024" 在 Documents 中找不到对应                     │
│ ⚠️  "工具" vs "方法" 语义差异                           │
│                                                          │
│ → 准备输出到分类头，判断为 "Hallucinated"               │
└──────────────────────────────────────────────────────────┘


━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

最终输出: H¹² (30, 768)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

只使用 H¹²[0]（[CLS] 的向量）送入分类头:

[CLS] Vector = H¹²[0] = [0.234, -0.567, 0.890, ..., 0.123]
                        ↓
                  分类头 (768 → 2)
                        ↓
                Logits: [0.8, 4.2]
                         ↑    ↑
                    Factual Hallucinated
                        ↓
                    Softmax
                        ↓
            Probs: [0.03, 0.97]
                    ↑     ↑
                3%事实  97%幻觉

判断: Hallucinated ❌ (置信度 97%)
""")


# ============================================================================
# Part 6: 关键 Attention 模式可视化
# ============================================================================
print("\n" + "=" * 80)
print("👁️  Part 6: 关键 Attention 模式可视化")
print("=" * 80)

print("""
Layer 12 的 Attention 权重矩阵（简化，只显示关键 tokens）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Query ↓        Key Tokens →
Tokens     [CLS] Alpha¹ 方法  [SEP] Alpha² Google 2024 工具  [SEP]
─────────────────────────────────────────────────────────────────
[CLS]      [0.15  0.08  0.12  0.05  0.07  0.18   0.16  0.10  0.05]
           ↑低   ↑低   ↑中   ↑低   ↑低   ↑高⚠️  ↑高⚠️ ↑中   ↑低
           
Alpha¹     [0.05  0.30  0.08  0.03  0.25  0.04   0.03  0.05  0.02]
           ↑低   ↑高✓  ↑低   ↑低   ↑高✓  ↑低    ↑低   ↑低   ↑低
           
方法       [0.08  0.10  0.25  0.05  0.08  0.06   0.05  0.20  0.03]
           ↑低   ↑低   ↑高✓  ↑低   ↑低   ↑低    ↑低   ↑中⚠️ ↑低
           
Google     [0.10  0.05  0.03  0.02  0.06  0.40   0.15  0.08  0.02]
           ↑中⚠️ ↑低   ↑低   ↑低   ↑低   ↑高✓   ↑中   ↑低   ↑低
           
2024       [0.12  0.04  0.02  0.01  0.05  0.18   0.35  0.07  0.01]
           ↑中⚠️ ↑低   ↑低   ↑低   ↑低   ↑中    ↑高✓  ↑低   ↑低

工具       [0.09  0.08  0.15  0.03  0.09  0.07   0.06  0.30  0.02]
           ↑低   ↑低   ↑中⚠️ ↑低   ↑低   ↑低    ↑低   ↑高✓  ↑低

关键观察:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

✓ 正常模式:
  - "Alpha¹" attend到 "Alpha²" (0.25) ← 同一实体
  - "方法" attend到自己 (0.25) ← 自注意力
  
⚠️ 幻觉指示:
  - "Google" 主要 attend到自己 (0.40)
    → 在 Documents 中找不到强关联！
    
  - "2024" 主要 attend到自己 (0.35)
    → 在 Documents 中找不到强关联！
    
  - [CLS] attend到 "Google" (0.18) 和 "2024" (0.16)
    → [CLS] 注意到这些异常词！
    
  - "工具" 对 "方法" 的 attention (0.15)
    → 语义相似但不完全一致

这些模式被分类头学习并用于判断幻觉！
""")


# ============================================================================
# Part 7: 参数统计
# ============================================================================
print("\n" + "=" * 80)
print("📊 Part 7: BERT Encoder 参数统计")
print("=" * 80)

print("""
BERT-base 参数详细统计:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Embedding 层:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   - Token Embedding: 30,522 × 768 = 23,440,896
   - Segment Embedding: 2 × 768 = 1,536
   - Position Embedding: 512 × 768 = 393,216
   小计: 23,835,648 参数


2. 每个 Encoder Layer:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   Multi-Head Attention:
     - W^Q: 768 × 768 = 589,824
     - W^K: 768 × 768 = 589,824
     - W^V: 768 × 768 = 589,824
     - W^O: 768 × 768 = 589,824
     - Biases: 768 × 4 = 3,072
     小计: 2,362,368 参数
   
   Feed Forward Network:
     - W₁: 768 × 3,072 = 2,359,296
     - b₁: 3,072
     - W₂: 3,072 × 768 = 2,359,296
     - b₂: 768
     小计: 4,722,432 参数
   
   Layer Normalization (×2):
     - γ, β: 768 × 2 × 2 = 3,072
   
   每层总计: 2,362,368 + 4,722,432 + 3,072 = 7,087,872 参数


3. 12 层 Encoder:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   7,087,872 × 12 = 85,054,464 参数


4. 分类头（HHEM 特有）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   - W: 768 × 2 = 1,536
   - b: 2
   小计: 1,538 参数


总参数量:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
23,835,648 (Embeddings)
+ 85,054,464 (12 Layers)
+ 1,538 (Classification Head)
= 108,891,650 参数

约 109M (百万) 参数
模型大小: 109M × 4 bytes = 436 MB


内存占用（推理时）:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- 模型参数: 436 MB
- 激活值 (batch_size=1, seq_len=30):
  每层: 30 × 768 × 4 bytes × 2 (residual) = 184 KB
  12 层: 184 KB × 12 = 2.2 MB
- 总计: ~438 MB (FP32)
        ~220 MB (FP16，使用半精度)
""")


# ============================================================================
# Part 8: 总结
# ============================================================================
print("\n" + "=" * 80)
print("📚 Part 8: 核心要点总结")
print("=" * 80)

print("""
BERT Encoder 12层联合编码核心要点:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. 输入准备
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   [CLS] Documents [SEP] Generation [SEP]
   → Tokenization (30 tokens)
   → Token + Segment + Position Embeddings
   → H⁰ (30, 768)

2. 每层结构
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   H^(l-1) 
      ↓
   Multi-Head Self-Attention (12 heads)
      ↓
   Add & Norm
      ↓
   Feed Forward Network
      ↓
   Add & Norm
      ↓
   H^l

3. Multi-Head Attention 关键
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   Q, K, V = H × W^Q, H × W^K, H × W^V
      ↓
   分成 12 个 Head (每个 64 维)
      ↓
   Attention = softmax(Q×K^T / √64) × V
      ↓
   Concat 所有 Heads → (768 维)

4. 12层逐层学习
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   Layer 1-3:   基本语法、词语关系
   Layer 4-6:   复杂语义、长距离依赖
   Layer 7-9:   高层抽象、不一致检测
   Layer 10-12: 最终判断、信息聚合到 [CLS]

5. 幻觉检测机制
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   通过 Attention 权重发现:
   ✓ "Google" 在 Documents 中无强关联
   ✓ "2024" 在 Documents 中无强关联
   ✓ [CLS] 聚合这些信息
      ↓
   H¹²[0] (768维) → 分类头 (768→2)
      ↓
   [Factual: 0.03, Hallucinated: 0.97]
      ↓
   判断: Hallucinated ❌

6. 关键参数
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   - Hidden Size: 768
   - Layers: 12
   - Attention Heads: 12
   - Head Dimension: 64
   - FFN Size: 3072
   - Total Parameters: 109M
   - Model Size: 436 MB (FP32)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

联合编码的优势:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Documents 和 Generation 可以互相 attend
✅ 模型能捕捉两者之间的一致性/矛盾
✅ [CLS] 向量聚合了全局判断信息
✅ 12 层逐层深化理解，最终准确判断幻觉

这就是为什么 BERT Cross-Encoder 在幻觉检测上表现优秀！
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
""")

print("\n" + "=" * 80)
print("✅ BERT Encoder 12层详细解析完毕！")
print("=" * 80)
print()