| Qwen + Titans 在 BABILong(qa1/32k) 上的训练流程说明（基于 examples/train_qwen_titans_babilong.py） |
| ================================================================================ |
|
|
| 目的 |
| ---- |
| 本脚本把 BABILong QA1 32k 数据做成“固定长度 32k”的监督样本，然后用 Titans 的 NeuralMemory 作为长期记忆， |
| 以 chunk(流式)方式处理超长序列：每个 chunk 先读记忆并注入 memory tokens，再跑 Qwen 得到 hidden_states， |
| 写回记忆，最后只对“答案 token”位置计算 loss，用分组学习率训练（记忆模块高 LR、Qwen 低 LR）。 |
|
|
|
|
| 1. 数据到张量（Dataset / DataLoader） |
| ------------------------------------ |
| 入口：BABILongDataset(data_path, tokenizer, max_length=32768, answer_reserve_tokens=64, max_samples=...) |
|
|
| 1) 读取数据 |
| - data_path 指向 qa1/32k.json |
| - json.load() 读入一个 list，每条样本假设包含： |
| - input: 长上下文（context） |
| - question: 问题 |
| - target: 答案（文本） |
|
|
| 2) 构造 prompt + answer |
| - prompt 文本格式： |
| "{input}\n\nQuestion: {question}\nAnswer:" |
| - answer 文本：f" {target}"（前导空格） |
|
|
| 3) Tokenize + 截断 + 拼接（重点：固定长度） |
| - prompt_ids = tokenizer(prompt, truncation=True, max_length=max_length - reserve, add_special_tokens=True) |
| 说明：reserve=answer_reserve_tokens，强制给答案预留 token 空间，避免答案被 prompt 截断挤掉。 |
| - answer_ids = tokenizer(answer, add_special_tokens=False)，并截断到剩余空间 available。 |
| - input_ids = concat(prompt_ids, answer_ids)，再截断到 max_length。 |
|
|
| 4) labels（只监督答案 token） |
| - labels 初始全为 -100（忽略） |
| - 仅将 answer 对应区间（prompt 末尾开始）设置为真实 token id： |
| labels[start:end] = input_ids[start:end] |
| 所以 loss 只来自答案 token，prompt 与 padding 都不算。 |
|
|
| 5) padding + attention_mask（固定 shape 的关键） |
| - 任何样本都会 pad 到 max_length（默认 32768）： |
| - input_ids 用 pad_token_id 填充 |
| - labels 用 -100 填充 |
| - attention_mask：真实 token 为 1，padding 为 0 |
|
|
| 6) collate_fn |
| - Dataset 已保证固定长度，因此 collate_fn 只做 stack： |
| {k: torch.stack([...], dim=0)} |
|
|
| 为什么必须固定长度？ |
| - DDP/FSDP 下如果不同 rank 的序列长度不同，会导致 chunk 次数不同， |
| 从而 collective 调用顺序不一致，最终容易出现 NCCL timeout。 |
|
|
|
|
| 2. Qwen 加载与基础设置（Transformers） |
| ------------------------------------- |
| 入口：main() 中 AutoTokenizer / AutoModelForCausalLM |
|
|
| 1) tokenizer |
| - AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) |
| - 若 tokenizer.pad_token 为空，则设置为 tokenizer.eos_token（便于 padding） |
|
|
| 2) 兼容性禁用（flash-attn / torchao / torchvision） |
| - 脚本显式把 transformers 的可用性检测函数改成返回 False， |
| 避免环境里“包存在但与 torch 不兼容”导致 import 崩溃。 |
|
|
| 3) qwen_model |
| - AutoModelForCausalLM.from_pretrained( |
| model_path, |
| torch_dtype=bf16/fp16/fp32（默认 bf16）, |
| device_map=None（DDP/FSDP 不允许切分）, |
| trust_remote_code=True, |
| attn_implementation="sdpa"（强制走 PyTorch SDPA）, |
| low_cpu_mem_usage=True |
| ) |
| - qwen_model.to(device) |
| - qwen_model.config.use_cache=False |
| - gradient_checkpointing_enable()（省显存） |
|
|
| 备注：脚本标题写 Qwen3-4B，但流程对 Qwen3-3B 完全一致，只需替换 model_path。 |
|
|
|
|
| 3. Titans 长期记忆模块（TitansLongTermMemory） |
| --------------------------------------------- |
| 类：TitansLongTermMemory(hidden_size, chunk_size=64, batch_size=128, dim_head=64, heads=..., memory_depth=2) |
|
|
| 内部组件： |
| 1) MemoryMLP(dim=dim_head, depth=memory_depth, expansion_factor=2.0) |
| 2) NeuralMemory( |
| dim=hidden_size, |
| chunk_size=memory_chunk_size, |
| batch_size=memory_batch_size, |
| dim_head=memory_dim_head, |
| heads=memory_heads, |
| model=MemoryMLP, |
| momentum=True, |
| qk_rmsnorm=True, |
| pre_rmsnorm=True, |
| default_step_transform_max_lr=1e-2, |
| init_adaptive_step_bias=-6.0, |
| max_grad_norm=1.0, |
| spectral_norm_surprises=True, |
| use_accelerated_scan=True |
| ) |
| 3) memory_query_tokens：可学习查询 token（默认 16 个） |
| 4) memory_proj：LayerNorm + Linear + GELU + Linear（检索结果投影） |
|
|
| 写入（write）： |
| - self.neural_memory(hidden_states, state=state, store_mask=..., detach_mem_state=True) |
| - detach_mem_state=True：跨 chunk 不反传（更稳、更省显存） |
| - store_mask：把 padding 的位置 mask 掉，不写入记忆 |
|
|
| 读取（read）： |
| - 不用 self.neural_memory(queries, ...) 的 forward（因为 forward 默认 store+retrieve，会把 query 写进记忆污染） |
| - 从 state.states[0] 取 last_update，构造 weights，调用： |
| self.neural_memory.retrieve_memories(queries, weights) |
| - 再过 memory_proj 得到 memory tokens（embedding 形态） |
|
|
|
|
| 4. 把 Titans “加到” Qwen：包装模型 QwenTitansForBABILong |
| --------------------------------------------------------- |
| 类：QwenTitansForBABILong(qwen_model, config) |
|
|
| 成员： |
| - self.qwen：Transformers CausalLM（Qwen） |
| - self.long_term_memory：TitansLongTermMemory |
| - self.memory_gate：Linear+Sigmoid（参数分组会包含它；当前 forward 里未显式用 gate 融合） |
|
|
| 设备与 dtype 对齐： |
| - 为避免 device mismatch（尤其是多卡/切分环境），脚本会把长期记忆模块放到与 Qwen 输出所在 device 一致。 |
| - config.memory_fp32=True 时，记忆模块用 float32 计算；Qwen 保持 bf16/fp16。 |
|
|
|
|
| 5. 32k 序列的流式前向：chunk 循环（核心） |
| ---------------------------------------- |
| 入口：QwenTitansForBABILong.forward(input_ids, attention_mask, labels) |
|
|
| 关键配置： |
| - config.max_length = 32768（数据侧固定长度） |
| - config.chunk_size = 4096（Qwen 前向每次只跑 4k token） |
| - config.num_memory_tokens = 16（每个 chunk 注入的记忆 token 数） |
|
|
| 步骤： |
| 1) 切 chunk |
| - 将 input_ids 按 chunk_size 4096 切分为多个片段 (start, end) |
| - 为覆盖 chunk 边界的 next-token loss，处理时会带 1 个 overlap token： |
| proc_start = max(0, start - 1) |
| chunk_ids = input_ids[:, proc_start:end] |
|
|
| 2) 逐 chunk 执行：读记忆 → 注入 → 跑 Qwen → 写回记忆 → 算 loss |
| 2.1 读记忆（read） |
| - 若 memory_state 非空： |
| memory_tokens = long_term_memory.read(batch_size, memory_state, num_tokens=16) |
|
|
| 2.2 注入 memory tokens，并跑 Qwen 得 hidden_states（_process_chunk） |
| - token_embeds = qwen.model.embed_tokens(chunk_ids)（或 get_input_embeddings） |
| - 若有 memory_tokens： |
| a) nan_to_num + scale + clamp（避免记忆输出过大扰动导致 NaN） |
| - scale = config.memory_token_scale（默认 0.05） |
| - clip = config.memory_token_clip（默认 2.0） |
| b) 拼到 embedding 前面： |
| inputs_embeds = cat([memory_tokens, token_embeds], dim=1) |
| attention_mask 也在前面补 1 |
| - 必须走 qwen.model.forward(inputs_embeds=..., attention_mask=...) |
| （不能直接逐层调用 decoder layer，因为 Qwen3 attention 依赖 position_embeddings(cos/sin)） |
| - outputs.last_hidden_state 得到 hidden_states |
| - 去掉前缀 memory token 对应的 hidden，只保留真实 token 对应 hidden |
|
|
| 2.3 写回记忆（write） |
| - 只写原始 [start, end) 对应 hidden，避免 overlap 的 token 重复写入： |
| start>0 时跳过 hidden_full 的第一个位置 |
| - store_mask 同样对齐并屏蔽 padding |
| - memory_fp32=True 时写入前转 float32 |
| - detach_mem_state=True：跨 chunk 不反传 |
|
|
| 2.4 计算 loss（只在答案 token，且只算必要 logits） |
| - shift_hidden = hidden_full[:, :-1] |
| - shift_labels = labels[:, 1:] |
| - valid = (shift_labels != -100) |
| - 仅对 valid 位置 flatten： |
| hs = shift_hidden[valid] |
| targets = shift_labels[valid] |
| - logits = qwen.lm_head(hs)（只算这部分 vocab logits，避免为整段 32k 建巨型 logits 张量） |
| - CrossEntropyLoss(reduction="sum") 求和，再除以有效 token 数得到 token 平均 loss |
| - 脚本对 hs/logits 做 nan_to_num 兜底，降低单 chunk 非有限导致整步 NaN 的风险。 |
|
|
| 输出： |
| - out["loss"]：答案 token 的 token 平均 loss |
| - 可选：teacher-forcing 的 pred_ids/target_ids（评估打印样例时使用） |
|
|
|
|
| 6. 训练器（Trainer）：优化器、混合精度、梯度累积、分布式 |
| ---------------------------------------------------------- |
| 入口：Trainer(model, train_dataloader, eval_dataloader, config, ...) |
|
|
| 1) 参数分组学习率（关键） |
| - model.get_param_groups() 依据参数名分两组： |
| - 含 long_term_memory / memory_gate：lr = lr_memory（默认 1e-4） |
| - 其余（Qwen）：lr = lr_pretrained（默认 5e-6） |
| - AdamW(param_groups) |
|
|
| 2) Scheduler |
| - CosineAnnealingLR(T_max=总 optimizer step 数, eta_min=1e-7) |
| - total_steps = ceil((len(dataloader)*epochs) / gradient_accumulation_steps) |
|
|
| 3) 混合精度 |
| - 默认 bf16 autocast（torch.amp.autocast） |
| - 若 fp16 才启用 GradScaler；bf16 不用 scaler（通常更稳） |
|
|
| 4) 主训练循环（train） |
| - 每个 micro-batch： |
| a) autocast 前向，loss / gradient_accumulation_steps |
| b) 分布式一致性检查： |
| - 若任意 rank loss 非有限（nan/inf），all_reduce(MIN) 后所有 rank 一起 skip |
| - 目的：避免 DDP/FSDP 梯度同步死锁 |
| c) 梯度累积： |
| - 非同步步用 model.no_sync()（减少通信） |
| - 同步步： |
| - clip_grad_norm |
| - optimizer.step |
| - scheduler.step |
| - zero_grad |
| - global_step++ |
| d) 按 eval_steps 触发 evaluate() |
|
|
| 5) 评估（evaluate） |
| - 同样走模型 forward，但可选收集 pred_ids/target_ids |
| - 计算： |
| - answer-only loss |
| - token-level accuracy（答案 token） |
| - EM（样本级答案完全匹配，teacher-forcing decode 对比；需 tokenizer） |
|
|
|
|
| 7. DDP / FSDP 包裹与注意点 |
| -------------------------- |
| 1) init_distributed |
| - 通过 torchrun 的环境变量 RANK/WORLD_SIZE/LOCAL_RANK 初始化 NCCL |
| - torch.cuda.set_device(local_rank) |
|
|
| 2) DDP |
| - DDP(model, device_ids=[local_rank], output_device=local_rank) |
|
|
| 3) FSDP（可选） |
| - auto_wrap_policy 只 wrap Qwen3DecoderLayer（transformer 层） |
| - ignored_modules=[model.long_term_memory, model.memory_gate] |
| 让 Titans 记忆模块不被分片，便于稳定训练与单独保存/加载 |
|
|
|
|
| 8. 保存与加载 checkpoint |
| ----------------------- |
| 训练结束会保存两类 checkpoint（覆盖写入）： |
| 1) memory-only（小文件） |
| - final_memory_checkpoint.pt |
| - 保存 long_term_memory 与 memory_gate 的参数 + global_step + config |
|
|
| 2) full（大文件，可选，默认开启） |
| - final_full_checkpoint.pt |
| - 保存完整 model_state_dict（包含 Qwen + Titans），避免只存 memory 导致 Qwen 微调更新丢失 |
|
|
| eval-only 模式： |
| - --eval_only 时优先尝试加载 full checkpoint（若包含 model_state_dict） |
| - 无论是否 full，都会再按“只加载记忆模块参数”的方式加载 memory_state_dict（兼容 memory-only） |
| - 支持 --max_eval_samples 快速只评估前 N 条验证样本 |
|
|
|
|
| 9. 一句话总结（从数据到训练） |
| ---------------------------- |
| JSON 样本(input/question/target) |
| → 固定长度 32k 的 input_ids/attention_mask，labels 只标注答案 token |
| → 32k 按 4k chunk 循环：读 Titans 记忆→注入 16 个 memory tokens→跑 Qwen 得 hidden→写回记忆（跨 chunk detach）→只在答案 token 位置算 CE loss |
| → AdamW 分组学习率（记忆高 LR / Qwen 低 LR）+ bf16 autocast + 梯度累积 + DDP/FSDP |
| → 最终保存 memory-only 与可选的完整权重 checkpoint。 |
|
|
|
|
