总参数: 4B
├─ Embedding层: 389M (151,643 × 2,560)
│  占比: 9.7%
│
├─ 36个Transformer层: 3,538M
│  每层参数: 98.3M
│  │
│  ├─ Attention部分: 26.2M/层 (26.6%)
│  │  ├─ Q投影: 6.55M (2,560 × 2,560)
│  │  ├─ K投影: 6.55M (2,560 × 2,560)
│  │  ├─ V投影: 6.55M (2,560 × 2,560)
│  │  └─ O投影: 6.55M (2,560 × 2,560)
│  │
│  ├─ FFN部分: 72.1M/层 (73.4%)
│  │  ├─ Gate投影: 14.4M (2,560 × 5,632)
│  │  ├─ Up投影: 14.4M (2,560 × 5,632)
│  │  └─ Down投影: 14.4M (5,632 × 2,560)
│  │  注：SwiGLU需要额外的Gate分支
│  │
│  └─ LayerNorm: 5KB/层 (可忽略)
│
└─ 最终LayerNorm: 2.5KB

关键洞察:
• FFN占每层参数的73%（计算密集）
• Attention仅占27%（但主导长序列性能）
• 中间层维度: 5,632 ≈ 2.2 × hidden_size（SwiGLU标准比例）

Architecture:
  model_type: qwen2          # Qwen3使用Qwen2架构
  hidden_size: 2560          # 隐藏层维度
  num_hidden_layers: 36      # Transformer层数
  num_attention_heads: 32    # 注意力头数（Q头数）
  num_key_value_heads: 32    # KV头数（32 = MHA，小于32 = GQA）
  intermediate_size: 5632    # FFN中间层维度（2.2x hidden_size，SwiGLU标准）

Tokenizer:
  vocab_size: 151936         # config声明大小（GPU对齐优化）
  actual_tokens: 151643      # 实际训练token数
  reserved_space: 293        # 预留扩展位（151643-151935）

Model:
  architecture: Dense        # 非MoE架构
  activation: SwiGLU         # 激活函数（非ReLU/GELU）
  normalization: RMSNorm     # 归一化方式
  norm_position: Pre-Norm    # 归一化位置

传统MHA (Multi-Head Attention):
• Q heads: 32个，每个80维 (2560/32)
• K heads: 32个，每个80维
• V heads: 32个，每个80维
• KV Cache: 32 × 80 × SeqLen × 2 (K+V)

GQA (Grouped Query Attention，小模型如0.6B):
• Q heads: 16个，每个64维
• K heads: 8个，每个64维
• V heads: 8个，每个64维
• KV Cache: 8 × 64 × SeqLen × 2 ← 减少50%！

工作原理:
Query1 ──┐
Query2 ──┼─→ 共享 KV1
Query3 ──┐
Query4 ──┼─→ 共享 KV2
...

优势:
✓ 内存占用减半（KV Cache是长序列瓶颈）
✓ 性能损失极小（<1% perplexity增加）
✓ 特别适合边缘设备和长上下文场景

传统位置编码问题:
Position Embedding: [0, 1, 2, 3, ..., 32767]
                     ↓ 直接加到token embedding上
问题:
❌ 外推性差（训练32K，推理64K时性能崩溃）
❌ 位置信息与内容信息混在一起
❌ 相对位置关系不明确

# 概念伪代码
def apply_rope(q, k, position):
    """
    通过旋转矩阵注入相对位置信息
    """
    # 每个维度对应一个旋转频率
    freq = 1.0 / (rope_theta ** (2 * dim / hidden_size))

    # 计算旋转角度
    angle = position * freq

    # 应用旋转（复数空间）
    q_rotated = rotate(q, angle)
    k_rotated = rotate(k, angle)

    # 注意力计算自然包含相对位置
    score = q_rotated @ k_rotated.T

    return score

关键特性:
✓ Attention(Q_pos_i, K_pos_j) 自动包含相对位置 (i-j)
✓ 不同维度使用不同频率（多尺度位置信息）
✓ 支持外推（通过调整rope_theta）

Base模型 (32K原生):
  rope_theta: 1,000,000
  max_position: 32,768
  effective_range: 0-32K ✓

Instruct模型 (262K扩展):
  rope_theta: 5,000,000  # 5x增大 → 降低旋转频率
  max_position: 262,144   # 8x扩展
  effective_range: 0-262K ✓

核心机制:
• 增大rope_theta → 旋转更慢 → 远距离位置不会"重叠"
• 结合YaRN温度缩放，实现平滑扩展

激活函数演进:
ReLU(x) = max(0, x)
  └─ 简单但表达力有限

GELU(x) = x · Φ(x)  [Φ是高斯累积分布]
  └─ 平滑，但计算稍慢

GLU(x) = (x·W_1) ⊗ σ(x·W_2)  [⊗是元素乘法]
  └─ 门控机制，但需要两倍参数

SwiGLU(x) = (x·W_gate) ⊗ Swish(x·W_up)
  └─ GLU + Swish，Qwen3选择！

# Qwen3的Feed-Forward Network
class SwiGLU_FFN:
    def __init__(self, hidden_size, intermediate_size):
        self.gate_proj = Linear(hidden_size, intermediate_size)  # 2560 → 5632
        self.up_proj = Linear(hidden_size, intermediate_size)    # 2560 → 5632
        self.down_proj = Linear(intermediate_size, hidden_size)  # 5632 → 2560

    def forward(self, x):
        # 两路并行计算
        gate = self.gate_proj(x)      # [batch, seq, 5632]
        up = self.up_proj(x)          # [batch, seq, 5632]

        # SwiGLU激活
        activated = gate * swish(up)  # 门控 × Swish(上行)

        # 投影回原维度
        output = self.down_proj(activated)
        return output

def swish(x):
    return x * sigmoid(x)  # 平滑非线性

参数开销:
传统ReLU FFN: 2 × hidden × inter = 2 × 2560 × 5632 = 28.8M
SwiGLU FFN:   3 × hidden × inter = 3 × 2560 × 5632 = 43.2M
增加50%参数，但性能提升2-3%！

# 传统LayerNorm
def layer_norm(x):
    mean = x.mean(dim=-1, keepdim=True)        # 需要计算均值
    var = x.var(dim=-1, keepdim=True)          # 需要计算方差
    return (x - mean) / sqrt(var + eps) * gamma + beta

计算步骤:
1. 计算均值 (O(n))
2. 计算方差 (O(n)，需要再遍历一次)
3. 减去均值 (O(n))
4. 除以标准差 (O(n))
5. 缩放平移 (O(n))
总共5次操作！

# Qwen3使用的RMSNorm
def rms_norm(x):
    rms = sqrt(mean(x**2) + eps)               # 只计算均方根
    return x / rms * gamma                      # 无需减均值

计算步骤:
1. 计算平方 (O(n))
2. 计算均值 (O(n))
3. 开方 (O(1))
4. 除以RMS (O(n))
5. 缩放 (O(n))
更快且数值更稳定！

性能对比:
• 速度: RMSNorm比LayerNorm快10-15%
• 精度: 性能几乎相同 (<0.1% perplexity差异)
• 稳定性: 大batch size时更稳定

传统Post-Norm结构:
Input
  ↓
SubLayer (Attention/FFN)
  ↓
Add (Residual)
  ↓
Norm
  ↓
Output

问题:
❌ 深层网络训练不稳定（梯度爆炸/消失）
❌ 需要careful的学习率调整
❌ warmup步数要长

Qwen3的Pre-Norm结构:
Input
  ↓
Norm ← 先归一化！
  ↓
SubLayer (Attention/FFN)
  ↓
Add (Residual)
  ↓
Output

优势:
✓ 训练更稳定（每个子层输入都是归一化的）
✓ 可以训练更深的网络（Qwen3-32B有64层）
✓ 学习率鲁棒性更好
✓ 已成为现代LLM标准

# Base模型：纯文本补全
Token ID: 151643
Token String: "<|endoftext|>"
Usage: 文档结束标记（GPT风格）

# Instruct/Thinking模型：多轮对话
Primary EOS: 151645 - "<|im_end|>"      # ChatML对话轮次结束
Fallback EOS: 151643 - "<|endoftext|>"  # 完整对话结束

Base-4B (贪婪解码):
  do_sample: false
  max_new_tokens: 2048
  temperature: null
  top_p: null
  top_k: null

Instruct-4B (采样生成):
  do_sample: true
  temperature: 0.7          # 较高随机性
  top_p: 0.8                # Nucleus sampling
  top_k: 20

Thinking-4B (精确推理):
  do_sample: true
  temperature: 0.6          # 略低于Instruct，更专注
  top_p: 0.95               # 更大概率空间
  top_k: 20

场景: 4个样本，真实长度分别为2, 4, 3, 2个tokens

Padding到统一长度128:
样本1: [tok1, tok2, <pad>, <pad>, ..., <pad>]  (126个padding)
样本2: [tok1, ..., tok4, <pad>, ..., <pad>]    (124个padding)
样本3: [tok1, tok2, tok3, <pad>, ..., <pad>]   (125个padding)
样本4: [tok1, tok2, <pad>, <pad>, ..., <pad>]  (126个padding)

统计:
• 总tokens: 4 × 128 = 512
• 有效tokens: 2+4+3+2 = 11
• 浪费率: 97.9%
• Attention计算: 512² = 262,144次操作
• 其中有效: 11² = 121次操作
• 计算浪费: 99.95%！

# 每个样本保持真实长度
样本1: [tok1, tok2]                      Shape: (1, 2)
样本2: [tok1, tok2, tok3, tok4]          Shape: (1, 4)
样本3: [tok1, tok2, tok3]                Shape: (1, 3)
样本4: [tok1, tok2]                      Shape: (1, 2)

特点:
• 不同batch可以有不同长度
• 每个token都参与有效计算
• 零浪费

# 将多个样本打包成一个序列
packed = [s1_tok1, s1_tok2, <eos>,
          s2_tok1, s2_tok2, s2_tok3, s2_tok4, <eos>,
          s3_tok1, s3_tok2, s3_tok3, <eos>,
          s4_tok1, s4_tok2, <eos>]

Shape: (1, 15) ← 仅15个tokens！

通过Attention Mask确保样本间不交互:
[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0]  样本1只看自己
[0,0,0,1,1,1,1,0,0,0,0,0,0,0,0]  样本2只看自己
[0,0,0,0,0,0,0,0,1,1,1,0,0,0,0]  样本3只看自己
[0,0,0,0,0,0,0,0,0,0,0,0,1,1,0]  样本4只看自己

优势:
✓ GPU利用率最大化
✓ 吞吐量大幅提升
✓ 训练/推理成本降低

查询: "你好" (4 tokens)

Padding方式 (固定32,768长度):
• 计算量: 32,768² × 2,560 × 36 ≈ 98 TFLOPs
• KV Cache内存: 9.4 GB
• 延迟: ~500ms
• 利用率: 0.015%

动态长度方式:
• 计算量: 4² × 2,560 × 36 ≈ 1.5 MFLOPs
• KV Cache内存: 1.15 MB
• 延迟: ~2ms
• 利用率: 100%
• 加速比: 250x！
• 内存节省: 99.988%

参数 vs 计算量的区别:

模型参数 (4B):
├─ 存储在GPU显存中
├─ 每次推理都使用全部参数
├─ 与序列长度无关
└─ 利用率: 永远100%

计算量 (FLOPs):
├─ 取决于输入长度
├─ 短序列 = 少计算
├─ 长序列 = 多计算
└─ 这是效率差异的来源

举例说明:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
输入: "你好" (4 tokens)
• 参数使用: 4B 全部 (100%)
• 计算量: 1.5 MFLOPs
• 时间: 2ms

输入: 长文档 (32K tokens)
• 参数使用: 4B 全部 (100%)
• 计算量: 9.8 TFLOPs
• 时间: 500ms

结论:
参数利用率都是100%！
差异在于Attention的O(n²)复杂度

# Base模型（32K context）
rope_theta = 1,000,000
max_position_embeddings = 32,768

# Instruct/Thinking模型（262K context）
rope_theta = 5,000,000      # 5x增大
max_position_embeddings = 262,144  # 8x扩展

┌─────────────────────────────────────────┐
│  0 - 151642: 普通BPE tokens (151,643个) │  ← vocab.json
├─────────────────────────────────────────┤
│  151643: <|endoftext|>                  │  ← Base EOS
│  151644: (未定义)                        │
│  151645: <|im_end|>                     │  ← Chat EOS
│  151646 - 151935: 预留空间 (290个)      │  ← 未来扩展
└─────────────────────────────────────────┘
   总计: 151,936 (config声明)

# 特殊token探测器发现的未使用token
Unused_Tokens = {
    128244: '',      # 可能用于<unk>
    128245: '~~',    # 保留标记1
    128247: '~~',    # 保留标记2
}

# 词表中的特殊标记
Special_Markers = {
    19542: '',           # 空标记
    21122: '<>',         # XML占位符
    71698: '<()>',       # 函数调用标记？
    74094: '>',          # 右括号
    82639: 'Ġ<|',        # 特殊token前缀
}

Base-4B:      151,388 merge rules
Instruct-4B:  151,387 merge rules  # -1
Thinking-4B:  151,387 merge rules  # -1

# 原因：后训练阶段略微调整了tokenization策略
# 但词表本身(vocab.json)保持一致

预训练阶段:
• 数据量: 36 trillion tokens
• 训练目标: 下一词预测（语言建模）
• 输出: Base模型（纯文本补全）
• 示例: 输入"人工智能" → 输出"的发展历程..."

后训练阶段:
• SFT数据量: ~100K-1M条指令对
• 训练目标: 遵循指令，对话交互
• 输出: Instruct模型（助手）
• 示例: 输入"解释人工智能" → 输出"人工智能是..."

关键差异:
预训练 ≈ 学习语言
后训练 ≈ 学习交流

数据量对比:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
阶段          数据量           占比
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
预训练        36T tokens      100%
SFT          100K-1M 条       0.000003%
RLHF         10K-100K 偏好对   0.0000003%

震撼事实:
仅用预训练0.000003%的数据量，
就能彻底改变模型的行为模式！

{
  "instruction": "将这段文字翻译成英文",
  "input": "你好，世界！",
  "output": "Hello, World!"
}

{
  "conversations": [
    {
      "from": "human",
      "value": "什么是机器学习？"
    },
    {
      "from": "gpt",
      "value": "机器学习是人工智能的一个分支..."
    },
    {
      "from": "human",
      "value": "能举个例子吗？"
    },
    {
      "from": "gpt",
      "value": "当然！比如邮件垃圾过滤器..."
    }
  ]
}

{
  "messages": [
    {
      "role": "user",
      "content": "解释量子计算"
    },
    {
      "role": "assistant",
      "content": "量子计算利用量子力学原理..."
    }
  ]
}

原始数据 (多种格式)
     ↓
步骤1: 格式统一
     ↓
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Alpaca格式:
{
  "instruction": "翻译",
  "input": "Hello",
  "output": "你好"
}
     ↓ 转换为统一messages格式
{
  "messages": [
    {"role": "user", "content": "翻译\nHello"},
    {"role": "assistant", "content": "你好"}
  ]
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ShareGPT格式:
{
  "conversations": [
    {"from": "human", "value": "Hello"},
    {"from": "gpt", "value": "你好"}
  ]
}
     ↓ 转换为统一messages格式
{
  "messages": [
    {"role": "user", "content": "Hello"},
    {"role": "assistant", "content": "你好"}
  ]
}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     ↓
步骤2: 应用Chat Template (Qwen3的ChatML)
     ↓
<|im_start|>user
Hello<|im_end|>
<|im_start|>assistant
你好<|im_end|>
     ↓
步骤3: Tokenization
     ↓
[151644, 872, 198, 9906, 151645, 
 151644, 77091, 198, 108386, 151645]
     ↓
步骤4: 模型训练
     ↓
模型只看到: [151644, 872, 198, ...]
完全不知道原始格式是什么！

关键理解:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. 模型不理解"格式"
   • 模型输入: token IDs (数字序列)
   • instruction/from/role: 这些是人类组织数据的方式
   • 模型从未见过这些字段名

2. 统一转换消除差异
   • 所有数据 → ChatML → Tokens
   • 模型学习的是ChatML模式
   • 永远是: <|im_start|>...content...<|im_end|>

3. 类比理解
   就像多个人用不同方言（格式）说话，
   但都被翻译成普通话（ChatML）后再教给学生（模型），
   学生只学会了普通话，不知道原本有不同方言。

4. 实际效果
   ✓ 可以混合任意格式的数据集
   ✓ 训练前统一转换即可
   ✓ 模型行为完全一致

类比其他标记语言:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
HTML  = HyperText Markup Language      (网页结构)
XML   = eXtensible Markup Language     (数据交换)
YAML  = YAML Ain't Markup Language     (配置文件)
ChatML= Chat Markup Language           (对话结构)

共同特点:
✓ 使用特殊标记（tags）区分内容和结构
✓ 人类可读
✓ 机器可解析
✓ 语义明确

ChatML示例:
<|im_start|>user          ← 标记：用户开始
你好<|im_end|>             ← 标记：结束
<|im_start|>assistant     ← 标记：助手开始  
你好！<|im_end|>           ← 标记：结束

与HTML对比:
<p>这是段落</p>           ← HTML标记
<|im_start|>...<|im_end|> ← ChatML标记

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B-instruct")

# 查看当前vocab大小
print(f"Current vocab size: {len(tokenizer)}")  # 151643

# 添加自定义token
custom_tokens = [
    "<|custom_start|>",    # 自定义任务开始
    "<|custom_end|>",      # 自定义任务结束
    "<|思考|>",             # 中文思考标记
    "<|代码|>",             # 中文代码标记
]

num_added = tokenizer.add_special_tokens({
    "additional_special_tokens": custom_tokens
})

print(f"Added {num_added} tokens")
print(f"New vocab size: {len(tokenizer)}")  # 151647

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-4B-instruct")

# 方法1：扩展embedding（推荐用于少量token）
model.resize_token_embeddings(len(tokenizer))

# 方法2：手动初始化（更精细控制）
old_embeddings = model.get_input_embeddings()
new_embeddings = torch.nn.Embedding(
    len(tokenizer), 
    old_embeddings.embedding_dim
)

# 复制旧权重
new_embeddings.weight.data[:old_embeddings.num_embeddings] = \
    old_embeddings.weight.data

# 新token用平均值初始化
new_embeddings.weight.data[old_embeddings.num_embeddings:] = \
    old_embeddings.weight.data.mean(dim=0)

model.set_input_embeddings(new_embeddings)

# LM Head通常与input embeddings共享权重
# 如果不共享，需要单独扩展
if not model.config.tie_word_embeddings:
    old_lm_head = model.get_output_embeddings()
    new_lm_head = torch.nn.Linear(
        old_lm_head.in_features,
        len(tokenizer),
        bias=False
    )
    new_lm_head.weight.data[:old_lm_head.out_features] = \
        old_lm_head.weight.data
    model.set_output_embeddings(new_lm_head)

# 使用原有的双EOS策略
generation_config = {
    "eos_token_id": [151645, 151643],  # <|im_end|>, <|endoftext|>
    "pad_token_id": 151643,
}

# 添加任务特定的EOS
custom_eos_id = tokenizer.convert_tokens_to_ids("<|custom_end|>")

generation_config = {
    "eos_token_id": [
        151645,        # 保留对话结束
        custom_eos_id, # 自定义任务结束
    ],
}

# Instruct模型默认不支持<think>，需要修改template
custom_template = """
{%- if tools %}
    {{- '<|im_start|>system\n' }}
    {%- if messages[0].role == 'system' %}
        {{- messages[0].content + '\n\n' }}
    {%- endif %}
    {{- "You can use <think></think> tags for reasoning.\n" }}
    {{- "# Tools\n\n..." }}
    {{- '<|im_end|>\n' }}
{%- endif %}

{%- for message in messages %}
    {{- '<|im_start|>' + message.role + '\n' }}
    {{- message.content }}
    {{- '<|im_end|>\n' }}
{%- endfor %}

{%- if add_generation_prompt %}
    {{- '<|im_start|>assistant\n' }}
{%- endif %}
"""

tokenizer.chat_template = custom_template

from transformers import TrainingArguments, Trainer

# 1. 准备数据
train_dataset = [
    {
        "messages": [
            {"role": "user", "content": "解释RoPE"},
            {"role": "assistant", "content": "<think>需要解释位置编码...</think>RoPE是..."}
        ]
    }
]

# 2. 格式化为训练格式
def format_chat(example):
    text = tokenizer.apply_chat_template(
        example["messages"],
        tokenize=False,
        add_generation_prompt=False
    )
    return {"text": text}

formatted_dataset = [format_chat(x) for x in train_dataset]

# 3. Tokenize
def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        max_length=4096,  # 根据需求调整
    )

# 4. 训练参数
training_args = TrainingArguments(
    output_dir="./qwen3-custom",
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=16,
    learning_rate=2e-5,
    warmup_steps=100,
    logging_steps=10,
    save_strategy="steps",
    save_steps=500,
    bf16=True,  # Qwen3支持bf16
)

# 5. 开始训练
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
)

trainer.train()

graph LR
    A[Base-4B<br/>32K context] -->|SFT| B[Instruct-4B<br/>262K context]
    A -->|SFT + Reasoning| C[Thinking-4B<br/>262K context]

    style A fill:#f9f,stroke:#333
    style B fill:#bbf,stroke:#333
    style C fill:#bfb,stroke:#333

关键差异:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
特性           Base模型          Instruct模型
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
架构           完全相同           完全相同
参数量         完全相同           完全相同
词汇表         完全相同           完全相同
训练阶段       仅预训练           预训练+SFT+RLHF
输入形式       纯文本            ChatML格式对话
输出行为       文本续写          指令遵循/对话
适用场景       Fine-tuning基座   直接使用
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

结论: 架构无差异，行为由后训练塑造！

{
  "Base-4B": {
    "max_position": 32768,
    "rope_theta": 1000000,
    "eos_id": 151643,
    "eos_str": "<|endoftext|>"
  },
  "Instruct-4B": {
    "max_position": 262144,
    "rope_theta": 5000000,
    "eos_id": [151645, 151643],
    "eos_str": "<|im_end|>"
  }
}