Update full code snapshot (exclude data and model checkpoints)

.github/workflows/python-publish.yml

@@ -0,0 +1,36 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/test.yaml

@@ -0,0 +1,24 @@
+name: Tests the examples in README
+on: [push, pull_request]
+
+env:
+  TYPECHECK: True
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install dependencies
+        run: |
+          python -m pip install uv
+          python -m uv pip install --upgrade pip
+          python -m uv pip install torch --index-url https://download.pytorch.org/whl/nightly/cpu
+          python -m uv pip install -e .[test]
+      - name: Test with pytest
+        run: |
+          python -m pytest tests/

.gitignore

@@ -1,6 +1,174 @@
+train_local.py
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
 .pytest_cache/
-.mypy_cache/
-.ruff_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
 *.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

README.md

@@ -1,98 +1,187 @@
----
-license: mit
----
+<img src="./fig2.png" width="400px"></img>
 
-## 这里是什么
+<img src="./fig1.png" width="400px"></img>
 
-这是一个**最小代码快照**：只包含运行 `examples/train_qwen_titans_babilong_v4.py`（Qwen3 + Titans v4，BABILong QA1 32k，跨 chunk 梯度）所需的仓库内代码文件。
+## Titans - Pytorch
 
-- **不包含**：Qwen 权重、BABILong 数据集文件、以及原项目中 v4 未使用的其它模块
-- **用途**：方便复现实验/对照、归档 v4 代码与配置要点
+Unofficial implementation of [Titans](https://arxiv.org/abs/2501.00663) in Pytorch. Will also contain some explorations into architectures beyond their simple 1-4 layer MLP for the neural memory module, if it works well to any degree.
 
----
+[Paper review by Yannic](https://www.youtube.com/watch?v=v67plFw1nMw)
 
-## 代码清单（仅 v4 用到的仓库内代码）
+[Quick Colab Run](https://colab.research.google.com/drive/11cGgSABykte3qbK-hjzPgLif3-9UUejm?usp=sharing)
 
-- `examples/train_qwen_titans_babilong_v4.py`
-- `titans_pytorch/neural_memory.py`
-- `titans_pytorch/memory_models.py`
-- `titans_pytorch/__init__.py`（本仓库内的最小导出，避免引入 v4 未使用模块）
-- `LICENSE`（上游 `titans-pytorch` 的 MIT License）
+## Appreciation
 
----
+- [Eryk](https://github.com/sentialx) for sharing his early experimental results with me, positive for 2 layer MLP
 
-## 权重目录与数据集目录（v4 默认配置）
+## Install
 
-`examples/train_qwen_titans_babilong_v4.py` 的 `TrainingConfig` 里默认写死了本地路径（需要你按机器环境修改）：
-
-- **Qwen3 权重目录（HF snapshot）**：
-  - `model_path`：`/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554`
-- **BABILong QA1 32k 数据 JSON**：
-  - `data_path`：`/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json`
+```bash
+$ pip install titans-pytorch
+```
 
-说明：
-- 这两个路径**不会被上传到本仓库**，这里只做“路径与配置说明”。
-- v4 脚本当前**没有**提供 `--model_path/--data_path` 命令行参数；如需改路径，请直接改 `TrainingConfig` 里的默认值。
+## Usage
 
----
+```python
+import torch
+from titans_pytorch import NeuralMemory
 
-## 程序特性（v4 重点）
+mem = NeuralMemory(
+    dim = 384,
+    chunk_size = 64 # set to smaller chunk size for better perf on smaller sequence lengths (but more memory usage)
+).cuda()
 
-v4 的目标是：在 32k 长序列 chunk streaming 的训练中，尽可能实现**跨 chunk 的梯度流动**，并在显存可控的前提下训练“记忆模块 + 少量底座参数”。
+seq = torch.randn(2, 1024, 384).cuda()
+retrieved, mem_state = mem(seq)
 
-- **跨 chunk 梯度（核心）**
-  - `chunkwise_backward=False`：整段序列（32k）一起反传（而不是每个 chunk 独立反传）
-  - `detach_mem_state=False`：记忆 state 不 detach，使梯度图能跨 chunk 连接
-  - `cross_chunk_gradient_steps`：限制梯度回传穿过多少个历史 chunk（控制显存/稳定性）
+assert seq.shape == retrieved.shape
+```
 
-- **冻结策略（v4 header 描述）**
-  - 冻结 Qwen backbone 的大部分参数
-  - **保留可训练**：`embed_tokens`（输入适配）、`lm_head`（必要时解开 tied weights）、以及 Titans 记忆模块相关参数
+A transformer with the `MAC` configuration can be used as
 
-- **学习率分组（v4：更细粒度）**
-  - `lr_memory` / `lr_memory_attention`：记忆模块（含 deep integration 相关）
-  - `lr_embed`：`embed_tokens`
-  - `lr_lm_head`：`lm_head`
+```python
+import torch
+from titans_pytorch import MemoryAsContextTransformer
 
-- **稳定性与兼容性**
-  - 脚本开头主动禁用/模拟 `torchao`，避免 `transformers` 导入时的版本冲突
-  - 建议开启 `gradient_checkpointing=True`（v4 默认开启），缓解 32k full backward 的显存压力
-  - 支持 DDP/FSDP（FSDP auto-wrap `Qwen3DecoderLayer` 与 v4 自定义层）
+transformer = MemoryAsContextTransformer(
+    num_tokens = 256,
+    dim = 256,
+    depth = 2,
+    segment_len = 128,              # local attention window size
+    num_persist_mem_tokens = 4,
+    num_longterm_mem_tokens = 16,
+)
 
-- **评估与保存**
-  - 评估指标为 **answer-only**（只在 `labels != -100` 的答案 token 上计算 loss/acc）
-  - 输出：
-    - `eval_metrics.jsonl`
-    - `final_memory_checkpoint.pt`（仅保存 requires_grad 且属于记忆/门控/embed/head 的参数）
-    - `final_full_checkpoint.pt`（可选保存完整 state_dict）
+token_ids = torch.randint(0, 256, (1, 1023))
 
----
+loss = transformer(token_ids, return_loss = True) # (1, 1023, 256)
+loss.backward()
 
-## 运行方式（示例）
+# after much training
 
-以下命令仅作参考；请先在脚本中把 `model_path/data_path` 改成你机器上的真实路径。
+sampled = transformer.sample(token_ids[:, :4], 512)
+```
 
-- **单机多卡（FSDP）训练**：
+## Experiments
 
 ```bash
-torchrun --standalone --nproc_per_node=4 examples/train_qwen_titans_babilong_v4.py --fsdp
+$ pip install uv
 ```
 
-- **评估（eval_only）**：
+Then modify `train_mac.py` and run it to query nature
 
 ```bash
-python examples/train_qwen_titans_babilong_v4.py --eval_only --ckpt_path ./outputs/qwen_titans_babilong_v4/final_memory_checkpoint.pt
+$ uv run train_mac.py
 ```
 
----
+## Citations
 
-## 依赖提示（非完整列表）
+```bibtex
+@inproceedings{Behrouz2024TitansLT,
+    title   = {Titans: Learning to Memorize at Test Time},
+    author  = {Ali Behrouz and Peilin Zhong and Vahab S. Mirrokni},
+    year    = {2024},
+    url     = {https://api.semanticscholar.org/CorpusID:275212078}
+}
+```
 
-该脚本依赖的关键 Python 包包括：`torch`、`transformers`、`einops`、`tqdm`、`tensordict`、`assoc-scan`、`einx` 等。
+```bibtex
+@article{Sun2024LearningT,
+    title   = {Learning to (Learn at Test Time): RNNs with Expressive Hidden States},
+    author  = {Yu Sun and Xinhao Li and Karan Dalal and Jiarui Xu and Arjun Vikram and Genghan Zhang and Yann Dubois and Xinlei Chen and Xiaolong Wang and Oluwasanmi Koyejo and Tatsunori Hashimoto and Carlos Guestrin},
+    journal = {ArXiv},
+    year    = {2024},
+    volume  = {abs/2407.04620},
+    url     = {https://api.semanticscholar.org/CorpusID:271039606}
+}
+```
 
----
+```bibtex
+@inproceedings{Yang2024GatedDN,
+    title   = {Gated Delta Networks: Improving Mamba2 with Delta Rule},
+    author  = {Songlin Yang and Jan Kautz and Ali Hatamizadeh},
+    year    = {2024},
+    url     = {https://api.semanticscholar.org/CorpusID:274598177}
+}
+```
 
-## 许可证与来源
+```bibtex
+@inproceedings{Nguyen2024TurningUT,
+    title   = {Turning Up the Heat: Min-p Sampling for Creative and Coherent LLM Outputs},
+    author  = {Minh Nguyen and Andrew Baker and Clement Neo and Allen Roush and Andreas Kirsch and Ravid Shwartz-Ziv},
+    year    = {2024},
+    url     = {https://api.semanticscholar.org/CorpusID:270870613}
+}
+```
 
-本仓库内的 `titans_pytorch/*` 代码来自上游 `titans-pytorch`（MIT License），对应许可见 `LICENSE`。
+```bibtex
+@article{Zhu2024HyperConnections,
+    title   = {Hyper-Connections},
+    author  = {Defa Zhu and Hongzhi Huang and Zihao Huang and Yutao Zeng and Yunyao Mao and Banggu Wu and Qiyang Min and Xun Zhou},
+    journal = {ArXiv},
+    year    = {2024},
+    volume  = {abs/2409.19606},
+    url     = {https://api.semanticscholar.org/CorpusID:272987528}
+}
+```
 
+```bibtex
+@article{Zhou2024ValueRL,
+    title   = {Value Residual Learning For Alleviating Attention Concentration In Transformers},
+    author  = {Zhanchao Zhou and Tianyi Wu and Zhiyun Jiang and Zhenzhong Lan},
+    journal = {ArXiv},
+    year    = {2024},
+    volume  = {abs/2410.17897},
+    url     = {https://api.semanticscholar.org/CorpusID:273532030}
+}
+```
+
+```bibtex
+@software{Kyrylov_Accelerated_Scan_2024,
+    author  = {Kyrylov, Volodymyr},
+    doi     = {10.5281/zenodo.10600962},
+    title   = {Accelerated Scan},
+    version = {0.1.2},
+    year    = {2024}
+}
+```
+
+```bibtex
+@misc{wang2025testtimeregressionunifyingframework,
+    title   = {Test-time regression: a unifying framework for designing sequence models with associative memory},
+    author  = {Ke Alexander Wang and Jiaxin Shi and Emily B. Fox},
+    year    = {2025},
+    eprint  = {2501.12352},
+    archivePrefix = {arXiv},
+    primaryClass = {cs.LG},
+    url     = {https://arxiv.org/abs/2501.12352},
+}
+```
+
+```bibtex
+@misc{jordan2024muon,
+    author  = {Keller Jordan and Yuchen Jin and Vlado Boza and Jiacheng You and
+                    Franz Cesista and Laker Newhouse and Jeremy Bernstein},
+    title   = {Muon: An optimizer for hidden layers in neural networks},
+    year    = {2024},
+    url     = {https://kellerjordan.github.io/posts/muon/}
+}
+```
+
+```bibtex
+@inproceedings{Zhang2025TestTimeTD,
+    title   = {Test-Time Training Done Right},
+    author  = {Tianyuan Zhang and Sai Bi and Yicong Hong and Kai Zhang and Fujun Luan and Songlin Yang and Kalyan Sunkavalli and William T. Freeman and Hao Tan},
+    year    = {2025},
+    url     = {https://api.semanticscholar.org/CorpusID:279071244}
+}
+```
+
+```bibtex
+@inproceedings{Behrouz2025ATLASLT,
+    title  = {ATLAS: Learning to Optimally Memorize the Context at Test Time},
+    author = {Ali Behrouz and Ze-Minghui Li and Praneeth Kacham and Majid Daliri and Yuan Deng and Peilin Zhong and Meisam Razaviyayn and Vahab S. Mirrokni},
+    year   = {2025},
+    url    = {https://api.semanticscholar.org/CorpusID:278996373}
+}
+```

examples/BABILONG_DATA_PIPELINE.md

@@ -0,0 +1,177 @@
+## BABILong（QA1 / 32k）数据处理与训练数据流说明
+
+本文档描述当前仓库里 **BABILong QA1（32k.json）** 在训练脚本中的实际处理方式：从原始 JSON，到 tokenizer、padding、labels、DataLoader，再到喂给 `QwenTitansForBABILong` 的整条数据流。
+
+代码入口：
+
+- `examples/train_qwen_titans_babilong.py`
+
+---
+
+## 数据源与样本格式
+
+默认数据路径（可改）：
+
+- `TrainingConfig.data_path = /data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json`
+
+文件内容为一个 JSON 列表，每条样本大体包含：
+
+- `input`：长上下文（故事/事实）
+- `question`：问题
+- `target`：答案（短文本）
+
+训练脚本会把它拼成 prompt：
+
+```
+{input}
+
+Question: {question}
+Answer:
+```
+
+并把答案拼接为（答案前加空格）：
+
+```
+ {target}
+```
+
+---
+
+## 关键目标：固定长度样本（FSDP/DDP 必须）
+
+当前实现 **强制每条样本输出固定长度 `config.max_length`（默认 32768）**，原因：
+
+- 模型前向会按 `chunk_size` 把序列分 chunk 循环处理
+- 在 FSDP/DDP 下，如果不同 rank 的序列长度不同 → chunk 数不同 → collectives 顺序不一致 → NCCL watchdog 超时
+
+因此数据侧必须固定长度，保证每步每个 rank 的 chunk 次数一致。
+
+相关参数：
+
+- `TrainingConfig.max_length`：固定输出长度（默认 32768）
+- `TrainingConfig.answer_reserve_tokens`：给答案预留 token 数（默认 64）
+
+---
+
+## Dataset：`BABILongDataset.__getitem__` 的处理流程
+
+位置：`examples/train_qwen_titans_babilong.py`
+
+### Step 1：tokenize prompt（截断）
+
+- 对 prompt 进行 tokenize
+- 最大长度限制为 `max_length - answer_reserve_tokens`
+- `add_special_tokens=True`（让 tokenizer 自己加 BOS/EOS 等需要的特殊 token）
+
+### Step 2：tokenize answer（不加特殊 token）
+
+- 对 `" {target}"` tokenize
+- `add_special_tokens=False`
+
+### Step 3：拼接并截断到 `max_length`
+
+- 先算 prompt token 数 `len(prompt_ids)`
+- answer 只保留剩余可用空间：`available = max_length - len(prompt_ids)`
+- `input_ids = concat(prompt_ids, answer_ids[:available])`
+
+### Step 4：构造 `labels`（只监督答案）
+
+- `labels` 初始全为 `-100`
+- 只有答案 token 的位置才写入对应 token id
+- 这样 loss 只在答案 token 上计算（prompt 与 padding 不参与 loss）
+
+### Step 5：padding 到固定长度 + attention_mask
+
+如果拼接后长度 `< max_length`：
+
+- `input_ids` 右侧 pad 到 `max_length`（pad_id = tokenizer.pad_token_id）
+- `labels` pad 的部分保持 `-100`
+- `attention_mask`：
+  - 真 token 为 1
+  - padding 为 0
+
+> 备注：脚本在 `main()` 里如果发现 `tokenizer.pad_token is None`，会设置 `pad_token = eos_token`，确保有 pad_id。
+
+---
+
+## DataLoader 与分布式采样
+
+### DataLoader
+
+- `batch_size = 1`（32k 序列 + chunk streaming，一般只能 1）
+- `collate_fn` 只做 stack（Dataset 已固定长度，不做动态 padding）
+- `num_workers = 0`（避免多进程复制大张量带来的额外开销/不稳定）
+
+### 训练/验证切分
+
+- `random_split(full_dataset, [train_size, eval_size], generator=manual_seed(config.seed))`
+- 默认 `train_ratio=0.9`
+
+### 分布式（torchrun）
+
+当使用 `torchrun` 启动时：
+
+- 训练集：`DistributedSampler(..., shuffle=True, seed=config.seed)`
+- 验证集：`DistributedSampler(..., shuffle=False)`
+- 每个 epoch 会调用 `train_sampler.set_epoch(epoch)`，保证各 rank shuffle 一致
+
+---
+
+## 喂给模型的数据张量形状
+
+由于固定长度：
+
+- `input_ids`: `[B, max_length]`（默认 `[1, 32768]`）
+- `attention_mask`: `[B, max_length]`
+- `labels`: `[B, max_length]`
+
+模型内部再按 `chunk_size`（默认 4096）切成 8 个 chunk 进行 streaming。
+
+---
+
+## 训练与日志（跟数据流相关的行为）
+
+- **梯度累积**：`gradient_accumulation_steps=8`
+  - 每 8 个 micro-batch 才做一次 optimizer step
+- **每 80 个 batch 输出一次**：
+  - `--log_every_batches 80`（默认 80）
+  - 会自动换算成 `logging_steps = ceil(log_every_batches / gradient_accumulation_steps)`
+  - 并在 rank0 额外 `logger.info(...)` 打一行到终端，方便 `tee` 保存
+
+---
+
+## 运行方式（推荐）
+
+### 8 卡 + FSDP
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 \
+torchrun --standalone --nproc_per_node=8 \
+  examples/train_qwen_titans_babilong.py --fsdp --log_every_batches 80
+```
+
+### 快速小跑（2 卡调试）
+
+```bash
+CUDA_VISIBLE_DEVICES=0,1 \
+torchrun --standalone --nproc_per_node=2 \
+  examples/train_qwen_titans_babilong.py --fsdp --max_samples 8 --num_epochs 1 --eval_steps 1000000
+```
+
+---
+
+## 训练产物（输出）
+
+默认输出目录：
+
+- `TrainingConfig.output_dir = ./outputs/qwen_titans_babilong`
+
+默认只保存一个 final checkpoint（覆盖写入）：
+
+- `final_memory_checkpoint.pt`
+
+内容包括：
+
+- `memory_state_dict`：只包含 `long_term_memory` / `memory_gate` 的参数（体积更小）
+- `global_step`
+

examples/QWEN3_TITANS_MEMORY_INTEGRATION.md

@@ -0,0 +1,169 @@
+## Qwen3-4B-Instruct + Titans NeuralMemory（MAC 风格）集成流程说明
+
+本文档描述当前仓库里 **“Qwen3-4B-Instruct 作为 Core（短期处理器） + Titans NeuralMemory 作为长期记忆”** 的实际落地方式，代码入口为：
+
+- `examples/train_qwen_titans_babilong.py`
+
+---
+
+## 整体思路（Streaming + MAC）
+
+- **Core**：`Qwen3-4B-Instruct` 只负责处理一个可控窗口大小的 chunk（例如 4k）。
+- **Long-term Memory**：`titans_pytorch.NeuralMemory` 维护一个随 chunk 滚动更新的 **memory_state**（快权重/动量等状态）。
+- **MAC（Memory-as-Context）风格注入**：每个 chunk 开始时，从长期记忆 **读取一小段 memory tokens**，将它们 **作为“额外上下文 token”前缀** 拼到 chunk 前面，让 Qwen 在注意力里直接可用。
+
+这使得整体序列长度可以远大于 Qwen 的单次可承受长度：Qwen 看到的是「当前 chunk + 记忆 tokens」，而长期信息通过 Titans 的 state 跨 chunk 保留与检索。
+
+---
+
+## 关键代码组件
+
+### 1) `TitansLongTermMemory`：长期记忆模块封装
+
+位置：`examples/train_qwen_titans_babilong.py`
+
+内部包含：
+
+- **`self.neural_memory: NeuralMemory`**
+  - `dim = hidden_size`
+  - `heads = config.memory_heads`
+  - `dim_head = config.memory_dim_head`
+  - `model = MemoryMLP(dim=dim_head, depth=config.memory_depth, ...)`
+  - 写入稳定性相关配置：`default_step_transform_max_lr / init_adaptive_step_bias / max_grad_norm / ...`
+- **`self.memory_query_tokens: nn.Parameter`**
+  - 形状 `[1, 16, hidden_size]`
+  - 作为“从长期记忆里检索”的查询 token（可训练）
+- **`self.memory_proj: nn.Sequential`**
+  - 将 `retrieve_memories()` 的输出再映射回适合注入 Qwen 的表征空间
+
+#### `read()`：只读检索（不会写入）
+
+当前实现 **明确避免** 使用 `NeuralMemory.forward(queries)` 来读：
+
+- `NeuralMemory.forward()` 默认会同时做 store + retrieve
+- 如果用 queries 调 `forward()`，会把 query 也写进记忆，造成污染
+
+因此当前实现采用：
+
+- 从 `memory_state.states[0]` 取出“最新快权重”作为 `weights`
+- 调用 `self.neural_memory.retrieve_memories(queries, weights)` 完成纯检索
+
+#### `write()`：写入更新（跨 chunk 不反传）
+
+写入时调用：
+
+- `self.neural_memory(hidden_states, state=..., store_mask=..., detach_mem_state=True)`
+
+其中 `detach_mem_state=True` 的含义是：
+
+- **记忆 state 的更新过程不参与跨 chunk 的反向传播**
+- 优点：训练更稳、显存更省、避免长链条反传导致 NaN/爆显存
+- 代价：loss 不会“端到端”优化写入更新过程（但仍可优化 query/proj 等参数）
+
+---
+
+### 2) `QwenTitansForBABILong`：Qwen + 记忆的主包装模型
+
+位置：`examples/train_qwen_titans_babilong.py`
+
+包含：
+
+- `self.qwen`: `AutoModelForCausalLM` 加载的 Qwen3
+- `self.long_term_memory`: `TitansLongTermMemory`
+- `self.memory_gate`: 当前仅占位（参数会训练/保存，但 **forward 里未实际使用**，目前是“纯 memory tokens 前缀注入”路线）
+
+并做了关键的 device/dtype 对齐：
+
+- Qwen 通常用 `bf16`
+- 记忆模块可以强制用 `float32`（`config.memory_fp32=True`）以降低 NaN 风险
+
+---
+
+## 前向流程（单个样本，Streaming）
+
+入口：`QwenTitansForBABILong.forward(input_ids, attention_mask, labels)`
+
+### Step 0：输入形状与 chunk 划分
+
+- 输入被固定为 `seq_len = config.max_length`（例如 32768）
+- 用 `chunk_size`（例如 4096）切成多个 chunks（例如 8 个）
+- 为了覆盖 chunk 边界的 next-token 预测，每个 chunk 会带 **1 个 overlap token**：
+  - `proc_start = max(0, start - 1)`
+  - 当前 chunk 实际处理 `[proc_start, end)`，但写入记忆只写 `[start, end)`（避免重复写 overlap）
+
+### Step 1：从长期记忆读取 memory tokens
+
+- 初始 `memory_state = None`：第一段不会注入 memory tokens
+- 从第二个 chunk 开始：
+  - `memory_tokens = long_term_memory.read(batch_size, memory_state, num_tokens=config.num_memory_tokens)`
+
+### Step 2：把 memory tokens 作为前缀注入 Qwen（MAC）
+
+在 `_process_chunk()` 中完成：
+
+- 先拿到 token embeddings：`token_embeds = qwen.model.embed_tokens(chunk_ids)`
+- 若存在 memory tokens：
+  - `nan_to_num + scale + clamp`（避免记忆扰动太大引发不稳定）
+  - `torch.cat([memory_tokens, token_embeds], dim=1)` 作为 `inputs_embeds`
+  - 同步扩展 `attention_mask`：为 memory token 补 1
+
+### Step 3：调用 `self.qwen.model(...)` 做 chunk 前向
+
+这里必须走 `Qwen3Model.forward()`（即 `self.qwen.model`），原因是：
+
+- Qwen3Attention 依赖 `position_embeddings=(cos, sin)` 等由 `Qwen3Model` 内部生成并传入
+- 不能直接逐层调用 `Qwen3DecoderLayer`（会出现 `cos, sin = position_embeddings` 的 None 问题）
+
+得到：
+
+- `hidden_states = outputs.last_hidden_state`
+- 如果注入了 memory tokens，则把它们从��出里切掉：`hidden_states = hidden_states[:, num_mem:]`
+
+### Step 4：把 chunk 的 hidden 写入 Titans 记忆
+
+写入采用：
+
+- 去掉 overlap 的 `chunk_hidden`
+- `store_mask` 用 `attention_mask`（padding=0 的位置不写入）
+- 调用 `long_term_memory.write(mem_inp, state=memory_state, store_mask=...)`
+
+返回并更新：
+
+- `memory_state = next_state`
+
+### Step 5：只在“答案 tokens”上计算 loss（省显存）
+
+`labels` 中：
+
+- prompt 与 padding 为 `-100`
+- 仅答案 token 有监督标签
+
+loss 计算策略：
+
+- 只选择 `labels != -100` 的位置
+- 对应 hidden 做 shift（next-token）
+- 仅对有效位置做 `lm_head` 与交叉熵（避免全 vocab、全序列 logits 占用巨大显存）
+
+---
+
+## 分布式训练（FSDP）集成要点
+
+代码入口仍在：`examples/train_qwen_titans_babilong.py`
+
+- **必须 `device_map=None`**：FSDP/DDP 不允许 HF 自动切分到多卡
+- **强制 `attn_implementation="sdpa"`**：避免环境里 flash-attn/torchao/torchvision 的兼容性导入问题
+- **FSDP wrap 策略**：
+  - 只 wrap `Qwen3DecoderLayer`
+  - `ignored_modules=[model.long_term_memory, model.memory_gate]`：记忆模块不参与分片（便于保存/调试，也避免小模块反复 allgather）
+- **固定长度输入（非常关键）**：
+  - FSDP 需要所有 rank 每步进入 collectives 的顺序一致
+  - 如果不同 rank 的 chunk 次数不同，会出现 `_ALLGATHER_BASE` / `ALLREDUCE` 顺序错位，从而 NCCL watchdog 超时
+  - 因此数据侧必须 pad 到 `config.max_length`，保证每步 chunk 数一致
+
+---
+
+## 当前实现的取舍与可改进点
+
+- **`memory_gate` 目前未参与 forward**：现在是纯“memory tokens 作为上下文前缀”的 MAC 注入；如果需要门控融合，需要在 forward 里显式引入 gate 计算与融合路径。
+- **`detach_mem_state=True`**：训练更稳/省显存，但不会端到端训练“写入更新过程”；如果后续要做更强的端到端学习，需要重新评估这条策略（以及显存与稳定性代价）。
+

examples/QWEN_TITANS_BABILONG_TRAINING_FLOW_CN.txt

@@ -0,0 +1,272 @@
+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。
+

examples/TITANS_ANALYSIS_CN.md

@@ -0,0 +1,212 @@
+# Titans-PyTorch 代码分析报告
+
+## 概述
+
+Titans 是 Google 在 2024 年底提出的新型长期记忆机制，核心思想是**将神经网络的权重作为长期记忆**，通过**测试时训练（Test-Time Training, TTT）**来动态存储和检索信息。
+
+## 核心组件分析
+
+### 1. NeuralMemory (神经记忆模块)
+
+```
+位置: titans_pytorch/neural_memory.py
+```
+
+这是 Titans 的核心组件，主要特点：
+
+#### 1.1 记忆存储机制
+- **记忆载体**: 使用 MLP（或其他模型）的权重作为记忆存储
+- **存储过程**: 通过计算梯度来"写入"记忆
+  ```python
+  # 损失函数：|M(k) - v|²
+  # 其中 M 是记忆网络，k 是 key，v 是 value
+  def default_loss_fn(pred, target):
+      return (pred - target).pow(2).mean(dim = -1)
+  ```
+
+#### 1.2 记忆检索机制
+- 将 query 输入到记忆网络，获取存储的信息
+- 使用 `functional_call` 进行前向传播
+
+#### 1.3 关键参数
+
+| 参数 | 说明 | 建议值 |
+|------|------|--------|
+| `chunk_size` | 分块大小，控制记忆更新粒度 | 32-128 |
+| `batch_size` | 批处理大小，控制权重更新频率 | 64-256 |
+| `momentum` | 是否使用动量优化 | True |
+| `momentum_order` | 动量阶数 | 1-2 |
+| `dim_head` | 每个头的维度 | 64 |
+| `heads` | 注意力头数 | 4-8 |
+
+### 2. MemoryMLP (记忆网络)
+
+```
+位置: titans_pytorch/memory_models.py
+```
+
+Titans 提供了多种记忆网络架构：
+
+| 模型 | 描述 | 适用场景 |
+|------|------|----------|
+| `MemoryMLP` | 基础 MLP，来自 TTT 论文 | 通用场景 |
+| `MemorySwiGluMLP` | SwiGLU 激活的 MLP | 更强表达能力 |
+| `FactorizedMemoryMLP` | 分解权重的 MLP | 降低参数量 |
+| `MemoryAttention` | 使用注意力的记忆 | 复杂依赖关系 |
+| `GatedResidualMemoryMLP` | 门控残差 MLP | 深层网络 |
+
+### 3. MemoryAsContextTransformer (MAC Transformer)
+
+```
+位置: titans_pytorch/mac_transformer.py
+```
+
+将 NeuralMemory 集成到 Transformer 中的完整实现：
+
+#### 核心设计
+1. **Segment 分段**: 将长序列分成固定长度的 segment
+2. **Longterm Memory Tokens**: 在每个 segment 开头添加记忆 token
+3. **Persistent Memory**: 全局共享的持久记忆 token
+4. **记忆更新**: 通过 NeuralMemory 动态更新记忆
+
+## 将 Titans 集成到 Qwen 的三种方案
+
+### 方案 1: 外部包装器（最简单）
+
+```python
+class TitansMemoryWrapper(nn.Module):
+    def __init__(self, qwen_model, ...):
+        self.qwen = qwen_model
+        self.neural_memory = NeuralMemory(...)
+        
+    def forward(self, input_ids, memory_state=None):
+        # 1. 获取 Qwen 隐藏状态
+        hidden = self.qwen(..., output_hidden_states=True).hidden_states[-1]
+        
+        # 2. 记忆增强
+        retrieved, next_state = self.neural_memory(hidden, state=memory_state)
+        
+        # 3. 融合输出
+        enhanced = hidden + gate * retrieved
+        return enhanced, next_state
+```
+
+**优点**: 不修改 Qwen 内部结构，易于实现
+**缺点**: 记忆与模型的交互较浅
+
+### 方案 2: 层级集成（中等复杂度）
+
+```python
+class QwenDecoderLayerWithMemory(nn.Module):
+    def forward(self, hidden_states, memory_state=None):
+        # 标准 attention
+        attn_output = self.self_attn(hidden_states)
+        hidden_states = residual + attn_output
+        
+        # Titans 记忆增强
+        retrieved, next_state = self.neural_memory(hidden_states, state=memory_state)
+        hidden_states = hidden_states + gate * retrieved
+        
+        # 标准 FFN
+        hidden_states = self.mlp(hidden_states)
+        return hidden_states, next_state
+```
+
+**优点**: 记忆与模型深度集成
+**缺点**: 需要修改模型结构
+
+### 方案 3: Memory-as-Context（最接近论文）
+
+```python
+class QwenWithMAC(nn.Module):
+    def __init__(self, qwen_model, ...):
+        self.qwen = qwen_model
+        self.longterm_mem = nn.Parameter(...)  # 长期记忆 token
+        self.persist_mem = nn.Parameter(...)   # 持久记忆 token
+        self.neural_memories = nn.ModuleDict({
+            '2': NeuralMemory(...),
+            '4': NeuralMemory(...),
+            '6': NeuralMemory(...),
+        })
+```
+
+**优点**: 最接近论文实现，效果最好
+**缺点**: 实现复杂，需要处理位置编码
+
+## 关键实现细节
+
+### 1. 梯度计算
+
+Titans 使用 `torch.func.vmap` 和 `torch.func.grad` 进行高效的批量梯度计算：
+
+```python
+from torch.func import functional_call, vmap, grad
+
+def forward_and_loss(params, inputs, loss_weights, target):
+    pred = functional_call(self.memory_model, params, inputs)
+    loss = (pred - target).pow(2).mean(dim=-1)
+    return (loss * loss_weights).sum(), loss
+
+grad_fn = grad(forward_and_loss, has_aux=True)
+self.per_sample_grad_fn = vmap(grad_fn, in_dims=(0, 0, 0, 0))
+```
+
+### 2. Associative Scan（关联扫描）
+
+用于高效计算动量和权重衰减：
+
+```python
+from assoc_scan import AssocScan
+
+self.assoc_scan = AssocScan(use_accelerated=True)
+# 用于计算: x[t] = α[t] * x[t-1] + (1-α[t]) * input[t]
+```
+
+### 3. 自适应学习率
+
+每个 token 的学习率是动态学习的：
+
+```python
+adaptive_lr = self.to_adaptive_step(seq)
+adaptive_lr = adaptive_lr.sigmoid() * max_lr  # 限制在 [0, max_lr]
+```
+
+## 性能优化建议
+
+### 1. chunk_size 选择
+- 较小的 chunk_size（如 32）: 更细粒度的记忆更新，但内存占用更大
+- 较大的 chunk_size（如 128）: 更高效，但记忆粒度较粗
+
+### 2. batch_size 选择
+- 较小的 batch_size（如 64）: 更频繁的权重更新，可能更好地捕捉细节
+- 较大的 batch_size（如 256）: 训练更稳定，但可能丢失细节
+
+### 3. 使用加速扫描
+```python
+NeuralMemory(..., use_accelerated_scan=True)
+```
+
+### 4. 使用 FlexAttention（PyTorch 2.0+）
+```python
+MemoryAsContextTransformer(..., use_flex_attn=True)
+```
+
+## 安装和依赖
+
+```bash
+pip install titans-pytorch
+
+# 完整依赖
+pip install torch einops tensordict assoc-scan rotary-embedding-torch x-transformers hyper-connections axial-positional-embedding
+```
+
+## 参考文献
+
+1. [Titans: Learning to Memorize at Test Time](https://arxiv.org/abs/2401.00000) - Google, 2024
+2. [Learning to (Learn at Test Time): RNNs with Expressive Hidden States](https://arxiv.org/abs/2407.04620) - TTT Paper
+3. [Gated Delta Networks](https://arxiv.org/abs/2401.00000) - Momentum 机制参考
+
+## 示例代码位置
+
+详细的集成示例代码请参考:
+`examples/qwen_with_titans_memory.py`

examples/eval_qwen_baseline.py

@@ -0,0 +1,515 @@
+"""
+Qwen3-4B baseline evaluation on BABILong QA1 (32k).
+
+This script evaluates the pretrained Qwen model WITHOUT any training,
+using the same chunk-based streaming approach as the Titans training script.
+
+Purpose: Establish a baseline to compare with Titans memory-augmented models.
+"""
+
+import os
+import json
+import math
+import argparse
+import logging
+from dataclasses import dataclass
+from typing import Optional, Dict, List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+from tqdm import tqdm
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class EvalConfig:
+    # paths - same as training config
+    model_path: str = "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554"
+    data_path: str = "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json"
+    output_dir: str = "./outputs/qwen_baseline_eval"
+
+    # streaming settings - same as training
+    chunk_size: int = 8192
+    max_length: int = 32768
+    answer_reserve_tokens: int = 64
+
+    # evaluation
+    batch_size: int = 1  # use 1 for simplicity in baseline eval
+    max_samples: Optional[int] = 500  # same as training default
+    print_examples: int = 20
+
+    # precision
+    bf16: bool = True
+    fp16: bool = False
+    use_tf32: bool = True
+
+    seed: int = 42
+
+
+class BABILongDataset(Dataset):
+    """Same dataset class as training script for consistency."""
+
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer,
+        max_length: int = 32768,
+        answer_reserve_tokens: int = 64,
+        max_samples: Optional[int] = None,
+    ):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.answer_reserve_tokens = answer_reserve_tokens
+
+        logger.info(f"Loading dataset: {data_path}")
+        with open(data_path, "r") as f:
+            self.data = json.load(f)
+
+        if max_samples:
+            self.data = self.data[:max_samples]
+
+        logger.info(f"Dataset size: {len(self.data)}")
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        text = f"{item['input']}\n\nQuestion: {item['question']}\nAnswer:"
+        target = item["target"]
+
+        pad_id = self.tokenizer.pad_token_id or 0
+        reserve = int(self.answer_reserve_tokens)
+
+        prompt_ids = self.tokenizer(
+            text,
+            max_length=max(self.max_length - reserve, 1),
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        answer_ids = self.tokenizer(
+            f" {target}",
+            add_special_tokens=False,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        available = max(self.max_length - prompt_ids.numel(), 0)
+        answer_ids = answer_ids[:available]
+
+        input_ids = torch.cat([prompt_ids, answer_ids], dim=0)[: self.max_length]
+
+        labels = torch.full_like(input_ids, fill_value=-100)
+        if answer_ids.numel() > 0:
+            start = prompt_ids.numel()
+            end = min(start + answer_ids.numel(), labels.numel())
+            labels[start:end] = input_ids[start:end]
+
+        seq_len = input_ids.numel()
+        if seq_len < self.max_length:
+            pad_len = self.max_length - seq_len
+            input_ids = F.pad(input_ids, (0, pad_len), value=int(pad_id))
+            labels = F.pad(labels, (0, pad_len), value=-100)
+            attention_mask = torch.cat(
+                [torch.ones(seq_len, dtype=torch.long), torch.zeros(pad_len, dtype=torch.long)],
+                dim=0,
+            )
+        else:
+            attention_mask = torch.ones(self.max_length, dtype=torch.long)
+
+        return {
+            "input_ids": input_ids.to(dtype=torch.long),
+            "labels": labels.to(dtype=torch.long),
+            "attention_mask": attention_mask,
+            "target_text": target,  # keep original target for comparison
+        }
+
+
+def collate_fn(batch):
+    # separate target_text from tensor fields
+    target_texts = [b.pop("target_text") for b in batch]
+    tensor_batch = {k: torch.stack([b[k] for b in batch], dim=0) for k in batch[0].keys()}
+    tensor_batch["target_texts"] = target_texts
+    return tensor_batch
+
+
+class QwenChunkwiseEvaluator:
+    """
+    Evaluates Qwen model using chunk-wise streaming (same as training).
+    
+    Key difference from training: NO memory module, just pure Qwen forward pass.
+    Each chunk is processed independently with KV cache reset between samples.
+    """
+
+    def __init__(self, model, tokenizer, config: EvalConfig, device: torch.device):
+        self.model = model
+        self.tokenizer = tokenizer
+        self.config = config
+        self.device = device
+        self.hidden_size = model.config.hidden_size
+
+    def _split_into_chunks(self, seq_len: int, chunk_size: int):
+        """Split sequence into chunks, same as training."""
+        chunks = []
+        for start in range(0, seq_len, chunk_size):
+            end = min(start + chunk_size, seq_len)
+            chunks.append((start, end))
+        return chunks
+
+    @torch.no_grad()
+    def evaluate_sample(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels: torch.Tensor,
+    ) -> Dict:
+        """
+        Evaluate a single sample using chunk-wise streaming.
+        
+        Process:
+        1. Split input into chunks
+        2. Process each chunk through Qwen (with overlap for next-token prediction)
+        3. Collect predictions only for answer tokens (labels != -100)
+        4. Compute loss, token accuracy, and EM accuracy
+        """
+        batch_size, seq_len = input_ids.shape
+        chunk_size = self.config.chunk_size
+        chunks = self._split_into_chunks(seq_len, chunk_size)
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = 0.0
+        total_loss_tokens = 0
+
+        pred_tokens: List[int] = []
+        target_tokens: List[int] = []
+
+        for start, end in chunks:
+            # Include 1 overlap token for next-token prediction at chunk boundaries
+            proc_start = max(0, start - 1)
+            chunk_ids = input_ids[:, proc_start:end]
+            chunk_labels = labels[:, proc_start:end]
+            chunk_mask = attention_mask[:, proc_start:end]
+
+            # Forward pass through Qwen
+            outputs = self.model(
+                input_ids=chunk_ids,
+                attention_mask=chunk_mask,
+                use_cache=False,
+                output_hidden_states=False,
+                return_dict=True,
+            )
+            logits = outputs.logits  # [batch, seq, vocab]
+
+            # Compute loss and predictions for answer tokens
+            if chunk_labels is not None and (chunk_labels != -100).any():
+                # Shift for next-token prediction
+                shift_logits = logits[:, :-1, :].contiguous()
+                shift_labels = chunk_labels[:, 1:].contiguous()
+
+                valid = shift_labels != -100
+                if valid.any():
+                    valid_logits = shift_logits[valid]
+                    valid_targets = shift_labels[valid]
+
+                    # Compute loss
+                    chunk_loss = loss_fct_sum(valid_logits.float(), valid_targets)
+                    total_loss_sum += chunk_loss.item()
+                    total_loss_tokens += valid_targets.numel()
+
+                    # Collect predictions
+                    pred_ids = torch.argmax(valid_logits, dim=-1)
+                    pred_tokens.extend(pred_ids.cpu().tolist())
+                    target_tokens.extend(valid_targets.cpu().tolist())
+
+        # Compute metrics
+        if total_loss_tokens > 0:
+            avg_loss = total_loss_sum / total_loss_tokens
+        else:
+            avg_loss = 0.0
+
+        # Token accuracy
+        if len(pred_tokens) > 0:
+            tok_correct = sum(p == t for p, t in zip(pred_tokens, target_tokens))
+            tok_acc = tok_correct / len(pred_tokens)
+        else:
+            tok_acc = 0.0
+
+        # EM accuracy (exact match of decoded strings)
+        if len(pred_tokens) > 0:
+            pred_text = self.tokenizer.decode(pred_tokens, skip_special_tokens=True).strip()
+            target_text = self.tokenizer.decode(target_tokens, skip_special_tokens=True).strip()
+            em_match = (pred_text == target_text)
+        else:
+            pred_text = ""
+            target_text = ""
+            em_match = False
+
+        return {
+            "loss": avg_loss,
+            "tok_acc": tok_acc,
+            "em_match": em_match,
+            "pred_text": pred_text,
+            "target_text": target_text,
+            "num_tokens": len(pred_tokens),
+        }
+
+    @torch.no_grad()
+    def evaluate_dataset(self, dataloader: DataLoader, print_examples: int = 10) -> Dict:
+        """Evaluate entire dataset."""
+        self.model.eval()
+
+        total_loss = 0.0
+        total_batches = 0
+        total_tok_correct = 0
+        total_tok_total = 0
+        total_em_correct = 0
+        total_em_total = 0
+        printed = 0
+
+        pbar = tqdm(dataloader, desc="Evaluating", dynamic_ncols=True)
+        for batch in pbar:
+            input_ids = batch["input_ids"].to(self.device)
+            attention_mask = batch["attention_mask"].to(self.device)
+            labels = batch["labels"].to(self.device)
+            target_texts = batch["target_texts"]
+
+            # Process each sample in batch
+            for i in range(input_ids.shape[0]):
+                result = self.evaluate_sample(
+                    input_ids[i:i+1],
+                    attention_mask[i:i+1],
+                    labels[i:i+1],
+                )
+
+                if result["num_tokens"] > 0:
+                    total_loss += result["loss"]
+                    total_batches += 1
+                    total_tok_correct += int(result["tok_acc"] * result["num_tokens"])
+                    total_tok_total += result["num_tokens"]
+                    total_em_correct += int(result["em_match"])
+                    total_em_total += 1
+
+                    # Print examples
+                    if printed < print_examples:
+                        logger.info(
+                            f"[EVAL SAMPLE {printed + 1}] "
+                            f"pred={repr(result['pred_text'])} | "
+                            f"label={repr(result['target_text'])} | "
+                            f"match={result['em_match']}"
+                        )
+                        printed += 1
+
+                # Update progress bar
+                if total_em_total > 0:
+                    pbar.set_postfix({
+                        "em_acc": f"{total_em_correct / total_em_total * 100:.1f}%",
+                        "tok_acc": f"{total_tok_correct / max(total_tok_total, 1) * 100:.1f}%",
+                    })
+
+        # Compute final metrics
+        avg_loss = total_loss / max(total_batches, 1)
+        tok_acc = total_tok_correct / max(total_tok_total, 1)
+        em_acc = total_em_correct / max(total_em_total, 1)
+
+        return {
+            "loss": avg_loss,
+            "tok_acc": tok_acc,
+            "em_acc": em_acc,
+            "total_samples": total_em_total,
+            "total_tokens": total_tok_total,
+        }
+
+
+def main():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser(description="Evaluate Qwen baseline on BABILong")
+    parser.add_argument("--model_path", type=str, default=None, help="Path to Qwen model")
+    parser.add_argument("--data_path", type=str, default=None, help="Path to BABILong data")
+    parser.add_argument("--output_dir", type=str, default=None, help="Output directory")
+    parser.add_argument("--max_samples", type=int, default=None, help="Max samples to evaluate")
+    parser.add_argument("--chunk_size", type=int, default=None, help="Chunk size for streaming")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size")
+    parser.add_argument("--print_examples", type=int, default=20, help="Number of examples to print")
+    parser.add_argument("--eval_split", type=str, default="eval", choices=["train", "eval", "all"],
+                        help="Which split to evaluate: train (90%), eval (10%), or all")
+    args = parser.parse_args()
+
+    config = EvalConfig()
+    if args.model_path:
+        config.model_path = args.model_path
+    if args.data_path:
+        config.data_path = args.data_path
+    if args.output_dir:
+        config.output_dir = args.output_dir
+    if args.max_samples is not None:
+        config.max_samples = args.max_samples
+    if args.chunk_size is not None:
+        config.chunk_size = args.chunk_size
+    if args.batch_size:
+        config.batch_size = args.batch_size
+    if args.print_examples is not None:
+        config.print_examples = args.print_examples
+
+    torch.manual_seed(config.seed)
+
+    # Device setup
+    if torch.cuda.is_available():
+        device = torch.device("cuda")
+    else:
+        device = torch.device("cpu")
+
+    # TF32 settings
+    if torch.cuda.is_available() and config.use_tf32:
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        try:
+            torch.set_float32_matmul_precision("high")
+        except Exception:
+            pass
+
+    logger.info("=" * 60)
+    logger.info("Qwen3-4B Baseline Evaluation (NO TRAINING)")
+    logger.info("=" * 60)
+    logger.info(f"model_path: {config.model_path}")
+    logger.info(f"data_path: {config.data_path}")
+    logger.info(f"output_dir: {config.output_dir}")
+    logger.info(f"max_samples: {config.max_samples}")
+    logger.info(f"max_length: {config.max_length}")
+    logger.info(f"chunk_size: {config.chunk_size}")
+    logger.info(f"eval_split: {args.eval_split}")
+    logger.info("=" * 60)
+
+    # Load tokenizer
+    logger.info("Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(config.model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Disable flash-attn checks
+    try:
+        import transformers
+        from transformers.utils import import_utils as _import_utils
+
+        def _disabled(*args, **kwargs):
+            return False
+
+        _import_utils.is_flash_attn_2_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_flash_attn_2_available"):
+            transformers.utils.is_flash_attn_2_available = _disabled
+        _import_utils.is_torchao_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_torchao_available"):
+            transformers.utils.is_torchao_available = _disabled
+    except Exception as e:
+        logger.warning(f"Disable checks failed (ignored): {e}")
+
+    # Load model
+    logger.info("Loading model...")
+    torch_dtype = torch.bfloat16 if config.bf16 else (torch.float16 if config.fp16 else torch.float32)
+    model = AutoModelForCausalLM.from_pretrained(
+        config.model_path,
+        torch_dtype=torch_dtype,
+        device_map=None,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        low_cpu_mem_usage=True,
+    )
+    model.to(device)
+    model.config.use_cache = False
+    model.eval()
+    logger.info(f"Model loaded: {model.config.hidden_size} hidden size, {model.config.num_hidden_layers} layers")
+
+    # Load dataset
+    logger.info("Loading dataset...")
+    full_dataset = BABILongDataset(
+        config.data_path,
+        tokenizer,
+        max_length=config.max_length,
+        answer_reserve_tokens=config.answer_reserve_tokens,
+        max_samples=config.max_samples,
+    )
+
+    # Split dataset same as training (90% train, 10% eval)
+    train_size = int(0.9 * len(full_dataset))
+    eval_size = len(full_dataset) - train_size
+    train_dataset, eval_dataset = torch.utils.data.random_split(
+        full_dataset,
+        [train_size, eval_size],
+        generator=torch.Generator().manual_seed(config.seed),
+    )
+
+    # Select which split to evaluate
+    if args.eval_split == "train":
+        dataset = train_dataset
+        split_name = "train"
+    elif args.eval_split == "eval":
+        dataset = eval_dataset
+        split_name = "eval"
+    else:  # all
+        dataset = full_dataset
+        split_name = "all"
+
+    logger.info(f"Evaluating on '{split_name}' split: {len(dataset)} samples")
+
+    dataloader = DataLoader(
+        dataset,
+        batch_size=config.batch_size,
+        shuffle=False,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+
+    # Create evaluator
+    evaluator = QwenChunkwiseEvaluator(model, tokenizer, config, device)
+
+    # Run evaluation
+    logger.info("Starting evaluation...")
+    results = evaluator.evaluate_dataset(dataloader, print_examples=config.print_examples)
+
+    # Print results
+    ppl = math.exp(min(20.0, results["loss"]))
+    logger.info("=" * 60)
+    logger.info("EVALUATION RESULTS (Qwen Baseline - NO TRAINING)")
+    logger.info("=" * 60)
+    logger.info(f"Split: {split_name}")
+    logger.info(f"Total samples: {results['total_samples']}")
+    logger.info(f"Total answer tokens: {results['total_tokens']}")
+    logger.info(f"Loss: {results['loss']:.4f}")
+    logger.info(f"Perplexity: {ppl:.3f}")
+    logger.info(f"Token Accuracy: {results['tok_acc'] * 100:.2f}%")
+    logger.info(f"EM Accuracy: {results['em_acc'] * 100:.2f}%")
+    logger.info("=" * 60)
+
+    # Save results
+    os.makedirs(config.output_dir, exist_ok=True)
+    results_path = os.path.join(config.output_dir, f"baseline_results_{split_name}.json")
+    with open(results_path, "w") as f:
+        json.dump({
+            "split": split_name,
+            "total_samples": int(results["total_samples"]),
+            "total_tokens": int(results["total_tokens"]),
+            "loss": float(results["loss"]),
+            "perplexity": float(ppl),
+            "tok_acc_pct": float(results["tok_acc"] * 100),
+            "em_acc_pct": float(results["em_acc"] * 100),
+            "config": {
+                "model_path": config.model_path,
+                "data_path": config.data_path,
+                "max_samples": config.max_samples,
+                "max_length": config.max_length,
+                "chunk_size": config.chunk_size,
+            }
+        }, f, indent=2)
+    logger.info(f"Results saved to: {results_path}")
+
+
+if __name__ == "__main__":
+    main()

examples/outputs/qwen_titans_babilong_v4/eval_metrics.jsonl

@@ -0,0 +1,12 @@
+{"phase": "epoch", "epoch": 1, "global_step": 1, "train_avg_loss": 18.17474365234375, "eval_loss": 17.120962142944336, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 2, "train_avg_loss": 17.02557945251465, "eval_loss": 16.274072647094727, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 3, "global_step": 3, "train_avg_loss": 16.092069625854492, "eval_loss": 15.3228759765625, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 4, "global_step": 4, "train_avg_loss": 15.068357467651367, "eval_loss": 14.723411560058594, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 5, "global_step": 5, "train_avg_loss": 14.212869644165039, "eval_loss": 13.746140480041504, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 6, "global_step": 6, "train_avg_loss": 13.273895263671875, "eval_loss": 13.325453758239746, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 7, "global_step": 7, "train_avg_loss": 12.399141311645508, "eval_loss": 12.49329662322998, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 15.649271011352539, "eval_loss": 12.257902145385742, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 14, "train_avg_loss": 8.916175842285156, "eval_loss": 5.23334264755249, "em_acc_pct": 15.384615957736969, "tok_acc_pct": 15.384615957736969}
+{"phase": "epoch", "epoch": 3, "global_step": 21, "train_avg_loss": 3.033076763153076, "eval_loss": 2.6507105827331543, "em_acc_pct": 28.846153616905212, "tok_acc_pct": 28.846153616905212}
+{"phase": "epoch", "epoch": 4, "global_step": 28, "train_avg_loss": 1.8393750190734863, "eval_loss": 1.956390142440796, "em_acc_pct": 30.769231915473938, "tok_acc_pct": 30.769231915473938}
+{"phase": "epoch", "epoch": 5, "global_step": 35, "train_avg_loss": 1.6820091009140015, "eval_loss": 1.9739787578582764, "em_acc_pct": 28.846153616905212, "tok_acc_pct": 28.846153616905212}

examples/qwen_mac_integration.py

@@ -0,0 +1,692 @@
+"""
+MAC (Memory-as-Context) 结构集成到 Qwen 的详细实现
+
+=== MAC 结构核心原理 ===
+
+1. 将长序列分成多个 segment（如每 128 个 token 一个 segment）
+2. 在每个 segment 的【开头】插入 longterm_mem_tokens（如 16 个）
+3. 这些 memory tokens 会参与 attention 计算
+4. 使用 NeuralMemory 模块来动态更新这些 memory tokens 的内容
+
+原始序列: [t1, t2, t3, ..., t128, t129, ..., t256, ...]
+                 ↓
+MAC 序列:  [M1..M16, t1...t128, M1..M16, t129...t256, ...]
+            ↑                    ↑
+         memory tokens       memory tokens
+
+=== Qwen2 架构 ===
+
+Qwen2DecoderLayer:
+├── input_layernorm (RMSNorm)
+├── self_attn (Qwen2Attention/Qwen2FlashAttention2)
+│   ├── q_proj, k_proj, v_proj
+│   ├── RoPE (rotary positional embedding)
+│   └── o_proj
+├── post_attention_layernorm (RMSNorm)
+└── mlp (Qwen2MLP: gate_proj, up_proj, down_proj with SiLU)
+
+我们需要在特定层添加 NeuralMemory 模块
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from typing import Optional, Tuple, List, Dict, Any
+from copy import deepcopy
+from functools import partial
+
+from einops import rearrange, repeat, pack, unpack
+
+# Titans 组件
+from titans_pytorch import NeuralMemory, MemoryMLP
+from titans_pytorch.neural_memory import NeuralMemState
+
+
+# ============================================================================
+# 辅助函数
+# ============================================================================
+
+def exists(v):
+    return v is not None
+
+def default(v, d):
+    return v if exists(v) else d
+
+def divisible_by(num, den):
+    return (num % den) == 0
+
+def round_up_multiple(seq, mult):
+    return ((seq + mult - 1) // mult) * mult
+
+
+# ============================================================================
+# MAC 风格的 Qwen 实现
+# ============================================================================
+
+class QwenMACTransformer(nn.Module):
+    """
+    将 MAC 结构应用到 Qwen 模型的完整实现
+    
+    架构图:
+    
+    Input IDs
+        │
+        ▼
+    ┌─────────────────┐
+    │  Token Embed    │
+    └────────┬────────┘
+             │
+             ▼
+    ┌─────────────────────────────────────────┐
+    │  插入 Memory Tokens 到每个 Segment 开头   │
+    │  [M1..Mn, t1..t_seg, M1..Mn, ...]       │
+    └────────┬────────────────────────────────┘
+             │
+             ▼
+    ╔═════════════════════════════════════════╗
+    ║         Qwen Decoder Layer 1            ║
+    ║  ┌────────────────────────────────┐     ║
+    ║  │ RMSNorm → Self-Attention → Add │     ║
+    ║  └────────────────────────────────┘     ║
+    ║  ┌────────────────────────────────┐     ║
+    ║  │ RMSNorm → MLP → Add            │     ║
+    ║  └────────────────────────────────┘     ║
+    ╚═════════════════════════════════════════╝
+             │
+             ▼
+    ╔═════════════════════════════════════════╗
+    ║    Qwen Decoder Layer 2 (with Memory)   ║
+    ║  ┌────────────────────────────────┐     ║
+    ║  │ RMSNorm → Self-Attention → Add │     ║
+    ║  └────────────────────────────────┘     ║
+    ║  ┌──────────────────────────────────┐   ║
+    ║  │  ★ NeuralMemory 记忆增强 ★        │   ║
+    ║  │  retrieved = mem(hidden_states)  │   ║
+    ║  │  hidden += gate * retrieved      │   ║
+    ║  └──────────────────────────────────┘   ║
+    ║  ┌────────────────────────────────┐     ║
+    ║  │ RMSNorm → MLP → Add            │     ║
+    ║  └────────────────────────────────┘     ║
+    ╚════════════════════��════════════════════╝
+             │
+             ▼
+          ... 更多层 ...
+             │
+             ▼
+    ┌─────────────────┐
+    │  Final RMSNorm  │
+    └────────┬────────┘
+             │
+             ▼
+    ┌─────────────────┐
+    │    LM Head      │
+    └────────┬────────┘
+             │
+             ▼
+        Logits
+    """
+    
+    def __init__(
+        self,
+        qwen_model,
+        # === Segment 配置 ===
+        segment_len: int = 128,              # 每个 segment 的长度
+        num_longterm_mem_tokens: int = 16,   # 每个 segment 开头的 memory token 数量
+        num_persist_mem_tokens: int = 4,     # 全局持久 memory token 数量
+        
+        # === NeuralMemory 配置 ===
+        neural_memory_layers: Tuple[int, ...] = (2, 4, 6),  # 哪些层使用记忆
+        memory_chunk_size: int = 64,         # 记忆模块的 chunk 大小
+        memory_batch_size: int = 128,        # 记忆更新的批次大小
+        memory_depth: int = 2,               # 记忆 MLP 的深度
+        
+        # === 其他配置 ===
+        dim_head: int = 64,
+        num_heads: int = None,               # 默认从模型配置读取
+        use_momentum: bool = True,
+        gate_memory_output: bool = False,    # 是否用记忆门控 attention 输出
+    ):
+        super().__init__()
+        
+        # 保存原始 Qwen 模型
+        self.qwen = qwen_model
+        self.config = qwen_model.config
+        
+        # 获取模型维度
+        self.hidden_size = self.config.hidden_size
+        self.num_layers = self.config.num_hidden_layers
+        num_heads = default(num_heads, self.hidden_size // dim_head)
+        
+        # Segment 配置
+        self.segment_len = segment_len
+        self.num_longterm_mem_tokens = num_longterm_mem_tokens
+        self.num_persist_mem_tokens = num_persist_mem_tokens
+        self.total_segment_len = segment_len + num_longterm_mem_tokens
+        
+        # =====================================================================
+        # Memory Tokens (这是 MAC 的核心!)
+        # =====================================================================
+        
+        # 持久记忆 tokens - 放在序列最前面，所有 segment 共享
+        # 用于存储全局上下文信息
+        self.persist_mem_tokens = nn.Parameter(
+            torch.randn(num_persist_mem_tokens, self.hidden_size) * 0.02
+        )
+        
+        # 长期记忆 tokens - 插入到每个 segment 的开头
+        # 这些 token 会被 NeuralMemory 动态更新
+        self.longterm_mem_tokens = nn.Parameter(
+            torch.randn(num_longterm_mem_tokens, self.hidden_size) * 0.02
+        )
+        
+        # =====================================================================
+        # NeuralMemory 模块
+        # =====================================================================
+        
+        self.neural_memory_layers = neural_memory_layers
+        self.gate_memory_output = gate_memory_output
+        
+        # 为每个指定层创建 NeuralMemory
+        self.neural_memories = nn.ModuleDict()
+        self.memory_projections = nn.ModuleDict()  # 投影层
+        self.memory_gates = nn.ModuleDict()        # 门控层
+        
+        # 创建记忆网络模板
+        memory_model_template = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0
+        )
+        
+        for layer_idx in neural_memory_layers:
+            layer_key = str(layer_idx)
+            
+            # NeuralMemory 模块
+            self.neural_memories[layer_key] = NeuralMemory(
+                dim=self.hidden_size,
+                chunk_size=memory_chunk_size,
+                batch_size=memory_batch_size,
+                dim_head=dim_head,
+                heads=num_heads,
+                model=deepcopy(memory_model_template),
+                momentum=use_momentum,
+                momentum_order=1,
+                qk_rmsnorm=True,
+                pre_rmsnorm=True,
+                default_step_transform_max_lr=0.1,
+            )
+            
+            # 门控层 - 控制记忆的影响程度
+            self.memory_gates[layer_key] = nn.Sequential(
+                nn.Linear(self.hidden_size, self.hidden_size),
+                nn.Sigmoid()
+            )
+        
+        print(f"[QwenMAC] 初始化完成:")
+        print(f"  - 隐藏层大小: {self.hidden_size}")
+        print(f"  - 层数: {self.num_layers}")
+        print(f"  - Segment 长度: {segment_len}")
+        print(f"  - Longterm Memory Tokens: {num_longterm_mem_tokens}")
+        print(f"  - Persist Memory Tokens: {num_persist_mem_tokens}")
+        print(f"  - 记忆层: {neural_memory_layers}")
+    
+    def _insert_memory_tokens(
+        self,
+        hidden_states: Tensor,  # [batch, seq_len, hidden]
+        batch_size: int,
+        seq_len: int,
+    ) -> Tuple[Tensor, int]:
+        """
+        在序列中插入 memory tokens
+        
+        输入: [batch, seq_len, hidden]
+        输出: [batch, new_seq_len, hidden]
+        
+        处理流程:
+        原始: [t1, t2, ..., t128, t129, ..., t256]
+        
+        1. 分成 segments:
+           Seg1: [t1, ..., t128]
+           Seg2: [t129, ..., t256]
+        
+        2. 每个 segment 前插入 longterm_mem:
+           Seg1: [M1, ..., M16, t1, ..., t128]
+           Seg2: [M1, ..., M16, t129, ..., t256]
+        
+        3. 合并 + 前置 persist_mem:
+           [P1, ..., P4, M1..M16, t1..t128, M1..M16, t129..t256]
+        """
+        segment_len = self.segment_len
+        num_longterm = self.num_longterm_mem_tokens
+        num_persist = self.num_persist_mem_tokens
+        
+        # 计算需要多少个 segment
+        num_segments = (seq_len + segment_len - 1) // segment_len
+        
+        # Padding 到 segment_len 的整数倍
+        padded_len = num_segments * segment_len
+        if seq_len < padded_len:
+            padding = padded_len - seq_len
+            hidden_states = F.pad(hidden_states, (0, 0, 0, padding))
+        
+        # 重塑为 segments: [batch, num_segments, segment_len, hidden]
+        hidden_states = rearrange(
+            hidden_states,
+            'b (s n) d -> b s n d',
+            s=num_segments,
+            n=segment_len
+        )
+        
+        # 扩展 longterm memory tokens: [batch, num_segments, num_longterm, hidden]
+        longterm_mem = repeat(
+            self.longterm_mem_tokens,
+            'n d -> b s n d',
+            b=batch_size,
+            s=num_segments
+        )
+        
+        # 在每个 segment 前插入 memory tokens
+        # [batch, num_segments, num_longterm + segment_len, hidden]
+        hidden_states = torch.cat([longterm_mem, hidden_states], dim=2)
+        
+        # 展平 segments: [batch, num_segments * (num_longterm + segment_len), hidden]
+        hidden_states = rearrange(hidden_states, 'b s n d -> b (s n) d')
+        
+        # 添加持久记忆 tokens 在最前面
+        persist_mem = repeat(
+            self.persist_mem_tokens,
+            'n d -> b n d',
+            b=batch_size
+        )
+        hidden_states = torch.cat([persist_mem, hidden_states], dim=1)
+        
+        new_seq_len = hidden_states.shape[1]
+        
+        return hidden_states, new_seq_len
+    
+    def _remove_memory_tokens(
+        self,
+        hidden_states: Tensor,
+        original_seq_len: int,
+    ) -> Tensor:
+        """
+        从输出中移除 memory tokens，恢复原始序列长度
+        """
+        segment_len = self.segment_len
+        num_longterm = self.num_longterm_mem_tokens
+        num_persist = self.num_persist_mem_tokens
+        total_segment_len = segment_len + num_longterm
+        
+        batch_size = hidden_states.shape[0]
+        
+        # 移除 persist tokens
+        hidden_states = hidden_states[:, num_persist:]
+        
+        # 计算 segments
+        num_segments = (original_seq_len + segment_len - 1) // segment_len
+        
+        # 重塑为 segments
+        hidden_states = rearrange(
+            hidden_states,
+            'b (s n) d -> b s n d',
+            s=num_segments,
+            n=total_segment_len
+        )
+        
+        # 移除每个 segment 开头的 memory tokens
+        hidden_states = hidden_states[:, :, num_longterm:, :]
+        
+        # 展平并截取原始长度
+        hidden_states = rearrange(hidden_states, 'b s n d -> b (s n) d')
+        hidden_states = hidden_states[:, :original_seq_len, :]
+        
+        return hidden_states
+    
+    def _create_mac_attention_mask(
+        self,
+        seq_len_with_mem: int,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> Tensor:
+        """
+        创建 MAC 风格的 attention mask
+        
+        MAC mask 的特点:
+        1. Persist memory tokens 对所有位置可见
+        2. 每个 segment 内部是 causal 的
+        3. Memory tokens 可以 attend 到之前的 segment
+        
+        这是一个简化版本，完整版需要考虑更多细节
+        """
+        # 创建基础 causal mask
+        mask = torch.ones(seq_len_with_mem, seq_len_with_mem, device=device, dtype=dtype)
+        mask = torch.tril(mask)
+        
+        # Persist memory 对所有位置可见
+        num_persist = self.num_persist_mem_tokens
+        mask[:, :num_persist] = 1.0
+        
+        return mask
+    
+    def forward(
+        self,
+        input_ids: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        position_ids: Optional[Tensor] = None,
+        memory_states: Optional[Dict[str, NeuralMemState]] = None,
+        return_memory_states: bool = True,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        前向传播
+        
+        Args:
+            input_ids: [batch, seq_len]
+            attention_mask: [batch, seq_len]
+            memory_states: 各层的记忆状态（用于增量推理）
+            
+        Returns:
+            dict with 'logits', 'hidden_states', 'memory_states'
+        """
+        batch_size, seq_len = input_ids.shape
+        device = input_ids.device
+        
+        # =====================================================================
+        # Step 1: Token Embedding
+        # =====================================================================
+        if hasattr(self.qwen.model, 'embed_tokens'):
+            hidden_states = self.qwen.model.embed_tokens(input_ids)
+        else:
+            hidden_states = self.qwen.get_input_embeddings()(input_ids)
+        
+        # =====================================================================
+        # Step 2: 插入 Memory Tokens
+        # =====================================================================
+        hidden_states, seq_len_with_mem = self._insert_memory_tokens(
+            hidden_states, batch_size, seq_len
+        )
+        
+        # =====================================================================
+        # Step 3: 创建 Attention Mask (简化版)
+        # =====================================================================
+        # 注意: 完整实现需要更复杂的 mask 处理
+        # 这里用 None 让模型使用默认 causal mask
+        mac_attention_mask = None
+        
+        # =====================================================================
+        # Step 4: 逐层处理
+        # =====================================================================
+        if memory_states is None:
+            memory_states = {}
+        next_memory_states = {}
+        
+        # 遍历 Qwen 的所有层
+        for layer_idx, layer in enumerate(self.qwen.model.layers):
+            layer_key = str(layer_idx)
+            
+            # -----------------------------------------------------------------
+            # 4.1 标准的 Qwen Decoder Layer 前向传播
+            # -----------------------------------------------------------------
+            # Qwen2DecoderLayer.forward() 的简化版本
+            
+            residual = hidden_states
+            
+            # Input LayerNorm
+            hidden_states = layer.input_layernorm(hidden_states)
+            
+            # Self Attention
+            # 注意: 这里简化了 attention 的调用，实际可能需要更多参数
+            attn_output = layer.self_attn(
+                hidden_states=hidden_states,
+                attention_mask=mac_attention_mask,
+                position_ids=None,  # 会自动生成
+            )
+            
+            # 处理不同返回格式
+            if isinstance(attn_output, tuple):
+                attn_output = attn_output[0]
+            
+            hidden_states = residual + attn_output
+            
+            # -----------------------------------------------------------------
+            # 4.2 NeuralMemory 记忆增强 (仅在指定层)
+            # -----------------------------------------------------------------
+            if layer_key in self.neural_memories:
+                neural_mem = self.neural_memories[layer_key]
+                gate_fn = self.memory_gates[layer_key]
+                
+                # 获取该层的记忆状态
+                mem_state = memory_states.get(layer_key)
+                
+                # 记忆检索和更新
+                retrieved, next_mem_state = neural_mem(
+                    hidden_states,
+                    state=mem_state
+                )
+                
+                # 门控融合
+                gate = gate_fn(hidden_states)
+                
+                if self.gate_memory_output:
+                    # 方式1: 用检索到的记忆门控后续输出
+                    hidden_states = hidden_states * (1 + gate * retrieved.sigmoid())
+                else:
+                    # 方式2: 直接加上门控后的记忆（更常用）
+                    hidden_states = hidden_states + gate * retrieved
+                
+                # 保存记忆状态
+                next_memory_states[layer_key] = next_mem_state
+            
+            # -----------------------------------------------------------------
+            # 4.3 Feed Forward Network
+            # -----------------------------------------------------------------
+            residual = hidden_states
+            hidden_states = layer.post_attention_layernorm(hidden_states)
+            hidden_states = layer.mlp(hidden_states)
+            hidden_states = residual + hidden_states
+        
+        # =====================================================================
+        # Step 5: Final LayerNorm
+        # =====================================================================
+        hidden_states = self.qwen.model.norm(hidden_states)
+        
+        # =====================================================================
+        # Step 6: 移除 Memory Tokens
+        # =====================================================================
+        hidden_states = self._remove_memory_tokens(hidden_states, seq_len)
+        
+        # =====================================================================
+        # Step 7: LM Head
+        # =====================================================================
+        logits = self.qwen.lm_head(hidden_states)
+        
+        # =====================================================================
+        # 返回结果
+        # =====================================================================
+        result = {
+            'logits': logits,
+            'hidden_states': hidden_states,
+        }
+        
+        if return_memory_states:
+            result['memory_states'] = next_memory_states
+            
+        return result
+    
+    def generate(
+        self,
+        input_ids: Tensor,
+        max_new_tokens: int = 100,
+        temperature: float = 1.0,
+        top_p: float = 0.9,
+        memory_states: Optional[Dict] = None,
+        **kwargs
+    ) -> Tensor:
+        """
+        简单的生成函数
+        """
+        generated = input_ids.clone()
+        
+        for _ in range(max_new_tokens):
+            outputs = self.forward(
+                generated,
+                memory_states=memory_states,
+                return_memory_states=True
+            )
+            
+            logits = outputs['logits'][:, -1, :]
+            memory_states = outputs['memory_states']
+            
+            # 采样
+            if temperature > 0:
+                probs = F.softmax(logits / temperature, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+            else:
+                next_token = logits.argmax(dim=-1, keepdim=True)
+            
+            generated = torch.cat([generated, next_token], dim=-1)
+            
+            # 检查 EOS
+            if hasattr(self.config, 'eos_token_id'):
+                if (next_token == self.config.eos_token_id).all():
+                    break
+        
+        return generated
+
+
+# ============================================================================
+# 使用示例
+# ============================================================================
+
+def main():
+    """
+    完整的使用示例
+    """
+    print("=" * 70)
+    print("MAC (Memory-as-Context) 集成到 Qwen 的示例")
+    print("=" * 70)
+    
+    # -------------------------------------------------------------------------
+    # 方式 1: 使用 Hugging Face 的 Qwen 模型
+    # -------------------------------------------------------------------------
+    
+    try:
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        
+        print("\n[1] 加载 Qwen 模型...")
+        model_name = "Qwen/Qwen2-0.5B"
+        
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            trust_remote_code=True
+        )
+        
+        qwen_model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else None,
+            trust_remote_code=True
+        )
+        
+        print(f"  模型配置:")
+        print(f"  - hidden_size: {qwen_model.config.hidden_size}")
+        print(f"  - num_layers: {qwen_model.config.num_hidden_layers}")
+        print(f"  - num_heads: {qwen_model.config.num_attention_heads}")
+        
+        # 创建 MAC 版本
+        print("\n[2] 创建 QwenMAC 模型...")
+        mac_model = QwenMACTransformer(
+            qwen_model=qwen_model,
+            segment_len=64,              # 每 64 个 token 一个 segment
+            num_longterm_mem_tokens=8,   # 每个 segment 8 个 memory token
+            num_persist_mem_tokens=4,    # 4 个全局 memory token
+            neural_memory_layers=(1, 3, 5),  # 在第 1, 3, 5 层添加记忆
+            memory_chunk_size=32,
+            memory_batch_size=64,
+        )
+        
+        if torch.cuda.is_available():
+            mac_model = mac_model.cuda()
+        
+        # 测试前向传播
+        print("\n[3] 测试前向传播...")
+        test_text = "人工智能正在改变世界，它可以"
+        inputs = tokenizer(test_text, return_tensors="pt")
+        
+        device = next(mac_model.parameters()).device
+        input_ids = inputs.input_ids.to(device)
+        
+        with torch.no_grad():
+            outputs = mac_model(input_ids)
+            
+        print(f"  输入形状: {input_ids.shape}")
+        print(f"  输出 logits 形状: {outputs['logits'].shape}")
+        print(f"  记忆状态数量: {len(outputs['memory_states'])}")
+        
+        # 测试生成
+        print("\n[4] 测试文本生成...")
+        with torch.no_grad():
+            generated = mac_model.generate(
+                input_ids,
+                max_new_tokens=50,
+                temperature=0.7
+            )
+        
+        generated_text = tokenizer.decode(generated[0], skip_special_tokens=True)
+        print(f"  生成文本: {generated_text}")
+        
+    except ImportError as e:
+        print(f"\n注意: 需要安装 transformers")
+        print(f"pip install transformers")
+        print(f"错误: {e}")
+    
+    # -------------------------------------------------------------------------
+    # 方式 2: 独立测试 NeuralMemory 组件
+    # -------------------------------------------------------------------------
+    
+    print("\n" + "=" * 70)
+    print("[独立测试] NeuralMemory 组件")
+    print("=" * 70)
+    
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    
+    # 创建 NeuralMemory
+    mem = NeuralMemory(
+        dim=512,           # 隐藏维度
+        chunk_size=32,     # 分块大小
+        batch_size=64,     # 批次大小
+        dim_head=64,       # 每个头的维度
+        heads=8,           # 头数
+        model=MemoryMLP(dim=64, depth=2),
+        momentum=True,
+        qk_rmsnorm=True,
+    ).to(device)
+    
+    # 模拟输入
+    batch_size = 2
+    seq_len = 256
+    hidden_dim = 512
+    
+    x = torch.randn(batch_size, seq_len, hidden_dim).to(device)
+    
+    print(f"\n输入形状: {x.shape}")
+    
+    # 第一次前向传播
+    retrieved, state = mem(x)
+    print(f"检索输出形状: {retrieved.shape}")
+    print(f"记忆状态 seq_index: {state.seq_index}")
+    
+    # 第二次前向传播（传入之前的状态）
+    x2 = torch.randn(batch_size, seq_len, hidden_dim).to(device)
+    retrieved2, state2 = mem(x2, state=state)
+    print(f"第二次检索输出形状: {retrieved2.shape}")
+    print(f"更新后 seq_index: {state2.seq_index}")
+    
+    print("\n" + "=" * 70)
+    print("完成!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

examples/qwen_titans_streaming.py

@@ -0,0 +1,600 @@
+"""
+Qwen + Titans 流式处理超长序列
+
+核心思想:
+- Qwen 作为 Core（短期处理器），每次只处理一个 chunk
+- Titans NeuralMemory 作为长期记忆，跨 chunk 保持状态
+- 虽然 Core 窗口有限（如 4k/8k），但整体能处理任意长度的上下文
+
+处理流程:
+┌─────────────────────────────────────────────────────────────────────┐
+│                        超长文档 (1M tokens)                          │
+│  [chunk_0] [chunk_1] [chunk_2] ... [chunk_n-1] [chunk_n + question] │
+└─────────────────────────────────────────────────────────────────────┘
+        │         │         │              │              │
+        ▼         ▼         ▼              ▼              ▼
+     ┌─────┐   ┌─────┐   ┌─────┐       ┌─────┐       ┌─────┐
+     │Qwen │   │Qwen │   │Qwen │  ...  │Qwen │       │Qwen │
+     │Core │   │Core │   │Core │       │Core │       │Core │
+     └──┬──┘   └──┬──┘   └──┬──┘       └──┬──┘       └──┬──┘
+        │         │         │              │              │
+        ▼         ▼         ▼              ▼              ▼
+     ┌─────────────────────────────────────────────────────────┐
+     │              Titans Long-term Memory                    │
+     │  M_0 ──write──> M_1 ──write──> M_2 ... M_n-1 ──read──> │
+     │                                                         │
+     │  存储：关键事实、实体关系、重要信息                        │
+     │  检索：回答问题时取回相关记忆                             │
+     └─────────────────────────────────────────────────────────┘
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from typing import Optional, List, Dict, Any, Tuple
+from dataclasses import dataclass
+from tqdm import tqdm
+import math
+
+from einops import rearrange, repeat
+
+# Titans 组件
+from titans_pytorch import NeuralMemory, MemoryMLP
+from titans_pytorch.neural_memory import NeuralMemState
+
+
+@dataclass
+class StreamingConfig:
+    """流式处理配置"""
+    chunk_size: int = 4096           # 每个 chunk 的 token 数
+    memory_chunk_size: int = 64      # NeuralMemory 内部的 chunk 大小
+    memory_batch_size: int = 128     # NeuralMemory 的 batch size
+    num_memory_tokens: int = 16      # 每次注入的 memory token 数量
+    overlap_size: int = 128          # chunk 之间的重叠（可选，帮助上下文连贯）
+    
+
+class TitansLongTermMemory(nn.Module):
+    """
+    Titans 长期记忆模块
+    
+    负责：
+    1. 将 chunk 的信息写入长期记忆
+    2. 从长期记忆中检索相关信息
+    3. 生成 memory tokens 注入到 Core 中
+    """
+    
+    def __init__(
+        self,
+        hidden_size: int,
+        chunk_size: int = 64,
+        batch_size: int = 128,
+        dim_head: int = 64,
+        num_heads: int = None,
+        memory_depth: int = 2,
+    ):
+        super().__init__()
+        
+        self.hidden_size = hidden_size
+        num_heads = num_heads or (hidden_size // dim_head)
+        
+        # 创建记忆网络
+        memory_model = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0
+        )
+        
+        # NeuralMemory - 这是长期记忆的核心
+        self.neural_memory = NeuralMemory(
+            dim=hidden_size,
+            chunk_size=chunk_size,
+            batch_size=batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=True,
+            momentum_order=1,
+            qk_rmsnorm=True,
+            pre_rmsnorm=True,
+            default_step_transform_max_lr=0.1,
+        )
+        
+        # Memory tokens - 可学习的查询向量
+        # 用于从长期记忆中检索信息
+        self.memory_query_tokens = nn.Parameter(
+            torch.randn(1, 16, hidden_size) * 0.02
+        )
+        
+        # 投影层：将检索结果转换为适合注入 Core 的格式
+        self.memory_proj = nn.Sequential(
+            nn.LayerNorm(hidden_size),
+            nn.Linear(hidden_size, hidden_size),
+            nn.GELU(),
+            nn.Linear(hidden_size, hidden_size),
+        )
+        
+    def write(
+        self,
+        hidden_states: Tensor,  # [batch, seq_len, hidden]
+        state: Optional[NeuralMemState] = None,
+    ) -> Tuple[Tensor, NeuralMemState]:
+        """
+        将当前 chunk 的信息写入长期记忆
+        
+        Args:
+            hidden_states: 当前 chunk 经过 Qwen 处理后的隐藏状态
+            state: 之前的记忆状态
+            
+        Returns:
+            retrieved: 从记忆中检索到的信息
+            next_state: 更新后的记忆状态
+        """
+        # NeuralMemory 同时执行 store（写入）和 retrieve（读取）
+        retrieved, next_state = self.neural_memory(
+            hidden_states,
+            state=state
+        )
+        
+        return retrieved, next_state
+    
+    def read(
+        self,
+        batch_size: int,
+        state: NeuralMemState,
+        num_tokens: int = 16,
+    ) -> Tensor:
+        """
+        从长期记忆中读取信息，生成 memory tokens
+        
+        这些 tokens 会被注入到 Core 的输入中
+        """
+        # 扩展 query tokens
+        queries = repeat(
+            self.memory_query_tokens[:, :num_tokens],
+            '1 n d -> b n d',
+            b=batch_size
+        )
+        
+        # 使用 query tokens 从记忆中检索
+        retrieved, _ = self.neural_memory(
+            queries,
+            state=state
+        )
+        
+        # 投影
+        memory_tokens = self.memory_proj(retrieved)
+        
+        return memory_tokens
+
+
+class QwenTitansStreaming(nn.Module):
+    """
+    Qwen + Titans 流式处理模型
+    
+    能够处理任意长度的序列，通过：
+    1. 将序列分成 chunks
+    2. 每个 chunk 用 Qwen Core 处理
+    3. 用 Titans 长期记忆跨 chunk 传递信息
+    """
+    
+    def __init__(
+        self,
+        qwen_model,
+        config: StreamingConfig = None,
+    ):
+        super().__init__()
+        
+        self.qwen = qwen_model
+        self.config = config or StreamingConfig()
+        self.hidden_size = qwen_model.config.hidden_size
+        
+        # 长期记忆模块
+        self.long_term_memory = TitansLongTermMemory(
+            hidden_size=self.hidden_size,
+            chunk_size=self.config.memory_chunk_size,
+            batch_size=self.config.memory_batch_size,
+        )
+        
+        # 记忆融合门控
+        self.memory_gate = nn.Sequential(
+            nn.Linear(self.hidden_size * 2, self.hidden_size),
+            nn.Sigmoid()
+        )
+        
+        print(f"[QwenTitansStreaming] 初始化完成:")
+        print(f"  - Chunk size: {self.config.chunk_size}")
+        print(f"  - Memory chunk size: {self.config.memory_chunk_size}")
+        print(f"  - Memory batch size: {self.config.memory_batch_size}")
+        print(f"  - Overlap size: {self.config.overlap_size}")
+    
+    def _split_into_chunks(
+        self,
+        input_ids: Tensor,
+        chunk_size: int,
+        overlap: int = 0,
+    ) -> List[Tensor]:
+        """
+        将输入序列分成 chunks
+        
+        Args:
+            input_ids: [batch, seq_len]
+            chunk_size: 每个 chunk 的大小
+            overlap: chunk 之间的重叠
+            
+        Returns:
+            List of chunks, each [batch, chunk_size]
+        """
+        batch_size, seq_len = input_ids.shape
+        chunks = []
+        
+        stride = chunk_size - overlap
+        
+        for start in range(0, seq_len, stride):
+            end = min(start + chunk_size, seq_len)
+            chunk = input_ids[:, start:end]
+            
+            # Padding if needed
+            if chunk.shape[1] < chunk_size:
+                pad_len = chunk_size - chunk.shape[1]
+                chunk = F.pad(chunk, (0, pad_len), value=0)
+            
+            chunks.append(chunk)
+            
+            if end >= seq_len:
+                break
+        
+        return chunks
+    
+    def process_document(
+        self,
+        input_ids: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        return_all_hidden_states: bool = False,
+        show_progress: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        流式处理整个文档
+        
+        这是核心方法：
+        1. 将文档分成 chunks
+        2. 逐个 chunk 处理
+        3. 每个 chunk 后更新长期记忆
+        
+        Args:
+            input_ids: [batch, seq_len] - 可以是任意长度！
+            attention_mask: [batch, seq_len]
+            
+        Returns:
+            包含最终隐藏状态、记忆状态等的字典
+        """
+        batch_size, total_seq_len = input_ids.shape
+        device = input_ids.device
+        
+        # 分成 chunks
+        chunks = self._split_into_chunks(
+            input_ids,
+            self.config.chunk_size,
+            self.config.overlap_size
+        )
+        
+        num_chunks = len(chunks)
+        print(f"[process_document] 总长度: {total_seq_len}, 分成 {num_chunks} 个 chunks")
+        
+        # 初始化记忆状态
+        memory_state = None
+        all_hidden_states = []
+        
+        # 逐个 chunk 处理
+        iterator = tqdm(enumerate(chunks), total=num_chunks, desc="Processing chunks") \
+                   if show_progress else enumerate(chunks)
+        
+        for chunk_idx, chunk_ids in iterator:
+            # =========================================================
+            # Step 1: 从长期记忆读取 memory tokens（除了第一个 chunk）
+            # =========================================================
+            memory_tokens = None
+            if memory_state is not None and chunk_idx > 0:
+                memory_tokens = self.long_term_memory.read(
+                    batch_size=batch_size,
+                    state=memory_state,
+                    num_tokens=self.config.num_memory_tokens
+                )
+            
+            # =========================================================
+            # Step 2: 用 Qwen Core 处理当前 chunk
+            # =========================================================
+            chunk_hidden = self._process_chunk_with_memory(
+                chunk_ids,
+                memory_tokens=memory_tokens,
+            )
+            
+            # =========================================================
+            # Step 3: 将当前 chunk 的信息写入长期记忆
+            # =========================================================
+            _, memory_state = self.long_term_memory.write(
+                chunk_hidden,
+                state=memory_state
+            )
+            
+            if return_all_hidden_states:
+                all_hidden_states.append(chunk_hidden)
+        
+        # 返回结果
+        result = {
+            'last_hidden_states': chunk_hidden,
+            'memory_state': memory_state,
+            'num_chunks_processed': num_chunks,
+        }
+        
+        if return_all_hidden_states:
+            result['all_hidden_states'] = all_hidden_states
+        
+        return result
+    
+    def _process_chunk_with_memory(
+        self,
+        chunk_ids: Tensor,
+        memory_tokens: Optional[Tensor] = None,
+    ) -> Tensor:
+        """
+        处理单个 chunk，可选地注入 memory tokens
+        
+        Args:
+            chunk_ids: [batch, chunk_size]
+            memory_tokens: [batch, num_mem_tokens, hidden] - 从长期记忆检索的
+            
+        Returns:
+            hidden_states: [batch, chunk_size, hidden]
+        """
+        batch_size = chunk_ids.shape[0]
+        
+        # 获取 token embeddings
+        if hasattr(self.qwen.model, 'embed_tokens'):
+            hidden_states = self.qwen.model.embed_tokens(chunk_ids)
+        else:
+            hidden_states = self.qwen.get_input_embeddings()(chunk_ids)
+        
+        # 如果有 memory tokens，将其拼接到输入前面
+        if memory_tokens is not None:
+            # [batch, num_mem + chunk_size, hidden]
+            hidden_states = torch.cat([memory_tokens, hidden_states], dim=1)
+        
+        # 通过 Qwen 的所有层
+        for layer in self.qwen.model.layers:
+            layer_output = layer(hidden_states, attention_mask=None)
+            if isinstance(layer_output, tuple):
+                hidden_states = layer_output[0]
+            else:
+                hidden_states = layer_output
+        
+        # Final norm
+        hidden_states = self.qwen.model.norm(hidden_states)
+        
+        # 如果添加了 memory tokens，需要移除它们
+        if memory_tokens is not None:
+            num_mem = memory_tokens.shape[1]
+            hidden_states = hidden_states[:, num_mem:]
+        
+        return hidden_states
+    
+    def generate_answer(
+        self,
+        question_ids: Tensor,
+        memory_state: NeuralMemState,
+        max_new_tokens: int = 100,
+        temperature: float = 0.7,
+    ) -> Tensor:
+        """
+        基于长期记忆生成答案
+        
+        关键：虽然 Core 只看到问题，但它能从长期记忆中
+        检索到之前 1M tokens 中的相关事实！
+        
+        Args:
+            question_ids: [batch, question_len] - 问题的 token ids
+            memory_state: 处理完整个文档后的记忆状态
+            max_new_tokens: 最大生成长度
+            
+        Returns:
+            generated_ids: [batch, question_len + generated_len]
+        """
+        batch_size = question_ids.shape[0]
+        generated = question_ids.clone()
+        
+        for _ in range(max_new_tokens):
+            # 从长期记忆读取相关信息
+            memory_tokens = self.long_term_memory.read(
+                batch_size=batch_size,
+                state=memory_state,
+                num_tokens=self.config.num_memory_tokens
+            )
+            
+            # 处理当前序列 + memory tokens
+            hidden = self._process_chunk_with_memory(
+                generated,
+                memory_tokens=memory_tokens
+            )
+            
+            # 预测下一个 token
+            logits = self.qwen.lm_head(hidden[:, -1:, :])
+            
+            if temperature > 0:
+                probs = F.softmax(logits.squeeze(1) / temperature, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+            else:
+                next_token = logits.squeeze(1).argmax(dim=-1, keepdim=True)
+            
+            generated = torch.cat([generated, next_token], dim=1)
+            
+            # 检查 EOS
+            if hasattr(self.qwen.config, 'eos_token_id'):
+                if (next_token == self.qwen.config.eos_token_id).all():
+                    break
+        
+        return generated
+
+
+# ============================================================================
+# BABILong 风格的使用示例
+# ============================================================================
+
+def babilong_style_example():
+    """
+    演示如何用 Qwen + Titans 处理 BABILong 风格的超长序列任务
+    
+    BABILong 任务结构:
+    - 前面是很长的背景文档（可能 1M tokens）
+    - 最后是一个问题
+    - 需要从文档中找到相关事实来回答
+    """
+    
+    print("=" * 70)
+    print("Qwen + Titans 流式处理超长序列示例")
+    print("=" * 70)
+    
+    try:
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        
+        # 加载模型
+        print("\n[1] 加载 Qwen 模型...")
+        model_name = "Qwen/Qwen2-0.5B"  # 或 Qwen/Qwen3-4B
+        
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        qwen_model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto" if torch.cuda.is_available() else None,
+            trust_remote_code=True
+        )
+        
+        # 创建流式处理模型
+        print("\n[2] 创建 QwenTitansStreaming 模型...")
+        config = StreamingConfig(
+            chunk_size=2048,        # 每次处理 2k tokens
+            memory_chunk_size=64,
+            memory_batch_size=128,
+            num_memory_tokens=16,
+            overlap_size=64,        # chunk 间 64 token 重叠
+        )
+        
+        model = QwenTitansStreaming(qwen_model, config)
+        
+        if torch.cuda.is_available():
+            model = model.cuda()
+        
+        # =====================================================================
+        # 模拟 BABILong 任务
+        # =====================================================================
+        print("\n[3] 模拟 BABILong 任务...")
+        
+        # 模拟一个长文档（实际可能有几十万 tokens）
+        long_document = """
+        这是一个关于人工智能发展历史的长篇文档。
+        
+        第一章：早期发展
+        人工智能的概念最早可以追溯到 1950 年代。1956 年的达特茅斯会议
+        被认为是人工智能作为一门学科正式诞生的标志。
+        
+        [这里假设有很多很多内容...]
+        
+        重要事实：达特茅斯会议在 1956 年举行。
+        
+        [更多内容...]
+        
+        第五十章：现代发展
+        2022 年，大型语言模型取得了突破性进展。
+        
+        重要事实：GPT-4 在 2023 年发布。
+        
+        [更多内容...]
+        """
+        
+        # 复制文档以模拟超长序列
+        # 实际使用时这里会是真正的长文档
+        very_long_document = long_document * 100  # 模拟长文档
+        
+        question = "\n问题：达特茅斯会议是在哪一年举行的？"
+        full_input = very_long_document + question
+        
+        # Tokenize
+        print(f"  文档长度（字符）: {len(full_input)}")
+        inputs = tokenizer(full_input, return_tensors="pt")
+        input_ids = inputs.input_ids
+        print(f"  文档长度（tokens）: {input_ids.shape[1]}")
+        
+        device = next(model.parameters()).device
+        input_ids = input_ids.to(device)
+        
+        # 流式处理
+        print("\n[4] 流式处理文档...")
+        with torch.no_grad():
+            result = model.process_document(
+                input_ids,
+                show_progress=True
+            )
+        
+        print(f"\n  处理完成!")
+        print(f"  - 处理了 {result['num_chunks_processed']} 个 chunks")
+        print(f"  - 记忆状态 seq_index: {result['memory_state'].seq_index}")
+        
+        # 生成答案（实际场景）
+        # print("\n[5] 基于长期记忆生成答案...")
+        # answer = model.generate_answer(
+        #     question_ids,
+        #     memory_state=result['memory_state'],
+        #     max_new_tokens=50
+        # )
+        
+    except ImportError as e:
+        print(f"\n需要安装依赖: pip install transformers")
+        print(f"错误: {e}")
+    
+    # =========================================================================
+    # 独立测试
+    # =========================================================================
+    print("\n" + "=" * 70)
+    print("[独立测试] Titans 长期记忆模块")
+    print("=" * 70)
+    
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    
+    # 创建长期记忆模块
+    ltm = TitansLongTermMemory(
+        hidden_size=512,
+        chunk_size=64,
+        batch_size=128,
+        dim_head=64,
+        num_heads=8,
+    ).to(device)
+    
+    # 模拟多个 chunk 的处理
+    batch_size = 2
+    chunk_size = 256
+    hidden_dim = 512
+    num_chunks = 5
+    
+    print(f"\n模拟处理 {num_chunks} 个 chunks:")
+    
+    memory_state = None
+    for i in range(num_chunks):
+        # 模拟当前 chunk 的隐藏状态
+        chunk_hidden = torch.randn(batch_size, chunk_size, hidden_dim).to(device)
+        
+        # 写入长期记忆
+        retrieved, memory_state = ltm.write(chunk_hidden, state=memory_state)
+        
+        print(f"  Chunk {i}: 写入完成, seq_index = {memory_state.seq_index}")
+    
+    # 从记忆中读取
+    print(f"\n从长期记忆中读取:")
+    memory_tokens = ltm.read(batch_size, memory_state, num_tokens=16)
+    print(f"  Memory tokens 形状: {memory_tokens.shape}")
+    
+    print("\n" + "=" * 70)
+    print("完成!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    babilong_style_example()

examples/qwen_with_titans_memory.py

@@ -0,0 +1,487 @@
+"""
+Titans Neural Memory 与 Qwen 模型集成示例
+
+本文件展示了如何将 Titans 的 NeuralMemory 模块集成到 Qwen 模型中，
+以增强其长期记忆能力。
+
+主要集成方案：
+1. 作为独立的记忆增强模块（Memory Augmented）
+2. 替换/增强特定层的注意力机制
+3. Memory-as-Context 方式（类似 MAC Transformer）
+"""
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from typing import Optional, Tuple
+from einops import rearrange, repeat
+from copy import deepcopy
+
+# 导入 Titans 的核心组件
+from titans_pytorch import NeuralMemory, MemoryMLP, NeuralMemState
+
+
+# ============================================================================
+# 方案 1: 简单的记忆增强包装器 (Memory Augmented Wrapper)
+# ============================================================================
+
+class TitansMemoryWrapper(nn.Module):
+    """
+    最简单的集成方式：在 Qwen 模型外部添加 Titans 记忆模块
+    
+    工作原理：
+    1. 使用 NeuralMemory 存储和检索长期信息
+    2. 将检索到的记忆与 Qwen 的输出融合
+    
+    适用场景：
+    - 不想修改 Qwen 内部结构
+    - 需要快速验证 Titans 记忆的效果
+    """
+    
+    def __init__(
+        self,
+        qwen_model,
+        hidden_size: int = 896,  # Qwen2-0.5B 的隐藏层大小
+        chunk_size: int = 64,
+        memory_batch_size: int = 128,
+        num_heads: int = 4,
+        dim_head: int = 64,
+        memory_depth: int = 2,
+    ):
+        super().__init__()
+        self.qwen = qwen_model
+        
+        # 投影层：将 Qwen 的隐藏状态投影到记忆维度
+        self.mem_dim = dim_head * num_heads
+        self.to_mem_input = nn.Linear(hidden_size, self.mem_dim)
+        self.from_mem_output = nn.Linear(self.mem_dim, hidden_size)
+        
+        # 创建 Titans 记忆模块
+        memory_model = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0
+        )
+        
+        self.neural_memory = NeuralMemory(
+            dim=self.mem_dim,
+            chunk_size=chunk_size,
+            batch_size=memory_batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=True,
+            momentum_order=1,
+            qk_rmsnorm=True,
+        )
+        
+        # 融合门控
+        self.fusion_gate = nn.Sequential(
+            nn.Linear(hidden_size * 2, hidden_size),
+            nn.Sigmoid()
+        )
+        
+    def forward(
+        self,
+        input_ids: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        memory_state: Optional[NeuralMemState] = None,
+        **kwargs
+    ):
+        # 获取 Qwen 的隐藏状态
+        qwen_outputs = self.qwen(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            output_hidden_states=True,
+            **kwargs
+        )
+        
+        hidden_states = qwen_outputs.hidden_states[-1]  # 最后一层隐藏状态
+        
+        # 投影到记忆空间
+        mem_input = self.to_mem_input(hidden_states)
+        
+        # 使用 Titans 记忆模块存储和检索
+        retrieved, next_memory_state = self.neural_memory(
+            mem_input,
+            state=memory_state
+        )
+        
+        # 投影回原始维度
+        retrieved_hidden = self.from_mem_output(retrieved)
+        
+        # 门控融合
+        gate = self.fusion_gate(torch.cat([hidden_states, retrieved_hidden], dim=-1))
+        enhanced_hidden = hidden_states + gate * retrieved_hidden
+        
+        # 使用增强的隐藏状态计算 logits
+        # 注意：这里需要访问 Qwen 的 lm_head
+        if hasattr(self.qwen, 'lm_head'):
+            logits = self.qwen.lm_head(enhanced_hidden)
+        else:
+            logits = qwen_outputs.logits
+            
+        return {
+            'logits': logits,
+            'hidden_states': enhanced_hidden,
+            'memory_state': next_memory_state,
+            'qwen_outputs': qwen_outputs
+        }
+
+
+# ============================================================================
+# 方案 2: 将 Titans 记忆嵌入到 Qwen 的特定层中
+# ============================================================================
+
+class QwenDecoderLayerWithMemory(nn.Module):
+    """
+    修改后的 Qwen Decoder 层，集成了 Titans 记忆模块
+    
+    在每个 attention 层后添加记忆检索和更新
+    """
+    
+    def __init__(
+        self,
+        original_layer,
+        hidden_size: int,
+        chunk_size: int = 64,
+        memory_batch_size: int = 128,
+        num_heads: int = 4,
+        dim_head: int = 64,
+    ):
+        super().__init__()
+        
+        # 保留原始层的组件
+        self.self_attn = original_layer.self_attn
+        self.mlp = original_layer.mlp
+        self.input_layernorm = original_layer.input_layernorm
+        self.post_attention_layernorm = original_layer.post_attention_layernorm
+        
+        # 添加 Titans 记忆模块
+        self.mem_dim = dim_head * num_heads
+        self.to_mem = nn.Linear(hidden_size, self.mem_dim)
+        self.from_mem = nn.Linear(self.mem_dim, hidden_size)
+        
+        memory_model = MemoryMLP(dim=dim_head, depth=2)
+        
+        self.neural_memory = NeuralMemory(
+            dim=self.mem_dim,
+            chunk_size=chunk_size,
+            batch_size=memory_batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=True,
+        )
+        
+        # 记忆输出的门控
+        self.mem_gate = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.Sigmoid()
+        )
+        
+    def forward(
+        self,
+        hidden_states: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        position_ids: Optional[Tensor] = None,
+        memory_state: Optional[NeuralMemState] = None,
+        **kwargs
+    ):
+        # 标准的 attention 前向传播
+        residual = hidden_states
+        hidden_states = self.input_layernorm(hidden_states)
+        
+        attn_output, attn_weights, _ = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            **kwargs
+        )
+        hidden_states = residual + attn_output
+        
+        # === Titans 记忆增强 ===
+        mem_input = self.to_mem(hidden_states)
+        retrieved, next_memory_state = self.neural_memory(
+            mem_input,
+            state=memory_state
+        )
+        mem_output = self.from_mem(retrieved)
+        
+        # 门控融合记忆
+        gate = self.mem_gate(hidden_states)
+        hidden_states = hidden_states + gate * mem_output
+        # ========================
+        
+        # 标准的 FFN 前向传播
+        residual = hidden_states
+        hidden_states = self.post_attention_layernorm(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+        
+        return hidden_states, next_memory_state
+
+
+# ============================================================================
+# 方案 3: Memory-as-Context 方式（最接近原论文）
+# ============================================================================
+
+class QwenWithMAC(nn.Module):
+    """
+    Memory-as-Context 方式集成 Titans 到 Qwen
+    
+    核心思想：
+    1. 将长序列分成多个 segment
+    2. 每个 segment 的开头添加 longterm memory tokens
+    3. 使用 NeuralMemory 来更新这些 memory tokens
+    
+    这种方式最接近 Titans 论文中的 MAC 配置
+    """
+    
+    def __init__(
+        self,
+        qwen_model,
+        hidden_size: int = 896,
+        segment_len: int = 128,
+        num_longterm_mem_tokens: int = 16,
+        num_persist_mem_tokens: int = 4,
+        memory_layers: Tuple[int, ...] = (2, 4, 6),
+        chunk_size: int = 64,
+        memory_batch_size: int = 128,
+    ):
+        super().__init__()
+        
+        self.qwen = qwen_model
+        self.hidden_size = hidden_size
+        self.segment_len = segment_len
+        self.num_longterm_mem_tokens = num_longterm_mem_tokens
+        
+        # 持久记忆 tokens（全局共享）
+        self.persist_mem = nn.Parameter(
+            torch.randn(num_persist_mem_tokens, hidden_size) * 0.02
+        )
+        
+        # 长期记忆 tokens（每个 segment 独立）
+        self.longterm_mem = nn.Parameter(
+            torch.randn(num_longterm_mem_tokens, hidden_size) * 0.02
+        )
+        
+        # 为指定层创建 NeuralMemory 模块
+        self.memory_layers = memory_layers
+        self.neural_memories = nn.ModuleDict()
+        
+        memory_model = MemoryMLP(dim=64, depth=2)
+        
+        for layer_idx in memory_layers:
+            self.neural_memories[str(layer_idx)] = NeuralMemory(
+                dim=hidden_size,
+                chunk_size=chunk_size,
+                batch_size=memory_batch_size,
+                dim_head=64,
+                heads=hidden_size // 64,
+                model=deepcopy(memory_model),
+                momentum=True,
+                qk_rmsnorm=True,
+            )
+            
+    def prepare_inputs_with_memory(
+        self,
+        hidden_states: Tensor,
+        batch_size: int,
+    ) -> Tensor:
+        """
+        在每个 segment 开头插入 memory tokens
+        """
+        seq_len = hidden_states.shape[1]
+        num_segments = (seq_len + self.segment_len - 1) // self.segment_len
+        
+        # 扩展 longterm memory
+        longterm = repeat(
+            self.longterm_mem,
+            'n d -> b s n d',
+            b=batch_size,
+            s=num_segments
+        )
+        
+        # 将序列分成 segments
+        padded_len = num_segments * self.segment_len
+        if seq_len < padded_len:
+            hidden_states = nn.functional.pad(
+                hidden_states,
+                (0, 0, 0, padded_len - seq_len)
+            )
+            
+        hidden_states = rearrange(
+            hidden_states,
+            'b (s n) d -> b s n d',
+            n=self.segment_len
+        )
+        
+        # 在每个 segment 前添加 memory tokens
+        hidden_states = torch.cat([longterm, hidden_states], dim=2)
+        
+        # 合并回完整序列
+        hidden_states = rearrange(hidden_states, 'b s n d -> b (s n) d')
+        
+        # 添加持久记忆 tokens 在最前面
+        persist = repeat(self.persist_mem, 'n d -> b n d', b=batch_size)
+        hidden_states = torch.cat([persist, hidden_states], dim=1)
+        
+        return hidden_states
+    
+    def forward(
+        self,
+        input_ids: Tensor,
+        attention_mask: Optional[Tensor] = None,
+        memory_states: Optional[dict] = None,
+        **kwargs
+    ):
+        batch_size = input_ids.shape[0]
+        
+        # 获取 token embeddings
+        if hasattr(self.qwen.model, 'embed_tokens'):
+            hidden_states = self.qwen.model.embed_tokens(input_ids)
+        else:
+            hidden_states = self.qwen.get_input_embeddings()(input_ids)
+        
+        # 添加 memory tokens
+        hidden_states = self.prepare_inputs_with_memory(hidden_states, batch_size)
+        
+        # 初始化记忆状态
+        if memory_states is None:
+            memory_states = {}
+            
+        next_memory_states = {}
+        
+        # 遍历 Qwen 的层
+        for layer_idx, layer in enumerate(self.qwen.model.layers):
+            # 标准的 transformer 层前向传播
+            layer_outputs = layer(
+                hidden_states,
+                attention_mask=None,  # 需要修改 attention mask 来处理 memory tokens
+                **kwargs
+            )
+            hidden_states = layer_outputs[0]
+            
+            # 在指定层应用 Titans 记忆
+            if str(layer_idx) in self.neural_memories:
+                neural_mem = self.neural_memories[str(layer_idx)]
+                mem_state = memory_states.get(str(layer_idx))
+                
+                retrieved, next_state = neural_mem(
+                    hidden_states,
+                    state=mem_state
+                )
+                
+                # 融合检索到的记忆
+                hidden_states = hidden_states + retrieved * 0.1  # 可学习的权重
+                next_memory_states[str(layer_idx)] = next_state
+        
+        # 最终的 layer norm
+        hidden_states = self.qwen.model.norm(hidden_states)
+        
+        # 计算 logits
+        logits = self.qwen.lm_head(hidden_states)
+        
+        return {
+            'logits': logits,
+            'hidden_states': hidden_states,
+            'memory_states': next_memory_states
+        }
+
+
+# ============================================================================
+# 使用示例
+# ============================================================================
+
+def example_usage():
+    """展示如何使用上述集成方案"""
+    
+    print("=" * 60)
+    print("Titans Neural Memory 与 Qwen 集成示例")
+    print("=" * 60)
+    
+    # 注意：需要先安装 transformers 和 qwen 相关依赖
+    # pip install transformers torch titans-pytorch
+    
+    try:
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        
+        # 加载 Qwen 模型（以 Qwen2-0.5B 为例）
+        model_name = "Qwen/Qwen2-0.5B"
+        
+        print(f"\n加载模型: {model_name}")
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        qwen_model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            trust_remote_code=True
+        )
+        
+        # 获取隐藏层大小
+        hidden_size = qwen_model.config.hidden_size
+        print(f"模型隐藏层大小: {hidden_size}")
+        
+        # 方案 1: 简单包装器
+        print("\n--- 方案 1: TitansMemoryWrapper ---")
+        wrapped_model = TitansMemoryWrapper(
+            qwen_model=qwen_model,
+            hidden_size=hidden_size,
+            chunk_size=64,
+            memory_batch_size=128,
+        )
+        
+        # 测试输入
+        text = "人工智能的发展历程"
+        inputs = tokenizer(text, return_tensors="pt")
+        
+        with torch.no_grad():
+            outputs = wrapped_model(
+                input_ids=inputs.input_ids.to(qwen_model.device),
+            )
+            print(f"输出 logits 形状: {outputs['logits'].shape}")
+            print(f"记忆状态: {type(outputs['memory_state'])}")
+        
+    except ImportError as e:
+        print(f"\n注意: 需要安装相关依赖")
+        print(f"pip install transformers torch titans-pytorch")
+        print(f"错误: {e}")
+    
+    # 独立测试 NeuralMemory
+    print("\n--- 独立测试 NeuralMemory ---")
+    
+    mem = NeuralMemory(
+        dim=384,
+        chunk_size=64,
+        batch_size=128,
+        dim_head=64,
+        heads=4,
+        model=MemoryMLP(dim=64, depth=2),
+        momentum=True,
+    ).cuda() if torch.cuda.is_available() else NeuralMemory(
+        dim=384,
+        chunk_size=64,
+        batch_size=128,
+        dim_head=64,
+        heads=4,
+        model=MemoryMLP(dim=64, depth=2),
+        momentum=True,
+    )
+    
+    # 模拟输入
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    seq = torch.randn(2, 256, 384).to(device)
+    
+    retrieved, mem_state = mem(seq)
+    print(f"输入形状: {seq.shape}")
+    print(f"检索输出形状: {retrieved.shape}")
+    print(f"记忆状态序列索引: {mem_state.seq_index}")
+    
+    print("\n" + "=" * 60)
+    print("集成完成!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    example_usage()

examples/run_training.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+# Qwen3-4B + Titans 在 BABILong QA1 32k 上的训练脚本
+
+# 设置环境变量
+# 如果你在外部已 export CUDA_VISIBLE_DEVICES，这里不要覆盖
+# 否则默认用满 8 卡
+if [ -z "${CUDA_VISIBLE_DEVICES}" ]; then
+  export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+fi
+echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES}"
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True,max_split_size_mb:512
+
+# 进入目录
+cd /root/githubs/titans-pytorch
+
+# 创建输出目录
+mkdir -p outputs
+
+# 可选：首次运行安装依赖（会改动当前 Python 环境，可能触发依赖冲突；建议你手动在独立环境里装）
+# echo "安装依赖..."
+# pip install -e .
+
+# 运行训练
+echo "开始训练..."
+IFS=',' read -ra _GPU_ARR <<< "${CUDA_VISIBLE_DEVICES}"
+NPROC=${#_GPU_ARR[@]}
+echo "torchrun nproc_per_node=${NPROC}"
+
+EXTRA_ARGS=""
+# 默认启用 FSDP（更省显存；DDP 在 32k/4k chunk 下容易接近 80GB）
+if [ -z "${USE_FSDP}" ]; then
+  export USE_FSDP=1
+fi
+
+if [ "${USE_FSDP}" = "1" ]; then
+  EXTRA_ARGS="--fsdp"
+  echo "启用 FSDP"
+else
+  echo "使用 DDP"
+fi
+
+torchrun --standalone --nproc_per_node=${NPROC} examples/train_qwen_titans_babilong.py ${EXTRA_ARGS} \
+  2>&1 | tee outputs/training_$(date +%Y%m%d_%H%M%S).log
+
+echo "训练完成!"

examples/train_qwen_baseline_babilong_v4.py

@@ -0,0 +1,1361 @@
+"""
+Qwen3 baseline (NO Titans) - BABILong QA1 (32k) with Cross-Chunk Gradients
+
+Control-group purpose:
+- Remove Titans memory modules entirely
+- Train ONLY Qwen's `embed_tokens` and `lm_head`
+- Keep ALL other training settings the same as `train_qwen_titans_babilong_v4.py`
+
+Key design (mirrors v4 training script behavior):
+1. Freeze Qwen backbone EXCEPT embed_tokens (trainable for input adaptation)
+2. Untie lm_head from embed_tokens if they share weights
+3. Train: embed_tokens + lm_head
+4. Keep chunkwise_backward=False + full-sequence backward (cross-chunk graph)
+5. Keep gradient_checkpointing & manual gradient all-reduce strategy for multi-GPU
+"""
+
+import os
+import sys
+
+# =============================================================================
+# CRITICAL: Disable torchao BEFORE importing transformers to avoid version conflicts
+# =============================================================================
+os.environ["TRANSFORMERS_NO_TORCHAO"] = "1"
+
+
+# Mock torchao to prevent import errors (same hack as v4)
+class _MockTorchAO:
+    def __getattr__(self, name):
+        return _MockTorchAO()
+
+    def __call__(self, *args, **kwargs):
+        return _MockTorchAO()
+
+
+sys.modules["torchao"] = _MockTorchAO()
+sys.modules["torchao.quantization"] = _MockTorchAO()
+
+import json
+import math
+import argparse
+import logging
+from contextlib import nullcontext
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.nn.parallel import DistributedDataParallel as DDP
+from tqdm import tqdm
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Configuration (keep defaults identical to v4, except output_dir/use_memory)
+# =============================================================================
+
+
+@dataclass
+class TrainingConfig:
+    # paths
+    model_path: str = "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554"
+    data_path: str = "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json"
+    output_dir: str = "./outputs/qwen_baseline_babilong_v4"
+
+    # training
+    num_epochs: int = 10
+    batch_size: int = 1
+    gradient_accumulation_steps: int = 16
+    max_grad_norm: float = 1.0
+
+    # learning rates (keep v4 values)
+    lr_embed: float = 1e-5  # Learning rate for embed_tokens
+    lr_lm_head: float = 1e-4  # Learning rate for lm_head
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+
+    # streaming (keep v4 values)
+    chunk_size: int = 4096
+
+    # evaluation / logging
+    eval_steps: int = 200
+    eval_topk: int = 0
+    logging_steps: int = 10
+    log_every_batches: int = 80
+    final_eval_print_examples: int = 10
+    debug_data_samples: int = 0
+    debug_label_batches: int = 0
+    debug_eval_stats: bool = False
+    debug_grad_norm: bool = False
+
+    # precision
+    bf16: bool = True
+    fp16: bool = False
+    use_tf32: bool = True
+    gradient_checkpointing: bool = True
+    chunkwise_backward: bool = False  # keep v4 default (full-sequence backward)
+
+    # data
+    max_length: int = 32768
+    answer_reserve_tokens: int = 64
+    label_prefix_tokens: int = 0
+    max_samples: Optional[int] = 500
+
+    # distributed
+    use_fsdp: bool = False
+    fsdp_use_orig_params: bool = True
+    ddp_find_unused_parameters: bool = False
+
+    # checkpoint
+    save_full_checkpoint: bool = True
+    final_ckpt_name: str = "final_memory_checkpoint.pt"  # keep same key layout for compatibility
+    final_full_ckpt_name: str = "final_full_checkpoint.pt"
+
+    seed: int = 42
+
+
+# =============================================================================
+# Dataset (identical to v4)
+# =============================================================================
+
+
+class BABILongDataset(Dataset):
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer,
+        max_length: int = 32768,
+        answer_reserve_tokens: int = 64,
+        label_prefix_tokens: int = 0,
+        max_samples: Optional[int] = None,
+    ):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.answer_reserve_tokens = answer_reserve_tokens
+        self.label_prefix_tokens = int(label_prefix_tokens)
+
+        logger.info(f"Loading dataset: {data_path}")
+        with open(data_path, "r") as f:
+            self.data = json.load(f)
+
+        if max_samples:
+            self.data = self.data[:max_samples]
+
+        logger.info(f"Dataset size: {len(self.data)}")
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        text = f"{item['input']}\n\nQuestion: {item['question']}\nAnswer:"
+        target = item["target"]
+
+        pad_id = self.tokenizer.pad_token_id or 0
+        reserve = int(self.answer_reserve_tokens)
+
+        prompt_ids = self.tokenizer(
+            text,
+            max_length=max(self.max_length - reserve, 1),
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        answer_ids = self.tokenizer(
+            f" {target}",
+            add_special_tokens=False,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        available = max(self.max_length - prompt_ids.numel(), 0)
+        answer_ids = answer_ids[:available]
+
+        input_ids = torch.cat([prompt_ids, answer_ids], dim=0)[: self.max_length]
+
+        labels = torch.full_like(input_ids, fill_value=-100)
+        if answer_ids.numel() > 0:
+            start = prompt_ids.numel()
+            end = min(start + answer_ids.numel(), labels.numel())
+            labels[start:end] = input_ids[start:end]
+            if self.label_prefix_tokens > 0:
+                prefix = min(start, self.label_prefix_tokens)
+                if prefix > 0:
+                    labels[start - prefix : start] = input_ids[start - prefix : start]
+
+        seq_len = input_ids.numel()
+        if seq_len < self.max_length:
+            pad_len = self.max_length - seq_len
+            input_ids = F.pad(input_ids, (0, pad_len), value=int(pad_id))
+            labels = F.pad(labels, (0, pad_len), value=-100)
+            attention_mask = torch.cat(
+                [torch.ones(seq_len, dtype=torch.long), torch.zeros(pad_len, dtype=torch.long)],
+                dim=0,
+            )
+        else:
+            attention_mask = torch.ones(self.max_length, dtype=torch.long)
+
+        return {
+            "input_ids": input_ids.to(dtype=torch.long),
+            "labels": labels.to(dtype=torch.long),
+            "attention_mask": attention_mask,
+        }
+
+
+def collate_fn(batch):
+    keys = batch[0].keys()
+    return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys}
+
+
+# =============================================================================
+# Baseline Model Wrapper (NO Titans)
+# =============================================================================
+
+
+class QwenBaselineForBABILongV4(nn.Module):
+    """
+    Baseline wrapper that mirrors v4's chunk streaming + loss computation,
+    but WITHOUT any Titans memory integration.
+
+    Trainable: embed_tokens + lm_head
+    Frozen: all transformer layers
+    """
+
+    def __init__(self, qwen_model, config: TrainingConfig):
+        super().__init__()
+        self.qwen = qwen_model
+        self.config = config
+        self.hidden_size = qwen_model.config.hidden_size
+        self.num_attention_heads = qwen_model.config.num_attention_heads
+
+        self._freeze_backbone()
+
+        logger.info("[QwenBaselineForBABILongV4] Initialized (NO TITANS)")
+        logger.info("Trainable: embed_tokens + lm_head | Frozen: transformer layers")
+        logger.info(f"  - hidden_size: {self.hidden_size}")
+        logger.info(f"  - num_attention_heads: {self.num_attention_heads}")
+        logger.info(f"  - chunk_size: {config.chunk_size}")
+        logger.info(f"  - chunkwise_backward: {config.chunkwise_backward}")
+
+    def _freeze_backbone(self):
+        """
+        Freeze Qwen transformer layers, keep embed_tokens + lm_head trainable.
+        Also untie lm_head from embed_tokens if they share weights (same as v4).
+        """
+        # Untie if tied (allows independent training & param grouping)
+        if hasattr(self.qwen, "lm_head") and hasattr(self.qwen, "model") and hasattr(self.qwen.model, "embed_tokens"):
+            lm_head_weight = self.qwen.lm_head.weight
+            embed_weight = self.qwen.model.embed_tokens.weight
+            try:
+                has_tied_weights = lm_head_weight.data_ptr() == embed_weight.data_ptr()
+            except Exception:
+                has_tied_weights = False
+
+            if has_tied_weights:
+                logger.info("[baseline v4] Detected tied weights - untying lm_head from embed_tokens")
+                new_lm_head = nn.Linear(
+                    self.qwen.lm_head.in_features,
+                    self.qwen.lm_head.out_features,
+                    bias=self.qwen.lm_head.bias is not None,
+                    device=lm_head_weight.device,
+                    dtype=lm_head_weight.dtype,
+                )
+                with torch.no_grad():
+                    new_lm_head.weight.copy_(lm_head_weight)
+                    if self.qwen.lm_head.bias is not None and new_lm_head.bias is not None:
+                        new_lm_head.bias.copy_(self.qwen.lm_head.bias)
+                self.qwen.lm_head = new_lm_head
+                logger.info(f"[baseline v4] Created independent lm_head: {new_lm_head.weight.shape}")
+
+        # Freeze everything
+        for _, p in self.named_parameters():
+            p.requires_grad = False
+
+        # Unfreeze embed_tokens
+        if hasattr(self.qwen, "model") and hasattr(self.qwen.model, "embed_tokens"):
+            for p in self.qwen.model.embed_tokens.parameters():
+                p.requires_grad = True
+        else:
+            emb = self.qwen.get_input_embeddings()
+            if emb is not None:
+                for p in emb.parameters():
+                    p.requires_grad = True
+
+        # Unfreeze lm_head (output embeddings)
+        if hasattr(self.qwen, "lm_head"):
+            for p in self.qwen.lm_head.parameters():
+                p.requires_grad = True
+        else:
+            out_emb = self.qwen.get_output_embeddings()
+            if out_emb is not None:
+                for p in out_emb.parameters():
+                    p.requires_grad = True
+
+        # Log counts
+        frozen_count = 0
+        trainable_count = 0
+        embed_count = 0
+        lm_head_count = 0
+        for name, param in self.named_parameters():
+            if param.requires_grad:
+                trainable_count += 1
+                if "embed_tokens" in name:
+                    embed_count += 1
+                    logger.info(f"[baseline v4] embed_tokens trainable: {name}")
+                elif "lm_head" in name:
+                    lm_head_count += 1
+                    logger.info(f"[baseline v4] lm_head trainable: {name}")
+            else:
+                frozen_count += 1
+
+        logger.info(f"[baseline v4] Frozen {frozen_count} parameters")
+        logger.info(f"[baseline v4] Trainable {trainable_count} parameters (embed: {embed_count} + lm_head: {lm_head_count})")
+
+    def _split_into_chunks(self, tensor: torch.Tensor, chunk_size: int):
+        seq_len = tensor.shape[1]
+        chunks = []
+        for start in range(0, seq_len, chunk_size):
+            end = min(start + chunk_size, seq_len)
+            chunks.append((start, end, tensor[:, start:end]))
+        return chunks
+
+    def _process_chunk(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if hasattr(self.qwen, "model") and hasattr(self.qwen.model, "embed_tokens"):
+            token_embeds = self.qwen.model.embed_tokens(chunk_ids)
+        else:
+            token_embeds = self.qwen.get_input_embeddings()(chunk_ids)
+
+        outputs = self.qwen.model(
+            inputs_embeds=token_embeds,
+            attention_mask=chunk_attention_mask,
+            use_cache=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+        return outputs.last_hidden_state
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_pred_tokens: bool = False,
+        topk: int = 0,
+        chunk_start: Optional[int] = None,
+        chunk_end: Optional[int] = None,
+        reset_mem_state: bool = False,  # kept for Trainer API compatibility
+    ) -> Dict[str, torch.Tensor]:
+        # Single chunk forward (for chunkwise backward)
+        if chunk_start is not None or chunk_end is not None:
+            start = 0 if chunk_start is None else int(chunk_start)
+            end = int(chunk_end) if chunk_end is not None else None
+            return self._forward_single_chunk(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                labels=labels,
+                chunk_start=start,
+                chunk_end=end,
+            )
+
+        # Full sequence forward (streaming chunks)
+        batch_size, _ = input_ids.shape
+        chunk_size = self.config.chunk_size
+        chunks = self._split_into_chunks(input_ids, chunk_size)
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+
+        topk_correct = None
+        topk_total = None
+
+        pred_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        target_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+
+        if topk and topk > 0:
+            device = input_ids.device
+            topk_correct = torch.tensor(0.0, device=device, dtype=torch.float32)
+            topk_total = torch.tensor(0.0, device=device, dtype=torch.float32)
+
+        for start, end, _ in chunks:
+            proc_start = max(0, start - 1)
+            chunk_ids = input_ids[:, proc_start:end]
+            chunk_labels = labels[:, proc_start:end] if labels is not None else None
+            chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+            hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+
+            if chunk_labels is not None and (chunk_labels != -100).any():
+                chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+                shift_hidden = hidden_full[:, :-1, :].contiguous()
+                shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+                valid = shift_labels != -100
+                if valid.any():
+                    hs = shift_hidden[valid]
+                    targets = shift_labels[valid]
+
+                    hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                    logits = self.qwen.lm_head(hs)
+                    logits = logits.float()
+                    logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                    targets = targets.to(device=logits.device)
+
+                    chunk_loss_sum = loss_fct_sum(logits, targets)
+                    total_loss_sum = chunk_loss_sum if total_loss_sum is None else (total_loss_sum + chunk_loss_sum)
+                    total_loss_tokens += targets.numel()
+
+                    if topk and topk > 0:
+                        k = min(int(topk), logits.shape[-1])
+                        topk_ids = torch.topk(logits, k=k, dim=-1).indices
+                        correct = (topk_ids == targets.unsqueeze(-1)).any(dim=-1)
+                        topk_correct = topk_correct + correct.float().sum()
+                        topk_total = topk_total + torch.tensor(float(targets.numel()), device=topk_total.device)
+
+                    if return_pred_tokens:
+                        idx = valid.nonzero(as_tuple=False)
+                        pred_flat = torch.argmax(logits, dim=-1).detach().to("cpu", dtype=torch.long).tolist()
+                        tgt_flat = targets.detach().to("cpu", dtype=torch.long).tolist()
+                        b_idx_flat = idx[:, 0].detach().to("cpu", dtype=torch.long).tolist()
+
+                        for i, b_idx in enumerate(b_idx_flat):
+                            pred_tokens_by_sample[b_idx].append(int(pred_flat[i]))
+                            target_tokens_by_sample[b_idx].append(int(tgt_flat[i]))
+
+        if total_loss_sum is None or total_loss_tokens == 0:
+            device = next(self.qwen.parameters()).device
+            loss = torch.zeros((), device=device, dtype=torch.float32)
+        else:
+            loss = total_loss_sum / total_loss_tokens
+
+        out: Dict[str, torch.Tensor] = {"loss": loss}
+
+        if return_pred_tokens:
+            lengths = torch.tensor([len(x) for x in target_tokens_by_sample], dtype=torch.long)
+            max_len = int(lengths.max().item()) if lengths.numel() > 0 else 0
+            if max_len > 0:
+                pred_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                tgt_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                for b in range(batch_size):
+                    L = int(lengths[b].item())
+                    if L > 0:
+                        pred_mat[b, :L] = torch.tensor(pred_tokens_by_sample[b], dtype=torch.long)
+                        tgt_mat[b, :L] = torch.tensor(target_tokens_by_sample[b], dtype=torch.long)
+            else:
+                pred_mat = torch.empty((batch_size, 0), dtype=torch.long)
+                tgt_mat = torch.empty((batch_size, 0), dtype=torch.long)
+            out["pred_ids"] = pred_mat
+            out["target_ids"] = tgt_mat
+            out["target_lengths"] = lengths
+
+        if topk and topk > 0 and topk_correct is not None and topk_total is not None:
+            out["topk_correct"] = topk_correct
+            out["topk_total"] = topk_total
+
+        return out
+
+    def _forward_single_chunk(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor],
+        labels: Optional[torch.Tensor],
+        chunk_start: int,
+        chunk_end: Optional[int],
+    ) -> Dict[str, torch.Tensor]:
+        seq_len = input_ids.shape[1]
+        end = chunk_end if chunk_end is not None else min(chunk_start + self.config.chunk_size, seq_len)
+        end = min(int(end), seq_len)
+        start = max(0, int(chunk_start))
+
+        proc_start = max(0, start - 1)
+        chunk_ids = input_ids[:, proc_start:end]
+        chunk_labels = labels[:, proc_start:end] if labels is not None else None
+        chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+        hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+
+        if chunk_labels is not None and (chunk_labels != -100).any():
+            chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+            shift_hidden = hidden_full[:, :-1, :].contiguous()
+            shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+            valid = shift_labels != -100
+            if valid.any():
+                hs = shift_hidden[valid]
+                targets = shift_labels[valid]
+
+                hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                logits = self.qwen.lm_head(hs)
+                logits = logits.float()
+                logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                targets = targets.to(device=logits.device)
+
+                total_loss_sum = loss_fct_sum(logits, targets)
+                total_loss_tokens = targets.numel()
+
+        if total_loss_sum is None:
+            total_loss_sum = hidden_full.float().sum() * 0.0
+
+        return {
+            "loss_sum": total_loss_sum,
+            "loss_tokens": total_loss_tokens,
+            "has_grad": True,
+        }
+
+    def get_param_groups(self, config: TrainingConfig):
+        # Prefer module-based collection for robustness (name patterns can vary across model code)
+        embed_mod = None
+        if hasattr(self.qwen, "model") and hasattr(self.qwen.model, "embed_tokens"):
+            embed_mod = self.qwen.model.embed_tokens
+        else:
+            embed_mod = self.qwen.get_input_embeddings()
+
+        head_mod = self.qwen.lm_head if hasattr(self.qwen, "lm_head") else self.qwen.get_output_embeddings()
+
+        embed_params = [p for p in (embed_mod.parameters() if embed_mod is not None else []) if p.requires_grad]
+        lm_head_params = [p for p in (head_mod.parameters() if head_mod is not None else []) if p.requires_grad]
+
+        # De-duplicate defensively (in case of unexpected weight tying)
+        seen = set()
+
+        def _uniq(params):
+            out = []
+            for p in params:
+                pid = id(p)
+                if pid in seen:
+                    continue
+                out.append(p)
+                seen.add(pid)
+            return out
+
+        embed_params = _uniq(embed_params)
+        lm_head_params = _uniq(lm_head_params)
+
+        param_groups = []
+        if len(embed_params) > 0:
+            param_groups.append(
+                {
+                    "params": embed_params,
+                    "lr": config.lr_embed,
+                    "weight_decay": config.weight_decay,
+                    "name": "embed_tokens",
+                }
+            )
+        if len(lm_head_params) > 0:
+            param_groups.append(
+                {
+                    "params": lm_head_params,
+                    "lr": config.lr_lm_head,
+                    "weight_decay": config.weight_decay,
+                    "name": "lm_head",
+                }
+            )
+
+        logger.info(f"[baseline v4 Param groups] embed_tokens={len(embed_params)}, lm_head={len(lm_head_params)}")
+        return param_groups
+
+
+# =============================================================================
+# Distributed Training Utilities (copied from v4)
+# =============================================================================
+
+
+def init_distributed() -> tuple:
+    if "RANK" not in os.environ or "WORLD_SIZE" not in os.environ:
+        return False, 0, 0, 1
+
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    local_rank = int(os.environ.get("LOCAL_RANK", 0))
+
+    if not dist.is_available():
+        raise RuntimeError("torch.distributed not available")
+
+    if not dist.is_initialized():
+        dist.init_process_group(backend="nccl", init_method="env://")
+
+    torch.cuda.set_device(local_rank)
+    return True, rank, local_rank, world_size
+
+
+def cleanup_distributed():
+    if dist.is_available() and dist.is_initialized():
+        dist.barrier()
+        dist.destroy_process_group()
+
+
+def unwrap_model(model: nn.Module) -> nn.Module:
+    if hasattr(model, "module"):
+        return model.module
+    if hasattr(model, "_fsdp_wrapped_module"):
+        wrapped = getattr(model, "_fsdp_wrapped_module", None)
+        if wrapped is not None and hasattr(wrapped, "module"):
+            return wrapped.module
+    return model
+
+
+def is_fsdp_model(model: nn.Module) -> bool:
+    try:
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+
+        return isinstance(model, FSDP)
+    except Exception:
+        return False
+
+
+def manual_all_reduce_gradients(model: nn.Module, world_size: int) -> None:
+    """
+    Manually synchronize gradients across GPUs without DDP.
+    Kept identical to v4 to match multi-GPU strategy under cross-chunk graphs.
+    """
+    if world_size <= 1:
+        return
+
+    grads_to_reduce = []
+    for param in model.parameters():
+        if param.grad is not None:
+            grads_to_reduce.append(param.grad)
+
+    if len(grads_to_reduce) == 0:
+        return
+
+    total_numel = sum(g.numel() for g in grads_to_reduce)
+    flat_grads = torch.zeros(
+        total_numel,
+        dtype=grads_to_reduce[0].dtype,
+        device=grads_to_reduce[0].device,
+    )
+
+    offset = 0
+    for grad in grads_to_reduce:
+        numel = grad.numel()
+        flat_grads[offset : offset + numel] = grad.view(-1)
+        offset += numel
+
+    dist.all_reduce(flat_grads, op=dist.ReduceOp.SUM)
+    flat_grads.div_(world_size)
+
+    offset = 0
+    for grad in grads_to_reduce:
+        numel = grad.numel()
+        grad.copy_(flat_grads[offset : offset + numel].view_as(grad))
+        offset += numel
+
+
+# =============================================================================
+# Trainer (same logic as v4; model provides get_param_groups + forward API)
+# =============================================================================
+
+
+class Trainer:
+    def __init__(
+        self,
+        model: nn.Module,
+        train_dataloader: DataLoader,
+        eval_dataloader: DataLoader,
+        config: TrainingConfig,
+        rank: int = 0,
+        world_size: int = 1,
+        is_distributed: bool = False,
+        tokenizer=None,
+        use_manual_grad_sync: bool = False,
+    ):
+        self.model = model
+        self.train_dataloader = train_dataloader
+        self.eval_dataloader = eval_dataloader
+        self.config = config
+        self.device = next(model.parameters()).device
+        self.rank = rank
+        self.world_size = world_size
+        self.is_distributed = is_distributed
+        self.is_main_process = rank == 0
+        self.tokenizer = tokenizer
+        self.use_manual_grad_sync = use_manual_grad_sync
+
+        base_model = unwrap_model(self.model)
+        param_groups = base_model.get_param_groups(config)
+        self.optimizer = AdamW(param_groups)
+
+        total_steps = math.ceil(
+            (len(train_dataloader) * config.num_epochs) / max(config.gradient_accumulation_steps, 1)
+        )
+        self.scheduler = CosineAnnealingLR(self.optimizer, T_max=total_steps, eta_min=1e-7)
+
+        self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+        self.global_step = 0
+
+    def _get_group_lr(self, group_name: str) -> Optional[float]:
+        for group in self.optimizer.param_groups:
+            if group.get("name") == group_name:
+                return group.get("lr")
+        return None
+
+    def train(self):
+        self.model.train()
+        if self.is_main_process:
+            logger.info("=" * 60)
+            logger.info("Starting baseline v4 training (NO TITANS, FROZEN backbone)")
+            logger.info("=" * 60)
+
+        last_epoch_loss = None
+        for epoch in range(self.config.num_epochs):
+            sampler = getattr(self.train_dataloader, "sampler", None)
+            if sampler is not None and hasattr(sampler, "set_epoch"):
+                sampler.set_epoch(epoch)
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1}/{self.config.num_epochs}")
+
+            epoch_loss = 0.0
+            num_batches = 0
+
+            pbar = self.train_dataloader
+            if self.is_main_process:
+                pbar = tqdm(
+                    self.train_dataloader,
+                    desc=f"Epoch {epoch + 1}/{self.config.num_epochs}",
+                    leave=False,
+                    dynamic_ncols=True,
+                )
+
+            for step, batch in enumerate(pbar):
+                batch = {k: v.to(self.device) for k, v in batch.items()}
+
+                ga = max(self.config.gradient_accumulation_steps, 1)
+                sync_gradients = ((step + 1) % ga == 0)
+                amp_enabled = self.config.fp16 or self.config.bf16
+                amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+
+                with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                    if self.config.chunkwise_backward:
+                        labels = batch.get("labels")
+                        if labels is not None:
+                            total_tokens = int((labels[:, 1:] != -100).sum().item())
+                        else:
+                            total_tokens = 0
+                        loss_scale = 0.0 if total_tokens == 0 else (1.0 / total_tokens / ga)
+
+                        seq_len = batch["input_ids"].shape[1]
+                        chunk_size = int(self.config.chunk_size)
+                        chunk_ranges = [
+                            (start, min(start + chunk_size, seq_len)) for start in range(0, seq_len, chunk_size)
+                        ]
+                        raw_loss_sum = None
+
+                        for idx, (start, end) in enumerate(chunk_ranges):
+                            is_last_chunk = idx == (len(chunk_ranges) - 1)
+                            sync_chunk = sync_gradients and is_last_chunk
+
+                            use_no_sync = (
+                                self.is_distributed
+                                and not sync_chunk
+                                and not self.use_manual_grad_sync
+                                and hasattr(self.model, "no_sync")
+                            )
+                            chunk_ctx = self.model.no_sync if use_no_sync else nullcontext
+                            with chunk_ctx():
+                                outputs = self.model(
+                                    input_ids=batch["input_ids"],
+                                    attention_mask=batch["attention_mask"],
+                                    labels=labels,
+                                    chunk_start=start,
+                                    chunk_end=end,
+                                    reset_mem_state=(idx == 0),
+                                )
+                                chunk_loss_sum = outputs["loss_sum"]
+                                raw_loss_sum = chunk_loss_sum.detach() if raw_loss_sum is None else (raw_loss_sum + chunk_loss_sum.detach())
+
+                                scaled_loss = chunk_loss_sum * float(loss_scale)
+                                if self.config.fp16:
+                                    self.scaler.scale(scaled_loss).backward()
+                                else:
+                                    scaled_loss.backward()
+
+                        if raw_loss_sum is None or total_tokens == 0:
+                            raw_loss = torch.zeros((), device=self.device, dtype=torch.float32)
+                        else:
+                            raw_loss = raw_loss_sum / total_tokens
+                        loss = raw_loss / ga
+                    else:
+                        use_no_sync = (
+                            self.is_distributed
+                            and not sync_gradients
+                            and not self.use_manual_grad_sync
+                            and hasattr(self.model, "no_sync")
+                        )
+                        ctx = self.model.no_sync if use_no_sync else nullcontext
+                        with ctx():
+                            outputs = self.model(
+                                input_ids=batch["input_ids"],
+                                attention_mask=batch["attention_mask"],
+                                labels=batch["labels"],
+                            )
+                            raw_loss = outputs["loss"]
+                            loss = raw_loss / ga
+
+                        if self.config.fp16:
+                            self.scaler.scale(loss).backward()
+                        else:
+                            loss.backward()
+
+                epoch_loss += raw_loss.detach().float().item()
+                num_batches += 1
+
+                if sync_gradients:
+                    grad_norm = None
+
+                    if self.use_manual_grad_sync and self.world_size > 1:
+                        if self.config.fp16:
+                            self.scaler.unscale_(self.optimizer)
+                        manual_all_reduce_gradients(self.model, self.world_size)
+
+                    if self.config.fp16:
+                        if not self.use_manual_grad_sync:
+                            self.scaler.unscale_(self.optimizer)
+                        grad_norm = torch.nn.utils.clip_grad_norm_(
+                            self.model.parameters(), self.config.max_grad_norm
+                        )
+                        self.scaler.step(self.optimizer)
+                        self.scaler.update()
+                    else:
+                        grad_norm = torch.nn.utils.clip_grad_norm_(
+                            self.model.parameters(), self.config.max_grad_norm
+                        )
+                        self.optimizer.step()
+
+                    self.scheduler.step()
+                    self.optimizer.zero_grad(set_to_none=True)
+                    self.global_step += 1
+
+                    if self.is_main_process:
+                        avg_loss = epoch_loss / max(num_batches, 1)
+                        pbar.set_postfix({"gstep": self.global_step, "loss": f"{avg_loss:.4f}"})
+
+                    if self.global_step % self.config.logging_steps == 0 and self.is_main_process:
+                        lr_embed = self._get_group_lr("embed_tokens") or 0.0
+                        lr_lm_head = self._get_group_lr("lm_head") or 0.0
+                        grad_note = ""
+                        if self.config.debug_grad_norm and grad_norm is not None:
+                            grad_note = f" | grad_norm={float(grad_norm):.4f}"
+                        logger.info(
+                            f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                            f"lr_embed={lr_embed:.2e} | lr_lm_head={lr_lm_head:.2e}{grad_note}"
+                        )
+
+                    if self.global_step % self.config.eval_steps == 0:
+                        eval_metrics = self.evaluate()
+                        if self.is_main_process:
+                            ppl = float(math.exp(min(20.0, eval_metrics["loss"])))
+                            logger.info(
+                                f"[EVAL] loss={eval_metrics['loss']:.4f}, ppl={ppl:.3f}, "
+                                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                            )
+                        self.model.train()
+
+            avg_epoch_loss = epoch_loss / max(num_batches, 1)
+            if self.is_distributed:
+                t = torch.tensor(avg_epoch_loss, device=self.device, dtype=torch.float32)
+                dist.all_reduce(t, op=dist.ReduceOp.SUM)
+                avg_epoch_loss = (t / self.world_size).item()
+
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1} done, avg loss={avg_epoch_loss:.4f}")
+            last_epoch_loss = avg_epoch_loss
+
+            eval_metrics = self.evaluate()
+            if self.is_main_process:
+                logger.info(
+                    f"[EPOCH {epoch + 1} EVAL] "
+                    f"eval_loss={eval_metrics['loss']:.4f}, "
+                    f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                    f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                )
+            self._append_eval_metrics(
+                eval_metrics,
+                phase="epoch",
+                epoch=int(epoch + 1),
+                train_avg_loss=avg_epoch_loss,
+            )
+            self.model.train()
+
+        if self.is_main_process:
+            logger.info("Training done, final evaluation")
+
+        final_eval = self.evaluate(print_examples=int(self.config.final_eval_print_examples))
+        if self.is_main_process:
+            ppl = float(math.exp(min(20.0, final_eval["loss"])))
+            logger.info(
+                f"[FINAL EVAL] loss={final_eval['loss']:.4f}, ppl={ppl:.3f}, "
+                f"em_acc={final_eval['em_acc'] * 100:.2f}%, "
+                f"tok_acc={final_eval['tok_acc'] * 100:.2f}%"
+            )
+            logger.info("Saving final checkpoint")
+
+        self._append_eval_metrics(
+            final_eval,
+            phase="final",
+            epoch=int(self.config.num_epochs),
+            train_avg_loss=last_epoch_loss,
+        )
+        self.save_final_checkpoint()
+
+    @torch.no_grad()
+    def evaluate(self, print_examples: int = 0) -> Dict[str, float]:
+        self.model.eval()
+        total_loss = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_batches = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+
+        total_tok_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_tok_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        printed = 0
+
+        for batch in self.eval_dataloader:
+            batch = {k: v.to(self.device) for k, v in batch.items()}
+            amp_enabled = self.config.fp16 or self.config.bf16
+            amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+            with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                outputs = self.model(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                    labels=batch["labels"],
+                    return_pred_tokens=True,
+                    topk=int(self.config.eval_topk) if self.config.eval_topk else 0,
+                )
+
+            if torch.isfinite(outputs["loss"]):
+                total_loss += outputs["loss"].detach().float()
+                total_batches += 1.0
+
+            pred_ids = outputs.get("pred_ids", None)
+            target_ids = outputs.get("target_ids", None)
+            lengths = outputs.get("target_lengths", None)
+
+            if (
+                pred_ids is not None
+                and target_ids is not None
+                and lengths is not None
+                and pred_ids.ndim == 2
+                and target_ids.ndim == 2
+                and lengths.ndim == 1
+                and pred_ids.shape == target_ids.shape
+                and pred_ids.shape[0] == lengths.shape[0]
+            ):
+                pred_cpu = pred_ids.to("cpu", dtype=torch.long)
+                tgt_cpu = target_ids.to("cpu", dtype=torch.long)
+                len_cpu = lengths.to("cpu", dtype=torch.long)
+
+                for i in range(int(len_cpu.shape[0])):
+                    L = int(len_cpu[i].item())
+                    if L <= 0:
+                        continue
+                    p = pred_cpu[i, :L]
+                    t = tgt_cpu[i, :L]
+
+                    total_tok_correct += torch.tensor(
+                        float((p == t).sum().item()), device=self.device, dtype=torch.float32
+                    )
+                    total_tok_total += torch.tensor(float(L), device=self.device, dtype=torch.float32)
+
+                    if self.tokenizer is not None:
+                        pred_text = self.tokenizer.decode(p.tolist(), skip_special_tokens=True).strip()
+                        tgt_text = self.tokenizer.decode(t.tolist(), skip_special_tokens=True).strip()
+                        em = float(pred_text == tgt_text)
+                        total_em_correct += torch.tensor(em, device=self.device, dtype=torch.float32)
+                        total_em_total += torch.tensor(1.0, device=self.device, dtype=torch.float32)
+
+                        if self.is_main_process and printed < print_examples:
+                            logger.info(
+                                f"[EVAL SAMPLE] pred={repr(pred_text)} | label={repr(tgt_text)} | match={bool(em)}"
+                            )
+                            printed += 1
+
+        if self.is_distributed:
+            dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_total, op=dist.ReduceOp.SUM)
+
+        avg_loss = (total_loss / total_batches.clamp(min=1.0)).item()
+        tok_acc = (total_tok_correct / total_tok_total.clamp(min=1.0)).item()
+        em_acc = (total_em_correct / total_em_total.clamp(min=1.0)).item()
+
+        return {"loss": avg_loss, "tok_acc": tok_acc, "em_acc": em_acc}
+
+    def _append_eval_metrics(
+        self,
+        metrics: Dict[str, float],
+        *,
+        phase: str,
+        epoch: Optional[int],
+        train_avg_loss: Optional[float],
+    ) -> None:
+        if not self.is_main_process:
+            return
+        os.makedirs(self.config.output_dir, exist_ok=True)
+        record = {
+            "phase": phase,
+            "epoch": epoch,
+            "global_step": int(self.global_step),
+            "train_avg_loss": None if train_avg_loss is None else float(train_avg_loss),
+            "eval_loss": float(metrics.get("loss", 0.0)),
+            "em_acc_pct": float(metrics.get("em_acc", 0.0) * 100.0),
+            "tok_acc_pct": float(metrics.get("tok_acc", 0.0) * 100.0),
+        }
+        metrics_path = os.path.join(self.config.output_dir, "eval_metrics.jsonl")
+        with open(metrics_path, "a") as f:
+            f.write(json.dumps(record) + "\n")
+
+    def save_final_checkpoint(self):
+        ckpt_path = os.path.join(self.config.output_dir, self.config.final_ckpt_name)
+        base_model = unwrap_model(self.model)
+
+        # Keep the same checkpoint key layout ("memory_state_dict") for compatibility with v4 tooling.
+        trainable_sd = {
+            name: p.detach().cpu()
+            for name, p in base_model.named_parameters()
+            if p.requires_grad and (("embed_tokens" in name) or ("lm_head" in name))
+        }
+
+        if is_fsdp_model(self.model) and len(trainable_sd) == 0:
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+
+            full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+            with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                full_sd = self.model.state_dict()
+            trainable_sd = {k: v for k, v in full_sd.items() if ("embed_tokens" in k) or ("lm_head" in k)}
+
+        if self.is_main_process:
+            torch.save(
+                {"memory_state_dict": trainable_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                ckpt_path,
+            )
+            logger.info(f"Saved trainable checkpoint: {ckpt_path}")
+        if self.is_distributed:
+            dist.barrier()
+
+        if self.config.save_full_checkpoint:
+            full_ckpt_path = os.path.join(self.config.output_dir, self.config.final_full_ckpt_name)
+            if is_fsdp_model(self.model):
+                from torch.distributed.fsdp import (
+                    FullyShardedDataParallel as FSDP,
+                    StateDictType,
+                    FullStateDictConfig,
+                )
+
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    full_sd = self.model.state_dict()
+            else:
+                full_sd = unwrap_model(self.model).state_dict()
+
+            if self.is_main_process:
+                torch.save(
+                    {"model_state_dict": full_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                    full_ckpt_path,
+                )
+                logger.info(f"Saved full checkpoint: {full_ckpt_path}")
+            if self.is_distributed:
+                dist.barrier()
+
+
+# =============================================================================
+# Main
+# =============================================================================
+
+
+def main():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser(description="Qwen3 baseline v4 (NO TITANS) - Frozen Backbone Training")
+    parser.add_argument("--fsdp", action="store_true")
+    parser.add_argument("--eval_only", action="store_true")
+    parser.add_argument("--ckpt_path", type=str, default=None)
+    parser.add_argument("--max_samples", type=int, default=None)
+    parser.add_argument("--max_length", type=int, default=None)
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--eval_steps", type=int, default=None)
+    parser.add_argument("--batch_size", type=int, default=None)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--gradient_checkpointing", action="store_true")
+    parser.add_argument("--no_chunkwise_backward", action="store_true")
+    parser.add_argument("--lr_embed", type=float, default=None)
+    parser.add_argument("--lr_lm_head", type=float, default=None)
+    parser.add_argument("--debug_grad_norm", action="store_true")
+    args = parser.parse_args()
+
+    config = TrainingConfig()
+
+    # Apply arguments (keep same behavior as v4 where applicable)
+    if args.fsdp:
+        config.use_fsdp = True
+    if args.max_samples is not None:
+        config.max_samples = args.max_samples
+    if args.max_length is not None:
+        config.max_length = int(args.max_length)
+    if args.output_dir is not None:
+        config.output_dir = args.output_dir
+    if args.num_epochs is not None:
+        config.num_epochs = args.num_epochs
+    if args.eval_steps is not None:
+        config.eval_steps = args.eval_steps
+    if args.batch_size is not None:
+        config.batch_size = int(args.batch_size)
+    if args.gradient_accumulation_steps is not None:
+        config.gradient_accumulation_steps = int(args.gradient_accumulation_steps)
+    if args.chunk_size is not None:
+        config.chunk_size = int(args.chunk_size)
+    if args.gradient_checkpointing:
+        config.gradient_checkpointing = True
+    if args.no_chunkwise_backward:
+        config.chunkwise_backward = False
+    if args.lr_embed is not None:
+        config.lr_embed = float(args.lr_embed)
+    if args.lr_lm_head is not None:
+        config.lr_lm_head = float(args.lr_lm_head)
+    if args.debug_grad_norm:
+        config.debug_grad_norm = True
+
+    is_distributed, rank, local_rank, world_size = init_distributed()
+    is_main = rank == 0
+
+    if config.use_fsdp and config.chunkwise_backward:
+        if is_main:
+            logger.warning("chunkwise_backward is incompatible with FSDP; disabling it.")
+        config.chunkwise_backward = False
+
+    if is_distributed and (not config.use_fsdp):
+        if not config.ddp_find_unused_parameters:
+            config.ddp_find_unused_parameters = True
+            if is_main:
+                logger.warning("Enabling DDP find_unused_parameters.")
+
+    torch.manual_seed(config.seed + rank)
+
+    if torch.cuda.is_available():
+        device = torch.device(f"cuda:{local_rank}" if is_distributed else "cuda")
+    else:
+        device = torch.device("cpu")
+
+    if torch.cuda.is_available() and config.bf16:
+        bf16_supported = False
+        try:
+            bf16_supported = torch.cuda.is_bf16_supported()
+        except Exception:
+            bf16_supported = False
+        if not bf16_supported:
+            if is_main:
+                logger.warning("bf16 not supported; falling back to fp16.")
+            config.bf16 = False
+            if not config.fp16:
+                config.fp16 = True
+
+    if torch.cuda.is_available() and getattr(config, "use_tf32", False):
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        try:
+            torch.set_float32_matmul_precision("high")
+        except Exception:
+            pass
+
+    if is_main:
+        logger.info("=" * 70)
+        logger.info("Qwen3-4B baseline v4 Training (NO TITANS, FROZEN BACKBONE)")
+        logger.info("=" * 70)
+        logger.info(f"distributed={is_distributed}, world_size={world_size}")
+        logger.info(f"model_path={config.model_path}")
+        logger.info(f"data_path={config.data_path}")
+        logger.info(f"output_dir={config.output_dir}")
+        logger.info(f"max_samples={config.max_samples}")
+        logger.info(f"max_length={config.max_length}")
+        logger.info(f"num_epochs={config.num_epochs}")
+        logger.info(f"chunk_size={config.chunk_size}")
+        logger.info("Trainable: embed_tokens + lm_head")
+        logger.info("=" * 70)
+
+    tokenizer = AutoTokenizer.from_pretrained(config.model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Disable flash-attn / torchao detection (same as v4)
+    try:
+        import transformers
+        from transformers.utils import import_utils as _import_utils
+
+        def _disabled(*args, **kwargs):
+            return False
+
+        _import_utils.is_flash_attn_2_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_flash_attn_2_available"):
+            transformers.utils.is_flash_attn_2_available = _disabled
+        if hasattr(_import_utils, "is_torchao_available"):
+            _import_utils.is_torchao_available = _disabled
+        if hasattr(_import_utils, "is_torchvision_available"):
+            _import_utils.is_torchvision_available = _disabled
+    except Exception as e:
+        if is_main:
+            logger.warning(f"Disable checks failed (ignored): {e}")
+
+    torch_dtype = torch.bfloat16 if config.bf16 else (torch.float16 if config.fp16 else torch.float32)
+
+    qwen_model = AutoModelForCausalLM.from_pretrained(
+        config.model_path,
+        torch_dtype=torch_dtype,
+        device_map=None,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        low_cpu_mem_usage=True,
+    )
+    qwen_model.to(device)
+    qwen_model.config.use_cache = False
+    if config.gradient_checkpointing and hasattr(qwen_model, "gradient_checkpointing_enable"):
+        qwen_model.gradient_checkpointing_enable()
+
+    train_dataset = BABILongDataset(
+        config.data_path,
+        tokenizer,
+        max_length=config.max_length,
+        answer_reserve_tokens=config.answer_reserve_tokens,
+        label_prefix_tokens=config.label_prefix_tokens,
+        max_samples=config.max_samples,
+    )
+
+    train_size = int(0.9 * len(train_dataset))
+    eval_size = len(train_dataset) - train_size
+    train_dataset, eval_dataset = torch.utils.data.random_split(
+        train_dataset,
+        [train_size, eval_size],
+        generator=torch.Generator().manual_seed(config.seed),
+    )
+
+    train_sampler = None
+    eval_sampler = None
+    if is_distributed:
+        from torch.utils.data.distributed import DistributedSampler
+
+        train_sampler = DistributedSampler(
+            train_dataset, num_replicas=world_size, rank=rank, shuffle=True, seed=config.seed
+        )
+        eval_sampler = DistributedSampler(eval_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=config.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset,
+        batch_size=config.batch_size,
+        shuffle=False,
+        sampler=eval_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+
+    model = QwenBaselineForBABILongV4(qwen_model, config)
+    model.to(device)
+
+    # Same multi-GPU strategy as v4: disable DDP under cross-chunk graphs, use manual sync
+    use_ddp = is_distributed and world_size > 1
+    use_manual_grad_sync = False
+
+    if use_ddp and not config.chunkwise_backward:
+        if is_main:
+            logger.info("=" * 70)
+            logger.info("Cross-chunk graph with multi-GPU: using MANUAL gradient sync (NO DDP wrap)")
+            logger.info("=" * 70)
+        use_ddp = False
+        use_manual_grad_sync = True
+
+    if use_ddp:
+        if config.use_fsdp:
+            from functools import partial
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, MixedPrecision
+            from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+            from transformers.models.qwen3.modeling_qwen3 import Qwen3DecoderLayer
+
+            mp_policy = MixedPrecision(param_dtype=torch_dtype, reduce_dtype=torch_dtype, buffer_dtype=torch_dtype)
+            auto_wrap = partial(transformer_auto_wrap_policy, transformer_layer_cls={Qwen3DecoderLayer})
+
+            model = FSDP(
+                model,
+                auto_wrap_policy=auto_wrap,
+                mixed_precision=mp_policy,
+                device_id=torch.cuda.current_device(),
+                use_orig_params=config.fsdp_use_orig_params,
+            )
+        else:
+            model = DDP(
+                model,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=config.ddp_find_unused_parameters,
+            )
+
+    trainer = Trainer(
+        model=model,
+        train_dataloader=train_dataloader,
+        eval_dataloader=eval_dataloader,
+        config=config,
+        rank=rank,
+        world_size=world_size,
+        is_distributed=is_distributed,
+        tokenizer=tokenizer,
+        use_manual_grad_sync=use_manual_grad_sync,
+    )
+
+    if args.eval_only:
+        ckpt_path = args.ckpt_path or os.path.join(config.output_dir, config.final_ckpt_name)
+        if is_main:
+            logger.info(f"eval_only: loading checkpoint: {ckpt_path}")
+        ckpt = torch.load(ckpt_path, map_location="cpu")
+
+        sd = ckpt.get("memory_state_dict", {})
+        if len(sd) > 0:
+            unwrap_model(model).load_state_dict(sd, strict=False)
+
+        eval_metrics = trainer.evaluate()
+        if is_main:
+            ppl = float(math.exp(min(20.0, eval_metrics["loss"])))
+            logger.info(
+                f"[EVAL] loss={eval_metrics['loss']:.4f}, ppl={ppl:.3f}, "
+                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+            )
+        cleanup_distributed()
+        return
+
+    trainer.train()
+    cleanup_distributed()
+
+
+if __name__ == "__main__":
+    main()
+

examples/train_qwen_titans_babilong.py

@@ -0,0 +1,1664 @@
+"""
+Qwen3 + Titans training on BABILong QA1 (32k).
+
+Key ideas:
+- Fixed-length 32k samples for DDP/FSDP stability.
+- Stream long sequences by chunk (default 8k).
+- Insert Titans memory modules into Qwen layers (stride configurable).
+"""
+
+import os
+import json
+import math
+import argparse
+import logging
+import weakref
+from contextlib import nullcontext
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any, List, Tuple, Callable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.nn.parallel import DistributedDataParallel as DDP
+from tqdm import tqdm
+
+from einops import rearrange
+
+# add repo root to sys.path
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Titans components
+from titans_pytorch import NeuralMemory, MemoryMLP
+from titans_pytorch.neural_memory import NeuralMemState
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TrainingConfig:
+    # paths
+    model_path: str = "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554"
+    data_path: str = "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json"
+    output_dir: str = "./outputs/qwen_titans_babilong"
+
+    # training
+    num_epochs: int = 10
+    batch_size: int = 2
+    gradient_accumulation_steps: int = 8
+    max_grad_norm: float = 1.0
+
+    # learning rates
+    lr_memory: float = 1e-4
+    lr_pretrained: float = 5e-6
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+
+    # streaming / memory
+    chunk_size: int = 8192
+    use_memory: bool = True
+    memory_chunk_size: int = 128
+    memory_batch_size: int = 128
+    memory_heads: int = 8
+    memory_dim_head: int = 64
+    memory_depth: int = 1
+    memory_layer_stride: int = 8
+    memory_fp32: bool = True
+    detach_mem_state: bool = True
+    freeze_base_model: bool = False  # 冻结 Qwen base，只训练记忆模块
+
+    # evaluation / logging
+    eval_steps: int = 200
+    eval_topk: int = 0
+    logging_steps: int = 10
+    log_every_batches: int = 80
+    final_eval_print_examples: int = 10
+    debug_data_samples: int = 0
+    debug_label_batches: int = 0
+    debug_eval_stats: bool = False
+    debug_grad_norm: bool = False
+
+    # precision
+    bf16: bool = True
+    fp16: bool = False
+    use_tf32: bool = True
+    gradient_checkpointing: bool = False
+    chunkwise_backward: bool = True
+    chunkwise_backward: bool = True
+
+    # data
+    max_length: int = 32768
+    answer_reserve_tokens: int = 64
+    label_prefix_tokens: int = 0
+    max_samples: Optional[int] = 500  # 快速实验用 500，完整训练可设置更大值
+
+    # fsdp
+    use_fsdp: bool = False
+    fsdp_use_orig_params: bool = True
+    ddp_find_unused_parameters: bool = False
+
+    # checkpoint
+    save_full_checkpoint: bool = True
+    final_ckpt_name: str = "final_memory_checkpoint.pt"
+    final_full_ckpt_name: str = "final_full_checkpoint.pt"
+
+    seed: int = 42
+
+
+class BABILongDataset(Dataset):
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer,
+        max_length: int = 32768,
+        answer_reserve_tokens: int = 64,
+        label_prefix_tokens: int = 0,
+        max_samples: Optional[int] = None,
+    ):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.answer_reserve_tokens = answer_reserve_tokens
+        self.label_prefix_tokens = int(label_prefix_tokens)
+
+        logger.info(f"Loading dataset: {data_path}")
+        with open(data_path, "r") as f:
+            self.data = json.load(f)
+
+        if max_samples:
+            self.data = self.data[:max_samples]
+
+        logger.info(f"Dataset size: {len(self.data)}")
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        text = f"{item['input']}\n\nQuestion: {item['question']}\nAnswer:"
+        target = item["target"]
+
+        pad_id = self.tokenizer.pad_token_id or 0
+        reserve = int(self.answer_reserve_tokens)
+
+        prompt_ids = self.tokenizer(
+            text,
+            max_length=max(self.max_length - reserve, 1),
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        answer_ids = self.tokenizer(
+            f" {target}",
+            add_special_tokens=False,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        available = max(self.max_length - prompt_ids.numel(), 0)
+        answer_ids = answer_ids[:available]
+
+        input_ids = torch.cat([prompt_ids, answer_ids], dim=0)[: self.max_length]
+
+        labels = torch.full_like(input_ids, fill_value=-100)
+        if answer_ids.numel() > 0:
+            start = prompt_ids.numel()
+            end = min(start + answer_ids.numel(), labels.numel())
+            labels[start:end] = input_ids[start:end]
+            if self.label_prefix_tokens > 0:
+                prefix = min(start, self.label_prefix_tokens)
+                if prefix > 0:
+                    labels[start - prefix:start] = input_ids[start - prefix:start]
+
+        seq_len = input_ids.numel()
+        if seq_len < self.max_length:
+            pad_len = self.max_length - seq_len
+            input_ids = F.pad(input_ids, (0, pad_len), value=int(pad_id))
+            labels = F.pad(labels, (0, pad_len), value=-100)
+            attention_mask = torch.cat(
+                [torch.ones(seq_len, dtype=torch.long), torch.zeros(pad_len, dtype=torch.long)],
+                dim=0,
+            )
+        else:
+            attention_mask = torch.ones(self.max_length, dtype=torch.long)
+
+        return {
+            "input_ids": input_ids.to(dtype=torch.long),
+            "labels": labels.to(dtype=torch.long),
+            "attention_mask": attention_mask,
+        }
+
+
+def collate_fn(batch):
+    keys = batch[0].keys()
+    return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys}
+
+
+def _get_raw_dataset_item(dataset, idx: int) -> Optional[Dict[str, Any]]:
+    base = dataset
+    true_idx = idx
+    if isinstance(dataset, torch.utils.data.Subset):
+        base = dataset.dataset
+        true_idx = dataset.indices[idx]
+    if isinstance(base, BABILongDataset) and hasattr(base, "data"):
+        try:
+            return base.data[true_idx]
+        except Exception:
+            return None
+    return None
+
+
+def log_dataset_debug_stats(dataset, tokenizer, name: str, num_samples: int) -> None:
+    if num_samples <= 0:
+        return
+    total = len(dataset)
+    if total <= 0:
+        logger.warning(f"[DATA DEBUG] {name}: empty dataset")
+        return
+
+    n = min(int(num_samples), total)
+    zero_label = 0
+    total_label_tokens = 0
+    total_loss_tokens = 0
+    total_attn_tokens = 0
+
+    for i in range(n):
+        sample = dataset[i]
+        labels = sample["labels"]
+        attn = sample["attention_mask"]
+
+        label_mask = labels != -100
+        label_tokens = int(label_mask.sum().item())
+        loss_tokens = int((labels[1:] != -100).sum().item()) if labels.numel() > 1 else 0
+        attn_tokens = int(attn.sum().item())
+
+        total_label_tokens += label_tokens
+        total_loss_tokens += loss_tokens
+        total_attn_tokens += attn_tokens
+        if label_tokens == 0:
+            zero_label += 1
+
+        if i < min(3, n):
+            label_pos = label_mask.nonzero(as_tuple=False).view(-1)
+            first_label = int(label_pos[0].item()) if label_pos.numel() > 0 else -1
+            last_label = int(label_pos[-1].item()) if label_pos.numel() > 0 else -1
+
+            decoded = ""
+            if tokenizer is not None and label_pos.numel() > 0:
+                answer_ids = labels[label_pos].tolist()
+                decoded = tokenizer.decode(answer_ids, skip_special_tokens=True).strip()
+                if len(decoded) > 200:
+                    decoded = decoded[:200] + "..."
+
+            raw_item = _get_raw_dataset_item(dataset, i)
+            target_chars = None
+            target_tokens = None
+            if raw_item is not None and tokenizer is not None:
+                target_text = str(raw_item.get("target", ""))
+                target_chars = len(target_text)
+                target_ids = tokenizer(
+                    f" {target_text}",
+                    add_special_tokens=False,
+                    return_tensors="pt",
+                ).input_ids.squeeze(0)
+                target_tokens = int(target_ids.numel())
+
+            logger.info(
+                f"[DATA DEBUG] {name} sample {i}: attn_tokens={attn_tokens}, "
+                f"label_tokens={label_tokens}, loss_tokens={loss_tokens}, "
+                f"label_span=[{first_label},{last_label}]"
+            )
+            if target_chars is not None or decoded:
+                logger.info(
+                    f"[DATA DEBUG] {name} target_chars={target_chars}, "
+                    f"target_tokens={target_tokens}, decoded_answer={repr(decoded)}"
+                )
+
+    avg_label = total_label_tokens / max(n, 1)
+    avg_loss = total_loss_tokens / max(n, 1)
+    avg_attn = total_attn_tokens / max(n, 1)
+    logger.info(
+        f"[DATA DEBUG] {name} summary: samples={n}, zero_label_samples={zero_label}, "
+        f"avg_label_tokens={avg_label:.2f}, avg_loss_tokens={avg_loss:.2f}, avg_attn_tokens={avg_attn:.2f}"
+    )
+
+
+class QwenDecoderLayerWithTitansMemory(nn.Module):
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        *,
+        hidden_size: int,
+        chunk_size: int,
+        batch_size: int,
+        dim_head: int,
+        num_heads: int,
+        memory_depth: int,
+        memory_fp32: bool,
+        detach_mem_state: bool,
+        parent_model: Optional[nn.Module] = None,
+    ):
+        super().__init__()
+        self.layer = base_layer
+        self.memory_fp32 = memory_fp32
+        self.detach_mem_state = bool(detach_mem_state)
+        self.memory_state: Optional[NeuralMemState] = None
+        self.parent_model_ref = weakref.ref(parent_model) if parent_model is not None else None
+
+        memory_model = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0,
+        )
+
+        self.neural_memory = NeuralMemory(
+            dim=hidden_size,
+            chunk_size=chunk_size,
+            batch_size=batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=True,
+            momentum_order=1,
+            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=False,
+        )
+
+        self.mem_gate = nn.Sequential(
+            nn.Linear(hidden_size * 2, hidden_size),
+            nn.Sigmoid(),
+        )
+
+        try:
+            layer_device = next(base_layer.parameters()).device
+            layer_dtype = next(base_layer.parameters()).dtype
+        except StopIteration:
+            layer_device = None
+            layer_dtype = None
+
+        if layer_device is not None:
+            mem_dtype = torch.float32 if memory_fp32 else layer_dtype
+            self.neural_memory = self.neural_memory.to(device=layer_device, dtype=mem_dtype)
+            if layer_dtype is not None:
+                self.mem_gate = self.mem_gate.to(device=layer_device, dtype=layer_dtype)
+            else:
+                self.mem_gate = self.mem_gate.to(device=layer_device)
+
+    def reset_memory_state(self):
+        self.memory_state = None
+
+    def _get_store_mask(self, hidden_states: torch.Tensor) -> Optional[torch.Tensor]:
+        parent_model = self.parent_model_ref() if self.parent_model_ref is not None else None
+        if parent_model is None or not hasattr(parent_model, "_mem_store_mask"):
+            return None
+        store_mask = getattr(parent_model, "_mem_store_mask")
+        if store_mask is None:
+            return None
+        store_mask = store_mask.to(device=hidden_states.device).bool()
+        if store_mask.shape[:2] != hidden_states.shape[:2]:
+            return None
+        return store_mask
+
+    def forward(self, *args, **kwargs):
+        outputs = self.layer(*args, **kwargs)
+
+        if isinstance(outputs, (tuple, list)):
+            hidden_states = outputs[0]
+            rest = outputs[1:]
+        else:
+            hidden_states = outputs
+            rest = None
+
+        full_store_mask = self._get_store_mask(hidden_states)
+        mem_inp = hidden_states.float() if self.memory_fp32 else hidden_states
+
+        store_seq = None
+        store_mask = full_store_mask
+        if store_mask is not None:
+            store_seq = mem_inp
+            if store_mask.shape[1] > 0 and not store_mask[:, 0].any():
+                store_seq = store_seq[:, 1:]
+                store_mask = store_mask[:, 1:]
+
+            store_chunk = self.neural_memory.store_chunk_size
+            remainder = store_seq.shape[1] % store_chunk
+            if remainder != 0:
+                store_seq = store_seq[:, :-remainder]
+                store_mask = store_mask[:, :-remainder]
+
+            if store_mask is not None and store_seq is not None:
+                if store_mask.shape[1] != store_seq.shape[1]:
+                    min_len = min(store_mask.shape[1], store_seq.shape[1])
+                    store_seq = store_seq[:, :min_len]
+                    store_mask = store_mask[:, :min_len]
+
+            if store_seq.shape[1] == 0:
+                store_seq = None
+                store_mask = None
+
+        mem_ctx = (
+            torch.amp.autocast(device_type=hidden_states.device.type, enabled=False)
+            if self.memory_fp32
+            else nullcontext()
+        )
+        with mem_ctx:
+            retrieved, next_state = self.neural_memory(
+                mem_inp,
+                store_seq=store_seq,
+                state=self.memory_state,
+                store_mask=store_mask,
+                detach_mem_state=self.detach_mem_state,
+            )
+        self.memory_state = next_state
+
+        if retrieved is not None:
+            retrieved = retrieved.to(dtype=hidden_states.dtype)
+            if full_store_mask is not None and full_store_mask.shape[:2] == retrieved.shape[:2]:
+                retrieved = retrieved * full_store_mask.unsqueeze(-1).to(dtype=retrieved.dtype)
+            gate = self.mem_gate(torch.cat([hidden_states, retrieved], dim=-1))
+            hidden_states = hidden_states + gate * retrieved
+
+        if rest is None:
+            return hidden_states
+        return (hidden_states, *rest)
+
+
+class QwenTitansForBABILong(nn.Module):
+    def __init__(self, qwen_model, config: TrainingConfig):
+        super().__init__()
+        self.qwen = qwen_model
+        self.config = config
+        self.hidden_size = qwen_model.config.hidden_size
+        self.use_memory = bool(getattr(config, "use_memory", True))
+
+        if self.use_memory:
+            self.memory_layer_stride = int(getattr(config, "memory_layer_stride", 4))
+            self.memory_layer_indices = [
+                idx for idx in range(len(self.qwen.model.layers)) if idx % self.memory_layer_stride == 0
+            ]
+
+            for layer_idx in self.memory_layer_indices:
+                base_layer = self.qwen.model.layers[layer_idx]
+                wrapped = QwenDecoderLayerWithTitansMemory(
+                    base_layer,
+                    hidden_size=self.hidden_size,
+                    chunk_size=config.memory_chunk_size,
+                    batch_size=config.memory_batch_size,
+                    dim_head=config.memory_dim_head,
+                    num_heads=config.memory_heads,
+                    memory_depth=config.memory_depth,
+                    memory_fp32=config.memory_fp32,
+                    detach_mem_state=config.detach_mem_state,
+                    parent_model=self.qwen.model,
+                )
+                self.qwen.model.layers[layer_idx] = wrapped
+        else:
+            self.memory_layer_stride = 0
+            self.memory_layer_indices = []
+
+        if self.use_memory:
+            logger.info("[QwenTitansForBABILong] Initialized")
+            logger.info(f"  - hidden_size: {self.hidden_size}")
+            logger.info(f"  - chunk_size: {config.chunk_size}")
+            logger.info(f"  - memory_layer_stride: {self.memory_layer_stride}")
+            logger.info(f"  - memory_layers: {self.memory_layer_indices}")
+        else:
+            logger.info("[QwenTitansForBABILong] Initialized (memory disabled)")
+            logger.info(f"  - hidden_size: {self.hidden_size}")
+            logger.info(f"  - chunk_size: {config.chunk_size}")
+
+        self._memory_layers = [
+            layer for layer in self.qwen.model.layers if isinstance(layer, QwenDecoderLayerWithTitansMemory)
+        ]
+        self.qwen.model._mem_store_mask = None
+
+    def _split_into_chunks(self, tensor, chunk_size):
+        seq_len = tensor.shape[1]
+        chunks = []
+        for start in range(0, seq_len, chunk_size):
+            end = min(start + chunk_size, seq_len)
+            chunks.append((start, end, tensor[:, start:end]))
+        return chunks
+
+    def reset_memory_states(self):
+        for layer in self._memory_layers:
+            layer.reset_memory_state()
+
+    def _set_mem_store_mask(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_mask: Optional[torch.Tensor],
+        chunk_start: int,
+    ) -> None:
+        if not self.use_memory:
+            self.qwen.model._mem_store_mask = None
+            return
+        if chunk_mask is None:
+            if chunk_start > 0:
+                store_mask = torch.ones_like(chunk_ids, dtype=torch.bool)
+                store_mask[:, 0] = False
+            else:
+                store_mask = None
+        else:
+            store_mask = chunk_mask.to(device=chunk_ids.device).bool()
+            if chunk_start > 0:
+                store_mask[:, 0] = False
+        self.qwen.model._mem_store_mask = store_mask
+
+    def get_memory_modules(self) -> List[nn.Module]:
+        if not self._memory_layers:
+            return []
+        modules = []
+        for layer in self._memory_layers:
+            modules.append(layer.neural_memory)
+            modules.append(layer.mem_gate)
+        return modules
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_pred_tokens: bool = False,
+        topk: int = 0,
+        chunkwise_backward: bool = False,
+        loss_scale: Optional[float] = None,
+        backward_fn: Optional[Callable[[torch.Tensor], None]] = None,
+        chunk_start: Optional[int] = None,
+        chunk_end: Optional[int] = None,
+        reset_mem_state: bool = False,
+    ) -> Dict[str, torch.Tensor]:
+        if chunk_start is not None or chunk_end is not None:
+            start = 0 if chunk_start is None else int(chunk_start)
+            end = int(chunk_end) if chunk_end is not None else None
+            return self._forward_single_chunk(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                labels=labels,
+                chunk_start=start,
+                chunk_end=end,
+                reset_mem_state=reset_mem_state,
+            )
+        batch_size, seq_len = input_ids.shape
+        chunk_size = self.config.chunk_size
+        chunks = self._split_into_chunks(input_ids, chunk_size)
+
+        self.reset_memory_states()
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+        topk_correct = None
+        topk_total = None
+
+        pred_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        target_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        if topk and topk > 0:
+            device = input_ids.device
+            topk_correct = torch.tensor(0.0, device=device, dtype=torch.float32)
+            topk_total = torch.tensor(0.0, device=device, dtype=torch.float32)
+
+        for start, end, _ in chunks:
+            proc_start = max(0, start - 1)
+            chunk_ids = input_ids[:, proc_start:end]
+            chunk_labels = labels[:, proc_start:end] if labels is not None else None
+            chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+            self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+            hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+            if self.use_memory:
+                self.qwen.model._mem_store_mask = None
+
+            if chunk_labels is not None and (chunk_labels != -100).any():
+                chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+                shift_hidden = hidden_full[:, :-1, :].contiguous()
+                shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+                valid = shift_labels != -100
+                if valid.any():
+                    hs = shift_hidden[valid]
+                    targets = shift_labels[valid]
+
+                    hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+
+                    logits = self.qwen.lm_head(hs)
+                    logits = logits.float()
+                    logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                    targets = targets.to(device=logits.device)
+
+                    chunk_loss_sum = loss_fct_sum(logits, targets)
+                    if total_loss_sum is None:
+                        total_loss_sum = chunk_loss_sum
+                    else:
+                        total_loss_sum = total_loss_sum + chunk_loss_sum
+                    total_loss_tokens += targets.numel()
+
+                    if topk and topk > 0:
+                        k = min(int(topk), logits.shape[-1])
+                        topk_ids = torch.topk(logits, k=k, dim=-1).indices
+                        correct = (topk_ids == targets.unsqueeze(-1)).any(dim=-1)
+                        topk_correct = topk_correct + correct.float().sum()
+                        topk_total = topk_total + torch.tensor(float(targets.numel()), device=topk_total.device)
+
+                    if return_pred_tokens:
+                        idx = valid.nonzero(as_tuple=False)
+                        pred_flat = torch.argmax(logits, dim=-1).detach().to("cpu", dtype=torch.long).tolist()
+                        tgt_flat = targets.detach().to("cpu", dtype=torch.long).tolist()
+                        b_idx_flat = idx[:, 0].detach().to("cpu", dtype=torch.long).tolist()
+
+                        for i, b_idx in enumerate(b_idx_flat):
+                            pred_tokens_by_sample[b_idx].append(int(pred_flat[i]))
+                            target_tokens_by_sample[b_idx].append(int(tgt_flat[i]))
+
+        if total_loss_sum is None or total_loss_tokens == 0:
+            device = next(self.qwen.parameters()).device
+            loss = torch.zeros((), device=device, dtype=torch.float32)
+        else:
+            loss = total_loss_sum / total_loss_tokens
+
+        out: Dict[str, torch.Tensor] = {"loss": loss}
+        if return_pred_tokens:
+            lengths = torch.tensor([len(x) for x in target_tokens_by_sample], dtype=torch.long)
+            max_len = int(lengths.max().item()) if lengths.numel() > 0 else 0
+            if max_len > 0:
+                pred_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                tgt_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                for b in range(batch_size):
+                    L = int(lengths[b].item())
+                    if L > 0:
+                        pred_mat[b, :L] = torch.tensor(pred_tokens_by_sample[b], dtype=torch.long)
+                        tgt_mat[b, :L] = torch.tensor(target_tokens_by_sample[b], dtype=torch.long)
+            else:
+                pred_mat = torch.empty((batch_size, 0), dtype=torch.long)
+                tgt_mat = torch.empty((batch_size, 0), dtype=torch.long)
+            out["pred_ids"] = pred_mat
+            out["target_ids"] = tgt_mat
+            out["target_lengths"] = lengths
+        if topk and topk > 0 and topk_correct is not None and topk_total is not None:
+            out["topk_correct"] = topk_correct
+            out["topk_total"] = topk_total
+        return out
+
+    def _forward_single_chunk(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor],
+        labels: Optional[torch.Tensor],
+        chunk_start: int,
+        chunk_end: Optional[int],
+        reset_mem_state: bool,
+    ) -> Dict[str, torch.Tensor]:
+        if reset_mem_state:
+            self.reset_memory_states()
+
+        seq_len = input_ids.shape[1]
+        end = chunk_end if chunk_end is not None else min(chunk_start + self.config.chunk_size, seq_len)
+        end = min(int(end), seq_len)
+        start = max(0, int(chunk_start))
+
+        proc_start = max(0, start - 1)
+        chunk_ids = input_ids[:, proc_start:end]
+        chunk_labels = labels[:, proc_start:end] if labels is not None else None
+        chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+        self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+        hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+        if self.use_memory:
+            self.qwen.model._mem_store_mask = None
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+
+        if chunk_labels is not None and (chunk_labels != -100).any():
+            chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+            shift_hidden = hidden_full[:, :-1, :].contiguous()
+            shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+            valid = shift_labels != -100
+            if valid.any():
+                hs = shift_hidden[valid]
+                targets = shift_labels[valid]
+
+                hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                logits = self.qwen.lm_head(hs)
+                logits = logits.float()
+                logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                targets = targets.to(device=logits.device)
+
+                total_loss_sum = loss_fct_sum(logits, targets)
+                total_loss_tokens = targets.numel()
+
+        if total_loss_sum is None:
+            # 创建一个有梯度图的零 loss，通过 hidden_full 建立连接
+            # 这对 DDP 至关重要：确保所有 rank 的 backward 调用一致
+            total_loss_sum = (hidden_full.float().sum() * 0.0)
+
+        return {
+            "loss_sum": total_loss_sum,
+            "loss_tokens": total_loss_tokens,
+            "has_grad": True,  # 现在总是有梯度图
+        }
+
+    def _process_chunk(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if hasattr(self.qwen.model, "embed_tokens"):
+            token_embeds = self.qwen.model.embed_tokens(chunk_ids)
+        else:
+            token_embeds = self.qwen.get_input_embeddings()(chunk_ids)
+
+        outputs = self.qwen.model(
+            inputs_embeds=token_embeds,
+            attention_mask=chunk_attention_mask,
+            use_cache=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+        return outputs.last_hidden_state
+
+    def freeze_base_model(self):
+        """
+        冻结 Qwen base 模型的大部分参数，保留记忆模块和独立的 lm_head 可训练。
+        
+        可训练的参数包括：
+        - neural_memory: Q/K/V projections, adaptive lr 等（Memory MLP 通过 Surprise 前向更新）
+        - mem_gate: 控制记忆输出和原始输出的混合
+        - lm_head: 独立的输出层（解开 tied weights）
+        
+        冻结的参数：
+        - qwen.model.embed_tokens (保持输入分布不变！)
+        - qwen.model.layers (除了 neural_memory 和 mem_gate)
+        - qwen.model.norm
+        """
+        frozen_count = 0
+        trainable_count = 0
+        lm_head_count = 0
+        
+        # 关键：解开 tied weights！
+        # 如果 lm_head 和 embed_tokens 共享权重，需要创建独立的 lm_head
+        if hasattr(self.qwen, 'lm_head') and hasattr(self.qwen.model, 'embed_tokens'):
+            lm_head_weight = self.qwen.lm_head.weight
+            embed_weight = self.qwen.model.embed_tokens.weight
+            has_tied_weights = lm_head_weight.data_ptr() == embed_weight.data_ptr()
+            
+            if has_tied_weights:
+                logger.info("[freeze_base_model] Detected tied weights - untying lm_head from embed_tokens")
+                # 创建独立的 lm_head 权重（复制当前权重）
+                new_lm_head = nn.Linear(
+                    self.qwen.lm_head.in_features,
+                    self.qwen.lm_head.out_features,
+                    bias=self.qwen.lm_head.bias is not None,
+                    device=lm_head_weight.device,
+                    dtype=lm_head_weight.dtype,
+                )
+                # 复制权重
+                with torch.no_grad():
+                    new_lm_head.weight.copy_(lm_head_weight)
+                    if self.qwen.lm_head.bias is not None and new_lm_head.bias is not None:
+                        new_lm_head.bias.copy_(self.qwen.lm_head.bias)
+                # 替换 lm_head
+                self.qwen.lm_head = new_lm_head
+                logger.info(f"[freeze_base_model] Created independent lm_head: {new_lm_head.weight.shape}")
+        
+        for name, param in self.named_parameters():
+            # 判断是否是需要保持可训��的参数
+            is_memory = "neural_memory" in name or "mem_gate" in name
+            is_lm_head = "lm_head" in name
+            
+            if is_memory:
+                param.requires_grad = True
+                trainable_count += 1
+            elif is_lm_head:
+                # 独立的 lm_head 可训练
+                param.requires_grad = True
+                trainable_count += 1
+                lm_head_count += 1
+                logger.info(f"[freeze_base_model] lm_head param: {name}")
+            else:
+                # 冻结其他所有参数，包括 embed_tokens！
+                param.requires_grad = False
+                frozen_count += 1
+        
+        logger.info(f"[freeze_base_model] Frozen: {frozen_count}, Trainable: {trainable_count} (lm_head: {lm_head_count})")
+        return self
+
+    def get_param_groups(self, lr_memory: float, lr_pretrained: float, weight_decay: float):
+        memory_params = []
+        pretrained_params = []
+
+        for name, param in self.named_parameters():
+            if not param.requires_grad:
+                continue
+            if "neural_memory" in name or "mem_gate" in name:
+                memory_params.append(param)
+            else:
+                pretrained_params.append(param)
+
+        param_groups = []
+        if len(memory_params) > 0:
+            param_groups.append(
+                {"params": memory_params, "lr": lr_memory, "weight_decay": weight_decay, "name": "memory_module"}
+            )
+        if len(pretrained_params) > 0:
+            param_groups.append(
+                {"params": pretrained_params, "lr": lr_pretrained, "weight_decay": weight_decay, "name": "pretrained"}
+            )
+        logger.info(f"Param groups: memory={len(memory_params)}, pretrained={len(pretrained_params)}")
+        return param_groups
+
+
+def init_distributed() -> tuple[bool, int, int, int]:
+    if "RANK" not in os.environ or "WORLD_SIZE" not in os.environ:
+        return False, 0, 0, 1
+
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    local_rank = int(os.environ.get("LOCAL_RANK", 0))
+
+    if not dist.is_available():
+        raise RuntimeError("torch.distributed not available")
+
+    if not dist.is_initialized():
+        dist.init_process_group(backend="nccl", init_method="env://")
+
+    torch.cuda.set_device(local_rank)
+    return True, rank, local_rank, world_size
+
+
+def cleanup_distributed():
+    if dist.is_available() and dist.is_initialized():
+        dist.barrier()
+        dist.destroy_process_group()
+
+
+def unwrap_model(model: nn.Module) -> nn.Module:
+    if hasattr(model, "module"):
+        return model.module
+    if hasattr(model, "_fsdp_wrapped_module"):
+        wrapped = getattr(model, "_fsdp_wrapped_module", None)
+        if wrapped is not None and hasattr(wrapped, "module"):
+            return wrapped.module
+    return model
+
+
+def is_fsdp_model(model: nn.Module) -> bool:
+    try:
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+        return isinstance(model, FSDP)
+    except Exception:
+        return False
+
+
+class Trainer:
+    def __init__(
+        self,
+        model: QwenTitansForBABILong,
+        train_dataloader: DataLoader,
+        eval_dataloader: DataLoader,
+        config: TrainingConfig,
+        rank: int = 0,
+        world_size: int = 1,
+        is_distributed: bool = False,
+        tokenizer=None,
+    ):
+        self.model = model
+        self.train_dataloader = train_dataloader
+        self.eval_dataloader = eval_dataloader
+        self.config = config
+        self.device = next(model.parameters()).device
+        self.rank = rank
+        self.world_size = world_size
+        self.is_distributed = is_distributed
+        self.is_main_process = (rank == 0)
+        self.tokenizer = tokenizer
+
+        base_model = unwrap_model(self.model)
+        param_groups = base_model.get_param_groups(
+            lr_memory=config.lr_memory,
+            lr_pretrained=config.lr_pretrained,
+            weight_decay=config.weight_decay,
+        )
+        self.optimizer = AdamW(param_groups)
+
+        total_steps = math.ceil(
+            (len(train_dataloader) * config.num_epochs) / max(config.gradient_accumulation_steps, 1)
+        )
+        self.scheduler = CosineAnnealingLR(self.optimizer, T_max=total_steps, eta_min=1e-7)
+
+        self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+        self.global_step = 0
+
+    def _get_group_lr(self, group_name: str) -> Optional[float]:
+        for group in self.optimizer.param_groups:
+            if group.get("name") == group_name:
+                return group.get("lr")
+        return None
+
+    def train(self):
+        self.model.train()
+        if self.is_main_process:
+            logger.info("Start training")
+
+        last_epoch_loss = None
+        for epoch in range(self.config.num_epochs):
+            sampler = getattr(self.train_dataloader, "sampler", None)
+            if sampler is not None and hasattr(sampler, "set_epoch"):
+                sampler.set_epoch(epoch)
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1}/{self.config.num_epochs}")
+
+            epoch_loss = 0.0
+            num_batches = 0
+
+            pbar = self.train_dataloader
+            if self.is_main_process:
+                pbar = tqdm(
+                    self.train_dataloader,
+                    desc=f"Epoch {epoch + 1}/{self.config.num_epochs}",
+                    leave=False,
+                    dynamic_ncols=True,
+                )
+            for step, batch in enumerate(pbar):
+                batch = {k: v.to(self.device) for k, v in batch.items()}
+                if (
+                    self.config.debug_label_batches > 0
+                    and self.is_main_process
+                    and step < int(self.config.debug_label_batches)
+                ):
+                    labels = batch.get("labels")
+                    if labels is not None:
+                        label_tokens = int((labels != -100).sum().item())
+                        loss_tokens = int((labels[:, 1:] != -100).sum().item()) if labels.size(1) > 1 else 0
+                        attn_tokens = int(batch["attention_mask"].sum().item())
+                        logger.info(
+                            f"[BATCH DEBUG] epoch={epoch + 1} step={step + 1}: "
+                            f"attn_tokens={attn_tokens}, label_tokens={label_tokens}, loss_tokens={loss_tokens}"
+                        )
+                    else:
+                        logger.info(f"[BATCH DEBUG] epoch={epoch + 1} step={step + 1}: labels missing")
+
+                ga = max(self.config.gradient_accumulation_steps, 1)
+                sync_gradients = ((step + 1) % ga == 0)
+                amp_enabled = self.config.fp16 or self.config.bf16
+                amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+                with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                    if self.config.chunkwise_backward:
+                        labels = batch.get("labels")
+                        if labels is not None:
+                            total_tokens = int((labels[:, 1:] != -100).sum().item())
+                        else:
+                            total_tokens = 0
+                        loss_scale = 0.0 if total_tokens == 0 else (1.0 / total_tokens / ga)
+
+                        seq_len = batch["input_ids"].shape[1]
+                        chunk_size = int(self.config.chunk_size)
+                        chunk_ranges = [
+                            (start, min(start + chunk_size, seq_len))
+                            for start in range(0, seq_len, chunk_size)
+                        ]
+                        raw_loss_sum = None
+
+                        for idx, (start, end) in enumerate(chunk_ranges):
+                            is_last_chunk = (idx == len(chunk_ranges) - 1)
+                            sync_chunk = sync_gradients and is_last_chunk
+                            chunk_ctx = (
+                                self.model.no_sync
+                                if (self.is_distributed and not sync_chunk)
+                                else nullcontext
+                            )
+                            with chunk_ctx():
+                                outputs = self.model(
+                                    input_ids=batch["input_ids"],
+                                    attention_mask=batch["attention_mask"],
+                                    labels=labels,
+                                    chunk_start=start,
+                                    chunk_end=end,
+                                    reset_mem_state=(idx == 0),
+                                )
+                                chunk_loss_sum = outputs["loss_sum"]
+                                chunk_loss_tokens = int(outputs.get("loss_tokens", 0))
+                                if raw_loss_sum is None:
+                                    raw_loss_sum = chunk_loss_sum.detach()
+                                else:
+                                    raw_loss_sum = raw_loss_sum + chunk_loss_sum.detach()
+                                
+                                # DDP 关键：所有 rank 必须执行相同的 backward 调用序列
+                                # 即使 loss_scale=0 或 chunk 无有效 token，也要调用 backward
+                                # 以确保 allreduce 同步
+                                scaled_loss = chunk_loss_sum * float(loss_scale)
+                                if self.config.fp16:
+                                    self.scaler.scale(scaled_loss).backward()
+                                else:
+                                    scaled_loss.backward()
+
+                        if raw_loss_sum is None or total_tokens == 0:
+                            raw_loss = torch.zeros((), device=self.device, dtype=torch.float32)
+                        else:
+                            raw_loss = raw_loss_sum / total_tokens
+                        loss = raw_loss / ga
+                    else:
+                        ctx = self.model.no_sync if (self.is_distributed and not sync_gradients) else nullcontext
+                        with ctx():
+                            outputs = self.model(
+                                input_ids=batch["input_ids"],
+                                attention_mask=batch["attention_mask"],
+                                labels=batch["labels"],
+                            )
+                            raw_loss = outputs["loss"]
+                            loss = raw_loss / ga
+
+                        if self.config.fp16:
+                            self.scaler.scale(loss).backward()
+                        else:
+                            loss.backward()
+
+                epoch_loss += raw_loss.detach().float().item()
+                num_batches += 1
+
+                if sync_gradients:
+                    grad_norm = None
+                    if self.config.fp16:
+                        self.scaler.unscale_(self.optimizer)
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.scaler.step(self.optimizer)
+                        self.scaler.update()
+                    else:
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.optimizer.step()
+
+                    self.scheduler.step()
+                    self.optimizer.zero_grad(set_to_none=True)
+                    self.global_step += 1
+
+                    if self.is_main_process:
+                        avg_loss = epoch_loss / max(num_batches, 1)
+                        pbar.set_postfix(
+                            {
+                                "gstep": self.global_step,
+                                "loss": f"{avg_loss:.4f}",
+                            }
+                        )
+
+                    if self.global_step % self.config.logging_steps == 0 and self.is_main_process:
+                        lr_mem = self._get_group_lr("memory_module")
+                        lr_pre = self._get_group_lr("pretrained")
+                        if lr_pre is None and self.optimizer.param_groups:
+                            lr_pre = self.optimizer.param_groups[0]["lr"]
+                        grad_note = ""
+                        if self.config.debug_grad_norm and grad_norm is not None:
+                            grad_note = f" | grad_norm={float(grad_norm):.4f}"
+                        if lr_mem is None:
+                            lr_label = f"lr={lr_pre:.2e}" if lr_pre is not None else "lr=NA"
+                            logger.info(
+                                f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                                f"{lr_label}{grad_note}"
+                            )
+                        else:
+                            logger.info(
+                                f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                                f"lr_mem={lr_mem:.2e} | lr_pre={lr_pre:.2e}{grad_note}"
+                            )
+
+                    if self.global_step % self.config.eval_steps == 0:
+                        eval_metrics = self.evaluate()
+                        if self.is_main_process:
+                            logger.info(
+                                f"Step {self.global_step}: "
+                                f"eval_loss={eval_metrics['loss']:.4f}, "
+                                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                            )
+                        self.model.train()
+
+            avg_epoch_loss = epoch_loss / max(num_batches, 1)
+            if self.is_distributed:
+                t = torch.tensor(avg_epoch_loss, device=self.device, dtype=torch.float32)
+                dist.all_reduce(t, op=dist.ReduceOp.SUM)
+                avg_epoch_loss = (t / self.world_size).item()
+
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1} done, avg loss={avg_epoch_loss:.4f}")
+            last_epoch_loss = avg_epoch_loss
+
+            eval_metrics = self.evaluate()
+            if self.is_main_process:
+                logger.info(
+                    f"[EPOCH {epoch + 1} EVAL] "
+                    f"eval_loss={eval_metrics['loss']:.4f}, "
+                    f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                    f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                )
+            self._append_eval_metrics(
+                eval_metrics,
+                phase="epoch",
+                epoch=int(epoch + 1),
+                train_avg_loss=avg_epoch_loss,
+            )
+            self.model.train()
+
+        if self.is_main_process:
+            logger.info("Training done, final evaluation")
+
+        final_eval = self.evaluate(print_examples=int(self.config.final_eval_print_examples))
+        if self.is_main_process:
+            ppl = float(math.exp(min(20.0, final_eval["loss"])))
+            logger.info(
+                f"[FINAL EVAL] loss={final_eval['loss']:.4f}, ppl≈{ppl:.3f}, "
+                f"em_acc={final_eval['em_acc'] * 100:.2f}%, "
+                f"tok_acc={final_eval['tok_acc'] * 100:.2f}%"
+            )
+            logger.info("Saving final checkpoint")
+        self._append_eval_metrics(
+            final_eval,
+            phase="final",
+            epoch=int(self.config.num_epochs),
+            train_avg_loss=last_epoch_loss,
+        )
+        self.save_final_checkpoint()
+
+    @torch.no_grad()
+    def evaluate(self, print_examples: int = 0) -> Dict[str, float]:
+        self.model.eval()
+        total_loss = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_batches = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+
+        total_tok_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_tok_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_topk_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_topk_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        printed = 0
+
+        for batch in self.eval_dataloader:
+            batch = {k: v.to(self.device) for k, v in batch.items()}
+            amp_enabled = self.config.fp16 or self.config.bf16
+            amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+            with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                outputs = self.model(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                    labels=batch["labels"],
+                    return_pred_tokens=True,
+                    topk=int(self.config.eval_topk) if self.config.eval_topk else 0,
+                )
+
+            if torch.isfinite(outputs["loss"]):
+                total_loss += outputs["loss"].detach().float()
+                total_batches += 1.0
+
+            pred_ids = outputs.get("pred_ids", None)
+            target_ids = outputs.get("target_ids", None)
+            lengths = outputs.get("target_lengths", None)
+            topk_correct = outputs.get("topk_correct", None)
+            topk_total = outputs.get("topk_total", None)
+            if topk_correct is not None and topk_total is not None:
+                total_topk_correct += topk_correct.detach().float()
+                total_topk_total += topk_total.detach().float()
+            if (
+                pred_ids is not None
+                and target_ids is not None
+                and lengths is not None
+                and pred_ids.ndim == 2
+                and target_ids.ndim == 2
+                and lengths.ndim == 1
+                and pred_ids.shape == target_ids.shape
+                and pred_ids.shape[0] == lengths.shape[0]
+            ):
+                pred_cpu = pred_ids.to("cpu", dtype=torch.long)
+                tgt_cpu = target_ids.to("cpu", dtype=torch.long)
+                len_cpu = lengths.to("cpu", dtype=torch.long)
+
+                for i in range(int(len_cpu.shape[0])):
+                    L = int(len_cpu[i].item())
+                    if L <= 0:
+                        continue
+                    p = pred_cpu[i, :L]
+                    t = tgt_cpu[i, :L]
+
+                    total_tok_correct += torch.tensor(float((p == t).sum().item()), device=self.device, dtype=torch.float32)
+                    total_tok_total += torch.tensor(float(L), device=self.device, dtype=torch.float32)
+
+                    if self.tokenizer is not None:
+                        pred_text = self.tokenizer.decode(p.tolist(), skip_special_tokens=True).strip()
+                        tgt_text = self.tokenizer.decode(t.tolist(), skip_special_tokens=True).strip()
+                        em = float(pred_text == tgt_text)
+                        total_em_correct += torch.tensor(em, device=self.device, dtype=torch.float32)
+                        total_em_total += torch.tensor(1.0, device=self.device, dtype=torch.float32)
+
+                        if self.is_main_process and printed < print_examples:
+                            logger.info(f"[EVAL SAMPLE] pred={repr(pred_text)} | label={repr(tgt_text)} | match={bool(em)}")
+                            printed += 1
+
+        if self.is_distributed:
+            dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_topk_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_topk_total, op=dist.ReduceOp.SUM)
+
+        avg_loss = (total_loss / total_batches.clamp(min=1.0)).item()
+        tok_acc = (total_tok_correct / total_tok_total.clamp(min=1.0)).item()
+        em_acc = (total_em_correct / total_em_total.clamp(min=1.0)).item()
+        topk_acc = (total_topk_correct / total_topk_total.clamp(min=1.0)).item()
+        if self.is_main_process:
+            if self.config.debug_eval_stats:
+                logger.info(
+                    "[EVAL DEBUG] total_batches="
+                    f"{float(total_batches.item()):.0f}, total_tok_total={float(total_tok_total.item()):.0f}, "
+                    f"total_em_total={float(total_em_total.item()):.0f}, "
+                    f"total_topk_total={float(total_topk_total.item()):.0f}"
+                )
+                if total_tok_total.item() == 0:
+                    logger.warning("[EVAL DEBUG] No answer tokens found in eval set; acc will be 0.")
+            logger.info(f"[EVAL METRIC] token_acc(answer-only) = {tok_acc * 100:.2f}%")
+            logger.info(f"[EVAL METRIC] EM/acc(answer-only) = {em_acc * 100:.2f}%")
+            if self.config.eval_topk and self.config.eval_topk > 0:
+                logger.info(f"[EVAL METRIC] top{int(self.config.eval_topk)}_acc(answer-only) = {topk_acc * 100:.2f}%")
+        return {"loss": avg_loss, "tok_acc": tok_acc, "em_acc": em_acc, "topk_acc": topk_acc}
+
+    def _append_eval_metrics(
+        self,
+        metrics: Dict[str, float],
+        *,
+        phase: str,
+        epoch: Optional[int],
+        train_avg_loss: Optional[float],
+    ) -> None:
+        if not self.is_main_process:
+            return
+        os.makedirs(self.config.output_dir, exist_ok=True)
+        record = {
+            "phase": phase,
+            "epoch": epoch,
+            "global_step": int(self.global_step),
+            "train_avg_loss": None if train_avg_loss is None else float(train_avg_loss),
+            "eval_loss": float(metrics.get("loss", 0.0)),
+            "em_acc_pct": float(metrics.get("em_acc", 0.0) * 100.0),
+            "tok_acc_pct": float(metrics.get("tok_acc", 0.0) * 100.0),
+        }
+        metrics_path = os.path.join(self.config.output_dir, "eval_metrics.jsonl")
+        with open(metrics_path, "a") as f:
+            f.write(json.dumps(record) + "\n")
+
+    def save_final_checkpoint(self):
+        ckpt_path = os.path.join(self.config.output_dir, self.config.final_ckpt_name)
+        base_model = unwrap_model(self.model)
+        memory_sd = {
+            name: p.detach().cpu()
+            for name, p in base_model.named_parameters()
+            if ("neural_memory" in name) or ("mem_gate" in name)
+        }
+
+        if is_fsdp_model(self.model) and len(memory_sd) == 0:
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+            full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+            with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                full_sd = self.model.state_dict()
+            memory_sd = {k: v for k, v in full_sd.items() if ("neural_memory" in k) or ("mem_gate" in k)}
+
+        if self.is_main_process:
+            torch.save(
+                {"memory_state_dict": memory_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                ckpt_path,
+            )
+            logger.info(f"Saved memory checkpoint: {ckpt_path}")
+        if self.is_distributed:
+            dist.barrier()
+
+        if self.config.save_full_checkpoint:
+            full_ckpt_path = os.path.join(self.config.output_dir, self.config.final_full_ckpt_name)
+            if is_fsdp_model(self.model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    full_sd = self.model.state_dict()
+            else:
+                full_sd = unwrap_model(self.model).state_dict()
+
+            if self.is_main_process:
+                torch.save(
+                    {"model_state_dict": full_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                    full_ckpt_path,
+                )
+                logger.info(f"Saved full checkpoint: {full_ckpt_path}")
+            if self.is_distributed:
+                dist.barrier()
+
+
+def main():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fsdp", action="store_true")
+    parser.add_argument("--eval_only", action="store_true")
+    parser.add_argument("--ckpt_path", type=str, default=None)
+    parser.add_argument("--max_eval_samples", type=int, default=None)
+    parser.add_argument("--max_samples", type=int, default=None)
+    parser.add_argument("--max_length", type=int, default=None)
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--eval_steps", type=int, default=None)
+    parser.add_argument("--eval_topk", type=int, default=0)
+    parser.add_argument("--batch_size", type=int, default=None)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--memory_layer_stride", type=int, default=None)
+    parser.add_argument("--no_memory", action="store_true")
+    parser.add_argument("--gradient_checkpointing", action="store_true")
+    parser.add_argument("--no_chunkwise_backward", action="store_true")
+    parser.add_argument("--log_every_batches", type=int, default=80)
+    parser.add_argument("--label_prefix_tokens", type=int, default=0)
+    parser.add_argument(
+        "--no_detach_mem_state",
+        action="store_true",
+        help="(ignored) kept for backward compatibility; detach_mem_state is forced True",
+    )
+    parser.add_argument("--debug_data_samples", type=int, default=0)
+    parser.add_argument("--debug_label_batches", type=int, default=0)
+    parser.add_argument("--debug_eval_stats", action="store_true")
+    parser.add_argument("--debug_grad_norm", action="store_true")
+    parser.add_argument(
+        "--freeze_base_model",
+        action="store_true",
+        help="冻结 Qwen base 模型，只训练记忆模块 (neural_memory + mem_gate)",
+    )
+    args = parser.parse_args()
+
+    config = TrainingConfig()
+    if args.fsdp:
+        config.use_fsdp = True
+    if args.no_memory:
+        config.use_memory = False
+    if args.max_samples is not None:
+        config.max_samples = args.max_samples
+    if args.max_length is not None:
+        config.max_length = int(args.max_length)
+    if args.output_dir is not None:
+        config.output_dir = args.output_dir
+    elif not config.use_memory:
+        config.output_dir = "./outputs/qwen_babilong_no_memory"
+    if args.num_epochs is not None:
+        config.num_epochs = args.num_epochs
+    if args.eval_steps is not None:
+        config.eval_steps = args.eval_steps
+    if args.eval_topk is not None:
+        config.eval_topk = int(args.eval_topk)
+    if args.batch_size is not None:
+        config.batch_size = int(args.batch_size)
+    if args.gradient_accumulation_steps is not None:
+        config.gradient_accumulation_steps = int(args.gradient_accumulation_steps)
+    if args.chunk_size is not None:
+        config.chunk_size = int(args.chunk_size)
+    if args.memory_layer_stride is not None:
+        config.memory_layer_stride = int(args.memory_layer_stride)
+    if args.gradient_checkpointing:
+        config.gradient_checkpointing = True
+    if args.no_chunkwise_backward:
+        config.chunkwise_backward = False
+    if args.label_prefix_tokens is not None:
+        config.label_prefix_tokens = int(args.label_prefix_tokens)
+    ignored_no_detach = bool(args.no_detach_mem_state)
+    if args.log_every_batches is not None:
+        config.log_every_batches = int(args.log_every_batches)
+        ga = max(int(config.gradient_accumulation_steps), 1)
+        config.logging_steps = max(1, math.ceil(config.log_every_batches / ga))
+    if args.debug_data_samples is not None:
+        config.debug_data_samples = int(args.debug_data_samples)
+    if args.debug_label_batches is not None:
+        config.debug_label_batches = int(args.debug_label_batches)
+    if args.debug_eval_stats:
+        config.debug_eval_stats = True
+    if args.debug_grad_norm:
+        config.debug_grad_norm = True
+
+    is_distributed, rank, local_rank, world_size = init_distributed()
+    is_main = (rank == 0)
+    if ignored_no_detach and is_main:
+        logger.warning("Ignoring --no_detach_mem_state; plan A keeps detach_mem_state=True.")
+
+    if config.use_fsdp and config.chunkwise_backward:
+        if is_main:
+            logger.warning("chunkwise_backward is incompatible with FSDP; disabling it.")
+        config.chunkwise_backward = False
+
+    if is_distributed and (not config.use_fsdp) and config.gradient_checkpointing:
+        config.gradient_checkpointing = False
+        if is_main:
+            logger.warning("gradient_checkpointing is unstable with DDP here; disabling it.")
+
+    if is_distributed and (not config.use_fsdp) and config.chunkwise_backward:
+        if is_main:
+            logger.info("DDP chunkwise backward enabled via per-chunk forward/backward.")
+
+    if is_distributed and (not config.use_fsdp):
+        if not config.ddp_find_unused_parameters:
+            config.ddp_find_unused_parameters = True
+            if is_main:
+                logger.warning("Enabling DDP find_unused_parameters to avoid unused grad errors.")
+
+    torch.manual_seed(config.seed + rank)
+
+    if torch.cuda.is_available():
+        device = torch.device(f"cuda:{local_rank}" if is_distributed else "cuda")
+    else:
+        device = torch.device("cpu")
+
+    if torch.cuda.is_available() and config.bf16:
+        bf16_supported = False
+        try:
+            bf16_supported = torch.cuda.is_bf16_supported()
+        except Exception:
+            bf16_supported = False
+        if not bf16_supported:
+            if is_main:
+                logger.warning("bf16 not supported on this GPU/runtime; falling back to fp16.")
+            config.bf16 = False
+            if not config.fp16:
+                config.fp16 = True
+
+    if torch.cuda.is_available() and getattr(config, "use_tf32", False):
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        try:
+            torch.set_float32_matmul_precision("high")
+        except Exception:
+            pass
+
+    if is_main:
+        logger.info("=" * 60)
+        logger.info("Qwen3-4B + Titans training (DDP/FSDP)")
+        logger.info("=" * 60)
+        logger.info(f"distributed={is_distributed}, world_size={world_size}, use_fsdp={config.use_fsdp}")
+        logger.info(f"mode={'EVAL_ONLY' if args.eval_only else 'TRAIN'}")
+        logger.info(f"model_path={config.model_path}")
+        logger.info(f"data_path={config.data_path}")
+        logger.info(f"output_dir={config.output_dir}")
+        logger.info(f"max_samples={config.max_samples}")
+        logger.info(f"max_length={config.max_length}")
+        logger.info(f"chunk_size={config.chunk_size}")
+        logger.info(f"use_memory={config.use_memory}")
+        if config.use_memory:
+            logger.info(f"memory_layer_stride={config.memory_layer_stride}")
+        logger.info(f"chunkwise_backward={config.chunkwise_backward}")
+        logger.info(f"label_prefix_tokens={config.label_prefix_tokens}")
+        logger.info(f"detach_mem_state={config.detach_mem_state}")
+        logger.info(f"freeze_base_model={config.freeze_base_model}")
+        if config.eval_topk:
+            logger.info(f"eval_topk={config.eval_topk}")
+
+    tokenizer = AutoTokenizer.from_pretrained(config.model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # disable flash-attn / torchao / torchvision detection
+    try:
+        import transformers
+        from transformers.utils import import_utils as _import_utils
+
+        def _disabled(*args, **kwargs):
+            return False
+
+        _import_utils.is_flash_attn_2_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_flash_attn_2_available"):
+            transformers.utils.is_flash_attn_2_available = _disabled
+
+        _import_utils.is_torchao_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_torchao_available"):
+            transformers.utils.is_torchao_available = _disabled
+
+        _import_utils.is_torchvision_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_torchvision_available"):
+            transformers.utils.is_torchvision_available = _disabled
+    except Exception as e:
+        logger.warning(f"Disable checks failed (ignored): {e}")
+
+    torch_dtype = torch.bfloat16 if config.bf16 else (torch.float16 if config.fp16 else torch.float32)
+
+    qwen_model = AutoModelForCausalLM.from_pretrained(
+        config.model_path,
+        torch_dtype=torch_dtype,
+        device_map=None,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        low_cpu_mem_usage=True,
+    )
+    qwen_model.to(device)
+    qwen_model.config.use_cache = False
+    if config.gradient_checkpointing and hasattr(qwen_model, "gradient_checkpointing_enable"):
+        qwen_model.gradient_checkpointing_enable()
+
+    train_dataset = BABILongDataset(
+        config.data_path,
+        tokenizer,
+        max_length=config.max_length,
+        answer_reserve_tokens=config.answer_reserve_tokens,
+        label_prefix_tokens=config.label_prefix_tokens,
+        max_samples=config.max_samples,
+    )
+
+    train_size = int(0.9 * len(train_dataset))
+    eval_size = len(train_dataset) - train_size
+    train_dataset, eval_dataset = torch.utils.data.random_split(
+        train_dataset,
+        [train_size, eval_size],
+        generator=torch.Generator().manual_seed(config.seed),
+    )
+
+    if is_main and config.debug_data_samples > 0:
+        log_dataset_debug_stats(train_dataset, tokenizer, "train", config.debug_data_samples)
+        log_dataset_debug_stats(eval_dataset, tokenizer, "eval", config.debug_data_samples)
+
+    train_sampler = None
+    eval_sampler = None
+    if is_distributed:
+        from torch.utils.data.distributed import DistributedSampler
+        train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True, seed=config.seed)
+        eval_sampler = DistributedSampler(eval_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=config.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset,
+        batch_size=config.batch_size,
+        shuffle=False,
+        sampler=eval_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+
+    model = QwenTitansForBABILong(qwen_model, config)
+    model.to(device)
+
+    # 处理 freeze_base_model 参数
+    if args.freeze_base_model:
+        config.freeze_base_model = True
+    
+    if config.freeze_base_model:
+        if not config.use_memory:
+            if is_main:
+                logger.error("--freeze_base_model requires memory module (--no_memory is incompatible)")
+            raise ValueError("freeze_base_model requires use_memory=True")
+        model.freeze_base_model()
+        if is_main:
+            logger.info("=" * 40)
+            logger.info("FREEZE MODE: Training memory + independent lm_head")
+            logger.info("  - Trainable: neural_memory, mem_gate, lm_head (untied)")
+            logger.info("  - Frozen: embed_tokens, transformer layers, norm")
+            logger.info("=" * 40)
+
+    if is_distributed:
+        if config.use_fsdp:
+            from functools import partial
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, MixedPrecision
+            from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+            from transformers.models.qwen3.modeling_qwen3 import Qwen3DecoderLayer
+
+            mp_policy = MixedPrecision(param_dtype=torch_dtype, reduce_dtype=torch_dtype, buffer_dtype=torch_dtype)
+            auto_wrap = partial(transformer_auto_wrap_policy, transformer_layer_cls={Qwen3DecoderLayer, QwenDecoderLayerWithTitansMemory})
+
+            model = FSDP(
+                model,
+                auto_wrap_policy=auto_wrap,
+                mixed_precision=mp_policy,
+                device_id=torch.cuda.current_device(),
+                use_orig_params=config.fsdp_use_orig_params,
+                ignored_modules=model.get_memory_modules(),
+            )
+        else:
+            model = DDP(
+                model,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=config.ddp_find_unused_parameters,
+            )
+            if config.gradient_checkpointing:
+                try:
+                    model._set_static_graph()
+                    if is_main:
+                        logger.warning("DDP static graph enabled for gradient checkpointing.")
+                except Exception as e:
+                    if is_main:
+                        logger.warning(f"DDP static graph enable failed (ignored): {e}")
+
+    trainer = Trainer(
+        model=model,
+        train_dataloader=train_dataloader,
+        eval_dataloader=eval_dataloader,
+        config=config,
+        rank=rank,
+        world_size=world_size,
+        is_distributed=is_distributed,
+        tokenizer=tokenizer,
+    )
+
+    if args.eval_only:
+        ckpt_path = args.ckpt_path or os.path.join(config.output_dir, config.final_ckpt_name)
+        if is_main:
+            logger.info(f"eval_only: loading checkpoint: {ckpt_path}")
+        ckpt = torch.load(ckpt_path, map_location="cpu")
+        has_full = isinstance(ckpt, dict) and ("model_state_dict" in ckpt)
+        if has_full:
+            full_sd = ckpt["model_state_dict"]
+            if is_fsdp_model(model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    sd_to_load = full_sd if is_main else {}
+                    model.load_state_dict(sd_to_load, strict=False)
+            else:
+                unwrap_model(model).load_state_dict(full_sd, strict=False)
+
+        memory_sd = ckpt.get("memory_state_dict", ckpt if isinstance(ckpt, dict) else {})
+        memory_sd = {k: v for k, v in memory_sd.items() if ("neural_memory" in k) or ("mem_gate" in k)}
+        if len(memory_sd) > 0:
+            if is_fsdp_model(model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    sd_to_load = memory_sd if is_main else {}
+                    model.load_state_dict(sd_to_load, strict=False)
+            else:
+                unwrap_model(model).load_state_dict(memory_sd, strict=False)
+
+        eval_metrics = trainer.evaluate()
+        if is_main:
+            ppl = float(math.exp(min(20.0, eval_metrics["loss"])))
+            logger.info(
+                f"[EVAL] loss={eval_metrics['loss']:.4f}, ppl≈{ppl:.3f}, "
+                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+            )
+        cleanup_distributed()
+        return
+
+    trainer.train()
+    cleanup_distributed()
+
+
+if __name__ == "__main__":
+    main()

examples/train_qwen_titans_babilong_v2.py

@@ -0,0 +1,1573 @@
+"""
+Qwen3 + Titans training on BABILong QA1 (32k).
+
+Key ideas:
+- Fixed-length 32k samples for DDP/FSDP stability.
+- Stream long sequences by chunk (default 8k).
+- Insert Titans memory modules into Qwen layers (stride configurable).
+"""
+
+import os
+import json
+import math
+import argparse
+import logging
+import weakref
+from contextlib import nullcontext
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any, List, Tuple, Callable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.nn.parallel import DistributedDataParallel as DDP
+from tqdm import tqdm
+
+from einops import rearrange
+
+# add repo root to sys.path
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Titans components
+from titans_pytorch import NeuralMemory, MemoryMLP
+from titans_pytorch.neural_memory import NeuralMemState
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TrainingConfig:
+    # paths
+    model_path: str = "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554"
+    data_path: str = "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json"
+    output_dir: str = "./outputs/qwen_titans_babilong"
+
+    # training
+    num_epochs: int = 10
+    batch_size: int = 2
+    gradient_accumulation_steps: int = 8
+    max_grad_norm: float = 1.0
+
+    # learning rates
+    lr_memory: float = 1e-4
+    lr_pretrained: float = 5e-6
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+
+    # streaming / memory
+    chunk_size: int = 8192
+    use_memory: bool = True
+    memory_chunk_size: int = 128
+    memory_batch_size: int = 128
+    memory_heads: int = 8
+    memory_dim_head: int = 64
+    memory_depth: int = 1
+    memory_layer_stride: int = 8
+    memory_fp32: bool = True
+    detach_mem_state: bool = True
+
+    # evaluation / logging
+    eval_steps: int = 200
+    eval_topk: int = 0
+    logging_steps: int = 10
+    log_every_batches: int = 80
+    final_eval_print_examples: int = 10
+    debug_data_samples: int = 0
+    debug_label_batches: int = 0
+    debug_eval_stats: bool = False
+    debug_grad_norm: bool = False
+
+    # precision
+    bf16: bool = True
+    fp16: bool = False
+    use_tf32: bool = True
+    gradient_checkpointing: bool = False
+    chunkwise_backward: bool = True
+    chunkwise_backward: bool = True
+
+    # data
+    max_length: int = 32768
+    answer_reserve_tokens: int = 64
+    label_prefix_tokens: int = 0
+    max_samples: Optional[int] = 500  # 快速实验用 500，完整训练可设置更大值
+
+    # fsdp
+    use_fsdp: bool = False
+    fsdp_use_orig_params: bool = True
+    ddp_find_unused_parameters: bool = False
+
+    # checkpoint
+    save_full_checkpoint: bool = True
+    final_ckpt_name: str = "final_memory_checkpoint.pt"
+    final_full_ckpt_name: str = "final_full_checkpoint.pt"
+
+    seed: int = 42
+
+
+class BABILongDataset(Dataset):
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer,
+        max_length: int = 32768,
+        answer_reserve_tokens: int = 64,
+        label_prefix_tokens: int = 0,
+        max_samples: Optional[int] = None,
+    ):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.answer_reserve_tokens = answer_reserve_tokens
+        self.label_prefix_tokens = int(label_prefix_tokens)
+
+        logger.info(f"Loading dataset: {data_path}")
+        with open(data_path, "r") as f:
+            self.data = json.load(f)
+
+        if max_samples:
+            self.data = self.data[:max_samples]
+
+        logger.info(f"Dataset size: {len(self.data)}")
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        text = f"{item['input']}\n\nQuestion: {item['question']}\nAnswer:"
+        target = item["target"]
+
+        pad_id = self.tokenizer.pad_token_id or 0
+        reserve = int(self.answer_reserve_tokens)
+
+        prompt_ids = self.tokenizer(
+            text,
+            max_length=max(self.max_length - reserve, 1),
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        answer_ids = self.tokenizer(
+            f" {target}",
+            add_special_tokens=False,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        available = max(self.max_length - prompt_ids.numel(), 0)
+        answer_ids = answer_ids[:available]
+
+        input_ids = torch.cat([prompt_ids, answer_ids], dim=0)[: self.max_length]
+
+        labels = torch.full_like(input_ids, fill_value=-100)
+        if answer_ids.numel() > 0:
+            start = prompt_ids.numel()
+            end = min(start + answer_ids.numel(), labels.numel())
+            labels[start:end] = input_ids[start:end]
+            if self.label_prefix_tokens > 0:
+                prefix = min(start, self.label_prefix_tokens)
+                if prefix > 0:
+                    labels[start - prefix:start] = input_ids[start - prefix:start]
+
+        seq_len = input_ids.numel()
+        if seq_len < self.max_length:
+            pad_len = self.max_length - seq_len
+            input_ids = F.pad(input_ids, (0, pad_len), value=int(pad_id))
+            labels = F.pad(labels, (0, pad_len), value=-100)
+            attention_mask = torch.cat(
+                [torch.ones(seq_len, dtype=torch.long), torch.zeros(pad_len, dtype=torch.long)],
+                dim=0,
+            )
+        else:
+            attention_mask = torch.ones(self.max_length, dtype=torch.long)
+
+        return {
+            "input_ids": input_ids.to(dtype=torch.long),
+            "labels": labels.to(dtype=torch.long),
+            "attention_mask": attention_mask,
+        }
+
+
+def collate_fn(batch):
+    keys = batch[0].keys()
+    return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys}
+
+
+def _get_raw_dataset_item(dataset, idx: int) -> Optional[Dict[str, Any]]:
+    base = dataset
+    true_idx = idx
+    if isinstance(dataset, torch.utils.data.Subset):
+        base = dataset.dataset
+        true_idx = dataset.indices[idx]
+    if isinstance(base, BABILongDataset) and hasattr(base, "data"):
+        try:
+            return base.data[true_idx]
+        except Exception:
+            return None
+    return None
+
+
+def log_dataset_debug_stats(dataset, tokenizer, name: str, num_samples: int) -> None:
+    if num_samples <= 0:
+        return
+    total = len(dataset)
+    if total <= 0:
+        logger.warning(f"[DATA DEBUG] {name}: empty dataset")
+        return
+
+    n = min(int(num_samples), total)
+    zero_label = 0
+    total_label_tokens = 0
+    total_loss_tokens = 0
+    total_attn_tokens = 0
+
+    for i in range(n):
+        sample = dataset[i]
+        labels = sample["labels"]
+        attn = sample["attention_mask"]
+
+        label_mask = labels != -100
+        label_tokens = int(label_mask.sum().item())
+        loss_tokens = int((labels[1:] != -100).sum().item()) if labels.numel() > 1 else 0
+        attn_tokens = int(attn.sum().item())
+
+        total_label_tokens += label_tokens
+        total_loss_tokens += loss_tokens
+        total_attn_tokens += attn_tokens
+        if label_tokens == 0:
+            zero_label += 1
+
+        if i < min(3, n):
+            label_pos = label_mask.nonzero(as_tuple=False).view(-1)
+            first_label = int(label_pos[0].item()) if label_pos.numel() > 0 else -1
+            last_label = int(label_pos[-1].item()) if label_pos.numel() > 0 else -1
+
+            decoded = ""
+            if tokenizer is not None and label_pos.numel() > 0:
+                answer_ids = labels[label_pos].tolist()
+                decoded = tokenizer.decode(answer_ids, skip_special_tokens=True).strip()
+                if len(decoded) > 200:
+                    decoded = decoded[:200] + "..."
+
+            raw_item = _get_raw_dataset_item(dataset, i)
+            target_chars = None
+            target_tokens = None
+            if raw_item is not None and tokenizer is not None:
+                target_text = str(raw_item.get("target", ""))
+                target_chars = len(target_text)
+                target_ids = tokenizer(
+                    f" {target_text}",
+                    add_special_tokens=False,
+                    return_tensors="pt",
+                ).input_ids.squeeze(0)
+                target_tokens = int(target_ids.numel())
+
+            logger.info(
+                f"[DATA DEBUG] {name} sample {i}: attn_tokens={attn_tokens}, "
+                f"label_tokens={label_tokens}, loss_tokens={loss_tokens}, "
+                f"label_span=[{first_label},{last_label}]"
+            )
+            if target_chars is not None or decoded:
+                logger.info(
+                    f"[DATA DEBUG] {name} target_chars={target_chars}, "
+                    f"target_tokens={target_tokens}, decoded_answer={repr(decoded)}"
+                )
+
+    avg_label = total_label_tokens / max(n, 1)
+    avg_loss = total_loss_tokens / max(n, 1)
+    avg_attn = total_attn_tokens / max(n, 1)
+    logger.info(
+        f"[DATA DEBUG] {name} summary: samples={n}, zero_label_samples={zero_label}, "
+        f"avg_label_tokens={avg_label:.2f}, avg_loss_tokens={avg_loss:.2f}, avg_attn_tokens={avg_attn:.2f}"
+    )
+
+
+class QwenDecoderLayerWithTitansMemory(nn.Module):
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        *,
+        hidden_size: int,
+        chunk_size: int,
+        batch_size: int,
+        dim_head: int,
+        num_heads: int,
+        memory_depth: int,
+        memory_fp32: bool,
+        detach_mem_state: bool,
+        parent_model: Optional[nn.Module] = None,
+    ):
+        super().__init__()
+        self.layer = base_layer
+        self.memory_fp32 = memory_fp32
+        self.detach_mem_state = bool(detach_mem_state)
+        self.memory_state: Optional[NeuralMemState] = None
+        self.parent_model_ref = weakref.ref(parent_model) if parent_model is not None else None
+
+        memory_model = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0,
+        )
+
+        self.neural_memory = NeuralMemory(
+            dim=hidden_size,
+            chunk_size=chunk_size,
+            batch_size=batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=True,
+            momentum_order=1,
+            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=False,
+        )
+
+        self.mem_gate = nn.Sequential(
+            nn.Linear(hidden_size * 2, hidden_size),
+            nn.Sigmoid(),
+        )
+
+        try:
+            layer_device = next(base_layer.parameters()).device
+            layer_dtype = next(base_layer.parameters()).dtype
+        except StopIteration:
+            layer_device = None
+            layer_dtype = None
+
+        if layer_device is not None:
+            mem_dtype = torch.float32 if memory_fp32 else layer_dtype
+            self.neural_memory = self.neural_memory.to(device=layer_device, dtype=mem_dtype)
+            if layer_dtype is not None:
+                self.mem_gate = self.mem_gate.to(device=layer_device, dtype=layer_dtype)
+            else:
+                self.mem_gate = self.mem_gate.to(device=layer_device)
+
+    def reset_memory_state(self):
+        self.memory_state = None
+
+    def _get_store_mask(self, hidden_states: torch.Tensor) -> Optional[torch.Tensor]:
+        parent_model = self.parent_model_ref() if self.parent_model_ref is not None else None
+        if parent_model is None or not hasattr(parent_model, "_mem_store_mask"):
+            return None
+        store_mask = getattr(parent_model, "_mem_store_mask")
+        if store_mask is None:
+            return None
+        store_mask = store_mask.to(device=hidden_states.device).bool()
+        if store_mask.shape[:2] != hidden_states.shape[:2]:
+            return None
+        return store_mask
+
+    def forward(self, *args, **kwargs):
+        outputs = self.layer(*args, **kwargs)
+
+        if isinstance(outputs, (tuple, list)):
+            hidden_states = outputs[0]
+            rest = outputs[1:]
+        else:
+            hidden_states = outputs
+            rest = None
+
+        full_store_mask = self._get_store_mask(hidden_states)
+        mem_inp = hidden_states.float() if self.memory_fp32 else hidden_states
+
+        store_seq = None
+        store_mask = full_store_mask
+        if store_mask is not None:
+            store_seq = mem_inp
+            if store_mask.shape[1] > 0 and not store_mask[:, 0].any():
+                store_seq = store_seq[:, 1:]
+                store_mask = store_mask[:, 1:]
+
+            store_chunk = self.neural_memory.store_chunk_size
+            remainder = store_seq.shape[1] % store_chunk
+            if remainder != 0:
+                store_seq = store_seq[:, :-remainder]
+                store_mask = store_mask[:, :-remainder]
+
+            if store_mask is not None and store_seq is not None:
+                if store_mask.shape[1] != store_seq.shape[1]:
+                    min_len = min(store_mask.shape[1], store_seq.shape[1])
+                    store_seq = store_seq[:, :min_len]
+                    store_mask = store_mask[:, :min_len]
+
+            if store_seq.shape[1] == 0:
+                store_seq = None
+                store_mask = None
+
+        mem_ctx = (
+            torch.amp.autocast(device_type=hidden_states.device.type, enabled=False)
+            if self.memory_fp32
+            else nullcontext()
+        )
+        with mem_ctx:
+            retrieved, next_state = self.neural_memory(
+                mem_inp,
+                store_seq=store_seq,
+                state=self.memory_state,
+                store_mask=store_mask,
+                detach_mem_state=self.detach_mem_state,
+            )
+        self.memory_state = next_state
+
+        if retrieved is not None:
+            retrieved = retrieved.to(dtype=hidden_states.dtype)
+            if full_store_mask is not None and full_store_mask.shape[:2] == retrieved.shape[:2]:
+                retrieved = retrieved * full_store_mask.unsqueeze(-1).to(dtype=retrieved.dtype)
+            gate = self.mem_gate(torch.cat([hidden_states, retrieved], dim=-1))
+            hidden_states = hidden_states + gate * retrieved
+
+        if rest is None:
+            return hidden_states
+        return (hidden_states, *rest)
+
+
+class QwenTitansForBABILong(nn.Module):
+    def __init__(self, qwen_model, config: TrainingConfig):
+        super().__init__()
+        self.qwen = qwen_model
+        self.config = config
+        self.hidden_size = qwen_model.config.hidden_size
+        self.use_memory = bool(getattr(config, "use_memory", True))
+
+        if self.use_memory:
+            self.memory_layer_stride = int(getattr(config, "memory_layer_stride", 4))
+            self.memory_layer_indices = [
+                idx for idx in range(len(self.qwen.model.layers)) if idx % self.memory_layer_stride == 0
+            ]
+
+            for layer_idx in self.memory_layer_indices:
+                base_layer = self.qwen.model.layers[layer_idx]
+                wrapped = QwenDecoderLayerWithTitansMemory(
+                    base_layer,
+                    hidden_size=self.hidden_size,
+                    chunk_size=config.memory_chunk_size,
+                    batch_size=config.memory_batch_size,
+                    dim_head=config.memory_dim_head,
+                    num_heads=config.memory_heads,
+                    memory_depth=config.memory_depth,
+                    memory_fp32=config.memory_fp32,
+                    detach_mem_state=config.detach_mem_state,
+                    parent_model=self.qwen.model,
+                )
+                self.qwen.model.layers[layer_idx] = wrapped
+        else:
+            self.memory_layer_stride = 0
+            self.memory_layer_indices = []
+
+        if self.use_memory:
+            logger.info("[QwenTitansForBABILong] Initialized")
+            logger.info(f"  - hidden_size: {self.hidden_size}")
+            logger.info(f"  - chunk_size: {config.chunk_size}")
+            logger.info(f"  - memory_layer_stride: {self.memory_layer_stride}")
+            logger.info(f"  - memory_layers: {self.memory_layer_indices}")
+        else:
+            logger.info("[QwenTitansForBABILong] Initialized (memory disabled)")
+            logger.info(f"  - hidden_size: {self.hidden_size}")
+            logger.info(f"  - chunk_size: {config.chunk_size}")
+
+        self._memory_layers = [
+            layer for layer in self.qwen.model.layers if isinstance(layer, QwenDecoderLayerWithTitansMemory)
+        ]
+        self.qwen.model._mem_store_mask = None
+
+    def _split_into_chunks(self, tensor, chunk_size):
+        seq_len = tensor.shape[1]
+        chunks = []
+        for start in range(0, seq_len, chunk_size):
+            end = min(start + chunk_size, seq_len)
+            chunks.append((start, end, tensor[:, start:end]))
+        return chunks
+
+    def reset_memory_states(self):
+        for layer in self._memory_layers:
+            layer.reset_memory_state()
+
+    def _set_mem_store_mask(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_mask: Optional[torch.Tensor],
+        chunk_start: int,
+    ) -> None:
+        if not self.use_memory:
+            self.qwen.model._mem_store_mask = None
+            return
+        if chunk_mask is None:
+            if chunk_start > 0:
+                store_mask = torch.ones_like(chunk_ids, dtype=torch.bool)
+                store_mask[:, 0] = False
+            else:
+                store_mask = None
+        else:
+            store_mask = chunk_mask.to(device=chunk_ids.device).bool()
+            if chunk_start > 0:
+                store_mask[:, 0] = False
+        self.qwen.model._mem_store_mask = store_mask
+
+    def get_memory_modules(self) -> List[nn.Module]:
+        if not self._memory_layers:
+            return []
+        modules = []
+        for layer in self._memory_layers:
+            modules.append(layer.neural_memory)
+            modules.append(layer.mem_gate)
+        return modules
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_pred_tokens: bool = False,
+        topk: int = 0,
+        chunkwise_backward: bool = False,
+        loss_scale: Optional[float] = None,
+        backward_fn: Optional[Callable[[torch.Tensor], None]] = None,
+        chunk_start: Optional[int] = None,
+        chunk_end: Optional[int] = None,
+        reset_mem_state: bool = False,
+    ) -> Dict[str, torch.Tensor]:
+        if chunk_start is not None or chunk_end is not None:
+            start = 0 if chunk_start is None else int(chunk_start)
+            end = int(chunk_end) if chunk_end is not None else None
+            return self._forward_single_chunk(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                labels=labels,
+                chunk_start=start,
+                chunk_end=end,
+                reset_mem_state=reset_mem_state,
+            )
+        batch_size, seq_len = input_ids.shape
+        chunk_size = self.config.chunk_size
+        chunks = self._split_into_chunks(input_ids, chunk_size)
+
+        self.reset_memory_states()
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+        topk_correct = None
+        topk_total = None
+
+        pred_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        target_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        if topk and topk > 0:
+            device = input_ids.device
+            topk_correct = torch.tensor(0.0, device=device, dtype=torch.float32)
+            topk_total = torch.tensor(0.0, device=device, dtype=torch.float32)
+
+        for start, end, _ in chunks:
+            proc_start = max(0, start - 1)
+            chunk_ids = input_ids[:, proc_start:end]
+            chunk_labels = labels[:, proc_start:end] if labels is not None else None
+            chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+            self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+            hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+            if self.use_memory:
+                self.qwen.model._mem_store_mask = None
+
+            if chunk_labels is not None and (chunk_labels != -100).any():
+                chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+                shift_hidden = hidden_full[:, :-1, :].contiguous()
+                shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+                valid = shift_labels != -100
+                if valid.any():
+                    hs = shift_hidden[valid]
+                    targets = shift_labels[valid]
+
+                    hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+
+                    logits = self.qwen.lm_head(hs)
+                    logits = logits.float()
+                    logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                    targets = targets.to(device=logits.device)
+
+                    chunk_loss_sum = loss_fct_sum(logits, targets)
+                    if total_loss_sum is None:
+                        total_loss_sum = chunk_loss_sum
+                    else:
+                        total_loss_sum = total_loss_sum + chunk_loss_sum
+                    total_loss_tokens += targets.numel()
+
+                    if topk and topk > 0:
+                        k = min(int(topk), logits.shape[-1])
+                        topk_ids = torch.topk(logits, k=k, dim=-1).indices
+                        correct = (topk_ids == targets.unsqueeze(-1)).any(dim=-1)
+                        topk_correct = topk_correct + correct.float().sum()
+                        topk_total = topk_total + torch.tensor(float(targets.numel()), device=topk_total.device)
+
+                    if return_pred_tokens:
+                        idx = valid.nonzero(as_tuple=False)
+                        pred_flat = torch.argmax(logits, dim=-1).detach().to("cpu", dtype=torch.long).tolist()
+                        tgt_flat = targets.detach().to("cpu", dtype=torch.long).tolist()
+                        b_idx_flat = idx[:, 0].detach().to("cpu", dtype=torch.long).tolist()
+
+                        for i, b_idx in enumerate(b_idx_flat):
+                            pred_tokens_by_sample[b_idx].append(int(pred_flat[i]))
+                            target_tokens_by_sample[b_idx].append(int(tgt_flat[i]))
+
+        if total_loss_sum is None or total_loss_tokens == 0:
+            device = next(self.qwen.parameters()).device
+            loss = torch.zeros((), device=device, dtype=torch.float32)
+        else:
+            loss = total_loss_sum / total_loss_tokens
+
+        out: Dict[str, torch.Tensor] = {"loss": loss}
+        if return_pred_tokens:
+            lengths = torch.tensor([len(x) for x in target_tokens_by_sample], dtype=torch.long)
+            max_len = int(lengths.max().item()) if lengths.numel() > 0 else 0
+            if max_len > 0:
+                pred_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                tgt_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                for b in range(batch_size):
+                    L = int(lengths[b].item())
+                    if L > 0:
+                        pred_mat[b, :L] = torch.tensor(pred_tokens_by_sample[b], dtype=torch.long)
+                        tgt_mat[b, :L] = torch.tensor(target_tokens_by_sample[b], dtype=torch.long)
+            else:
+                pred_mat = torch.empty((batch_size, 0), dtype=torch.long)
+                tgt_mat = torch.empty((batch_size, 0), dtype=torch.long)
+            out["pred_ids"] = pred_mat
+            out["target_ids"] = tgt_mat
+            out["target_lengths"] = lengths
+        if topk and topk > 0 and topk_correct is not None and topk_total is not None:
+            out["topk_correct"] = topk_correct
+            out["topk_total"] = topk_total
+        return out
+
+    def _forward_single_chunk(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor],
+        labels: Optional[torch.Tensor],
+        chunk_start: int,
+        chunk_end: Optional[int],
+        reset_mem_state: bool,
+    ) -> Dict[str, torch.Tensor]:
+        if reset_mem_state:
+            self.reset_memory_states()
+
+        seq_len = input_ids.shape[1]
+        end = chunk_end if chunk_end is not None else min(chunk_start + self.config.chunk_size, seq_len)
+        end = min(int(end), seq_len)
+        start = max(0, int(chunk_start))
+
+        proc_start = max(0, start - 1)
+        chunk_ids = input_ids[:, proc_start:end]
+        chunk_labels = labels[:, proc_start:end] if labels is not None else None
+        chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+        self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+        hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+        if self.use_memory:
+            self.qwen.model._mem_store_mask = None
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+
+        if chunk_labels is not None and (chunk_labels != -100).any():
+            chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+            shift_hidden = hidden_full[:, :-1, :].contiguous()
+            shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+            valid = shift_labels != -100
+            if valid.any():
+                hs = shift_hidden[valid]
+                targets = shift_labels[valid]
+
+                hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                logits = self.qwen.lm_head(hs)
+                logits = logits.float()
+                logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                targets = targets.to(device=logits.device)
+
+                total_loss_sum = loss_fct_sum(logits, targets)
+                total_loss_tokens = targets.numel()
+
+        if total_loss_sum is None:
+            # 创建一个有梯度图的零 loss，通过 hidden_full 建立连接
+            # 这对 DDP 至关重要：确保所有 rank 的 backward 调用一致
+            total_loss_sum = (hidden_full.float().sum() * 0.0)
+
+        return {
+            "loss_sum": total_loss_sum,
+            "loss_tokens": total_loss_tokens,
+            "has_grad": True,  # 现在总是有梯度图
+        }
+
+    def _process_chunk(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if hasattr(self.qwen.model, "embed_tokens"):
+            token_embeds = self.qwen.model.embed_tokens(chunk_ids)
+        else:
+            token_embeds = self.qwen.get_input_embeddings()(chunk_ids)
+
+        outputs = self.qwen.model(
+            inputs_embeds=token_embeds,
+            attention_mask=chunk_attention_mask,
+            use_cache=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+        return outputs.last_hidden_state
+
+    def get_param_groups(self, lr_memory: float, lr_pretrained: float, weight_decay: float):
+        memory_params = []
+        pretrained_params = []
+
+        for name, param in self.named_parameters():
+            if not param.requires_grad:
+                continue
+            if "neural_memory" in name or "mem_gate" in name:
+                memory_params.append(param)
+            else:
+                pretrained_params.append(param)
+
+        param_groups = []
+        if len(memory_params) > 0:
+            param_groups.append(
+                {"params": memory_params, "lr": lr_memory, "weight_decay": weight_decay, "name": "memory_module"}
+            )
+        if len(pretrained_params) > 0:
+            param_groups.append(
+                {"params": pretrained_params, "lr": lr_pretrained, "weight_decay": weight_decay, "name": "pretrained"}
+            )
+        logger.info(f"Param groups: memory={len(memory_params)}, pretrained={len(pretrained_params)}")
+        return param_groups
+
+
+def init_distributed() -> tuple[bool, int, int, int]:
+    if "RANK" not in os.environ or "WORLD_SIZE" not in os.environ:
+        return False, 0, 0, 1
+
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    local_rank = int(os.environ.get("LOCAL_RANK", 0))
+
+    if not dist.is_available():
+        raise RuntimeError("torch.distributed not available")
+
+    if not dist.is_initialized():
+        dist.init_process_group(backend="nccl", init_method="env://")
+
+    torch.cuda.set_device(local_rank)
+    return True, rank, local_rank, world_size
+
+
+def cleanup_distributed():
+    if dist.is_available() and dist.is_initialized():
+        dist.barrier()
+        dist.destroy_process_group()
+
+
+def unwrap_model(model: nn.Module) -> nn.Module:
+    if hasattr(model, "module"):
+        return model.module
+    if hasattr(model, "_fsdp_wrapped_module"):
+        wrapped = getattr(model, "_fsdp_wrapped_module", None)
+        if wrapped is not None and hasattr(wrapped, "module"):
+            return wrapped.module
+    return model
+
+
+def is_fsdp_model(model: nn.Module) -> bool:
+    try:
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+        return isinstance(model, FSDP)
+    except Exception:
+        return False
+
+
+class Trainer:
+    def __init__(
+        self,
+        model: QwenTitansForBABILong,
+        train_dataloader: DataLoader,
+        eval_dataloader: DataLoader,
+        config: TrainingConfig,
+        rank: int = 0,
+        world_size: int = 1,
+        is_distributed: bool = False,
+        tokenizer=None,
+    ):
+        self.model = model
+        self.train_dataloader = train_dataloader
+        self.eval_dataloader = eval_dataloader
+        self.config = config
+        self.device = next(model.parameters()).device
+        self.rank = rank
+        self.world_size = world_size
+        self.is_distributed = is_distributed
+        self.is_main_process = (rank == 0)
+        self.tokenizer = tokenizer
+
+        base_model = unwrap_model(self.model)
+        param_groups = base_model.get_param_groups(
+            lr_memory=config.lr_memory,
+            lr_pretrained=config.lr_pretrained,
+            weight_decay=config.weight_decay,
+        )
+        self.optimizer = AdamW(param_groups)
+
+        total_steps = math.ceil(
+            (len(train_dataloader) * config.num_epochs) / max(config.gradient_accumulation_steps, 1)
+        )
+        self.scheduler = CosineAnnealingLR(self.optimizer, T_max=total_steps, eta_min=1e-7)
+
+        self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+        self.global_step = 0
+
+    def _get_group_lr(self, group_name: str) -> Optional[float]:
+        for group in self.optimizer.param_groups:
+            if group.get("name") == group_name:
+                return group.get("lr")
+        return None
+
+    def train(self):
+        self.model.train()
+        if self.is_main_process:
+            logger.info("Start training")
+
+        last_epoch_loss = None
+        for epoch in range(self.config.num_epochs):
+            sampler = getattr(self.train_dataloader, "sampler", None)
+            if sampler is not None and hasattr(sampler, "set_epoch"):
+                sampler.set_epoch(epoch)
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1}/{self.config.num_epochs}")
+
+            epoch_loss = 0.0
+            num_batches = 0
+
+            pbar = self.train_dataloader
+            if self.is_main_process:
+                pbar = tqdm(
+                    self.train_dataloader,
+                    desc=f"Epoch {epoch + 1}/{self.config.num_epochs}",
+                    leave=False,
+                    dynamic_ncols=True,
+                )
+            for step, batch in enumerate(pbar):
+                batch = {k: v.to(self.device) for k, v in batch.items()}
+                if (
+                    self.config.debug_label_batches > 0
+                    and self.is_main_process
+                    and step < int(self.config.debug_label_batches)
+                ):
+                    labels = batch.get("labels")
+                    if labels is not None:
+                        label_tokens = int((labels != -100).sum().item())
+                        loss_tokens = int((labels[:, 1:] != -100).sum().item()) if labels.size(1) > 1 else 0
+                        attn_tokens = int(batch["attention_mask"].sum().item())
+                        logger.info(
+                            f"[BATCH DEBUG] epoch={epoch + 1} step={step + 1}: "
+                            f"attn_tokens={attn_tokens}, label_tokens={label_tokens}, loss_tokens={loss_tokens}"
+                        )
+                    else:
+                        logger.info(f"[BATCH DEBUG] epoch={epoch + 1} step={step + 1}: labels missing")
+
+                ga = max(self.config.gradient_accumulation_steps, 1)
+                sync_gradients = ((step + 1) % ga == 0)
+                amp_enabled = self.config.fp16 or self.config.bf16
+                amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+                with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                    if self.config.chunkwise_backward:
+                        labels = batch.get("labels")
+                        if labels is not None:
+                            total_tokens = int((labels[:, 1:] != -100).sum().item())
+                        else:
+                            total_tokens = 0
+                        loss_scale = 0.0 if total_tokens == 0 else (1.0 / total_tokens / ga)
+
+                        seq_len = batch["input_ids"].shape[1]
+                        chunk_size = int(self.config.chunk_size)
+                        chunk_ranges = [
+                            (start, min(start + chunk_size, seq_len))
+                            for start in range(0, seq_len, chunk_size)
+                        ]
+                        raw_loss_sum = None
+
+                        for idx, (start, end) in enumerate(chunk_ranges):
+                            is_last_chunk = (idx == len(chunk_ranges) - 1)
+                            sync_chunk = sync_gradients and is_last_chunk
+                            chunk_ctx = (
+                                self.model.no_sync
+                                if (self.is_distributed and not sync_chunk)
+                                else nullcontext
+                            )
+                            with chunk_ctx():
+                                outputs = self.model(
+                                    input_ids=batch["input_ids"],
+                                    attention_mask=batch["attention_mask"],
+                                    labels=labels,
+                                    chunk_start=start,
+                                    chunk_end=end,
+                                    reset_mem_state=(idx == 0),
+                                )
+                                chunk_loss_sum = outputs["loss_sum"]
+                                chunk_loss_tokens = int(outputs.get("loss_tokens", 0))
+                                if raw_loss_sum is None:
+                                    raw_loss_sum = chunk_loss_sum.detach()
+                                else:
+                                    raw_loss_sum = raw_loss_sum + chunk_loss_sum.detach()
+                                
+                                # DDP 关键：所有 rank 必须执行相同的 backward 调用序列
+                                # 即使 loss_scale=0 或 chunk 无有效 token，也要调用 backward
+                                # 以确保 allreduce 同步
+                                scaled_loss = chunk_loss_sum * float(loss_scale)
+                                if self.config.fp16:
+                                    self.scaler.scale(scaled_loss).backward()
+                                else:
+                                    scaled_loss.backward()
+
+                        if raw_loss_sum is None or total_tokens == 0:
+                            raw_loss = torch.zeros((), device=self.device, dtype=torch.float32)
+                        else:
+                            raw_loss = raw_loss_sum / total_tokens
+                        loss = raw_loss / ga
+                    else:
+                        ctx = self.model.no_sync if (self.is_distributed and not sync_gradients) else nullcontext
+                        with ctx():
+                            outputs = self.model(
+                                input_ids=batch["input_ids"],
+                                attention_mask=batch["attention_mask"],
+                                labels=batch["labels"],
+                            )
+                            raw_loss = outputs["loss"]
+                            loss = raw_loss / ga
+
+                        if self.config.fp16:
+                            self.scaler.scale(loss).backward()
+                        else:
+                            loss.backward()
+
+                epoch_loss += raw_loss.detach().float().item()
+                num_batches += 1
+
+                if sync_gradients:
+                    grad_norm = None
+                    if self.config.fp16:
+                        self.scaler.unscale_(self.optimizer)
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.scaler.step(self.optimizer)
+                        self.scaler.update()
+                    else:
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.optimizer.step()
+
+                    self.scheduler.step()
+                    self.optimizer.zero_grad(set_to_none=True)
+                    self.global_step += 1
+
+                    if self.is_main_process:
+                        avg_loss = epoch_loss / max(num_batches, 1)
+                        pbar.set_postfix(
+                            {
+                                "gstep": self.global_step,
+                                "loss": f"{avg_loss:.4f}",
+                            }
+                        )
+
+                    if self.global_step % self.config.logging_steps == 0 and self.is_main_process:
+                        lr_mem = self._get_group_lr("memory_module")
+                        lr_pre = self._get_group_lr("pretrained")
+                        if lr_pre is None and self.optimizer.param_groups:
+                            lr_pre = self.optimizer.param_groups[0]["lr"]
+                        grad_note = ""
+                        if self.config.debug_grad_norm and grad_norm is not None:
+                            grad_note = f" | grad_norm={float(grad_norm):.4f}"
+                        if lr_mem is None:
+                            lr_label = f"lr={lr_pre:.2e}" if lr_pre is not None else "lr=NA"
+                            logger.info(
+                                f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                                f"{lr_label}{grad_note}"
+                            )
+                        else:
+                            logger.info(
+                                f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                                f"lr_mem={lr_mem:.2e} | lr_pre={lr_pre:.2e}{grad_note}"
+                            )
+
+                    if self.global_step % self.config.eval_steps == 0:
+                        eval_metrics = self.evaluate()
+                        if self.is_main_process:
+                            logger.info(
+                                f"Step {self.global_step}: "
+                                f"eval_loss={eval_metrics['loss']:.4f}, "
+                                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                            )
+                        self.model.train()
+
+            avg_epoch_loss = epoch_loss / max(num_batches, 1)
+            if self.is_distributed:
+                t = torch.tensor(avg_epoch_loss, device=self.device, dtype=torch.float32)
+                dist.all_reduce(t, op=dist.ReduceOp.SUM)
+                avg_epoch_loss = (t / self.world_size).item()
+
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1} done, avg loss={avg_epoch_loss:.4f}")
+            last_epoch_loss = avg_epoch_loss
+
+            eval_metrics = self.evaluate()
+            if self.is_main_process:
+                logger.info(
+                    f"[EPOCH {epoch + 1} EVAL] "
+                    f"eval_loss={eval_metrics['loss']:.4f}, "
+                    f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                    f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                )
+            self._append_eval_metrics(
+                eval_metrics,
+                phase="epoch",
+                epoch=int(epoch + 1),
+                train_avg_loss=avg_epoch_loss,
+            )
+            self.model.train()
+
+        if self.is_main_process:
+            logger.info("Training done, final evaluation")
+
+        final_eval = self.evaluate(print_examples=int(self.config.final_eval_print_examples))
+        if self.is_main_process:
+            ppl = float(math.exp(min(20.0, final_eval["loss"])))
+            logger.info(
+                f"[FINAL EVAL] loss={final_eval['loss']:.4f}, ppl≈{ppl:.3f}, "
+                f"em_acc={final_eval['em_acc'] * 100:.2f}%, "
+                f"tok_acc={final_eval['tok_acc'] * 100:.2f}%"
+            )
+            logger.info("Saving final checkpoint")
+        self._append_eval_metrics(
+            final_eval,
+            phase="final",
+            epoch=int(self.config.num_epochs),
+            train_avg_loss=last_epoch_loss,
+        )
+        self.save_final_checkpoint()
+
+    @torch.no_grad()
+    def evaluate(self, print_examples: int = 0) -> Dict[str, float]:
+        self.model.eval()
+        total_loss = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_batches = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+
+        total_tok_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_tok_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_topk_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_topk_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        printed = 0
+
+        for batch in self.eval_dataloader:
+            batch = {k: v.to(self.device) for k, v in batch.items()}
+            amp_enabled = self.config.fp16 or self.config.bf16
+            amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+            with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                outputs = self.model(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                    labels=batch["labels"],
+                    return_pred_tokens=True,
+                    topk=int(self.config.eval_topk) if self.config.eval_topk else 0,
+                )
+
+            if torch.isfinite(outputs["loss"]):
+                total_loss += outputs["loss"].detach().float()
+                total_batches += 1.0
+
+            pred_ids = outputs.get("pred_ids", None)
+            target_ids = outputs.get("target_ids", None)
+            lengths = outputs.get("target_lengths", None)
+            topk_correct = outputs.get("topk_correct", None)
+            topk_total = outputs.get("topk_total", None)
+            if topk_correct is not None and topk_total is not None:
+                total_topk_correct += topk_correct.detach().float()
+                total_topk_total += topk_total.detach().float()
+            if (
+                pred_ids is not None
+                and target_ids is not None
+                and lengths is not None
+                and pred_ids.ndim == 2
+                and target_ids.ndim == 2
+                and lengths.ndim == 1
+                and pred_ids.shape == target_ids.shape
+                and pred_ids.shape[0] == lengths.shape[0]
+            ):
+                pred_cpu = pred_ids.to("cpu", dtype=torch.long)
+                tgt_cpu = target_ids.to("cpu", dtype=torch.long)
+                len_cpu = lengths.to("cpu", dtype=torch.long)
+
+                for i in range(int(len_cpu.shape[0])):
+                    L = int(len_cpu[i].item())
+                    if L <= 0:
+                        continue
+                    p = pred_cpu[i, :L]
+                    t = tgt_cpu[i, :L]
+
+                    total_tok_correct += torch.tensor(float((p == t).sum().item()), device=self.device, dtype=torch.float32)
+                    total_tok_total += torch.tensor(float(L), device=self.device, dtype=torch.float32)
+
+                    if self.tokenizer is not None:
+                        pred_text = self.tokenizer.decode(p.tolist(), skip_special_tokens=True).strip()
+                        tgt_text = self.tokenizer.decode(t.tolist(), skip_special_tokens=True).strip()
+                        em = float(pred_text == tgt_text)
+                        total_em_correct += torch.tensor(em, device=self.device, dtype=torch.float32)
+                        total_em_total += torch.tensor(1.0, device=self.device, dtype=torch.float32)
+
+                        if self.is_main_process and printed < print_examples:
+                            logger.info(f"[EVAL SAMPLE] pred={repr(pred_text)} | label={repr(tgt_text)} | match={bool(em)}")
+                            printed += 1
+
+        if self.is_distributed:
+            dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_topk_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_topk_total, op=dist.ReduceOp.SUM)
+
+        avg_loss = (total_loss / total_batches.clamp(min=1.0)).item()
+        tok_acc = (total_tok_correct / total_tok_total.clamp(min=1.0)).item()
+        em_acc = (total_em_correct / total_em_total.clamp(min=1.0)).item()
+        topk_acc = (total_topk_correct / total_topk_total.clamp(min=1.0)).item()
+        if self.is_main_process:
+            if self.config.debug_eval_stats:
+                logger.info(
+                    "[EVAL DEBUG] total_batches="
+                    f"{float(total_batches.item()):.0f}, total_tok_total={float(total_tok_total.item()):.0f}, "
+                    f"total_em_total={float(total_em_total.item()):.0f}, "
+                    f"total_topk_total={float(total_topk_total.item()):.0f}"
+                )
+                if total_tok_total.item() == 0:
+                    logger.warning("[EVAL DEBUG] No answer tokens found in eval set; acc will be 0.")
+            logger.info(f"[EVAL METRIC] token_acc(answer-only) = {tok_acc * 100:.2f}%")
+            logger.info(f"[EVAL METRIC] EM/acc(answer-only) = {em_acc * 100:.2f}%")
+            if self.config.eval_topk and self.config.eval_topk > 0:
+                logger.info(f"[EVAL METRIC] top{int(self.config.eval_topk)}_acc(answer-only) = {topk_acc * 100:.2f}%")
+        return {"loss": avg_loss, "tok_acc": tok_acc, "em_acc": em_acc, "topk_acc": topk_acc}
+
+    def _append_eval_metrics(
+        self,
+        metrics: Dict[str, float],
+        *,
+        phase: str,
+        epoch: Optional[int],
+        train_avg_loss: Optional[float],
+    ) -> None:
+        if not self.is_main_process:
+            return
+        os.makedirs(self.config.output_dir, exist_ok=True)
+        record = {
+            "phase": phase,
+            "epoch": epoch,
+            "global_step": int(self.global_step),
+            "train_avg_loss": None if train_avg_loss is None else float(train_avg_loss),
+            "eval_loss": float(metrics.get("loss", 0.0)),
+            "em_acc_pct": float(metrics.get("em_acc", 0.0) * 100.0),
+            "tok_acc_pct": float(metrics.get("tok_acc", 0.0) * 100.0),
+        }
+        metrics_path = os.path.join(self.config.output_dir, "eval_metrics.jsonl")
+        with open(metrics_path, "a") as f:
+            f.write(json.dumps(record) + "\n")
+
+    def save_final_checkpoint(self):
+        ckpt_path = os.path.join(self.config.output_dir, self.config.final_ckpt_name)
+        base_model = unwrap_model(self.model)
+        memory_sd = {
+            name: p.detach().cpu()
+            for name, p in base_model.named_parameters()
+            if ("neural_memory" in name) or ("mem_gate" in name)
+        }
+
+        if is_fsdp_model(self.model) and len(memory_sd) == 0:
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+            full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+            with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                full_sd = self.model.state_dict()
+            memory_sd = {k: v for k, v in full_sd.items() if ("neural_memory" in k) or ("mem_gate" in k)}
+
+        if self.is_main_process:
+            torch.save(
+                {"memory_state_dict": memory_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                ckpt_path,
+            )
+            logger.info(f"Saved memory checkpoint: {ckpt_path}")
+        if self.is_distributed:
+            dist.barrier()
+
+        if self.config.save_full_checkpoint:
+            full_ckpt_path = os.path.join(self.config.output_dir, self.config.final_full_ckpt_name)
+            if is_fsdp_model(self.model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    full_sd = self.model.state_dict()
+            else:
+                full_sd = unwrap_model(self.model).state_dict()
+
+            if self.is_main_process:
+                torch.save(
+                    {"model_state_dict": full_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                    full_ckpt_path,
+                )
+                logger.info(f"Saved full checkpoint: {full_ckpt_path}")
+            if self.is_distributed:
+                dist.barrier()
+
+
+def main():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fsdp", action="store_true")
+    parser.add_argument("--eval_only", action="store_true")
+    parser.add_argument("--ckpt_path", type=str, default=None)
+    parser.add_argument("--max_eval_samples", type=int, default=None)
+    parser.add_argument("--max_samples", type=int, default=None)
+    parser.add_argument("--max_length", type=int, default=None)
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--eval_steps", type=int, default=None)
+    parser.add_argument("--eval_topk", type=int, default=0)
+    parser.add_argument("--batch_size", type=int, default=None)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--memory_layer_stride", type=int, default=None)
+    parser.add_argument("--no_memory", action="store_true")
+    parser.add_argument("--gradient_checkpointing", action="store_true")
+    parser.add_argument("--no_chunkwise_backward", action="store_true")
+    parser.add_argument("--log_every_batches", type=int, default=80)
+    parser.add_argument("--label_prefix_tokens", type=int, default=0)
+    parser.add_argument(
+        "--no_detach_mem_state",
+        action="store_true",
+        help="Do not detach memory state across chunks (allows cross-chunk gradients)",
+    )
+    parser.add_argument("--debug_data_samples", type=int, default=0)
+    parser.add_argument("--debug_label_batches", type=int, default=0)
+    parser.add_argument("--debug_eval_stats", action="store_true")
+    parser.add_argument("--debug_grad_norm", action="store_true")
+    args = parser.parse_args()
+
+    config = TrainingConfig()
+    if args.fsdp:
+        config.use_fsdp = True
+    if args.no_memory:
+        config.use_memory = False
+    if args.max_samples is not None:
+        config.max_samples = args.max_samples
+    if args.max_length is not None:
+        config.max_length = int(args.max_length)
+    if args.output_dir is not None:
+        config.output_dir = args.output_dir
+    elif not config.use_memory:
+        config.output_dir = "./outputs/qwen_babilong_no_memory"
+    if args.num_epochs is not None:
+        config.num_epochs = args.num_epochs
+    if args.eval_steps is not None:
+        config.eval_steps = args.eval_steps
+    if args.eval_topk is not None:
+        config.eval_topk = int(args.eval_topk)
+    if args.batch_size is not None:
+        config.batch_size = int(args.batch_size)
+    if args.gradient_accumulation_steps is not None:
+        config.gradient_accumulation_steps = int(args.gradient_accumulation_steps)
+    if args.chunk_size is not None:
+        config.chunk_size = int(args.chunk_size)
+    if args.memory_layer_stride is not None:
+        config.memory_layer_stride = int(args.memory_layer_stride)
+    if args.gradient_checkpointing:
+        config.gradient_checkpointing = True
+    if args.no_chunkwise_backward:
+        config.chunkwise_backward = False
+    if args.label_prefix_tokens is not None:
+        config.label_prefix_tokens = int(args.label_prefix_tokens)
+    if args.no_detach_mem_state:
+        config.detach_mem_state = False  # 允许记忆梯度跨chunk传播
+    if args.log_every_batches is not None:
+        config.log_every_batches = int(args.log_every_batches)
+        ga = max(int(config.gradient_accumulation_steps), 1)
+        config.logging_steps = max(1, math.ceil(config.log_every_batches / ga))
+    if args.debug_data_samples is not None:
+        config.debug_data_samples = int(args.debug_data_samples)
+    if args.debug_label_batches is not None:
+        config.debug_label_batches = int(args.debug_label_batches)
+    if args.debug_eval_stats:
+        config.debug_eval_stats = True
+    if args.debug_grad_norm:
+        config.debug_grad_norm = True
+
+    is_distributed, rank, local_rank, world_size = init_distributed()
+    is_main = (rank == 0)
+
+    if config.use_fsdp and config.chunkwise_backward:
+        if is_main:
+            logger.warning("chunkwise_backward is incompatible with FSDP; disabling it.")
+        config.chunkwise_backward = False
+
+    if is_distributed and (not config.use_fsdp) and config.gradient_checkpointing:
+        config.gradient_checkpointing = False
+        if is_main:
+            logger.warning("gradient_checkpointing is unstable with DDP here; disabling it.")
+
+    if is_distributed and (not config.use_fsdp) and config.chunkwise_backward:
+        if is_main:
+            logger.info("DDP chunkwise backward enabled via per-chunk forward/backward.")
+
+    if is_distributed and (not config.use_fsdp):
+        if not config.ddp_find_unused_parameters:
+            config.ddp_find_unused_parameters = True
+            if is_main:
+                logger.warning("Enabling DDP find_unused_parameters to avoid unused grad errors.")
+
+    torch.manual_seed(config.seed + rank)
+
+    if torch.cuda.is_available():
+        device = torch.device(f"cuda:{local_rank}" if is_distributed else "cuda")
+    else:
+        device = torch.device("cpu")
+
+    if torch.cuda.is_available() and config.bf16:
+        bf16_supported = False
+        try:
+            bf16_supported = torch.cuda.is_bf16_supported()
+        except Exception:
+            bf16_supported = False
+        if not bf16_supported:
+            if is_main:
+                logger.warning("bf16 not supported on this GPU/runtime; falling back to fp16.")
+            config.bf16 = False
+            if not config.fp16:
+                config.fp16 = True
+
+    if torch.cuda.is_available() and getattr(config, "use_tf32", False):
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        try:
+            torch.set_float32_matmul_precision("high")
+        except Exception:
+            pass
+
+    if is_main:
+        logger.info("=" * 60)
+        logger.info("Qwen3-4B + Titans training (DDP/FSDP)")
+        logger.info("=" * 60)
+        logger.info(f"distributed={is_distributed}, world_size={world_size}, use_fsdp={config.use_fsdp}")
+        logger.info(f"mode={'EVAL_ONLY' if args.eval_only else 'TRAIN'}")
+        logger.info(f"model_path={config.model_path}")
+        logger.info(f"data_path={config.data_path}")
+        logger.info(f"output_dir={config.output_dir}")
+        logger.info(f"max_samples={config.max_samples}")
+        logger.info(f"max_length={config.max_length}")
+        logger.info(f"chunk_size={config.chunk_size}")
+        logger.info(f"use_memory={config.use_memory}")
+        if config.use_memory:
+            logger.info(f"memory_layer_stride={config.memory_layer_stride}")
+        logger.info(f"chunkwise_backward={config.chunkwise_backward}")
+        logger.info(f"label_prefix_tokens={config.label_prefix_tokens}")
+        logger.info(f"detach_mem_state={config.detach_mem_state}")
+        if config.eval_topk:
+            logger.info(f"eval_topk={config.eval_topk}")
+
+    tokenizer = AutoTokenizer.from_pretrained(config.model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # disable flash-attn / torchao / torchvision detection
+    try:
+        import transformers
+        from transformers.utils import import_utils as _import_utils
+
+        def _disabled(*args, **kwargs):
+            return False
+
+        _import_utils.is_flash_attn_2_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_flash_attn_2_available"):
+            transformers.utils.is_flash_attn_2_available = _disabled
+
+        _import_utils.is_torchao_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_torchao_available"):
+            transformers.utils.is_torchao_available = _disabled
+
+        _import_utils.is_torchvision_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_torchvision_available"):
+            transformers.utils.is_torchvision_available = _disabled
+    except Exception as e:
+        logger.warning(f"Disable checks failed (ignored): {e}")
+
+    torch_dtype = torch.bfloat16 if config.bf16 else (torch.float16 if config.fp16 else torch.float32)
+
+    qwen_model = AutoModelForCausalLM.from_pretrained(
+        config.model_path,
+        torch_dtype=torch_dtype,
+        device_map=None,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        low_cpu_mem_usage=True,
+    )
+    qwen_model.to(device)
+    qwen_model.config.use_cache = False
+    if config.gradient_checkpointing and hasattr(qwen_model, "gradient_checkpointing_enable"):
+        qwen_model.gradient_checkpointing_enable()
+
+    train_dataset = BABILongDataset(
+        config.data_path,
+        tokenizer,
+        max_length=config.max_length,
+        answer_reserve_tokens=config.answer_reserve_tokens,
+        label_prefix_tokens=config.label_prefix_tokens,
+        max_samples=config.max_samples,
+    )
+
+    train_size = int(0.9 * len(train_dataset))
+    eval_size = len(train_dataset) - train_size
+    train_dataset, eval_dataset = torch.utils.data.random_split(
+        train_dataset,
+        [train_size, eval_size],
+        generator=torch.Generator().manual_seed(config.seed),
+    )
+
+    if is_main and config.debug_data_samples > 0:
+        log_dataset_debug_stats(train_dataset, tokenizer, "train", config.debug_data_samples)
+        log_dataset_debug_stats(eval_dataset, tokenizer, "eval", config.debug_data_samples)
+
+    train_sampler = None
+    eval_sampler = None
+    if is_distributed:
+        from torch.utils.data.distributed import DistributedSampler
+        train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True, seed=config.seed)
+        eval_sampler = DistributedSampler(eval_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=config.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset,
+        batch_size=config.batch_size,
+        shuffle=False,
+        sampler=eval_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+
+    model = QwenTitansForBABILong(qwen_model, config)
+    model.to(device)
+
+    if is_distributed:
+        if config.use_fsdp:
+            from functools import partial
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, MixedPrecision
+            from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+            from transformers.models.qwen3.modeling_qwen3 import Qwen3DecoderLayer
+
+            mp_policy = MixedPrecision(param_dtype=torch_dtype, reduce_dtype=torch_dtype, buffer_dtype=torch_dtype)
+            auto_wrap = partial(transformer_auto_wrap_policy, transformer_layer_cls={Qwen3DecoderLayer, QwenDecoderLayerWithTitansMemory})
+
+            model = FSDP(
+                model,
+                auto_wrap_policy=auto_wrap,
+                mixed_precision=mp_policy,
+                device_id=torch.cuda.current_device(),
+                use_orig_params=config.fsdp_use_orig_params,
+                ignored_modules=model.get_memory_modules(),
+            )
+        else:
+            model = DDP(
+                model,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=config.ddp_find_unused_parameters,
+            )
+            if config.gradient_checkpointing:
+                try:
+                    model._set_static_graph()
+                    if is_main:
+                        logger.warning("DDP static graph enabled for gradient checkpointing.")
+                except Exception as e:
+                    if is_main:
+                        logger.warning(f"DDP static graph enable failed (ignored): {e}")
+
+    trainer = Trainer(
+        model=model,
+        train_dataloader=train_dataloader,
+        eval_dataloader=eval_dataloader,
+        config=config,
+        rank=rank,
+        world_size=world_size,
+        is_distributed=is_distributed,
+        tokenizer=tokenizer,
+    )
+
+    if args.eval_only:
+        ckpt_path = args.ckpt_path or os.path.join(config.output_dir, config.final_ckpt_name)
+        if is_main:
+            logger.info(f"eval_only: loading checkpoint: {ckpt_path}")
+        ckpt = torch.load(ckpt_path, map_location="cpu")
+        has_full = isinstance(ckpt, dict) and ("model_state_dict" in ckpt)
+        if has_full:
+            full_sd = ckpt["model_state_dict"]
+            if is_fsdp_model(model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    sd_to_load = full_sd if is_main else {}
+                    model.load_state_dict(sd_to_load, strict=False)
+            else:
+                unwrap_model(model).load_state_dict(full_sd, strict=False)
+
+        memory_sd = ckpt.get("memory_state_dict", ckpt if isinstance(ckpt, dict) else {})
+        memory_sd = {k: v for k, v in memory_sd.items() if ("neural_memory" in k) or ("mem_gate" in k)}
+        if len(memory_sd) > 0:
+            if is_fsdp_model(model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    sd_to_load = memory_sd if is_main else {}
+                    model.load_state_dict(sd_to_load, strict=False)
+            else:
+                unwrap_model(model).load_state_dict(memory_sd, strict=False)
+
+        eval_metrics = trainer.evaluate()
+        if is_main:
+            ppl = float(math.exp(min(20.0, eval_metrics["loss"])))
+            logger.info(
+                f"[EVAL] loss={eval_metrics['loss']:.4f}, ppl≈{ppl:.3f}, "
+                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+            )
+        cleanup_distributed()
+        return
+
+    trainer.train()
+    cleanup_distributed()
+
+
+if __name__ == "__main__":
+    main()

examples/train_qwen_titans_babilong_v3.py

@@ -0,0 +1,1683 @@
+"""
+Qwen3 + Titans Deep Integration (v3) - BABILong QA1 (32k)
+
+Key improvements over v1/v2:
+1. Deep Attention Integration: Memory participates in attention K/V computation
+2. Cross-chunk gradient flow: Support detach_mem_state=False for better long-term learning
+3. Memory-Augmented Attention: Memory as additional context source
+4. Dual-path architecture: Both attention-level and layer-level memory integration
+5. Better memory state management with optional gradient flow
+"""
+
+import os
+import sys
+
+# =============================================================================
+# CRITICAL: Disable torchao BEFORE importing transformers to avoid version conflicts
+# =============================================================================
+os.environ["TRANSFORMERS_NO_TORCHAO"] = "1"
+
+# Mock torchao to prevent import errors
+class _MockTorchAO:
+    def __getattr__(self, name):
+        return _MockTorchAO()
+    def __call__(self, *args, **kwargs):
+        return _MockTorchAO()
+
+sys.modules['torchao'] = _MockTorchAO()
+sys.modules['torchao.quantization'] = _MockTorchAO()
+
+import json
+import math
+import argparse
+import logging
+import weakref
+from contextlib import nullcontext
+from dataclasses import dataclass, asdict, field
+from typing import Optional, Dict, Any, List, Tuple, Callable
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from torch.nn.parallel import DistributedDataParallel as DDP
+from tqdm import tqdm
+
+from einops import rearrange, repeat
+
+# add repo root to sys.path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Titans components
+from titans_pytorch import NeuralMemory, MemoryMLP
+from titans_pytorch.neural_memory import NeuralMemState
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+@dataclass
+class TrainingConfig:
+    # paths
+    model_path: str = "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554"
+    data_path: str = "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json"
+    output_dir: str = "./outputs/qwen_titans_babilong_v3"
+
+    # training
+    num_epochs: int = 10  # Aligned with v1/v2
+    batch_size: int = 1  # Reduced for 32k length
+    gradient_accumulation_steps: int = 16  # Increased to maintain effective batch size
+    max_grad_norm: float = 1.0
+
+    # learning rates (separate for different components)
+    lr_memory: float = 1e-4
+    lr_memory_attention: float = 5e-5  # NEW: for attention-integrated memory
+    lr_pretrained: float = 5e-6
+    weight_decay: float = 0.01
+    warmup_steps: int = 100
+
+    # streaming / memory
+    chunk_size: int = 4096  # Reduced for memory efficiency
+    use_memory: bool = True
+    memory_chunk_size: int = 128
+    memory_batch_size: int = 128
+    memory_heads: int = 8
+    memory_dim_head: int = 64
+    memory_depth: int = 1  # Same as v1/v2
+    memory_layer_stride: int = 8  # Same as v1/v2
+    memory_fp32: bool = True
+
+    # NEW: v3 specific options
+    detach_mem_state: bool = True  # True for memory efficiency, set False for gradient flow
+    deep_memory_integration: bool = False  # Disable by default for memory efficiency
+    memory_as_context: bool = False  # Disable by default for memory efficiency
+    num_memory_tokens: int = 16  # Number of virtual memory tokens in attention
+    memory_gate_bias: float = -2.0  # Initial bias for memory gate (conservative)
+    use_momentum: bool = True
+    momentum_order: int = 1
+
+    # gradient flow control
+    gradient_checkpoint_memory: bool = False  # Checkpoint memory computation
+    cross_chunk_gradient_steps: int = 2  # Allow gradient through N chunks back
+
+    # evaluation / logging
+    eval_steps: int = 200
+    eval_topk: int = 0
+    logging_steps: int = 10
+    log_every_batches: int = 80
+    final_eval_print_examples: int = 10
+    debug_data_samples: int = 0
+    debug_label_batches: int = 0
+    debug_eval_stats: bool = False
+    debug_grad_norm: bool = False
+
+    # precision
+    bf16: bool = True
+    fp16: bool = False
+    use_tf32: bool = True
+    gradient_checkpointing: bool = False
+    chunkwise_backward: bool = True
+
+    # data
+    max_length: int = 32768
+    answer_reserve_tokens: int = 64
+    label_prefix_tokens: int = 0
+    max_samples: Optional[int] = 500  # Same as v1/v2 experiments (450 train, 50 eval)
+
+    # distributed
+    use_fsdp: bool = False
+    fsdp_use_orig_params: bool = True
+    ddp_find_unused_parameters: bool = False
+
+    # checkpoint
+    save_full_checkpoint: bool = True
+    final_ckpt_name: str = "final_memory_checkpoint.pt"
+    final_full_ckpt_name: str = "final_full_checkpoint.pt"
+
+    seed: int = 42
+
+
+# =============================================================================
+# Dataset
+# =============================================================================
+
+class BABILongDataset(Dataset):
+    def __init__(
+        self,
+        data_path: str,
+        tokenizer,
+        max_length: int = 32768,
+        answer_reserve_tokens: int = 64,
+        label_prefix_tokens: int = 0,
+        max_samples: Optional[int] = None,
+    ):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.answer_reserve_tokens = answer_reserve_tokens
+        self.label_prefix_tokens = int(label_prefix_tokens)
+
+        logger.info(f"Loading dataset: {data_path}")
+        with open(data_path, "r") as f:
+            self.data = json.load(f)
+
+        if max_samples:
+            self.data = self.data[:max_samples]
+
+        logger.info(f"Dataset size: {len(self.data)}")
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        item = self.data[idx]
+        text = f"{item['input']}\n\nQuestion: {item['question']}\nAnswer:"
+        target = item["target"]
+
+        pad_id = self.tokenizer.pad_token_id or 0
+        reserve = int(self.answer_reserve_tokens)
+
+        prompt_ids = self.tokenizer(
+            text,
+            max_length=max(self.max_length - reserve, 1),
+            truncation=True,
+            add_special_tokens=True,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        answer_ids = self.tokenizer(
+            f" {target}",
+            add_special_tokens=False,
+            return_tensors="pt",
+        ).input_ids.squeeze(0)
+
+        available = max(self.max_length - prompt_ids.numel(), 0)
+        answer_ids = answer_ids[:available]
+
+        input_ids = torch.cat([prompt_ids, answer_ids], dim=0)[: self.max_length]
+
+        labels = torch.full_like(input_ids, fill_value=-100)
+        if answer_ids.numel() > 0:
+            start = prompt_ids.numel()
+            end = min(start + answer_ids.numel(), labels.numel())
+            labels[start:end] = input_ids[start:end]
+            if self.label_prefix_tokens > 0:
+                prefix = min(start, self.label_prefix_tokens)
+                if prefix > 0:
+                    labels[start - prefix:start] = input_ids[start - prefix:start]
+
+        seq_len = input_ids.numel()
+        if seq_len < self.max_length:
+            pad_len = self.max_length - seq_len
+            input_ids = F.pad(input_ids, (0, pad_len), value=int(pad_id))
+            labels = F.pad(labels, (0, pad_len), value=-100)
+            attention_mask = torch.cat(
+                [torch.ones(seq_len, dtype=torch.long), torch.zeros(pad_len, dtype=torch.long)],
+                dim=0,
+            )
+        else:
+            attention_mask = torch.ones(self.max_length, dtype=torch.long)
+
+        return {
+            "input_ids": input_ids.to(dtype=torch.long),
+            "labels": labels.to(dtype=torch.long),
+            "attention_mask": attention_mask,
+        }
+
+
+def collate_fn(batch):
+    keys = batch[0].keys()
+    return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys}
+
+
+# =============================================================================
+# Memory-Augmented Attention Module (NEW in v3)
+# =============================================================================
+
+class MemoryAugmentedAttention(nn.Module):
+    """
+    Deep integration of memory into attention mechanism.
+    Memory provides additional context that enhances hidden states.
+    """
+    def __init__(
+        self,
+        hidden_size: int,
+        num_attention_heads: int,
+        num_memory_tokens: int = 16,
+        memory_dim_head: int = 64,
+        memory_fp32: bool = True,
+        gate_bias: float = -2.0,
+    ):
+        super().__init__()
+        self.hidden_size = hidden_size
+        self.num_heads = num_attention_heads
+        self.head_dim = hidden_size // num_attention_heads
+        self.memory_fp32 = memory_fp32
+
+        # Memory transformation: projects and mixes memory with hidden states
+        self.memory_transform = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size),
+        )
+
+        # Learnable memory gate per head
+        self.memory_gate = nn.Parameter(torch.full((num_attention_heads, 1, 1), gate_bias))
+
+        # Output projection
+        self.memory_output_proj = nn.Linear(hidden_size, hidden_size, bias=False)
+        nn.init.zeros_(self.memory_output_proj.weight)  # Start as identity
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        memory_context: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: [batch, seq_len, hidden_size] - current hidden states
+            memory_context: [batch, seq_len, hidden_size] - retrieved memory
+            attention_mask: optional attention mask
+        Returns:
+            enhanced_hidden: [batch, seq_len, hidden_size]
+        """
+        batch_size, seq_len, _ = hidden_states.shape
+
+        # Transform memory
+        mem_transformed = self.memory_transform(memory_context)
+
+        # Reshape to multi-head format for gating
+        mem_heads = rearrange(mem_transformed, 'b n (h d) -> b h n d', h=self.num_heads)
+
+        # Compute memory gate (sigmoid for smooth interpolation)
+        gate = torch.sigmoid(self.memory_gate)  # [num_heads, 1, 1]
+
+        # Apply gated memory enhancement
+        mem_contribution = mem_heads * gate
+        mem_contribution = rearrange(mem_contribution, 'b h n d -> b n (h d)')
+
+        # Project and add to hidden states
+        enhanced = hidden_states + self.memory_output_proj(mem_contribution)
+
+        return enhanced
+
+
+# =============================================================================
+# Deep Memory Layer (v3 - integrates memory at multiple levels)
+# =============================================================================
+
+class QwenDecoderLayerWithDeepMemory(nn.Module):
+    """
+    v3: Deep integration of Titans memory into Qwen decoder layer.
+
+    Key differences from v1/v2:
+    1. Memory participates in attention computation (not just post-processing)
+    2. Support for cross-chunk gradient flow
+    3. Dual-path architecture: attention-level + layer-level memory
+    4. Better memory state management
+    """
+    def __init__(
+        self,
+        base_layer: nn.Module,
+        layer_idx: int,
+        *,
+        hidden_size: int,
+        num_attention_heads: int,
+        chunk_size: int,
+        batch_size: int,
+        dim_head: int,
+        num_heads: int,
+        memory_depth: int,
+        memory_fp32: bool,
+        detach_mem_state: bool,
+        deep_integration: bool,
+        memory_as_context: bool,
+        num_memory_tokens: int,
+        memory_gate_bias: float,
+        use_momentum: bool,
+        momentum_order: int,
+        parent_model: Optional[nn.Module] = None,
+    ):
+        super().__init__()
+        self.layer = base_layer
+        self.layer_idx = layer_idx
+        self.memory_fp32 = memory_fp32
+        self.detach_mem_state = bool(detach_mem_state)
+        self.deep_integration = deep_integration
+        self.memory_as_context = memory_as_context
+        self.memory_state: Optional[NeuralMemState] = None
+        self.parent_model_ref = weakref.ref(parent_model) if parent_model is not None else None
+
+        # Chunk counter for gradient flow control
+        self._chunk_counter = 0
+        self._gradient_steps_back = 2  # Allow gradient through 2 chunks
+
+        # Core Neural Memory module
+        memory_model = MemoryMLP(
+            dim=dim_head,
+            depth=memory_depth,
+            expansion_factor=2.0,
+        )
+
+        self.neural_memory = NeuralMemory(
+            dim=hidden_size,
+            chunk_size=chunk_size,
+            batch_size=batch_size,
+            dim_head=dim_head,
+            heads=num_heads,
+            model=memory_model,
+            momentum=use_momentum,
+            momentum_order=momentum_order,
+            qk_rmsnorm=True,
+            pre_rmsnorm=True,
+            default_step_transform_max_lr=1e-2,
+            init_adaptive_step_bias=-4.0,  # Slightly higher than v1/v2 for faster adaptation
+            max_grad_norm=1.0,
+            spectral_norm_surprises=True,
+            use_accelerated_scan=False,
+        )
+
+        # Layer-level memory gate (similar to v1/v2)
+        self.mem_gate = nn.Sequential(
+            nn.Linear(hidden_size * 2, hidden_size),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size),
+            nn.Sigmoid(),
+        )
+        # Initialize gate to be conservative
+        nn.init.zeros_(self.mem_gate[-2].weight)
+        nn.init.constant_(self.mem_gate[-2].bias, memory_gate_bias)
+
+        # NEW: Deep attention integration
+        if deep_integration:
+            self.memory_attention = MemoryAugmentedAttention(
+                hidden_size=hidden_size,
+                num_attention_heads=num_attention_heads,
+                num_memory_tokens=num_memory_tokens,
+                memory_dim_head=dim_head,
+                memory_fp32=memory_fp32,
+                gate_bias=memory_gate_bias,
+            )
+        else:
+            self.memory_attention = None
+
+        # NEW: Pre-attention memory projection (for memory-as-context)
+        if memory_as_context:
+            self.memory_context_proj = nn.Sequential(
+                nn.Linear(hidden_size, hidden_size),
+                nn.SiLU(),
+                nn.Linear(hidden_size, hidden_size),
+            )
+            nn.init.zeros_(self.memory_context_proj[-1].weight)
+            nn.init.zeros_(self.memory_context_proj[-1].bias)
+        else:
+            self.memory_context_proj = None
+
+        # Move to appropriate device/dtype
+        try:
+            layer_device = next(base_layer.parameters()).device
+            layer_dtype = next(base_layer.parameters()).dtype
+        except StopIteration:
+            layer_device = None
+            layer_dtype = None
+
+        if layer_device is not None:
+            mem_dtype = torch.float32 if memory_fp32 else layer_dtype
+            self.neural_memory = self.neural_memory.to(device=layer_device, dtype=mem_dtype)
+            if layer_dtype is not None:
+                self.mem_gate = self.mem_gate.to(device=layer_device, dtype=layer_dtype)
+                if self.memory_attention is not None:
+                    self.memory_attention = self.memory_attention.to(device=layer_device, dtype=layer_dtype)
+                if self.memory_context_proj is not None:
+                    self.memory_context_proj = self.memory_context_proj.to(device=layer_device, dtype=layer_dtype)
+
+    def reset_memory_state(self):
+        self.memory_state = None
+        self._chunk_counter = 0
+
+    def set_gradient_steps_back(self, steps: int):
+        """Control how many chunks back gradient can flow."""
+        self._gradient_steps_back = steps
+
+    def _get_store_mask(self, hidden_states: torch.Tensor) -> Optional[torch.Tensor]:
+        parent_model = self.parent_model_ref() if self.parent_model_ref is not None else None
+        if parent_model is None or not hasattr(parent_model, "_mem_store_mask"):
+            return None
+        store_mask = getattr(parent_model, "_mem_store_mask")
+        if store_mask is None:
+            return None
+        store_mask = store_mask.to(device=hidden_states.device).bool()
+        if store_mask.shape[:2] != hidden_states.shape[:2]:
+            return None
+        return store_mask
+
+    def _should_detach_state(self) -> bool:
+        """Determine if memory state should be detached based on chunk counter."""
+        if self.detach_mem_state:
+            return True
+        # Allow gradient flow through recent chunks
+        self._chunk_counter += 1
+        return self._chunk_counter > self._gradient_steps_back
+
+    def forward(self, *args, **kwargs):
+        # Get original layer output
+        outputs = self.layer(*args, **kwargs)
+
+        if isinstance(outputs, (tuple, list)):
+            hidden_states = outputs[0]
+            rest = outputs[1:]
+        else:
+            hidden_states = outputs
+            rest = None
+
+        # Get store mask
+        full_store_mask = self._get_store_mask(hidden_states)
+
+        # Prepare memory input
+        mem_inp = hidden_states.float() if self.memory_fp32 else hidden_states
+
+        # Prepare store sequence and mask
+        store_seq = None
+        store_mask = full_store_mask
+        if store_mask is not None:
+            store_seq = mem_inp
+            # Skip first token if not the first chunk
+            if store_mask.shape[1] > 0 and not store_mask[:, 0].any():
+                store_seq = store_seq[:, 1:]
+                store_mask = store_mask[:, 1:]
+
+            # Align to chunk size
+            store_chunk = self.neural_memory.store_chunk_size
+            remainder = store_seq.shape[1] % store_chunk
+            if remainder != 0:
+                store_seq = store_seq[:, :-remainder]
+                store_mask = store_mask[:, :-remainder]
+
+            if store_mask is not None and store_seq is not None:
+                if store_mask.shape[1] != store_seq.shape[1]:
+                    min_len = min(store_mask.shape[1], store_seq.shape[1])
+                    store_seq = store_seq[:, :min_len]
+                    store_mask = store_mask[:, :min_len]
+
+            if store_seq.shape[1] == 0:
+                store_seq = None
+                store_mask = None
+
+        # Memory computation context
+        mem_ctx = (
+            torch.amp.autocast(device_type=hidden_states.device.type, enabled=False)
+            if self.memory_fp32
+            else nullcontext()
+        )
+
+        # Determine if we should detach memory state
+        should_detach = self._should_detach_state()
+
+        with mem_ctx:
+            retrieved, next_state = self.neural_memory(
+                mem_inp,
+                store_seq=store_seq,
+                state=self.memory_state,
+                store_mask=store_mask,
+                detach_mem_state=should_detach,
+            )
+        self.memory_state = next_state
+
+        if retrieved is not None:
+            retrieved = retrieved.to(dtype=hidden_states.dtype)
+
+            # Apply store mask to retrieved memory
+            if full_store_mask is not None and full_store_mask.shape[:2] == retrieved.shape[:2]:
+                retrieved = retrieved * full_store_mask.unsqueeze(-1).to(dtype=retrieved.dtype)
+
+            # ===== v3 Deep Integration =====
+
+            # Path 1: Memory-augmented attention (if enabled)
+            if self.memory_attention is not None:
+                hidden_states = self.memory_attention(
+                    hidden_states=hidden_states,
+                    memory_context=retrieved,
+                    attention_mask=None,  # Could pass attention mask if needed
+                )
+
+            # Path 2: Memory as context projection (if enabled)
+            if self.memory_context_proj is not None:
+                context_enhancement = self.memory_context_proj(retrieved)
+                hidden_states = hidden_states + context_enhancement
+
+            # Path 3: Layer-level gated fusion (always active)
+            gate = self.mem_gate(torch.cat([hidden_states, retrieved], dim=-1))
+            hidden_states = hidden_states + gate * retrieved
+
+        if rest is None:
+            return hidden_states
+        return (hidden_states, *rest)
+
+
+# =============================================================================
+# Main Model Wrapper
+# =============================================================================
+
+class QwenTitansForBABILongV3(nn.Module):
+    """
+    v3: Qwen3 with deep Titans memory integration.
+    """
+    def __init__(self, qwen_model, config: TrainingConfig):
+        super().__init__()
+        self.qwen = qwen_model
+        self.config = config
+        self.hidden_size = qwen_model.config.hidden_size
+        self.num_attention_heads = qwen_model.config.num_attention_heads
+        self.use_memory = bool(getattr(config, "use_memory", True))
+
+        if self.use_memory:
+            self.memory_layer_stride = int(getattr(config, "memory_layer_stride", 6))
+            self.memory_layer_indices = [
+                idx for idx in range(len(self.qwen.model.layers))
+                if idx % self.memory_layer_stride == 0
+            ]
+
+            for layer_idx in self.memory_layer_indices:
+                base_layer = self.qwen.model.layers[layer_idx]
+                wrapped = QwenDecoderLayerWithDeepMemory(
+                    base_layer,
+                    layer_idx=layer_idx,
+                    hidden_size=self.hidden_size,
+                    num_attention_heads=self.num_attention_heads,
+                    chunk_size=config.memory_chunk_size,
+                    batch_size=config.memory_batch_size,
+                    dim_head=config.memory_dim_head,
+                    num_heads=config.memory_heads,
+                    memory_depth=config.memory_depth,
+                    memory_fp32=config.memory_fp32,
+                    detach_mem_state=config.detach_mem_state,
+                    deep_integration=config.deep_memory_integration,
+                    memory_as_context=config.memory_as_context,
+                    num_memory_tokens=config.num_memory_tokens,
+                    memory_gate_bias=config.memory_gate_bias,
+                    use_momentum=config.use_momentum,
+                    momentum_order=config.momentum_order,
+                    parent_model=self.qwen.model,
+                )
+                self.qwen.model.layers[layer_idx] = wrapped
+        else:
+            self.memory_layer_stride = 0
+            self.memory_layer_indices = []
+
+        if self.use_memory:
+            logger.info("[QwenTitansForBABILongV3] Initialized with DEEP memory integration")
+            logger.info(f"  - hidden_size: {self.hidden_size}")
+            logger.info(f"  - num_attention_heads: {self.num_attention_heads}")
+            logger.info(f"  - chunk_size: {config.chunk_size}")
+            logger.info(f"  - memory_layer_stride: {self.memory_layer_stride}")
+            logger.info(f"  - memory_layers: {self.memory_layer_indices}")
+            logger.info(f"  - deep_memory_integration: {config.deep_memory_integration}")
+            logger.info(f"  - memory_as_context: {config.memory_as_context}")
+            logger.info(f"  - detach_mem_state: {config.detach_mem_state}")
+            logger.info(f"  - cross_chunk_gradient_steps: {config.cross_chunk_gradient_steps}")
+        else:
+            logger.info("[QwenTitansForBABILongV3] Initialized (memory disabled)")
+
+        self._memory_layers = [
+            layer for layer in self.qwen.model.layers
+            if isinstance(layer, QwenDecoderLayerWithDeepMemory)
+        ]
+        self.qwen.model._mem_store_mask = None
+
+        # Set gradient steps for cross-chunk gradient flow
+        for layer in self._memory_layers:
+            layer.set_gradient_steps_back(config.cross_chunk_gradient_steps)
+
+    def _split_into_chunks(self, tensor, chunk_size):
+        seq_len = tensor.shape[1]
+        chunks = []
+        for start in range(0, seq_len, chunk_size):
+            end = min(start + chunk_size, seq_len)
+            chunks.append((start, end, tensor[:, start:end]))
+        return chunks
+
+    def reset_memory_states(self):
+        for layer in self._memory_layers:
+            layer.reset_memory_state()
+
+    def _set_mem_store_mask(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_mask: Optional[torch.Tensor],
+        chunk_start: int,
+    ) -> None:
+        if not self.use_memory:
+            self.qwen.model._mem_store_mask = None
+            return
+        if chunk_mask is None:
+            if chunk_start > 0:
+                store_mask = torch.ones_like(chunk_ids, dtype=torch.bool)
+                store_mask[:, 0] = False
+            else:
+                store_mask = None
+        else:
+            store_mask = chunk_mask.to(device=chunk_ids.device).bool()
+            if chunk_start > 0:
+                store_mask[:, 0] = False
+        self.qwen.model._mem_store_mask = store_mask
+
+    def get_memory_modules(self) -> List[nn.Module]:
+        if not self._memory_layers:
+            return []
+        modules = []
+        for layer in self._memory_layers:
+            modules.append(layer.neural_memory)
+            modules.append(layer.mem_gate)
+            if layer.memory_attention is not None:
+                modules.append(layer.memory_attention)
+            if layer.memory_context_proj is not None:
+                modules.append(layer.memory_context_proj)
+        return modules
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_pred_tokens: bool = False,
+        topk: int = 0,
+        chunk_start: Optional[int] = None,
+        chunk_end: Optional[int] = None,
+        reset_mem_state: bool = False,
+    ) -> Dict[str, torch.Tensor]:
+
+        # Single chunk forward (for chunkwise backward)
+        if chunk_start is not None or chunk_end is not None:
+            start = 0 if chunk_start is None else int(chunk_start)
+            end = int(chunk_end) if chunk_end is not None else None
+            return self._forward_single_chunk(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                labels=labels,
+                chunk_start=start,
+                chunk_end=end,
+                reset_mem_state=reset_mem_state,
+            )
+
+        # Full sequence forward
+        batch_size, seq_len = input_ids.shape
+        chunk_size = self.config.chunk_size
+        chunks = self._split_into_chunks(input_ids, chunk_size)
+
+        self.reset_memory_states()
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+        topk_correct = None
+        topk_total = None
+
+        pred_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+        target_tokens_by_sample: List[List[int]] = [[] for _ in range(batch_size)]
+
+        if topk and topk > 0:
+            device = input_ids.device
+            topk_correct = torch.tensor(0.0, device=device, dtype=torch.float32)
+            topk_total = torch.tensor(0.0, device=device, dtype=torch.float32)
+
+        for start, end, _ in chunks:
+            proc_start = max(0, start - 1)
+            chunk_ids = input_ids[:, proc_start:end]
+            chunk_labels = labels[:, proc_start:end] if labels is not None else None
+            chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+            self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+            hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+            if self.use_memory:
+                self.qwen.model._mem_store_mask = None
+
+            if chunk_labels is not None and (chunk_labels != -100).any():
+                chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+                shift_hidden = hidden_full[:, :-1, :].contiguous()
+                shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+                valid = shift_labels != -100
+                if valid.any():
+                    hs = shift_hidden[valid]
+                    targets = shift_labels[valid]
+
+                    hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                    logits = self.qwen.lm_head(hs)
+                    logits = logits.float()
+                    logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                    targets = targets.to(device=logits.device)
+
+                    chunk_loss_sum = loss_fct_sum(logits, targets)
+                    if total_loss_sum is None:
+                        total_loss_sum = chunk_loss_sum
+                    else:
+                        total_loss_sum = total_loss_sum + chunk_loss_sum
+                    total_loss_tokens += targets.numel()
+
+                    if topk and topk > 0:
+                        k = min(int(topk), logits.shape[-1])
+                        topk_ids = torch.topk(logits, k=k, dim=-1).indices
+                        correct = (topk_ids == targets.unsqueeze(-1)).any(dim=-1)
+                        topk_correct = topk_correct + correct.float().sum()
+                        topk_total = topk_total + torch.tensor(float(targets.numel()), device=topk_total.device)
+
+                    if return_pred_tokens:
+                        idx = valid.nonzero(as_tuple=False)
+                        pred_flat = torch.argmax(logits, dim=-1).detach().to("cpu", dtype=torch.long).tolist()
+                        tgt_flat = targets.detach().to("cpu", dtype=torch.long).tolist()
+                        b_idx_flat = idx[:, 0].detach().to("cpu", dtype=torch.long).tolist()
+
+                        for i, b_idx in enumerate(b_idx_flat):
+                            pred_tokens_by_sample[b_idx].append(int(pred_flat[i]))
+                            target_tokens_by_sample[b_idx].append(int(tgt_flat[i]))
+
+        if total_loss_sum is None or total_loss_tokens == 0:
+            device = next(self.qwen.parameters()).device
+            loss = torch.zeros((), device=device, dtype=torch.float32)
+        else:
+            loss = total_loss_sum / total_loss_tokens
+
+        out: Dict[str, torch.Tensor] = {"loss": loss}
+        if return_pred_tokens:
+            lengths = torch.tensor([len(x) for x in target_tokens_by_sample], dtype=torch.long)
+            max_len = int(lengths.max().item()) if lengths.numel() > 0 else 0
+            if max_len > 0:
+                pred_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                tgt_mat = torch.full((batch_size, max_len), -1, dtype=torch.long)
+                for b in range(batch_size):
+                    L = int(lengths[b].item())
+                    if L > 0:
+                        pred_mat[b, :L] = torch.tensor(pred_tokens_by_sample[b], dtype=torch.long)
+                        tgt_mat[b, :L] = torch.tensor(target_tokens_by_sample[b], dtype=torch.long)
+            else:
+                pred_mat = torch.empty((batch_size, 0), dtype=torch.long)
+                tgt_mat = torch.empty((batch_size, 0), dtype=torch.long)
+            out["pred_ids"] = pred_mat
+            out["target_ids"] = tgt_mat
+            out["target_lengths"] = lengths
+        if topk and topk > 0 and topk_correct is not None and topk_total is not None:
+            out["topk_correct"] = topk_correct
+            out["topk_total"] = topk_total
+        return out
+
+    def _forward_single_chunk(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor],
+        labels: Optional[torch.Tensor],
+        chunk_start: int,
+        chunk_end: Optional[int],
+        reset_mem_state: bool,
+    ) -> Dict[str, torch.Tensor]:
+        if reset_mem_state:
+            self.reset_memory_states()
+
+        seq_len = input_ids.shape[1]
+        end = chunk_end if chunk_end is not None else min(chunk_start + self.config.chunk_size, seq_len)
+        end = min(int(end), seq_len)
+        start = max(0, int(chunk_start))
+
+        proc_start = max(0, start - 1)
+        chunk_ids = input_ids[:, proc_start:end]
+        chunk_labels = labels[:, proc_start:end] if labels is not None else None
+        chunk_mask = attention_mask[:, proc_start:end] if attention_mask is not None else None
+
+        self._set_mem_store_mask(chunk_ids, chunk_mask, start)
+        hidden_full = self._process_chunk(chunk_ids, chunk_mask)
+        if self.use_memory:
+            self.qwen.model._mem_store_mask = None
+
+        loss_fct_sum = nn.CrossEntropyLoss(reduction="sum")
+        total_loss_sum = None
+        total_loss_tokens = 0
+
+        if chunk_labels is not None and (chunk_labels != -100).any():
+            chunk_labels_local = chunk_labels.to(device=hidden_full.device)
+            shift_hidden = hidden_full[:, :-1, :].contiguous()
+            shift_labels = chunk_labels_local[:, 1:].contiguous()
+
+            valid = shift_labels != -100
+            if valid.any():
+                hs = shift_hidden[valid]
+                targets = shift_labels[valid]
+
+                hs = torch.nan_to_num(hs.float(), nan=0.0, posinf=0.0, neginf=0.0)
+                logits = self.qwen.lm_head(hs)
+                logits = logits.float()
+                logits = torch.nan_to_num(logits, nan=0.0, posinf=0.0, neginf=0.0)
+                targets = targets.to(device=logits.device)
+
+                total_loss_sum = loss_fct_sum(logits, targets)
+                total_loss_tokens = targets.numel()
+
+        if total_loss_sum is None:
+            total_loss_sum = (hidden_full.float().sum() * 0.0)
+
+        return {
+            "loss_sum": total_loss_sum,
+            "loss_tokens": total_loss_tokens,
+            "has_grad": True,
+        }
+
+    def _process_chunk(
+        self,
+        chunk_ids: torch.Tensor,
+        chunk_attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if hasattr(self.qwen.model, "embed_tokens"):
+            token_embeds = self.qwen.model.embed_tokens(chunk_ids)
+        else:
+            token_embeds = self.qwen.get_input_embeddings()(chunk_ids)
+
+        outputs = self.qwen.model(
+            inputs_embeds=token_embeds,
+            attention_mask=chunk_attention_mask,
+            use_cache=False,
+            output_hidden_states=False,
+            return_dict=True,
+        )
+        return outputs.last_hidden_state
+
+    def get_param_groups(self, config: TrainingConfig):
+        """
+        v3: Three parameter groups with different learning rates.
+        """
+        memory_core_params = []  # Neural memory core
+        memory_attention_params = []  # Memory-augmented attention
+        pretrained_params = []
+
+        for name, param in self.named_parameters():
+            if not param.requires_grad:
+                continue
+            if "neural_memory" in name or "mem_gate" in name:
+                memory_core_params.append(param)
+            elif "memory_attention" in name or "memory_context_proj" in name:
+                memory_attention_params.append(param)
+            else:
+                pretrained_params.append(param)
+
+        param_groups = []
+        if len(memory_core_params) > 0:
+            param_groups.append({
+                "params": memory_core_params,
+                "lr": config.lr_memory,
+                "weight_decay": config.weight_decay,
+                "name": "memory_core"
+            })
+        if len(memory_attention_params) > 0:
+            param_groups.append({
+                "params": memory_attention_params,
+                "lr": config.lr_memory_attention,
+                "weight_decay": config.weight_decay,
+                "name": "memory_attention"
+            })
+        if len(pretrained_params) > 0:
+            param_groups.append({
+                "params": pretrained_params,
+                "lr": config.lr_pretrained,
+                "weight_decay": config.weight_decay,
+                "name": "pretrained"
+            })
+
+        logger.info(f"Param groups: memory_core={len(memory_core_params)}, "
+                   f"memory_attention={len(memory_attention_params)}, "
+                   f"pretrained={len(pretrained_params)}")
+        return param_groups
+
+
+# =============================================================================
+# Distributed Training Utilities
+# =============================================================================
+
+def init_distributed() -> tuple:
+    if "RANK" not in os.environ or "WORLD_SIZE" not in os.environ:
+        return False, 0, 0, 1
+
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    local_rank = int(os.environ.get("LOCAL_RANK", 0))
+
+    if not dist.is_available():
+        raise RuntimeError("torch.distributed not available")
+
+    if not dist.is_initialized():
+        dist.init_process_group(backend="nccl", init_method="env://")
+
+    torch.cuda.set_device(local_rank)
+    return True, rank, local_rank, world_size
+
+
+def cleanup_distributed():
+    if dist.is_available() and dist.is_initialized():
+        dist.barrier()
+        dist.destroy_process_group()
+
+
+def unwrap_model(model: nn.Module) -> nn.Module:
+    if hasattr(model, "module"):
+        return model.module
+    if hasattr(model, "_fsdp_wrapped_module"):
+        wrapped = getattr(model, "_fsdp_wrapped_module", None)
+        if wrapped is not None and hasattr(wrapped, "module"):
+            return wrapped.module
+    return model
+
+
+def is_fsdp_model(model: nn.Module) -> bool:
+    try:
+        from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+        return isinstance(model, FSDP)
+    except Exception:
+        return False
+
+
+# =============================================================================
+# Trainer
+# =============================================================================
+
+class Trainer:
+    def __init__(
+        self,
+        model: QwenTitansForBABILongV3,
+        train_dataloader: DataLoader,
+        eval_dataloader: DataLoader,
+        config: TrainingConfig,
+        rank: int = 0,
+        world_size: int = 1,
+        is_distributed: bool = False,
+        tokenizer=None,
+    ):
+        self.model = model
+        self.train_dataloader = train_dataloader
+        self.eval_dataloader = eval_dataloader
+        self.config = config
+        self.device = next(model.parameters()).device
+        self.rank = rank
+        self.world_size = world_size
+        self.is_distributed = is_distributed
+        self.is_main_process = (rank == 0)
+        self.tokenizer = tokenizer
+
+        base_model = unwrap_model(self.model)
+        param_groups = base_model.get_param_groups(config)
+        self.optimizer = AdamW(param_groups)
+
+        total_steps = math.ceil(
+            (len(train_dataloader) * config.num_epochs) / max(config.gradient_accumulation_steps, 1)
+        )
+        self.scheduler = CosineAnnealingLR(self.optimizer, T_max=total_steps, eta_min=1e-7)
+
+        self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+        self.global_step = 0
+
+    def _get_group_lr(self, group_name: str) -> Optional[float]:
+        for group in self.optimizer.param_groups:
+            if group.get("name") == group_name:
+                return group.get("lr")
+        return None
+
+    def train(self):
+        self.model.train()
+        if self.is_main_process:
+            logger.info("=" * 60)
+            logger.info("Starting v3 training with deep memory integration")
+            logger.info("=" * 60)
+
+        last_epoch_loss = None
+        for epoch in range(self.config.num_epochs):
+            sampler = getattr(self.train_dataloader, "sampler", None)
+            if sampler is not None and hasattr(sampler, "set_epoch"):
+                sampler.set_epoch(epoch)
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1}/{self.config.num_epochs}")
+
+            epoch_loss = 0.0
+            num_batches = 0
+
+            pbar = self.train_dataloader
+            if self.is_main_process:
+                pbar = tqdm(
+                    self.train_dataloader,
+                    desc=f"Epoch {epoch + 1}/{self.config.num_epochs}",
+                    leave=False,
+                    dynamic_ncols=True,
+                )
+
+            for step, batch in enumerate(pbar):
+                batch = {k: v.to(self.device) for k, v in batch.items()}
+
+                ga = max(self.config.gradient_accumulation_steps, 1)
+                sync_gradients = ((step + 1) % ga == 0)
+                amp_enabled = self.config.fp16 or self.config.bf16
+                amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+
+                with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                    if self.config.chunkwise_backward:
+                        labels = batch.get("labels")
+                        if labels is not None:
+                            total_tokens = int((labels[:, 1:] != -100).sum().item())
+                        else:
+                            total_tokens = 0
+                        loss_scale = 0.0 if total_tokens == 0 else (1.0 / total_tokens / ga)
+
+                        seq_len = batch["input_ids"].shape[1]
+                        chunk_size = int(self.config.chunk_size)
+                        chunk_ranges = [
+                            (start, min(start + chunk_size, seq_len))
+                            for start in range(0, seq_len, chunk_size)
+                        ]
+                        raw_loss_sum = None
+
+                        for idx, (start, end) in enumerate(chunk_ranges):
+                            is_last_chunk = (idx == len(chunk_ranges) - 1)
+                            sync_chunk = sync_gradients and is_last_chunk
+                            chunk_ctx = (
+                                self.model.no_sync
+                                if (self.is_distributed and not sync_chunk)
+                                else nullcontext
+                            )
+                            with chunk_ctx():
+                                outputs = self.model(
+                                    input_ids=batch["input_ids"],
+                                    attention_mask=batch["attention_mask"],
+                                    labels=labels,
+                                    chunk_start=start,
+                                    chunk_end=end,
+                                    reset_mem_state=(idx == 0),
+                                )
+                                chunk_loss_sum = outputs["loss_sum"]
+                                if raw_loss_sum is None:
+                                    raw_loss_sum = chunk_loss_sum.detach()
+                                else:
+                                    raw_loss_sum = raw_loss_sum + chunk_loss_sum.detach()
+
+                                scaled_loss = chunk_loss_sum * float(loss_scale)
+                                if self.config.fp16:
+                                    self.scaler.scale(scaled_loss).backward()
+                                else:
+                                    scaled_loss.backward()
+
+                        if raw_loss_sum is None or total_tokens == 0:
+                            raw_loss = torch.zeros((), device=self.device, dtype=torch.float32)
+                        else:
+                            raw_loss = raw_loss_sum / total_tokens
+                        loss = raw_loss / ga
+                    else:
+                        ctx = self.model.no_sync if (self.is_distributed and not sync_gradients) else nullcontext
+                        with ctx():
+                            outputs = self.model(
+                                input_ids=batch["input_ids"],
+                                attention_mask=batch["attention_mask"],
+                                labels=batch["labels"],
+                            )
+                            raw_loss = outputs["loss"]
+                            loss = raw_loss / ga
+
+                        if self.config.fp16:
+                            self.scaler.scale(loss).backward()
+                        else:
+                            loss.backward()
+
+                epoch_loss += raw_loss.detach().float().item()
+                num_batches += 1
+
+                if sync_gradients:
+                    grad_norm = None
+                    if self.config.fp16:
+                        self.scaler.unscale_(self.optimizer)
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.scaler.step(self.optimizer)
+                        self.scaler.update()
+                    else:
+                        grad_norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.config.max_grad_norm)
+                        self.optimizer.step()
+
+                    self.scheduler.step()
+                    self.optimizer.zero_grad(set_to_none=True)
+                    self.global_step += 1
+
+                    if self.is_main_process:
+                        avg_loss = epoch_loss / max(num_batches, 1)
+                        pbar.set_postfix({"gstep": self.global_step, "loss": f"{avg_loss:.4f}"})
+
+                    if self.global_step % self.config.logging_steps == 0 and self.is_main_process:
+                        lr_mem = self._get_group_lr("memory_core") or 0.0
+                        lr_mem_attn = self._get_group_lr("memory_attention") or 0.0
+                        lr_pre = self._get_group_lr("pretrained") or 0.0
+                        grad_note = ""
+                        if self.config.debug_grad_norm and grad_norm is not None:
+                            grad_note = f" | grad_norm={float(grad_norm):.4f}"
+                        logger.info(
+                            f"Step {self.global_step} | loss={epoch_loss / max(num_batches, 1):.4f} | "
+                            f"lr_mem={lr_mem:.2e} | lr_mem_attn={lr_mem_attn:.2e} | lr_pre={lr_pre:.2e}{grad_note}"
+                        )
+
+                    if self.global_step % self.config.eval_steps == 0:
+                        eval_metrics = self.evaluate()
+                        if self.is_main_process:
+                            logger.info(
+                                f"Step {self.global_step}: "
+                                f"eval_loss={eval_metrics['loss']:.4f}, "
+                                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                            )
+                        self.model.train()
+
+            avg_epoch_loss = epoch_loss / max(num_batches, 1)
+            if self.is_distributed:
+                t = torch.tensor(avg_epoch_loss, device=self.device, dtype=torch.float32)
+                dist.all_reduce(t, op=dist.ReduceOp.SUM)
+                avg_epoch_loss = (t / self.world_size).item()
+
+            if self.is_main_process:
+                logger.info(f"Epoch {epoch + 1} done, avg loss={avg_epoch_loss:.4f}")
+            last_epoch_loss = avg_epoch_loss
+
+            eval_metrics = self.evaluate()
+            if self.is_main_process:
+                logger.info(
+                    f"[EPOCH {epoch + 1} EVAL] "
+                    f"eval_loss={eval_metrics['loss']:.4f}, "
+                    f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                    f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+                )
+            self._append_eval_metrics(
+                eval_metrics,
+                phase="epoch",
+                epoch=int(epoch + 1),
+                train_avg_loss=avg_epoch_loss,
+            )
+            self.model.train()
+
+        if self.is_main_process:
+            logger.info("Training done, final evaluation")
+
+        final_eval = self.evaluate(print_examples=int(self.config.final_eval_print_examples))
+        if self.is_main_process:
+            ppl = float(math.exp(min(20.0, final_eval["loss"])))
+            logger.info(
+                f"[FINAL EVAL] loss={final_eval['loss']:.4f}, ppl={ppl:.3f}, "
+                f"em_acc={final_eval['em_acc'] * 100:.2f}%, "
+                f"tok_acc={final_eval['tok_acc'] * 100:.2f}%"
+            )
+            logger.info("Saving final checkpoint")
+        self._append_eval_metrics(
+            final_eval,
+            phase="final",
+            epoch=int(self.config.num_epochs),
+            train_avg_loss=last_epoch_loss,
+        )
+        self.save_final_checkpoint()
+
+    @torch.no_grad()
+    def evaluate(self, print_examples: int = 0) -> Dict[str, float]:
+        self.model.eval()
+        total_loss = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_batches = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+
+        total_tok_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_tok_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_correct = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        total_em_total = torch.tensor(0.0, device=self.device, dtype=torch.float32)
+        printed = 0
+
+        for batch in self.eval_dataloader:
+            batch = {k: v.to(self.device) for k, v in batch.items()}
+            amp_enabled = self.config.fp16 or self.config.bf16
+            amp_dtype = torch.float16 if self.config.fp16 else torch.bfloat16
+            with torch.amp.autocast(device_type=self.device.type, enabled=amp_enabled, dtype=amp_dtype):
+                outputs = self.model(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                    labels=batch["labels"],
+                    return_pred_tokens=True,
+                    topk=int(self.config.eval_topk) if self.config.eval_topk else 0,
+                )
+
+            if torch.isfinite(outputs["loss"]):
+                total_loss += outputs["loss"].detach().float()
+                total_batches += 1.0
+
+            pred_ids = outputs.get("pred_ids", None)
+            target_ids = outputs.get("target_ids", None)
+            lengths = outputs.get("target_lengths", None)
+
+            if (
+                pred_ids is not None
+                and target_ids is not None
+                and lengths is not None
+                and pred_ids.ndim == 2
+                and target_ids.ndim == 2
+                and lengths.ndim == 1
+                and pred_ids.shape == target_ids.shape
+                and pred_ids.shape[0] == lengths.shape[0]
+            ):
+                pred_cpu = pred_ids.to("cpu", dtype=torch.long)
+                tgt_cpu = target_ids.to("cpu", dtype=torch.long)
+                len_cpu = lengths.to("cpu", dtype=torch.long)
+
+                for i in range(int(len_cpu.shape[0])):
+                    L = int(len_cpu[i].item())
+                    if L <= 0:
+                        continue
+                    p = pred_cpu[i, :L]
+                    t = tgt_cpu[i, :L]
+
+                    total_tok_correct += torch.tensor(float((p == t).sum().item()), device=self.device, dtype=torch.float32)
+                    total_tok_total += torch.tensor(float(L), device=self.device, dtype=torch.float32)
+
+                    if self.tokenizer is not None:
+                        pred_text = self.tokenizer.decode(p.tolist(), skip_special_tokens=True).strip()
+                        tgt_text = self.tokenizer.decode(t.tolist(), skip_special_tokens=True).strip()
+                        em = float(pred_text == tgt_text)
+                        total_em_correct += torch.tensor(em, device=self.device, dtype=torch.float32)
+                        total_em_total += torch.tensor(1.0, device=self.device, dtype=torch.float32)
+
+                        if self.is_main_process and printed < print_examples:
+                            logger.info(f"[EVAL SAMPLE] pred={repr(pred_text)} | label={repr(tgt_text)} | match={bool(em)}")
+                            printed += 1
+
+        if self.is_distributed:
+            dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_tok_total, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_correct, op=dist.ReduceOp.SUM)
+            dist.all_reduce(total_em_total, op=dist.ReduceOp.SUM)
+
+        avg_loss = (total_loss / total_batches.clamp(min=1.0)).item()
+        tok_acc = (total_tok_correct / total_tok_total.clamp(min=1.0)).item()
+        em_acc = (total_em_correct / total_em_total.clamp(min=1.0)).item()
+
+        return {"loss": avg_loss, "tok_acc": tok_acc, "em_acc": em_acc}
+
+    def _append_eval_metrics(
+        self,
+        metrics: Dict[str, float],
+        *,
+        phase: str,
+        epoch: Optional[int],
+        train_avg_loss: Optional[float],
+    ) -> None:
+        if not self.is_main_process:
+            return
+        os.makedirs(self.config.output_dir, exist_ok=True)
+        record = {
+            "phase": phase,
+            "epoch": epoch,
+            "global_step": int(self.global_step),
+            "train_avg_loss": None if train_avg_loss is None else float(train_avg_loss),
+            "eval_loss": float(metrics.get("loss", 0.0)),
+            "em_acc_pct": float(metrics.get("em_acc", 0.0) * 100.0),
+            "tok_acc_pct": float(metrics.get("tok_acc", 0.0) * 100.0),
+        }
+        metrics_path = os.path.join(self.config.output_dir, "eval_metrics.jsonl")
+        with open(metrics_path, "a") as f:
+            f.write(json.dumps(record) + "\n")
+
+    def save_final_checkpoint(self):
+        ckpt_path = os.path.join(self.config.output_dir, self.config.final_ckpt_name)
+        base_model = unwrap_model(self.model)
+
+        # Save memory-related parameters
+        memory_sd = {
+            name: p.detach().cpu()
+            for name, p in base_model.named_parameters()
+            if ("neural_memory" in name) or ("mem_gate" in name) or
+               ("memory_attention" in name) or ("memory_context_proj" in name)
+        }
+
+        if is_fsdp_model(self.model) and len(memory_sd) == 0:
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+            full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+            with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                full_sd = self.model.state_dict()
+            memory_sd = {
+                k: v for k, v in full_sd.items()
+                if ("neural_memory" in k) or ("mem_gate" in k) or
+                   ("memory_attention" in k) or ("memory_context_proj" in k)
+            }
+
+        if self.is_main_process:
+            torch.save(
+                {"memory_state_dict": memory_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                ckpt_path,
+            )
+            logger.info(f"Saved memory checkpoint: {ckpt_path}")
+        if self.is_distributed:
+            dist.barrier()
+
+        if self.config.save_full_checkpoint:
+            full_ckpt_path = os.path.join(self.config.output_dir, self.config.final_full_ckpt_name)
+            if is_fsdp_model(self.model):
+                from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType, FullStateDictConfig
+                full_cfg = FullStateDictConfig(offload_to_cpu=True, rank0_only=True)
+                with FSDP.state_dict_type(self.model, StateDictType.FULL_STATE_DICT, full_cfg):
+                    full_sd = self.model.state_dict()
+            else:
+                full_sd = unwrap_model(self.model).state_dict()
+
+            if self.is_main_process:
+                torch.save(
+                    {"model_state_dict": full_sd, "global_step": self.global_step, "config": asdict(self.config)},
+                    full_ckpt_path,
+                )
+                logger.info(f"Saved full checkpoint: {full_ckpt_path}")
+            if self.is_distributed:
+                dist.barrier()
+
+
+# =============================================================================
+# Main
+# =============================================================================
+
+def main():
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    parser = argparse.ArgumentParser(description="Qwen3 + Titans v3 Deep Integration Training")
+    parser.add_argument("--fsdp", action="store_true")
+    parser.add_argument("--eval_only", action="store_true")
+    parser.add_argument("--ckpt_path", type=str, default=None)
+    parser.add_argument("--max_samples", type=int, default=None)
+    parser.add_argument("--max_length", type=int, default=None)
+    parser.add_argument("--output_dir", type=str, default=None)
+    parser.add_argument("--num_epochs", type=int, default=None)
+    parser.add_argument("--eval_steps", type=int, default=None)
+    parser.add_argument("--batch_size", type=int, default=None)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=None)
+    parser.add_argument("--chunk_size", type=int, default=None)
+    parser.add_argument("--memory_layer_stride", type=int, default=None)
+    parser.add_argument("--no_memory", action="store_true")
+    parser.add_argument("--gradient_checkpointing", action="store_true")
+    parser.add_argument("--no_chunkwise_backward", action="store_true")
+
+    # v3 specific arguments
+    parser.add_argument("--detach_mem_state", action="store_true",
+                       help="Detach memory state (disable cross-chunk gradients)")
+    parser.add_argument("--no_deep_integration", action="store_true",
+                       help="Disable deep attention integration")
+    parser.add_argument("--no_memory_as_context", action="store_true",
+                       help="Disable memory-as-context projection")
+    parser.add_argument("--cross_chunk_gradient_steps", type=int, default=None,
+                       help="Number of chunks to allow gradient flow through")
+    parser.add_argument("--memory_depth", type=int, default=None)
+    parser.add_argument("--num_memory_tokens", type=int, default=None)
+
+    parser.add_argument("--debug_grad_norm", action="store_true")
+    args = parser.parse_args()
+
+    config = TrainingConfig()
+
+    # Apply arguments
+    if args.fsdp:
+        config.use_fsdp = True
+    if args.no_memory:
+        config.use_memory = False
+    if args.max_samples is not None:
+        config.max_samples = args.max_samples
+    if args.max_length is not None:
+        config.max_length = int(args.max_length)
+    if args.output_dir is not None:
+        config.output_dir = args.output_dir
+    elif not config.use_memory:
+        config.output_dir = "./outputs/qwen_babilong_no_memory_v3"
+    if args.num_epochs is not None:
+        config.num_epochs = args.num_epochs
+    if args.eval_steps is not None:
+        config.eval_steps = args.eval_steps
+    if args.batch_size is not None:
+        config.batch_size = int(args.batch_size)
+    if args.gradient_accumulation_steps is not None:
+        config.gradient_accumulation_steps = int(args.gradient_accumulation_steps)
+    if args.chunk_size is not None:
+        config.chunk_size = int(args.chunk_size)
+    if args.memory_layer_stride is not None:
+        config.memory_layer_stride = int(args.memory_layer_stride)
+    if args.gradient_checkpointing:
+        config.gradient_checkpointing = True
+    if args.no_chunkwise_backward:
+        config.chunkwise_backward = False
+
+    # v3 specific
+    if args.detach_mem_state:
+        config.detach_mem_state = True
+    if args.no_deep_integration:
+        config.deep_memory_integration = False
+    if args.no_memory_as_context:
+        config.memory_as_context = False
+    if args.cross_chunk_gradient_steps is not None:
+        config.cross_chunk_gradient_steps = int(args.cross_chunk_gradient_steps)
+    if args.memory_depth is not None:
+        config.memory_depth = int(args.memory_depth)
+    if args.num_memory_tokens is not None:
+        config.num_memory_tokens = int(args.num_memory_tokens)
+    if args.debug_grad_norm:
+        config.debug_grad_norm = True
+
+    is_distributed, rank, local_rank, world_size = init_distributed()
+    is_main = (rank == 0)
+
+    if config.use_fsdp and config.chunkwise_backward:
+        if is_main:
+            logger.warning("chunkwise_backward is incompatible with FSDP; disabling it.")
+        config.chunkwise_backward = False
+
+    if is_distributed and (not config.use_fsdp) and config.gradient_checkpointing:
+        config.gradient_checkpointing = False
+        if is_main:
+            logger.warning("gradient_checkpointing is unstable with DDP here; disabling it.")
+
+    if is_distributed and (not config.use_fsdp):
+        if not config.ddp_find_unused_parameters:
+            config.ddp_find_unused_parameters = True
+            if is_main:
+                logger.warning("Enabling DDP find_unused_parameters.")
+
+    torch.manual_seed(config.seed + rank)
+
+    if torch.cuda.is_available():
+        device = torch.device(f"cuda:{local_rank}" if is_distributed else "cuda")
+    else:
+        device = torch.device("cpu")
+
+    if torch.cuda.is_available() and config.bf16:
+        bf16_supported = False
+        try:
+            bf16_supported = torch.cuda.is_bf16_supported()
+        except Exception:
+            bf16_supported = False
+        if not bf16_supported:
+            if is_main:
+                logger.warning("bf16 not supported; falling back to fp16.")
+            config.bf16 = False
+            if not config.fp16:
+                config.fp16 = True
+
+    if torch.cuda.is_available() and getattr(config, "use_tf32", False):
+        torch.backends.cuda.matmul.allow_tf32 = True
+        torch.backends.cudnn.allow_tf32 = True
+        try:
+            torch.set_float32_matmul_precision("high")
+        except Exception:
+            pass
+
+    if is_main:
+        logger.info("=" * 70)
+        logger.info("Qwen3-4B + Titans v3 DEEP INTEGRATION Training")
+        logger.info("=" * 70)
+        logger.info(f"distributed={is_distributed}, world_size={world_size}")
+        logger.info(f"model_path={config.model_path}")
+        logger.info(f"data_path={config.data_path}")
+        logger.info(f"output_dir={config.output_dir}")
+        logger.info(f"max_samples={config.max_samples}")
+        logger.info(f"max_length={config.max_length}")
+        logger.info(f"num_epochs={config.num_epochs}")
+        logger.info(f"chunk_size={config.chunk_size}")
+        logger.info(f"use_memory={config.use_memory}")
+        if config.use_memory:
+            logger.info(f"memory_layer_stride={config.memory_layer_stride}")
+            logger.info(f"memory_depth={config.memory_depth}")
+            logger.info(f"deep_memory_integration={config.deep_memory_integration}")
+            logger.info(f"memory_as_context={config.memory_as_context}")
+            logger.info(f"detach_mem_state={config.detach_mem_state}")
+            logger.info(f"cross_chunk_gradient_steps={config.cross_chunk_gradient_steps}")
+            logger.info(f"num_memory_tokens={config.num_memory_tokens}")
+
+    tokenizer = AutoTokenizer.from_pretrained(config.model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Disable flash-attn detection (torchao already disabled at top of file)
+    try:
+        import transformers
+        from transformers.utils import import_utils as _import_utils
+
+        def _disabled(*args, **kwargs):
+            return False
+
+        _import_utils.is_flash_attn_2_available = _disabled
+        if hasattr(transformers, "utils") and hasattr(transformers.utils, "is_flash_attn_2_available"):
+            transformers.utils.is_flash_attn_2_available = _disabled
+        if hasattr(_import_utils, "is_torchao_available"):
+            _import_utils.is_torchao_available = _disabled
+        if hasattr(_import_utils, "is_torchvision_available"):
+            _import_utils.is_torchvision_available = _disabled
+    except Exception as e:
+        if is_main:
+            logger.warning(f"Disable checks failed (ignored): {e}")
+
+    torch_dtype = torch.bfloat16 if config.bf16 else (torch.float16 if config.fp16 else torch.float32)
+
+    qwen_model = AutoModelForCausalLM.from_pretrained(
+        config.model_path,
+        torch_dtype=torch_dtype,
+        device_map=None,
+        trust_remote_code=True,
+        attn_implementation="sdpa",
+        low_cpu_mem_usage=True,
+    )
+    qwen_model.to(device)
+    qwen_model.config.use_cache = False
+    if config.gradient_checkpointing and hasattr(qwen_model, "gradient_checkpointing_enable"):
+        qwen_model.gradient_checkpointing_enable()
+
+    train_dataset = BABILongDataset(
+        config.data_path,
+        tokenizer,
+        max_length=config.max_length,
+        answer_reserve_tokens=config.answer_reserve_tokens,
+        label_prefix_tokens=config.label_prefix_tokens,
+        max_samples=config.max_samples,
+    )
+
+    train_size = int(0.9 * len(train_dataset))
+    eval_size = len(train_dataset) - train_size
+    train_dataset, eval_dataset = torch.utils.data.random_split(
+        train_dataset,
+        [train_size, eval_size],
+        generator=torch.Generator().manual_seed(config.seed),
+    )
+
+    train_sampler = None
+    eval_sampler = None
+    if is_distributed:
+        from torch.utils.data.distributed import DistributedSampler
+        train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True, seed=config.seed)
+        eval_sampler = DistributedSampler(eval_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_dataloader = DataLoader(
+        train_dataset,
+        batch_size=config.batch_size,
+        shuffle=(train_sampler is None),
+        sampler=train_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+    eval_dataloader = DataLoader(
+        eval_dataset,
+        batch_size=config.batch_size,
+        shuffle=False,
+        sampler=eval_sampler,
+        collate_fn=collate_fn,
+        num_workers=0,
+    )
+
+    model = QwenTitansForBABILongV3(qwen_model, config)
+    model.to(device)
+
+    if is_distributed:
+        if config.use_fsdp:
+            from functools import partial
+            from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, MixedPrecision
+            from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
+            from transformers.models.qwen3.modeling_qwen3 import Qwen3DecoderLayer
+
+            mp_policy = MixedPrecision(param_dtype=torch_dtype, reduce_dtype=torch_dtype, buffer_dtype=torch_dtype)
+            auto_wrap = partial(
+                transformer_auto_wrap_policy,
+                transformer_layer_cls={Qwen3DecoderLayer, QwenDecoderLayerWithDeepMemory}
+            )
+
+            model = FSDP(
+                model,
+                auto_wrap_policy=auto_wrap,
+                mixed_precision=mp_policy,
+                device_id=torch.cuda.current_device(),
+                use_orig_params=config.fsdp_use_orig_params,
+                ignored_modules=model.get_memory_modules(),
+            )
+        else:
+            model = DDP(
+                model,
+                device_ids=[local_rank],
+                output_device=local_rank,
+                find_unused_parameters=config.ddp_find_unused_parameters,
+            )
+
+    trainer = Trainer(
+        model=model,
+        train_dataloader=train_dataloader,
+        eval_dataloader=eval_dataloader,
+        config=config,
+        rank=rank,
+        world_size=world_size,
+        is_distributed=is_distributed,
+        tokenizer=tokenizer,
+    )
+
+    if args.eval_only:
+        ckpt_path = args.ckpt_path or os.path.join(config.output_dir, config.final_ckpt_name)
+        if is_main:
+            logger.info(f"eval_only: loading checkpoint: {ckpt_path}")
+        ckpt = torch.load(ckpt_path, map_location="cpu")
+
+        memory_sd = ckpt.get("memory_state_dict", {})
+        if len(memory_sd) > 0:
+            unwrap_model(model).load_state_dict(memory_sd, strict=False)
+
+        eval_metrics = trainer.evaluate()
+        if is_main:
+            ppl = float(math.exp(min(20.0, eval_metrics["loss"])))
+            logger.info(
+                f"[EVAL] loss={eval_metrics['loss']:.4f}, ppl={ppl:.3f}, "
+                f"em_acc={eval_metrics['em_acc'] * 100:.2f}%, "
+                f"tok_acc={eval_metrics['tok_acc'] * 100:.2f}%"
+            )
+        cleanup_distributed()
+        return
+
+    trainer.train()
+    cleanup_distributed()
+
+
+if __name__ == "__main__":
+    main()

outputs/freeze_base_500/eval_metrics.jsonl

@@ -0,0 +1 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 15.339897155761719, "eval_loss": 9.975086212158203, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}

outputs/freeze_base_500_v2/eval_metrics.jsonl

@@ -0,0 +1 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 15.48836898803711, "eval_loss": 10.238042831420898, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}

outputs/freeze_base_500_v4/eval_metrics.jsonl

@@ -0,0 +1 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 15.516389846801758, "eval_loss": 10.93748950958252, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}

outputs/freeze_base_500_v5/eval_metrics.jsonl

@@ -0,0 +1,7 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 15.43581771850586, "eval_loss": 10.169279098510742, "em_acc_pct": 1.9230769947171211, "tok_acc_pct": 1.9230769947171211}
+{"phase": "epoch", "epoch": 2, "global_step": 14, "train_avg_loss": 6.823464870452881, "eval_loss": 4.242016792297363, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}
+{"phase": "epoch", "epoch": 3, "global_step": 21, "train_avg_loss": 2.964919328689575, "eval_loss": 2.7159345149993896, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}
+{"phase": "epoch", "epoch": 4, "global_step": 28, "train_avg_loss": 1.9492820501327515, "eval_loss": 2.363089084625244, "em_acc_pct": 28.846153616905212, "tok_acc_pct": 28.846153616905212}
+{"phase": "epoch", "epoch": 5, "global_step": 35, "train_avg_loss": 1.6384100914001465, "eval_loss": 2.0535738468170166, "em_acc_pct": 26.923078298568726, "tok_acc_pct": 26.923078298568726}
+{"phase": "epoch", "epoch": 6, "global_step": 42, "train_avg_loss": 1.5474846363067627, "eval_loss": 2.0488321781158447, "em_acc_pct": 25.0, "tok_acc_pct": 25.0}
+{"phase": "epoch", "epoch": 7, "global_step": 49, "train_avg_loss": 1.438281774520874, "eval_loss": 2.1996049880981445, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}

outputs/full_finetune_forwardmem_v2/eval_metrics.jsonl

@@ -0,0 +1,4 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 12.47234058380127, "eval_loss": 6.324646949768066, "em_acc_pct": 13.461539149284363, "tok_acc_pct": 13.461539149284363}
+{"phase": "epoch", "epoch": 2, "global_step": 14, "train_avg_loss": 4.019615173339844, "eval_loss": 3.0129523277282715, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}
+{"phase": "epoch", "epoch": 3, "global_step": 21, "train_avg_loss": 2.1279730796813965, "eval_loss": 2.2121071815490723, "em_acc_pct": 28.846153616905212, "tok_acc_pct": 28.846153616905212}
+{"phase": "epoch", "epoch": 4, "global_step": 28, "train_avg_loss": 1.7763179540634155, "eval_loss": 2.294826030731201, "em_acc_pct": 25.0, "tok_acc_pct": 25.0}

outputs/qwen_

@@ -0,0 +1,121 @@
+W0127 11:26:50.717000 3370624 site-packages/torch/distributed/run.py:803] 
+W0127 11:26:50.717000 3370624 site-packages/torch/distributed/run.py:803] *****************************************
+W0127 11:26:50.717000 3370624 site-packages/torch/distributed/run.py:803] Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. 
+W0127 11:26:50.717000 3370624 site-packages/torch/distributed/run.py:803] *****************************************
+2026-01-27 11:26:55,908 - WARNING - chunkwise_backward is incompatible with FSDP; disabling it.
+2026-01-27 11:26:55,909 - INFO - ============================================================
+2026-01-27 11:26:55,909 - INFO - Qwen3-4B + Titans training (DDP/FSDP)
+2026-01-27 11:26:55,909 - INFO - ============================================================
+2026-01-27 11:26:55,909 - INFO - distributed=True, world_size=4, use_fsdp=True
+2026-01-27 11:26:55,909 - INFO - mode=TRAIN
+2026-01-27 11:26:55,909 - INFO - model_path=/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554
+2026-01-27 11:26:55,909 - INFO - data_path=/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json
+2026-01-27 11:26:55,909 - INFO - output_dir=./outputs/qwen_babilong_no_memory
+2026-01-27 11:26:55,909 - INFO - max_samples=2500
+2026-01-27 11:26:55,909 - INFO - max_length=32768
+2026-01-27 11:26:55,909 - INFO - chunk_size=4096
+2026-01-27 11:26:55,909 - INFO - use_memory=False
+2026-01-27 11:26:55,909 - INFO - chunkwise_backward=False
+2026-01-27 11:26:55,909 - INFO - label_prefix_tokens=0
+2026-01-27 11:26:55,909 - INFO - detach_mem_state=True
+
+
+
+
+2026-01-27 11:27:28,081 - INFO - Loading dataset: /data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json
+2026-01-27 11:27:28,095 - INFO - Loading dataset: /data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json
+2026-01-27 11:27:28,096 - INFO - Loading dataset: /data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json
+2026-01-27 11:27:28,097 - INFO - Loading dataset: /data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json
+2026-01-27 11:27:32,272 - INFO - Dataset size: 2500
+2026-01-27 11:27:32,273 - INFO - [QwenTitansForBABILong] Initialized (memory disabled)
+2026-01-27 11:27:32,273 - INFO -   - hidden_size: 2560
+2026-01-27 11:27:32,273 - INFO -   - chunk_size: 4096
+2026-01-27 11:27:32,308 - INFO - Dataset size: 2500
+2026-01-27 11:27:32,309 - INFO - [QwenTitansForBABILong] Initialized (memory disabled)
+2026-01-27 11:27:32,309 - INFO -   - hidden_size: 2560
+2026-01-27 11:27:32,309 - INFO -   - chunk_size: 4096
+2026-01-27 11:27:32,347 - INFO - Param groups: memory=0, pretrained=398
+/root/githubs/titans-pytorch/examples/train_qwen_titans_babilong.py:768: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.
+  self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+2026-01-27 11:27:32,349 - INFO - Start training
+2026-01-27 11:27:32,349 - INFO - Epoch 1/3
+
+/root/githubs/titans-pytorch/examples/train_qwen_titans_babilong.py:768: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.
+  self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+2026-01-27 11:27:32,442 - INFO - Dataset size: 2500
+2026-01-27 11:27:32,444 - INFO - [QwenTitansForBABILong] Initialized (memory disabled)
+2026-01-27 11:27:32,444 - INFO -   - hidden_size: 2560
+2026-01-27 11:27:32,444 - INFO -   - chunk_size: 4096
+2026-01-27 11:27:32,462 - INFO - Dataset size: 2500
+2026-01-27 11:27:32,466 - INFO - [QwenTitansForBABILong] Initialized (memory disabled)
+2026-01-27 11:27:32,466 - INFO -   - hidden_size: 2560
+2026-01-27 11:27:32,466 - INFO -   - chunk_size: 4096
+2026-01-27 11:27:32,519 - INFO - Param groups: memory=0, pretrained=398
+/root/githubs/titans-pytorch/examples/train_qwen_titans_babilong.py:768: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.
+  self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+2026-01-27 11:27:32,544 - INFO - Param groups: memory=0, pretrained=398
+/root/githubs/titans-pytorch/examples/train_qwen_titans_babilong.py:768: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.
+  self.scaler = torch.cuda.amp.GradScaler(enabled=config.fp16)
+
+
+
+Traceback (most recent call last):
+  File "/root/miniforge/lib/python3.12/subprocess.py", line 1990, in _internal_poll
+    pid, sts = _waitpid(self.pid, _WNOHANG)
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/multiprocessing/api.py", line 85, in _terminate_process_handler
+    sigval = signal.Signals(signum)
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+torch.distributed.elastic.multiprocessing.api.SignalException: Process 3370624 got signal: 1
+
+During handling of the above exception, another exception occurred:
+
+Traceback (most recent call last):
+  File "/root/miniforge/bin/torchrun", line 7, in <module>
+    sys.exit(main())
+             ^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/multiprocessing/errors/__init__.py", line 357, in wrapper
+    @wraps(f)
+              
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/run.py", line 936, in main
+    if args.module:
+^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/run.py", line 927, in run
+    cmd_args.append(args.training_script)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/launcher/api.py", line 156, in __call__
+    # entrypoint is a command and ``script.py`` is the python module.
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/launcher/api.py", line 284, in launch_agent
+    rdzv_handler=rdzv_registry.get_rendezvous_handler(rdzv_parameters),
+             ^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/metrics/api.py", line 138, in wrapper
+    raise
+          
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/agent/server/api.py", line 717, in run
+    """Restart (stops, rendezvous, starts) all local workers in the group."""
+                 ^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/agent/server/api.py", line 882, in _invoke_run
+    flakiness = 100.0
+                 ^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/metrics/api.py", line 138, in wrapper
+    raise
+          
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/agent/server/local_elastic_agent.py", line 389, in _monitor_workers
+    
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/multiprocessing/api.py", line 537, in wait
+    "TORCHELASTIC_SIGNALS_TO_HANDLE", "SIGTERM,SIGINT,SIGHUP,SIGQUIT"
+       ^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/multiprocessing/api.py", line 858, in _poll
+    def pids(self) -> dict[int, int]:
+                       ^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/subprocess.py", line 1236, in poll
+    return self._internal_poll()
+           ^^^^^^^^^^^^^^^^^^^^^
+  File "/root/miniforge/lib/python3.12/subprocess.py", line 2004, in _internal_poll
+    self._waitpid_lock.release()
+  File "/root/miniforge/lib/python3.12/site-packages/torch/distributed/elastic/multiprocessing/api.py", line 85, in _terminate_process_handler
+    sigval = signal.Signals(signum)
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+torch.distributed.elastic.multiprocessing.api.SignalException: Process 3370624 got signal: 15
+[W128 06:35:14.145474637 AllocatorConfig.cpp:28] Warning: PYTORCH_CUDA_ALLOC_CONF is deprecated, use PYTORCH_ALLOC_CONF instead (function operator())

outputs/qwen_babilong_no_memory/eval_metrics.jsonl

@@ -0,0 +1,4 @@
+{"phase": "epoch", "epoch": 1, "global_step": 17, "train_avg_loss": 5.368525505065918, "eval_loss": 1.7918081283569336, "em_acc_pct": 29.36508059501648, "tok_acc_pct": 29.36508059501648}
+{"phase": "epoch", "epoch": 2, "global_step": 34, "train_avg_loss": 1.7324517965316772, "eval_loss": 1.672330379486084, "em_acc_pct": 31.34920597076416, "tok_acc_pct": 31.34920597076416}
+{"phase": "epoch", "epoch": 3, "global_step": 51, "train_avg_loss": 1.6770515441894531, "eval_loss": 1.6550273895263672, "em_acc_pct": 30.95238208770752, "tok_acc_pct": 30.95238208770752}
+{"phase": "final", "epoch": 3, "global_step": 51, "train_avg_loss": 1.6770515441894531, "eval_loss": 1.6550273895263672, "em_acc_pct": 30.95238208770752, "tok_acc_pct": 30.95238208770752}

outputs/qwen_baseline_babilong_v4_ga2_4gpu/eval_metrics.jsonl

@@ -0,0 +1,3 @@
+{"phase": "epoch", "epoch": 1, "global_step": 56, "train_avg_loss": 6.816544055938721, "eval_loss": 2.1255977153778076, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}
+{"phase": "epoch", "epoch": 2, "global_step": 112, "train_avg_loss": 1.799431562423706, "eval_loss": 2.0042293071746826, "em_acc_pct": 15.384615957736969, "tok_acc_pct": 15.384615957736969}
+{"phase": "epoch", "epoch": 3, "global_step": 168, "train_avg_loss": 1.7182527780532837, "eval_loss": 2.104633331298828, "em_acc_pct": 15.384615957736969, "tok_acc_pct": 15.384615957736969}

outputs/qwen_baseline_eval/baseline_results_eval.json

@@ -0,0 +1,16 @@
+{
+  "split": "eval",
+  "total_samples": 50,
+  "total_tokens": 50,
+  "loss": 18.038174209594725,
+  "perplexity": 68214943.35535261,
+  "tok_acc_pct": 0.0,
+  "em_acc_pct": 0.0,
+  "config": {
+    "model_path": "/data/huangyifei/huggingface_cache/hub/models--Qwen--Qwen3-4B-Instruct-2507/snapshots/cdbee75f17c01a7cc42f958dc650907174af0554",
+    "data_path": "/data/yty/BABILong/babilong-train-5k-samples/data/qa1/32k.json",
+    "max_samples": 500,
+    "max_length": 32768,
+    "chunk_size": 8192
+  }
+}

outputs/qwen_titans_babilong/eval_metrics.jsonl

@@ -0,0 +1,31 @@
+{"phase": "epoch", "epoch": 1, "global_step": 17, "train_avg_loss": 0.3730778992176056, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 34, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 3, "global_step": 51, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 4, "global_step": 68, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 5, "global_step": 85, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 6, "global_step": 102, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 7, "global_step": 119, "train_avg_loss": 0.3728504478931427, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 0, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "final", "epoch": 1, "global_step": 0, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 2, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 4, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 3, "global_step": 6, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "final", "epoch": 3, "global_step": 6, "train_avg_loss": 11.931214332580566, "eval_loss": 11.931214332580566, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 2, "train_avg_loss": 18.321178436279297, "eval_loss": 21.45726776123047, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 4, "train_avg_loss": 16.057231903076172, "eval_loss": 20.39411163330078, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 3, "global_step": 6, "train_avg_loss": 15.725045204162598, "eval_loss": 20.471101760864258, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "final", "epoch": 3, "global_step": 6, "train_avg_loss": 15.725045204162598, "eval_loss": 20.471101760864258, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 2, "train_avg_loss": 18.435989379882812, "eval_loss": 21.166339874267578, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 2, "global_step": 4, "train_avg_loss": 15.885025024414062, "eval_loss": 20.61844825744629, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 3, "global_step": 6, "train_avg_loss": 16.04737663269043, "eval_loss": 20.586658477783203, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "final", "epoch": 3, "global_step": 6, "train_avg_loss": 16.04737663269043, "eval_loss": 20.586658477783203, "em_acc_pct": 0.0, "tok_acc_pct": 0.0}
+{"phase": "epoch", "epoch": 1, "global_step": 15, "train_avg_loss": 3.3097920417785645, "eval_loss": 3.314453601837158, "em_acc_pct": 0.0, "tok_acc_pct": 37.87878751754761}
+{"phase": "epoch", "epoch": 2, "global_step": 30, "train_avg_loss": 3.364327907562256, "eval_loss": 3.375408172607422, "em_acc_pct": 0.0, "tok_acc_pct": 37.12121248245239}
+{"phase": "epoch", "epoch": 3, "global_step": 45, "train_avg_loss": 3.3895301818847656, "eval_loss": 3.3486533164978027, "em_acc_pct": 0.0, "tok_acc_pct": 37.5}
+{"phase": "final", "epoch": 3, "global_step": 45, "train_avg_loss": 3.3895301818847656, "eval_loss": 3.3486533164978027, "em_acc_pct": 0.0, "tok_acc_pct": 37.5}
+{"phase": "epoch", "epoch": 1, "global_step": 2, "train_avg_loss": 3.844731330871582, "eval_loss": 3.2611234188079834, "em_acc_pct": 0.0, "tok_acc_pct": 41.66666567325592}
+{"phase": "final", "epoch": 1, "global_step": 2, "train_avg_loss": 3.844731330871582, "eval_loss": 3.2611234188079834, "em_acc_pct": 0.0, "tok_acc_pct": 41.66666567325592}
+{"phase": "epoch", "epoch": 1, "global_step": 17, "train_avg_loss": 9.678044319152832, "eval_loss": 5.9935407638549805, "em_acc_pct": 19.84127014875412, "tok_acc_pct": 19.84127014875412}
+{"phase": "epoch", "epoch": 2, "global_step": 34, "train_avg_loss": 5.083719730377197, "eval_loss": 4.875655174255371, "em_acc_pct": 18.25396865606308, "tok_acc_pct": 18.25396865606308}
+{"phase": "epoch", "epoch": 3, "global_step": 51, "train_avg_loss": 4.628010272979736, "eval_loss": 4.714605808258057, "em_acc_pct": 21.82539701461792, "tok_acc_pct": 21.82539701461792}
+{"phase": "final", "epoch": 3, "global_step": 51, "train_avg_loss": 4.628010272979736, "eval_loss": 4.714605808258057, "em_acc_pct": 21.82539701461792, "tok_acc_pct": 21.82539701461792}

outputs/qwen_titans_babilong_detach_4gpu_bs1_ckpt/eval_metrics.jsonl

@@ -0,0 +1 @@
+{"phase": "epoch", "epoch": 1, "global_step": 35, "train_avg_loss": 4.500145435333252, "eval_loss": 1.749605655670166, "em_acc_pct": 30.158731341362, "tok_acc_pct": 30.158731341362}

outputs/qwen_titans_babilong_v3/eval_metrics.jsonl

@@ -0,0 +1,5 @@
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 10.893842697143555, "eval_loss": 5.053490161895752, "em_acc_pct": 21.153846383094788, "tok_acc_pct": 21.153846383094788}
+{"phase": "epoch", "epoch": 1, "global_step": 7, "train_avg_loss": 10.93690013885498, "eval_loss": 5.081326484680176, "em_acc_pct": 23.076923191547394, "tok_acc_pct": 23.076923191547394}
+{"phase": "epoch", "epoch": 2, "global_step": 14, "train_avg_loss": 3.1573493480682373, "eval_loss": 2.4568819999694824, "em_acc_pct": 28.846153616905212, "tok_acc_pct": 28.846153616905212}
+{"phase": "epoch", "epoch": 3, "global_step": 21, "train_avg_loss": 1.8114500045776367, "eval_loss": 2.129908561706543, "em_acc_pct": 32.692307233810425, "tok_acc_pct": 32.692307233810425}
+{"phase": "epoch", "epoch": 4, "global_step": 28, "train_avg_loss": 1.5927897691726685, "eval_loss": 2.193814516067505, "em_acc_pct": 26.923078298568726, "tok_acc_pct": 26.923078298568726}

pyproject.toml

@@ -0,0 +1,73 @@
+[project]
+name = "titans-pytorch"
+version = "0.5.0"
+description = "Titans"
+authors = [
+    { name = "Phil Wang", email = "lucidrains@gmail.com" }
+]
+readme = "README.md"
+requires-python = ">= 3.9"
+license = { file = "LICENSE" }
+keywords = [
+    'artificial intelligence',
+    'deep learning',
+    'test time training',
+    'linear attention',
+    'memory',
+]
+
+classifiers=[
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'Topic :: Scientific/Engineering :: Artificial Intelligence',
+    'License :: OSI Approved :: MIT License',
+    'Programming Language :: Python :: 3.9',
+]
+
+dependencies = [
+    "assoc-scan>=0.0.4",
+    "axial_positional_embedding>=0.3.10",
+    "einops>=0.8.0",
+    "einx>=0.3.0",
+    "hyper-connections>=0.3.11",
+    "Ninja",
+    "rotary-embedding-torch",
+    "tensordict",
+    "torch>=2.8",
+    "tqdm",
+    "x-transformers"
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/titans-pytorch/"
+Repository = "https://github.com/lucidrains/titans-pytorch"
+
+[project.optional-dependencies]
+
+examples = [
+    "adam-atan2-pytorch>=0.1.18",
+    "wandb"
+]
+
+test = [
+    "pytest"
+]
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "."
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.rye]
+managed = true
+dev-dependencies = []
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["titans_pytorch"]

tests/test_titans.py

@@ -0,0 +1,427 @@
+from contextlib import contextmanager
+
+import torch
+from torch import nn
+
+import pytest
+from titans_pytorch import NeuralMemory
+from titans_pytorch.mac_transformer import flex_attention, SegmentedAttention, MemoryAsContextTransformer
+
+# functions
+
+def exists(v):
+    return v is not None
+
+def diff(x, y):
+    return (x - y).abs().amax()
+
+@contextmanager
+def torch_default_dtype(dtype):
+    prev_dtype = torch.get_default_dtype()
+    torch.set_default_dtype(dtype)
+    yield
+    torch.set_default_dtype(prev_dtype)
+
+# main test
+
+@pytest.mark.parametrize('seq_len', (32, 512, 77))
+@pytest.mark.parametrize('silu', (False, True))
+@pytest.mark.parametrize('chunk_size, attn_pool_chunks', ((64, True), (64, False), (1, False)))
+@pytest.mark.parametrize('momentum', (False, True))
+@pytest.mark.parametrize('qk_rmsnorm', (False, True))
+@pytest.mark.parametrize('heads', (1, 4))
+@pytest.mark.parametrize('max_grad_norm', (None, 2.))
+@pytest.mark.parametrize('num_kv_per_token', (1, 2))
+@pytest.mark.parametrize('per_parameter_lr_modulation', (False, True))
+@pytest.mark.parametrize('per_head_learned_parameters', (False, True))
+@pytest.mark.parametrize('test_store_mask', (False, True))
+def test_titans(
+    seq_len,
+    silu,
+    attn_pool_chunks,
+    chunk_size,
+    momentum,
+    qk_rmsnorm,
+    heads,
+    max_grad_norm,
+    num_kv_per_token,
+    per_parameter_lr_modulation,
+    per_head_learned_parameters,
+    test_store_mask
+):
+    mem = NeuralMemory(
+        dim = 16,
+        chunk_size = chunk_size,
+        activation = nn.SiLU() if silu else None,
+        attn_pool_chunks = attn_pool_chunks,
+        max_grad_norm = max_grad_norm,
+        num_kv_per_token = num_kv_per_token,
+        momentum = momentum,
+        qk_rmsnorm = qk_rmsnorm,
+        heads = heads,
+        per_parameter_lr_modulation = per_parameter_lr_modulation,
+        per_head_learned_parameters = per_head_learned_parameters
+    )
+
+    seq = torch.randn(2, seq_len, 16)
+
+    store_mask = None
+
+    if test_store_mask:
+        store_mask = torch.randint(0, 2, (2, seq_len)).bool()
+
+    retrieved, _ = mem(seq, store_mask = store_mask)
+
+    assert seq.shape == retrieved.shape
+
+def test_return_surprises():
+
+    mem = NeuralMemory(
+        dim = 384,
+        chunk_size = 2,
+        dim_head = 64,
+        heads = 4,
+    )
+
+    seq = torch.randn(4, 64, 384)
+
+    _, _, (surprises, adaptive_lr) = mem(seq, return_surprises = True)
+
+    assert all([t.shape == (4, 4, 64) for t in (surprises, adaptive_lr)])
+
+@pytest.mark.parametrize('learned_momentum_combine', (False, True))
+@pytest.mark.parametrize('learned_combine_include_zeroth', (False, True))
+def test_titans_second_order_momentum(
+    learned_momentum_combine,
+    learned_combine_include_zeroth
+):
+
+    mem  = NeuralMemory(
+        dim = 384,
+        dim_head = 64,
+        heads = 2,
+        chunk_size = 1,
+        batch_size = 2,
+        momentum_order = 2,
+        learned_momentum_combine = learned_momentum_combine,
+        learned_combine_include_zeroth = learned_combine_include_zeroth
+    )
+
+    seq = torch.randn(2, 5, 384)
+
+    parallel_retrieved, state = mem(seq)
+    assert seq.shape == parallel_retrieved.shape
+
+def test_titans_attn_memory():
+    from titans_pytorch.memory_models import MemoryAttention
+
+    mem = NeuralMemory(
+        dim = 16,
+        chunk_size = 64,
+        model = MemoryAttention(
+            dim = 16
+        )
+    )
+
+    seq = torch.randn(2, 1024, 16)
+    retrieved, _ = mem(seq)
+
+    assert seq.shape == retrieved.shape
+
+def test_swiglu_ff_memory():
+    from titans_pytorch.memory_models import MemorySwiGluMLP
+
+    mem = NeuralMemory(
+        dim = 16,
+        chunk_size = 2,
+        mem_model_norm_add_residual = False,
+        model = MemorySwiGluMLP(
+            dim = 16,
+            depth = 2
+        )
+    )
+
+    seq = torch.randn(2, 64, 16)
+    retrieved, _ = mem(seq)
+
+    assert seq.shape == retrieved.shape
+
+@pytest.mark.parametrize('gated_transition', (True, False))
+def test_neural_mem_chaining_chunks(
+    gated_transition
+):
+    mem  = NeuralMemory(
+        dim = 16,
+        dim_head = 16,
+        heads = 2,
+        chunk_size = 16,
+        gated_transition = gated_transition
+    )
+
+    seq = torch.randn(2, 48, 16)
+
+    parallel_retrieved, state = mem(seq)
+
+    seq_first, seq_second, seq_third = seq.split(16, dim = 1)
+
+    first_retrieved, state = mem(seq_first)
+    second_retrieved, state = mem(seq_second, state = state)
+    third_retrieved, state = mem(seq_third, state = state)
+
+    assert torch.allclose(parallel_retrieved, torch.cat((first_retrieved, second_retrieved, third_retrieved), dim = 1), atol = 1e-5)
+
+def test_neural_mem_chaining_with_weight_residual():
+    mem  = NeuralMemory(
+        dim = 16,
+        dim_head = 16,
+        heads = 2,
+        chunk_size = 64
+    )
+
+    mem2 = NeuralMemory(
+        dim = 16,
+        dim_head = 16,
+        heads = 2,
+        chunk_size = 64,
+        accept_weight_residual = True
+    )
+
+    seq = torch.randn(2, 256, 16)
+
+    seq, state = mem(seq)
+
+    parallel_retrieved, _ = mem2(seq, prev_weights = state.updates)
+
+    seq_first, seq_second = seq[:, :128], seq[:, 128:]
+
+    first_retrieved, state1 = mem2(seq_first, prev_weights = state.updates)
+    second_retrieved, state2 = mem2(seq_second, state = state1, prev_weights = state.updates)
+
+    assert torch.allclose(parallel_retrieved, torch.cat((first_retrieved, second_retrieved), dim = 1), atol = 1e-5)
+
+def test_neural_mem_chaining_with_batch_size():
+    mem  = NeuralMemory(
+        dim = 16,
+        dim_head = 16,
+        heads = 2,
+        chunk_size = 16,
+        batch_size = 64
+    )
+
+    seq = torch.randn(2, 112, 16)
+
+    parallel_retrieved, state = mem(seq)
+
+    seq_first, seq_second, seq_third = seq[:, :16], seq[:, 16:64], seq[:, 64:]
+
+    first_retrieved, state = mem(seq_first)
+    second_retrieved, state = mem(seq_second, state = state)
+    third_retrieved, state = mem(seq_third, state = state)
+
+    parallel_part_retrieved = torch.cat((first_retrieved, second_retrieved, third_retrieved), dim = 1)
+
+    assert torch.allclose(parallel_retrieved, parallel_part_retrieved, atol = 1e-5)
+
+@pytest.mark.parametrize('seq_len', (1023, 17))
+@pytest.mark.parametrize('num_persist_mem_tokens', (0, 16))
+@pytest.mark.parametrize('num_longterm_mem_tokens', (0, 16))
+@pytest.mark.parametrize('neural_mem_gate_attn_output', (False, True))
+@pytest.mark.parametrize('neural_mem_segment_len', (8, 16))
+@pytest.mark.parametrize('neural_mem_weight_residual', (False, True))
+@pytest.mark.parametrize('neural_mem_batch_size', (None, 64))
+@pytest.mark.parametrize('neural_mem_qkv_receives_diff_views', (False, True))
+@pytest.mark.parametrize('neural_mem_momentum', (False, True))
+def test_mac(
+    seq_len,
+    num_persist_mem_tokens,
+    num_longterm_mem_tokens,
+    neural_mem_gate_attn_output,
+    neural_mem_segment_len,
+    neural_mem_weight_residual,
+    neural_mem_batch_size,
+    neural_mem_qkv_receives_diff_views,
+    neural_mem_momentum
+):
+    transformer = MemoryAsContextTransformer(
+        num_tokens = 256,
+        dim = 16,
+        depth = 2,
+        num_persist_mem_tokens = num_persist_mem_tokens,
+        num_longterm_mem_tokens = num_longterm_mem_tokens,
+        segment_len = 128,
+        neural_mem_gate_attn_output = neural_mem_gate_attn_output,
+        neural_memory_segment_len = neural_mem_segment_len,
+        neural_memory_batch_size = neural_mem_batch_size,
+        neural_memory_qkv_receives_diff_views = neural_mem_qkv_receives_diff_views,
+        neural_mem_weight_residual = neural_mem_weight_residual,
+        neural_memory_kwargs = dict(
+            momentum = neural_mem_momentum
+        )
+    )
+
+    x = torch.randint(0, 256, (1, seq_len))
+
+    logits = transformer(x)
+    assert logits.shape == (1, seq_len, 256)
+
+@pytest.mark.parametrize('sliding', (False, True))
+@pytest.mark.parametrize('mem_layers', ((), None))
+@pytest.mark.parametrize('longterm_mems', (0, 4, 16))
+@pytest.mark.parametrize('prompt_len', (4, 16))
+@torch_default_dtype(torch.float64)
+def test_mac_sampling(
+    sliding,
+    mem_layers,
+    longterm_mems,
+    prompt_len
+):
+    transformer = MemoryAsContextTransformer(
+        num_tokens = 256,
+        dim = 16,
+        depth = 4,
+        segment_len = 32,
+        num_persist_mem_tokens = 4,
+        num_longterm_mem_tokens = longterm_mems,
+        sliding_window_attn = sliding,
+        neural_memory_layers = mem_layers,
+        neural_mem_gate_attn_output = False
+    )
+
+    ids = torch.randint(0, 256, (1, 1023))
+
+    # after much training
+
+    prompt = ids[:, :prompt_len]
+
+    sampled = transformer.sample(prompt, 53, use_cache = False, temperature = 0.)
+    sampled_with_cache = transformer.sample(prompt, 53, use_cache = True, temperature = 0.)
+
+    assert torch.allclose(sampled, sampled_with_cache)
+
+@pytest.mark.parametrize('seq_len', (2, 64, 256))
+@pytest.mark.parametrize('prompt_len', (0, 65))
+@pytest.mark.parametrize('mem_chunk_size', (2, 32, 64))
+@pytest.mark.parametrize('gated_transition', (False, True))
+@torch_default_dtype(torch.float64)
+def test_neural_mem_inference(
+    seq_len,
+    prompt_len,
+    mem_chunk_size,
+    gated_transition
+):
+
+    mem = NeuralMemory(
+        dim = 16,
+        chunk_size = mem_chunk_size,
+        gated_transition = gated_transition
+    )
+
+    seq = torch.randn(2, seq_len, 16)
+    parallel_retrieved, _ = mem(seq)
+
+    assert seq.shape == parallel_retrieved.shape
+
+    state = None
+    sequential_retrieved = []
+
+    # test initial parallel prompt
+
+    test_parallel_prompt = prompt_len > 0 and prompt_len < seq_len
+
+    if test_parallel_prompt:
+        prompt, seq = seq[:, :prompt_len], seq[:, prompt_len:]
+        retrieved_prompt, state = mem(prompt)
+        sequential_retrieved.append(retrieved_prompt)
+
+    # sequential inference
+
+    for token in seq.unbind(dim = 1):
+
+        one_retrieved, state = mem.forward(
+            token,
+            state = state,
+        )
+
+        sequential_retrieved.append(one_retrieved)
+
+    sequential_retrieved = torch.cat(sequential_retrieved, dim = -2)
+
+    assert torch.allclose(parallel_retrieved, sequential_retrieved, atol = 1e-6)
+
+@pytest.mark.parametrize('seq_len', (1023, 17))
+@pytest.mark.parametrize('sliding', (True, False))
+def test_flex(
+    seq_len,
+    sliding
+):
+    if not (torch.cuda.is_available() and exists(flex_attention)):
+        pytest.skip()
+
+    attn = SegmentedAttention(
+        dim = 16,
+        segment_len = 32,
+        num_persist_mem_tokens = 1,
+        num_longterm_mem_tokens = 1,
+        use_flex_attn = True,
+        sliding = sliding
+    ).cuda()
+
+    seq = torch.randn(1, seq_len, 16).cuda()
+
+    out_flex, _ = attn(seq)
+    out_non_flex, _ = attn(seq, disable_flex_attn = True)
+
+    assert torch.allclose(out_flex, out_non_flex, atol = 1e-5)
+
+@pytest.mark.parametrize('use_accelerated', (True, False))
+def test_assoc_scan(
+    use_accelerated
+):
+    from titans_pytorch.neural_memory import AssocScan
+
+    if use_accelerated and not torch.cuda.is_available():
+        pytest.skip()
+
+    scan = AssocScan(use_accelerated = use_accelerated)
+
+    seq_len = 128
+    mid_point = seq_len // 2
+
+    gates = torch.randn(2, seq_len, 16).sigmoid()
+    inputs = torch.randn(2, seq_len, 16)
+
+    if use_accelerated:
+        gates = gates.cuda()
+        inputs = inputs.cuda()
+
+    output = scan(gates, inputs)
+
+    gates1, gates2 = gates[:, :mid_point], gates[:, mid_point:]
+    inputs1, inputs2 = inputs[:, :mid_point], inputs[:, mid_point:]
+
+    first_half = scan(gates1, inputs1)
+
+    second_half = scan(gates2, inputs2, prev = first_half[:, -1])
+    assert second_half.shape == inputs2.shape
+
+    assert torch.allclose(output[:, -1], second_half[:, -1], atol = 1e-5)
+
+def test_mem_state_detach():
+    from titans_pytorch.neural_memory import mem_state_detach
+
+    mem = NeuralMemory(
+        dim = 384,
+        chunk_size = 2,
+        qk_rmsnorm = True,
+        dim_head = 64,
+        heads = 4,
+    )
+
+    seq = torch.randn(4, 64, 384)
+
+    state = None
+
+    for _ in range(2):
+        parallel_retrieved, state = mem(seq, state = state)
+        state = mem_state_detach(state)
+        parallel_retrieved.sum().backward()

titans_pytorch/__init__.py

@@ -1,17 +1,17 @@
-"""
-Minimal `titans_pytorch` exports for `train_qwen_titans_babilong_v4.py`.
+from titans_pytorch.neural_memory import (
+    NeuralMemory,
+    NeuralMemState,
+    mem_state_detach
+)
 
-This Hugging Face repo intentionally contains only the code paths used by the v4
-training script (NeuralMemory + MemoryMLP), and does NOT ship unrelated modules
-from the original project.
-"""
+from titans_pytorch.memory_models import (
+    MemoryMLP,
+    MemoryAttention,
+    FactorizedMemoryMLP,
+    MemorySwiGluMLP,
+    GatedResidualMemoryMLP
+)
 
-from titans_pytorch.neural_memory import NeuralMemState, NeuralMemory, mem_state_detach
-from titans_pytorch.memory_models import MemoryMLP
-
-__all__ = [
-    "NeuralMemory",
-    "NeuralMemState",
-    "mem_state_detach",
-    "MemoryMLP",
-]
+from titans_pytorch.mac_transformer import (
+    MemoryAsContextTransformer
+)

titans_pytorch/implicit_mlp_attention.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import torch
+from torch import nn, cat, is_tensor
+import torch.nn.functional as F
+from torch.nn import Module, ModuleList
+from torch.utils._pytree import tree_map
+
+from einops.layers.torch import Rearrange
+
+from rotary_embedding_torch import RotaryEmbedding
+
+# functions
+
+def exists(v):
+    return v is not None
+
+# classes
+
+class ImplicitMLPAttention(Module):
+    def __init__(
+        self,
+        dim,
+        mlp_hiddens: tuple[int, ...],
+        *,
+        activation = nn.SiLU(),
+        heads = 8,
+        talking_heads = True,
+        prenorm = True,
+        keys_rmsnorm = True # https://openreview.net/forum?id=HkztQWZfl2
+    ):
+        super().__init__()
+        assert isinstance(mlp_hiddens, tuple) and len(mlp_hiddens) >= 2
+        dim_mlp_in, *dim_mlp_inner, dim_mlp_out = mlp_hiddens
+
+        self.norm = nn.RMSNorm(dim) if prenorm else nn.Identity()
+
+        dim_query_inner = dim_mlp_in * heads
+        self.to_queries = nn.Linear(dim, dim_query_inner, bias = False)
+
+        # keys and values
+
+        self.rotary_embed = RotaryEmbedding(min(mlp_hiddens)) # just use the minimum dimension, the rest is partially rotaried
+
+        # each key value forms an implicit weight (memory) of (dim_key, dim_values)
+        # chaining them would then be the implicit MLP from TTT / Titans
+
+        self.keys = ModuleList([])
+        self.key_norms = ModuleList([])
+
+        self.values = ModuleList([])
+
+        for dim_in, dim_out in zip(mlp_hiddens[:-1], mlp_hiddens[1:]):
+
+            dim_keys_inner = dim_in * heads
+            dim_values_inner = dim_out * heads
+
+            keys = nn.Linear(dim, dim_keys_inner, bias = False)
+            key_norms = nn.RMSNorm(dim_in) if keys_rmsnorm else nn.Identity()
+
+            values = nn.Linear(dim, dim_values_inner, bias = False)
+
+            self.keys.append(keys)
+            self.key_norms.append(key_norms)
+
+            self.values.append(values)
+
+        self.activation = activation
+
+        # talking head - Shazeer et al.
+
+        self.talking_heads = nn.Identity()
+
+        if talking_heads and len(dim_mlp_inner) > 0:
+            self.talking_heads = nn.Conv2d(heads, heads, 1, bias = False)
+            nn.init.dirac_(self.talking_heads.weight)
+
+        # split merging of heads
+
+        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
+        self.merge_heads = Rearrange('b h n d -> b n (h d)')
+
+        self.to_out = nn.Linear(dim_mlp_out * heads, dim, bias = False)
+
+    def forward(
+        self,
+        tokens,
+        cache = None,
+        return_kv_cache = False
+    ):
+        batch, seq_len, device = *tokens.shape[:2], tokens.device
+
+        tokens = self.norm(tokens)
+
+        queries = self.to_queries(tokens)
+
+        keys = [fn(tokens) for fn in self.keys]
+        values = [fn(tokens) for fn in self.values]
+
+        # split heads for input as well as all keys, values that form the implicit weights
+
+        queries, keys, values = tree_map(self.split_heads, (queries, keys, values))
+
+        # maybe norm all keys
+
+        keys = [norm(k) for norm, k in zip(self.key_norms, keys)]
+
+        # cache
+
+        if exists(cache):
+            cache_keys, cache_values = cache
+
+            keys = [cat(args, dim = -2) for args in zip(cache_keys, keys)]
+            values = [cat(args, dim = -2) for args in zip(cache_values, values)]
+
+        # attend
+
+        def attend(q, k, v):
+            q, k = self.rotary_embed.rotate_queries_with_cached_keys(q, k)
+
+            return F.scaled_dot_product_attention(q, k, v, is_causal = True)
+
+        # implicit memory mlp
+
+        out = queries
+
+        for i, (key, value) in enumerate(zip(keys, values), start = 1):
+            is_last = i == len(keys)
+
+            out = attend(out, key, value)
+
+            if not is_last:
+                out = self.talking_heads(out)
+                out = self.activation(out)
+
+        # merge heads
+
+        out = self.merge_heads(out)
+        out = self.to_out(out)
+
+        if not return_kv_cache:
+            return out
+
+        return out, (keys, values)
+
+# 3 layers implicit MLP attention - 64 -> 128 -> 128 -> 64 w/ relu
+
+if __name__ == '__main__':
+
+    implicit_mlp_attn = ImplicitMLPAttention(
+        512,
+        (64, 128, 128, 64),
+        activation = nn.ReLU()
+    )
+
+    tokens = torch.randn(1, 1024, 512)
+
+    out, cache = implicit_mlp_attn(tokens)
+    out, cache = implicit_mlp_attn(tokens, cache = cache)
+
+    assert out.shape == tokens.shape

titans_pytorch/mac_transformer.py

@@ -0,0 +1,921 @@
+from __future__ import annotations
+from typing import Callable
+
+from math import ceil
+from copy import deepcopy
+from functools import partial
+from collections import namedtuple
+
+import tqdm
+
+import torch
+from torch import nn, stack, cat
+import torch.nn.functional as F
+from torch.nn import Module, ModuleList, Linear
+
+# flex attention
+# https://pytorch.org/blog/flexattention/
+
+flex_attention = None
+
+try:
+    from torch.nn.attention.flex_attention import flex_attention, create_block_mask
+    if torch.cuda.is_available():
+        flex_attention = torch.compile(flex_attention)
+except ImportError:
+    pass
+
+def create_mac_block_mask(seq_len, window_size, persist_mem_len, sliding = False):
+
+    def create_mac_mask(_, __, q_idx, kv_idx):
+        is_persist_mem = kv_idx < persist_mem_len
+        kv_without_mem = kv_idx - persist_mem_len
+        causal_mask = q_idx >= kv_without_mem
+
+        if not sliding:
+            block_diagonal = (q_idx // window_size) == (kv_without_mem // window_size)
+            causal_mask = causal_mask & block_diagonal
+        else:
+            sliding_mask = (q_idx - kv_without_mem) <= window_size
+            causal_mask = causal_mask & sliding_mask
+
+        return is_persist_mem | (~is_persist_mem & causal_mask)
+
+    block_mask = create_block_mask(create_mac_mask, B = None, H = None, Q_LEN = seq_len, KV_LEN = seq_len + persist_mem_len, _compile = True)
+    return block_mask
+
+# einstein notation related
+
+from einops import repeat, rearrange, pack, unpack, einsum
+from einops.layers.torch import Rearrange
+
+# b - batch
+# n - sequence
+# h - heads
+# d - feature dimension
+
+# absolute and relative positions
+
+from axial_positional_embedding import ContinuousAxialPositionalEmbedding
+from rotary_embedding_torch import RotaryEmbedding
+
+# hyper connections / attend from x-transformers, which handles different queries and key lengths better
+
+from x_transformers.attend import Attend
+
+from hyper_connections import mc_get_init_and_expand_reduce_stream_functions
+
+# proposed neural memory
+
+from titans_pytorch.neural_memory import NeuralMemory
+
+# constants
+
+LinearNoBias = partial(Linear, bias = False)
+
+AttnIntermediates = namedtuple('AttnIntermediates', ('value_residual', 'cached_key_values'))
+
+# helpers
+
+def exists(v):
+    return v is not None
+
+def default(v, d):
+    return v if exists(v) else d
+
+def identity(t):
+    return t
+
+def divisible_by(num, den):
+    return (num % den) == 0
+
+def round_up_multiple(seq, mult):
+    return ceil(seq / mult) * mult
+
+def round_down_multiple(seq, mult):
+    return seq // mult * mult
+
+def pack_with_inverse(t, pattern):
+    packed, packed_shape = pack(t, pattern)
+
+    def inverse(out, inv_pattern = None):
+        return unpack(out, packed_shape, default(inv_pattern, pattern))
+
+    return packed, inverse
+
+def pad_at_dim(t, pad, dim = -1, value = 0.):
+    dims_from_right = (- dim - 1) if dim < 0 else (t.ndim - dim - 1)
+    zeros = ((0, 0) * dims_from_right)
+    return F.pad(t, (*zeros, *pad), value = value)
+
+def pad_and_segment_with_inverse(
+    seq,
+    segment_len,
+    fold_into_batch = True,
+    inverse_remove_pad = True
+):
+    batch, seq_len = seq.shape[:2]
+    next_seq_len_mult = round_up_multiple(seq_len, segment_len)
+
+    padding = next_seq_len_mult - seq_len
+    needs_pad = padding > 0
+
+    if needs_pad:
+        seq = F.pad(seq, (0, 0, 0, padding))
+
+    if fold_into_batch:
+        seq = rearrange(seq, 'b (w n) d -> (b w) n d', n = segment_len)
+
+    def inverse(out):
+
+        if fold_into_batch:
+            out = rearrange(out, '(b w) ... n d -> b ... (w n) d', b = batch)
+
+        if needs_pad and inverse_remove_pad:
+            out = out[..., :-padding, :]
+
+        return out
+
+    return seq, inverse
+
+# sampling related
+
+def log(t, eps = 1e-20):
+    return torch.log(t.clamp(min = eps))
+
+def gumbel_noise(t):
+    noise = torch.rand_like(t)
+    return -log(-log(noise))
+
+def gumbel_sample(t, temperature = 1.):
+    if temperature > 0.:
+        t = t / temperature + gumbel_noise(t)
+    return t.argmax(dim = -1, keepdim = True)
+
+# min_p
+# https://arxiv.org/abs/2407.01082
+
+def min_p_filter(logits, min_p = 0.1):
+    probs = logits.softmax(dim = -1)
+    max_probs = probs.amax(dim = -1, keepdim = True)
+    limit = min_p * max_probs
+    return torch.where(probs < limit, float('-inf'), logits)
+
+# feedforward and attention
+
+class GEGLU(Module):
+    def forward(self, x):
+        x, gate = x.chunk(2, dim = -1)
+        return F.silu(gate) * x
+
+def FeedForward(dim, mult = 4):
+    dim_inner = int(dim * mult * 2 / 3)
+
+    return nn.Sequential(
+        nn.RMSNorm(dim),
+        nn.Linear(dim, dim_inner * 2),
+        GEGLU(),
+        nn.Linear(dim_inner, dim)
+    )
+
+class SegmentedAttention(Module):
+    def __init__(
+        self,
+        dim,
+        segment_len,
+        num_persist_mem_tokens = 0,
+        num_longterm_mem_tokens = 0,
+        dim_head = 64,
+        heads = 8,
+        sliding = False,
+        accept_value_residual = False,
+        attend_kwargs: dict = dict(),
+        use_flex_attn = False
+    ):
+        super().__init__()
+        self.norm = nn.RMSNorm(dim)
+
+        dim_inner = dim_head * heads
+
+        self.rotary_emb = RotaryEmbedding(dim_head)
+
+        self.attend = Attend(causal = True, **attend_kwargs)
+
+        self.to_qkv = LinearNoBias(dim, dim_inner * 3)
+        self.to_out = LinearNoBias(dim_inner, dim)
+
+        self.to_learned_v_mix = nn.Sequential(
+            nn.Linear(dim, heads),
+            Rearrange('b n h -> b h n 1'),
+            nn.Sigmoid()
+        ) if accept_value_residual else None
+
+        self.segment_len = segment_len
+        self.num_longterm_mem_tokens = num_longterm_mem_tokens
+
+        total_segment_len = segment_len + num_longterm_mem_tokens
+        self.total_segment_len = total_segment_len
+
+        self.sliding = sliding # sliding window attn - doubt their non-sliding results being the best. local attention with overlapping windows is very strong
+
+        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
+        self.merge_heads = Rearrange('b h n d -> b n (h d)')
+
+        self.persistent_memory = nn.Parameter(torch.zeros(2, heads, num_persist_mem_tokens, dim_head))
+
+        # flex attn related
+
+        assert not (use_flex_attn and not exists(flex_attention)), 'you need to be on the latest pytorch with a cuda device available'
+        self.use_flex_attn = use_flex_attn
+
+        self.segment_len = segment_len
+        self.num_persist_mem_tokens = num_persist_mem_tokens
+
+    def forward_inference(
+        self,
+        token,
+        cache,
+        value_residual = None,
+        output_gating = None,
+    ):
+        batch = token.shape[0]
+
+        # attention
+
+        token = self.norm(token)
+
+        q, k, v = self.to_qkv(token).chunk(3, dim = -1)
+        q, k, v = map(self.split_heads, (q, k, v))
+
+        # value residual
+
+        orig_v = v
+
+        if exists(self.to_learned_v_mix):
+            mix = self.to_learned_v_mix(token)
+            v = v.lerp(value_residual, mix)
+
+        # caching
+
+        ck, cv = cache
+        k = cat((ck, k), dim = -2)
+        v = cat((cv, v), dim = -2)
+
+        next_cache = (k, v)
+
+        # relative positions
+
+        q, k = self.rotary_emb.rotate_queries_with_cached_keys(q, k)
+
+        # fold
+
+        q, k, v = tuple(rearrange(t, 'b h n d -> b h n d') for t in (q, k, v))
+
+        # take care of persistent memory key / values
+
+        pmk, pmv = repeat(self.persistent_memory, 'kv ... -> kv b ...', b = k.shape[0])
+
+        # persistent memory
+
+        k = cat((pmk, k), dim = -2)
+        v = cat((pmv, v), dim = -2)
+
+        # attention
+
+        out, _ = self.attend(q, k, v)
+
+        out = self.merge_heads(out)
+
+        out = self.to_out(out)
+
+        if exists(output_gating):
+            out = out * output_gating
+
+        return out, AttnIntermediates(orig_v, next_cache)
+
+    def forward_flex(
+        self,
+        seq,
+        value_residual = None,
+        flex_attn_fn: Callable | None = None,
+        output_gating = None,
+        cache = None
+    ):
+
+        assert not (exists(value_residual) ^ exists(self.to_learned_v_mix))
+
+        batch, seq_len = seq.shape[:2]
+
+        # attention
+
+        seq = self.norm(seq)
+
+        q, k, v = self.to_qkv(seq).chunk(3, dim = -1)
+        q, k, v = map(self.split_heads, (q, k, v))
+
+        # value residual
+
+        orig_v = v
+
+        if exists(self.to_learned_v_mix):
+            mix = self.to_learned_v_mix(seq)
+            v = v.lerp(value_residual, mix)
+
+        # caching
+
+        next_cache = (k, v)
+
+        # take care of persistent memory key / values
+
+        pmk, pmv = repeat(self.persistent_memory, 'kv h n d -> kv b h n d', b = batch)
+
+        # relative positions
+
+        q, k = self.rotary_emb.rotate_queries_with_cached_keys(q, k)
+
+        # persistent memory
+
+        k = cat((pmk, k), dim = -2)
+        v = cat((pmv, v), dim = -2)
+
+        # prep flex attention
+
+        if not exists(flex_attn_fn):
+            block_mask = create_mac_block_mask(seq_len, self.total_segment_len, self.num_persist_mem_tokens, self.sliding)
+
+            flex_attn_fn = partial(flex_attention, block_mask = block_mask)
+
+        # attention
+
+        out = flex_attn_fn(q, k, v)
+
+        out = self.merge_heads(out)
+
+        out = self.to_out(out)
+
+        if exists(output_gating):
+            out = out * output_gating
+
+        return out, AttnIntermediates(orig_v, next_cache)
+
+    def forward(
+        self,
+        seq,
+        value_residual = None,
+        flex_attn_fn: Callable | None = None,
+        disable_flex_attn = False,
+        output_gating = None,
+        cache = None
+    ):
+        is_inferencing = exists(cache)
+
+        if is_inferencing:
+            assert seq.shape[-2] == 1
+            return self.forward_inference(seq, cache, value_residual, output_gating = output_gating)
+
+        if seq.is_cuda and self.use_flex_attn and not disable_flex_attn:
+            return self.forward_flex(seq, value_residual, flex_attn_fn, output_gating = output_gating, cache = cache)
+
+        assert not (exists(value_residual) ^ exists(self.to_learned_v_mix))
+
+        segment_len, num_longterm_mem_tokens = self.segment_len, self.num_longterm_mem_tokens
+        total_segment_len = segment_len + num_longterm_mem_tokens
+
+        batch, seq_len = seq.shape[:2]
+
+        # auto pad to multiple
+
+        seq, inverse_segment = pad_and_segment_with_inverse(seq, total_segment_len, fold_into_batch = False)
+
+        # attention
+
+        seq = self.norm(seq)
+
+        q, k, v = self.to_qkv(seq).chunk(3, dim = -1)
+        q, k, v = map(self.split_heads, (q, k, v))
+
+        # value residual
+
+        orig_v = v
+
+        if exists(self.to_learned_v_mix):
+            mix = self.to_learned_v_mix(seq)
+            v = v.lerp(value_residual, mix)
+
+        # caching
+
+        next_cache = tuple(map(inverse_segment, (k, v)))
+
+        # relative positions
+
+        q, k = self.rotary_emb.rotate_queries_with_cached_keys(q, k)
+
+        # fold
+
+        q, k, v = tuple(rearrange(t, 'b h (w n) d -> (b w) h n d', n = total_segment_len) for t in (q, k, v))
+
+        # maybe sliding for cpu
+
+        attend_kwargs = dict()
+
+        if self.sliding:
+            k, v = tuple(rearrange(t, '(b w) ... -> b w ...', b = batch) for t in (k, v))
+            k, v = tuple(pad_at_dim(t, (1, 0), value = 0., dim = 1) for t in (k, v))
+            k = cat((k[:, :-1], k[:, 1:]), dim = -2)
+            v = cat((v[:, :-1], v[:, 1:]), dim = -2)
+            k, v = tuple(rearrange(t, 'b w ... -> (b w) ...') for t in (k, v))
+
+            # take care of masking
+
+            idx = torch.arange(seq.shape[-2], device = seq.device)
+            q_idx = rearrange(idx, '(w n) -> w n', n = total_segment_len)
+            k_idx = pad_at_dim(q_idx, (1, 0), dim = 0, value = -1e4)
+            k_idx = cat((k_idx[:-1], k_idx[1:]), dim = -1)
+
+            q_idx = rearrange(q_idx, 'w i -> w i 1')
+            k_idx = rearrange(k_idx, 'w j -> w 1 j')
+
+            sliding_mask = (q_idx - k_idx) <= total_segment_len
+            sliding_mask = F.pad(sliding_mask, (self.num_persist_mem_tokens, 0), value = True)
+
+            sliding_mask = repeat(sliding_mask, 'w i j -> (b w) 1 i j', b = batch)
+            attend_kwargs.update(mask = sliding_mask)
+
+        # take care of persistent memory key / values
+
+        pmk, pmv = repeat(self.persistent_memory, 'kv ... -> kv b ...', b = k.shape[0])
+
+        # persistent memory
+
+        k = cat((pmk, k), dim = -2)
+        v = cat((pmv, v), dim = -2)
+
+        # attention
+
+        out, _ = self.attend(q, k, v, **attend_kwargs)
+
+        out = self.merge_heads(out)
+
+        out = self.to_out(out)
+
+        out = rearrange(out, '(b w) n d -> b (w n) d', b = batch)
+
+        out = inverse_segment(out)
+
+        if exists(output_gating):
+            out = out * output_gating
+
+        return out, AttnIntermediates(orig_v, next_cache)
+
+# MAC transformer
+
+class MemoryAsContextTransformer(Module):
+    def __init__(
+        self,
+        *,
+        num_tokens,
+        dim,
+        depth,
+        segment_len,
+        neural_memory_segment_len = None,
+        neural_mem_gate_attn_output = False,
+        neural_memory_add_value_residual = False,
+        num_longterm_mem_tokens = 0,
+        num_persist_mem_tokens = 0,
+        neural_memory_batch_size = None,
+        neural_memory_qkv_receives_diff_views = False,
+        dim_head = 64,
+        heads = 8,
+        ff_mult = 4,
+        num_residual_streams = 4,
+        neural_memory_model: Module | None = None,
+        neural_memory_kwargs: dict = dict(),
+        neural_memory_layers: tuple[int, ...] | None = None,
+        use_flex_attn = False,
+        sliding_window_attn = False,
+        neural_mem_weight_residual = False,
+        token_emb: Module | None = None,
+    ):
+        super().__init__()
+
+        if not exists(token_emb):
+            token_emb = nn.Embedding(num_tokens, dim)
+
+        self.token_emb = token_emb
+
+        # absolute positions
+
+        self.axial_pos_emb = ContinuousAxialPositionalEmbedding(dim = dim, num_axial_dims = 2)
+
+        # long term mem tokens
+
+        self.segment_len = segment_len
+
+        self.num_longterm_mem_tokens = num_longterm_mem_tokens
+        has_longterm_mems = num_longterm_mem_tokens > 0
+
+        self.longterm_mems = nn.Parameter(torch.randn(num_longterm_mem_tokens, dim) * 0.02)
+
+        # maybe sliding window attn
+
+        self.sliding_window_attn = sliding_window_attn
+        self.attn_window_size = segment_len + num_longterm_mem_tokens
+
+        # hyper connection
+
+        init_hyper_conn, self.expand_streams, self.reduce_streams = mc_get_init_and_expand_reduce_stream_functions(num_residual_streams, dim = dim, add_stream_embed = True, disable = num_residual_streams == 1)
+
+        self.layers = ModuleList([])
+
+        self.neural_memory_segment_len = default(neural_memory_segment_len, num_longterm_mem_tokens + segment_len)
+
+        layers = tuple(range(1, depth + 1))
+
+        neural_memory_layers = default(neural_memory_layers, layers)
+
+        # weight residual related
+
+        self.neural_mem_weight_residual = neural_mem_weight_residual
+        is_first_neural_mem = True
+
+        # mem, attn, and feedforward layers
+
+        for layer in layers:
+            is_first = layer == 1
+
+            # attention and feedforward
+
+            attn = SegmentedAttention(
+                dim = dim,
+                dim_head = dim_head,
+                heads = heads,
+                segment_len = segment_len,
+                use_flex_attn = use_flex_attn,
+                accept_value_residual = not is_first,
+                num_longterm_mem_tokens = num_longterm_mem_tokens,
+                num_persist_mem_tokens = num_persist_mem_tokens,
+                sliding = sliding_window_attn
+            )
+
+            mem = None
+            mem_qkv_layer_selector = None
+            mem_hyper_conn = None
+
+            if layer in neural_memory_layers:
+                mem_hyper_conn = init_hyper_conn(add_branch_out_to_residual = not neural_mem_gate_attn_output)
+
+                if not is_first and neural_memory_qkv_receives_diff_views:
+                    num_layer_choices = (layer - 1) * 4 + 1 # for each layer, have memory input select from attn inp, attn out, ff inp, and ff out - plus one for the current point in the residual stream (memory input)
+
+                    mem_qkv_layer_selector = nn.Sequential(
+                        nn.RMSNorm(dim),
+                        nn.Linear(dim, 3 * num_layer_choices),
+                        Rearrange('... (views layers) -> views ... layers', views = 3),
+                        nn.Softmax(dim = -1)
+                    )
+
+                mem = NeuralMemory(
+                    dim = dim,
+                    chunk_size = self.neural_memory_segment_len,
+                    batch_size = neural_memory_batch_size,
+                    model = deepcopy(neural_memory_model),
+                    qkv_receives_diff_views = True,
+                    accept_weight_residual = neural_mem_weight_residual and not is_first_neural_mem,
+                    **neural_memory_kwargs
+                )
+
+                is_first_neural_mem = False
+
+            ff = FeedForward(dim = dim, mult = ff_mult)
+
+            self.layers.append(ModuleList([
+                mem_hyper_conn,
+                init_hyper_conn(),
+                init_hyper_conn(),
+                mem_qkv_layer_selector,
+                mem,
+                attn,
+                ff,
+            ]))
+
+        self.norm = nn.RMSNorm(dim)
+
+        self.to_logits = LinearNoBias(dim, num_tokens)
+
+        # whether to gate the attention output with the retrieved memories
+
+        self.gate_attn_output = neural_mem_gate_attn_output
+
+        # zero for maybe aux loss + device
+
+        self.register_buffer('zero', torch.tensor(0.), persistent = False)
+
+        # flex attn related
+
+        assert not (use_flex_attn and not exists(flex_attention)), 'you need to be on the latest pytorch with a cuda device available'
+        self.use_flex_attn = use_flex_attn
+
+        self.num_persist_mem_tokens = num_persist_mem_tokens
+
+    def seq_index_is_longterm(
+        self,
+        seq_index
+    ):
+        total_segment_len, segment_len = self.attn_window_size, self.segment_len
+        return ((seq_index % total_segment_len + 1) - segment_len) > 0
+
+    def seq_len_with_longterm_mem(
+        self,
+        seq_len
+    ):
+        assert seq_len > 0
+
+        segment_len, num_mem = self.segment_len, self.num_longterm_mem_tokens
+        return ((seq_len - 1) // segment_len) * num_mem + seq_len
+
+    @torch.no_grad()
+    def sample(
+        self,
+        prompt: Tensor,
+        seq_len: int,
+        temperature = 1.5,
+        filter_fn: Callable = min_p_filter,
+        filter_kwargs: dict = dict(
+            min_p = 0.1,
+        ),
+        show_progress = True,
+        use_cache = False
+    ):
+        was_training = self.training
+        self.eval()
+
+        prompt_seq_len, out = prompt.shape[-1], prompt.clone()
+        sample_num_times = max(0, seq_len - prompt_seq_len)
+
+        # cache for axial pos, attention, and neural memory
+
+        cache = None
+        factorized_pos_emb = None
+
+        # precompute factorized pos emb
+
+        if use_cache:
+            seq_len_with_mem = self.seq_len_with_longterm_mem(seq_len)
+
+            axial_dims = self.axial_pos_emb.maybe_derive_outer_dim(seq_len_with_mem, (self.neural_memory_segment_len,))
+
+            factorized_pos_emb = self.axial_pos_emb(axial_dims, return_factorized = True)
+
+        # sample
+
+        with tqdm.tqdm(total = sample_num_times, disable = not show_progress) as pbar:
+
+            while out.shape[-1] < seq_len:
+
+                logits, next_cache = self.forward(
+                    out,
+                    disable_flex_attn = True,
+                    cache = cache,
+                    return_cache = True,
+                    factorized_pos_emb = factorized_pos_emb
+                )
+
+                if use_cache:
+                    cache = next_cache
+
+                if not exists(logits):
+                    continue
+
+                logits = logits[:, -1]
+
+                logits = filter_fn(logits, **filter_kwargs)
+                sample = gumbel_sample(logits, temperature = temperature)
+
+                out = torch.cat((out, sample), dim = -1)
+                pbar.update(1)
+
+        self.train(was_training)
+
+        return out[..., prompt_seq_len:]
+
+    def forward(
+        self,
+        x,
+        return_loss = False,
+        return_loss_breakdown = False,
+        disable_flex_attn = False,
+        cache = None,
+        return_cache = False,
+        factorized_pos_emb = None
+    ):
+
+        if return_loss:
+            x, labels = x[:, :-1], x[:, 1:]
+
+        # math
+
+        batch, seq_len, neural_mem_segment_len, segment_len, num_longterm_mem_tokens, attn_window_size = *x.shape, self.neural_memory_segment_len, self.segment_len, self.num_longterm_mem_tokens, self.attn_window_size
+
+        seq_len_with_mem = self.seq_len_with_longterm_mem(seq_len)
+
+        # token embedding
+
+        x = self.token_emb(x)
+
+        # intersperse longterm memory
+
+        x, inverse_segment = pad_and_segment_with_inverse(x, segment_len, inverse_remove_pad = False)
+
+        mems = repeat(self.longterm_mems, 'n d -> b n d', b = x.shape[0])
+        x, inverse_pack_mems = pack_with_inverse((x, mems), 'b * d')
+
+        x = inverse_segment(x)
+
+        # splice out unneeded tokens from padding for longterm mems
+
+        x = x[:, :seq_len_with_mem]
+
+        # apply axial positional embedding
+        # so intra and inter segment can be more easily discerned by the network
+
+        pos_emb = self.axial_pos_emb.forward_with_seq_len(seq_len_with_mem, (neural_mem_segment_len,), factorized = factorized_pos_emb)
+
+        x = x + pos_emb
+
+        # prep flex attention
+
+        use_flex_attn = x.is_cuda and self.use_flex_attn and not disable_flex_attn
+
+        flex_attn_fn = None
+
+        if use_flex_attn:
+            block_mask = create_mac_block_mask(seq_len_with_mem, self.attn_window_size, self.num_persist_mem_tokens, self.sliding_window_attn)
+            flex_attn_fn = partial(flex_attention, block_mask = block_mask)
+
+        # kv caching
+
+        is_inferencing = exists(cache)
+
+        if not exists(cache):
+            cache = (seq_len_with_mem - 1, None, None)
+
+        inference_seq_index, kv_caches, neural_mem_caches = cache
+
+        kv_caches = iter(default(kv_caches, []))
+        neural_mem_caches = iter(default(neural_mem_caches, []))
+
+        next_kv_caches = []
+        next_neural_mem_caches = []
+
+        # value residual
+
+        value_residual = None
+
+        # neural mem weight residual
+
+        mem_weight_residual = None
+
+        # layers for the neural mem to select the qkv inputs from
+
+        mem_input_layers = []
+
+        # when inferencing, only do one token at a time
+
+        if is_inferencing:
+            ind = inference_seq_index
+            x = x[:, ind:(ind + 1)]
+
+        # expand and reduce streams for hyper connections
+
+        x = self.expand_streams(x)
+
+        for mem_hyper_conn, attn_hyper_conn, ff_hyper_conn, mem_qkv_layer_selector, mem, attn, ff in self.layers:
+
+            retrieved = None
+            attn_out_gates = None
+            next_neural_mem_cache = None
+
+            # maybe neural memory
+
+            if exists(mem):
+
+                mem_input, add_residual = mem_hyper_conn(x)
+
+                if not exists(mem_qkv_layer_selector):
+                    qkv_mem_input = stack((mem_input, mem_input, mem_input))
+                else:
+                    layers_to_choose_from = stack((mem_input, *mem_input_layers))
+
+                    # let the current `mem_input` select the 3 layers for qkv
+
+                    selected = mem_qkv_layer_selector(mem_input)
+
+                    qkv_mem_input = einsum(layers_to_choose_from, selected, 'l b n d, v b n l -> v b n d')
+
+                retrieved, next_neural_mem_cache = mem.forward(
+                    qkv_mem_input,
+                    state = next(neural_mem_caches, None),
+                    prev_weights = mem_weight_residual
+                )
+
+                if self.neural_mem_weight_residual:
+                    mem_weight_residual = next_neural_mem_cache.updates
+
+                if self.gate_attn_output:
+                    attn_out_gates = retrieved.sigmoid()
+                else:
+                    x = add_residual(retrieved)
+
+            # attention
+
+            attn_in, add_residual = attn_hyper_conn(x)
+
+            mem_input_layers.append(attn_in)
+
+            attn_out, (values, next_kv_cache) = attn(
+                attn_in,
+                value_residual = value_residual,
+                disable_flex_attn = disable_flex_attn,
+                flex_attn_fn = flex_attn_fn,
+                output_gating = attn_out_gates,
+                cache = next(kv_caches, None)
+            )
+
+            mem_input_layers.append(attn_out)
+
+            value_residual = default(value_residual, values)
+
+            x = add_residual(attn_out)
+
+            # caches
+
+            next_kv_caches.append(next_kv_cache)
+            next_neural_mem_caches.append(next_neural_mem_cache)
+
+            # feedforward
+
+            ff_in, add_ff_residual = ff_hyper_conn(x)
+
+            mem_input_layers.append(ff_in)
+
+            ff_out = ff(ff_in)
+
+            mem_input_layers.append(ff_out)
+
+            x = add_ff_residual(ff_out)
+
+        # taking care of cache first
+        # for early return when processing long term mem tokens during inference
+
+        if return_cache:
+            next_kv_caches = stack([stack(kv_cache) for kv_cache in next_kv_caches])
+
+            # handle kv cache length depending on local attention type
+
+            next_kv_caches = next_kv_caches[..., -attn_window_size:, :]
+
+            kv_cache_length = next_kv_caches.shape[-2]
+
+            if not self.sliding_window_attn and divisible_by(kv_cache_length, attn_window_size):
+                next_kv_caches = next_kv_caches[..., 0:0, :]
+
+            next_cache = (
+                inference_seq_index + 1,
+                next_kv_caches,
+                next_neural_mem_caches
+            )
+
+            is_longterm_mem = self.seq_index_is_longterm(inference_seq_index)
+
+            if is_inferencing and is_longterm_mem:
+                return None, next_cache
+
+        # hyper connection reducing of streams
+
+        x = self.reduce_streams(x)
+
+        # excise out the memories
+
+        if not is_inferencing:
+
+            x, inverse_segment = pad_and_segment_with_inverse(x, attn_window_size, inverse_remove_pad = False)
+
+            x, _ = inverse_pack_mems(x)
+
+            x = inverse_segment(x)
+
+            x = x[:, :seq_len]
+
+        # to logits
+
+        x = self.norm(x)
+
+        logits = self.to_logits(x)
+
+        if not return_loss:
+            if not return_cache:
+                return logits
+
+            return logits, next_cache
+
+        return F.cross_entropy(rearrange(logits, 'b n l -> b l n'), labels)

titans_pytorch/nested_attention.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import torch
+from torch import nn, cat, is_tensor
+import torch.nn.functional as F
+from torch.nn import Module, ModuleList
+from torch.utils._pytree import tree_map
+
+from einops.layers.torch import Rearrange
+
+from rotary_embedding_torch import RotaryEmbedding
+
+# functions
+
+def exists(v):
+    return v is not None
+
+# classes
+
+class NestedAttention(Module):
+    def __init__(
+        self,
+        dim,
+        *,
+        dim_head = 64,
+        heads = 8,
+        prenorm = True,
+        keys_rmsnorm = True # https://openreview.net/forum?id=HkztQWZfl2
+    ):
+        super().__init__()
+
+        self.norm = nn.RMSNorm(dim) if prenorm else nn.Identity()
+
+        dim_inner = dim_head * heads
+        self.to_queries = nn.Linear(dim, dim_inner, bias = False)
+
+        # keys and values
+
+        self.rotary_embed = RotaryEmbedding(dim_head)
+
+        self.to_keys = nn.Linear(dim, dim_inner * 3, bias = False)
+        self.to_values = nn.Linear(dim, dim_inner * 3, bias = False)
+
+        self.key_norms = ModuleList([nn.RMSNorm(dim_head) for _ in range(3)])
+        self.nested_key_norm = nn.RMSNorm(dim_head)
+
+        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
+        self.merge_heads = Rearrange('b h n d -> b n (h d)')
+
+        self.to_out = nn.Linear(dim_inner, dim, bias = False)
+
+    def forward(
+        self,
+        tokens,
+        cache = None,
+        return_kv_cache = False
+    ):
+        batch, seq_len, device = *tokens.shape[:2], tokens.device
+
+        tokens = self.norm(tokens)
+
+        queries = self.to_queries(tokens)
+
+        keys = self.to_keys(tokens).chunk(3, dim = -1)
+        values = self.to_values(tokens).chunk(3, dim = -1)
+
+        # split heads for input as well as all keys, values that form the implicit weights
+
+        queries, keys, values = tree_map(self.split_heads, (queries, keys, values))
+
+        # maybe norm all keys
+
+        keys = [norm(k) for norm, k in zip(self.key_norms, keys)]
+
+        # cache
+
+        if exists(cache):
+            (cache_keys, cache_values), (cache_nested_keys, cache_nested_values) = cache
+
+            keys = [cat(args, dim = -2) for args in zip(cache_keys, keys)]
+            values = [cat(args, dim = -2) for args in zip(cache_values, values)]
+
+        # attend
+
+        def attend(q, k, v):
+            q, k = self.rotary_embed.rotate_queries_with_cached_keys(q, k)
+
+            return F.scaled_dot_product_attention(q, k, v, is_causal = True)
+
+        # nested attention
+
+        nq, nk, nv = [attend(queries, key, value) for key, value in zip(keys, values)]
+
+        nk = self.nested_key_norm(nk)
+
+        if exists(cache):
+            nk = cat((cache_nested_keys, nk), dim = -2)
+            nv = cat((cache_nested_values, nv), dim = -2)
+
+        out = attend(nq, nk, nv)
+
+        # merge heads
+
+        out = self.merge_heads(out)
+
+        out = self.to_out(out)
+
+        if not return_kv_cache:
+            return out
+
+        return out, ((keys, values), (nk, nv))
+
+if __name__ == '__main__':
+
+    nested_attn = NestedAttention(512)
+
+    tokens = torch.randn(1, 1024, 512)
+
+    out1, cache = nested_attn(tokens)
+    out2, cache = nested_attn(tokens[:, -1:], cache = cache)
+
+    assert out1.shape == tokens.shape
+    assert out2.shape == (1, 1, 512)

train_implicit_mlp_attn.py

@@ -0,0 +1,259 @@
+# /// script
+# dependencies = [
+#     "accelerate",
+#     "titans-pytorch",
+#     "tqdm"
+# ]
+# ///
+
+import math
+import gzip
+import random
+import tqdm
+import numpy as np
+
+import torch
+from torch.optim import Adam
+from torch import nn, Tensor
+from torch.nn import Module, ModuleList
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+
+from einops import rearrange
+
+from titans_pytorch.implicit_mlp_attention import ImplicitMLPAttention
+from titans_pytorch.nested_attention import NestedAttention
+
+from accelerate import Accelerator
+
+# constants
+
+NUM_BATCHES = int(1e5)
+BATCH_SIZE = 4
+GRAD_ACCUM_EVERY = 4
+LEARNING_RATE = 1e-4
+VALIDATE_EVERY = 100
+PRIME_LENGTH = 32
+GENERATE_EVERY = 250
+GENERATE_LENGTH = 512
+SEQ_LEN = 512
+
+# helpers
+
+def exists(v):
+    return v is not None
+
+def cycle(loader):
+    while True:
+        for data in loader:
+            yield data
+
+def decode_token(token):
+    return str(chr(max(32, token)))
+
+def decode_tokens(tokens):
+    return "".join(list(map(decode_token, tokens)))
+
+# sampling helpers
+
+def log(t, eps = 1e-20):
+    return torch.log(t.clamp(min = eps))
+
+def gumbel_noise(t):
+    noise = torch.rand_like(t)
+    return -log(-log(noise))
+
+def gumbel_sample(t, temperature = 1., dim = -1, keepdim = True):
+    return ((t / max(temperature, 1e-10)) + gumbel_noise(t)).argmax(dim = dim, keepdim = keepdim)
+
+def top_k(logits, thres = 0.9):
+    k = math.ceil((1 - thres) * logits.shape[-1])
+    val, ind = torch.topk(logits, k)
+    probs = torch.full_like(logits, float('-inf'))
+    probs.scatter_(-1, ind, val)
+    return probs
+
+class Transformer(Module):
+    def __init__(
+        self,
+        *,
+        num_tokens,
+        dim,
+        depth,
+        heads = 8,
+        implicit_mlp_attn_hiddens = (64, 96, 64),
+        use_nested_attn = False,
+        dim_head = 64,
+        ff_expansion = 4.,
+        attn_kwargs: dict = dict(),
+    ):
+        super().__init__()
+        self.token_emb = nn.Embedding(num_tokens, dim)
+
+        self.layers = ModuleList([])
+
+        for _ in range(depth):
+
+            if use_nested_attn:
+                attn = NestedAttention(
+                    dim = dim,
+                    dim_head = dim_head,
+                    heads = heads,
+                    **attn_kwargs
+                )
+            else:
+                attn = ImplicitMLPAttention(
+                    dim = dim,
+                    mlp_hiddens = implicit_mlp_attn_hiddens,
+                    heads = heads,
+                    **attn_kwargs
+                )
+
+            ff = nn.Sequential(
+                nn.RMSNorm(dim),
+                nn.Linear(dim, int(dim * ff_expansion)),
+                nn.GELU(),
+                nn.Linear(int(dim * ff_expansion), dim)
+            )
+
+            self.layers.append(ModuleList([attn, ff]))
+
+        self.norm = nn.RMSNorm(dim)
+        self.to_logits = nn.Linear(dim, num_tokens, bias = False)
+
+    def sample(
+        self,
+        prompt: Tensor,
+        seq_len: int,
+        temperature = 1.,
+        filter_thres = 0.9,
+    ):
+        prompt_seq_len, out = prompt.shape[-1], prompt.clone()
+        sample_num_times = max(0, seq_len - prompt_seq_len)
+
+        for _ in range(sample_num_times):
+            logits = self.forward(out, return_loss = False)
+            logits = logits[:, -1]
+
+            logits = top_k(logits, thres = filter_thres)
+            sample = gumbel_sample(logits, temperature = temperature, dim = -1)
+
+            out = torch.cat((out, sample), dim = -1)
+
+        return out[..., prompt_seq_len:]
+
+    def forward(self, x, return_loss = False):
+
+        if return_loss:
+            x, target = x[:, :-1], x[:, 1:]
+
+        seq_len, device = x.shape[-1], x.device
+
+        tokens = self.token_emb(x)
+
+        for attn, ff in self.layers:
+            tokens = attn(tokens) + tokens
+            tokens = ff(tokens) + tokens
+
+        embed = self.norm(tokens)
+        logits = self.to_logits(embed)
+
+        if not return_loss:
+            return logits
+
+        return F.cross_entropy(
+            rearrange(logits, 'b n l -> b l n'),
+            target
+        )
+
+model = Transformer(
+    num_tokens = 256,
+    dim = 512,
+    depth = 6,
+    implicit_mlp_attn_hiddens = (64, 96, 64),
+    use_nested_attn = True # test implicit mlp attn vs nested attn
+)
+
+# prepare enwik8 data
+
+with gzip.open("./data/enwik8.gz") as file:
+    data = np.frombuffer(file.read(int(95e6)), dtype=np.uint8).copy()
+    np_train, np_valid = np.split(data, [int(90e6)])
+    data_train, data_val = torch.from_numpy(np_train), torch.from_numpy(np_valid)
+
+class TextSamplerDataset(Dataset):
+    def __init__(self, data, seq_len):
+        super().__init__()
+        self.data = data
+        self.seq_len = seq_len
+
+    def __len__(self):
+        return self.data.size(0) // self.seq_len
+
+    def __getitem__(self, index):
+        rand_start = torch.randint(0, self.data.size(0) - self.seq_len, (1,))
+        full_seq = self.data[rand_start : rand_start + self.seq_len + 1].long()
+        return full_seq
+
+train_dataset = TextSamplerDataset(data_train, SEQ_LEN)
+val_dataset = TextSamplerDataset(data_val, SEQ_LEN)
+train_loader = DataLoader(train_dataset, batch_size = BATCH_SIZE)
+val_loader = DataLoader(val_dataset, batch_size = BATCH_SIZE)
+
+# optimizer
+
+optim = Adam(model.parameters(), lr = LEARNING_RATE)
+
+# accelerate
+
+accelerator = Accelerator()
+
+model, optim, train_loader, val_loader = accelerator.prepare(model, optim, train_loader, val_loader)
+
+# cycle
+
+train_loader = cycle(train_loader)
+val_loader = cycle(val_loader)
+
+# training
+
+for i in tqdm.tqdm(range(NUM_BATCHES), mininterval = 10.0, desc = "training"):
+    model.train()
+
+    for _ in range(GRAD_ACCUM_EVERY):
+        data = next(train_loader)
+
+        loss = model(data, return_loss = True)
+
+        accelerator.backward(loss / GRAD_ACCUM_EVERY)
+
+    accelerator.print(f"training loss: {loss.item():.3f}")
+
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
+
+    optim.step()
+    optim.zero_grad()
+
+    if i % VALIDATE_EVERY == 0:
+        model.eval()
+        with torch.no_grad():
+            valid_data = next(val_loader)
+
+            loss = model(valid_data, return_loss = True)
+            accelerator.print(f"validation loss: {loss.item():.3f}")
+
+    if i % GENERATE_EVERY == 0:
+        model.eval()
+
+        inp = next(val_loader)[0, :PRIME_LENGTH]
+
+        prime = decode_tokens(inp)
+        accelerator.print(f"\n\n[prompt]: {prime}")
+
+        prompt = inp[None, ...]
+
+        sampled = model.sample(prompt, GENERATE_LENGTH)
+
+        base_decode_output = decode_tokens(sampled[0])
+
+        accelerator.print(f"\n[generated]: {base_decode_output}\n\n")

train_mac.py

@@ -0,0 +1,200 @@
+# /// script
+# dependencies = [
+#     "accelerate",
+#     "adam-atan2-pytorch>=0.1.18",
+#     "setuptools",
+#     "titans-pytorch",
+#     "tqdm",
+#     "wandb"
+# ]
+# ///
+
+import random
+import tqdm
+import gzip
+import numpy as np
+
+import torch
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, Dataset
+
+from adam_atan2_pytorch import AdoptAtan2
+
+from titans_pytorch import (
+    MemoryAsContextTransformer,
+    MemoryMLP,
+    MemoryAttention
+)
+
+# constants
+
+NUM_BATCHES = int(1e5)
+BATCH_SIZE = 4
+GRADIENT_ACCUMULATE_EVERY = 4
+LEARNING_RATE = 2e-4
+VALIDATE_EVERY  = 100
+GENERATE_EVERY  = 500
+PRIME_LENGTH = 100
+GENERATE_LENGTH = 512
+SHOULD_GENERATE = True
+SEQ_LEN = 512
+
+# neural memory related
+
+NEURAL_MEMORY_DEPTH = 2
+NUM_PERSIST_MEM = 4
+NUM_LONGTERM_MEM = 4
+NEURAL_MEM_LAYERS = (2, 4, 6)                   # layers 2, 4, 6 have neural memory, can add more
+NEURAL_MEM_GATE_ATTN_OUTPUT = False
+NEURAL_MEM_MOMENTUM = True
+NEURAL_MEM_MOMENTUM_ORDER = 1
+NEURAL_MEM_QK_NORM = True
+NEURAL_MEM_MAX_LR = 1e-1
+USE_MEM_ATTENTION_MODEL = False
+WINDOW_SIZE = 32
+NEURAL_MEM_SEGMENT_LEN = 4                      # set smaller for more granularity for learning rate / momentum etc
+NEURAL_MEM_BATCH_SIZE = 128                     # set smaller to update the neural memory weights more often as it traverses the sequence
+SLIDING_WINDOWS = True
+STORE_ATTN_POOL_CHUNKS = True                   # whether to use attention pooling for chunk derived momentum, per-layer lr mod, decay
+MEMORY_MODEL_PER_LAYER_LEARNED_LR = True
+NEURAL_MEM_WEIGHT_RESIDUAL = True               # learning to accept contributions from the weights of the previous neural mem layer brings about significant improvements. this was improvised and not in the paper, but inspired by the value residual learning free lunch paper
+NEURAL_MEM_QKV_RECEIVES_DIFF_VIEW = True        # will allow the neural memory to select what layers from which to derive queries / keys / values, effectively allowing it to graft itself to the transformer in any way to be beneficial. this is to address an issue from a phd student who noted that the mem network is learning nothing more than wk @ wv. this also generalizes all possible ways to connect the neural memory to a transformer, a sort of NAS
+NEURAL_MEM_SPEC_NORM_SURPRISES = True           # applying lessons from Muon optimizer to surprise updates, by spectral norming the surprises
+
+# experiment related
+
+PROJECT_NAME = 'titans-mac-transformer'
+RUN_NAME = f'mac - {NUM_LONGTERM_MEM} longterm mems, layers {NEURAL_MEM_LAYERS}'
+WANDB_ONLINE = False # turn this on to pipe experiment to cloud
+
+# perf related
+
+USE_ACCELERATED_SCAN = True
+USE_FLEX_ATTN = True
+USE_FAST_INFERENCE = False
+
+# wandb experiment tracker
+
+import wandb
+wandb.init(project = PROJECT_NAME, mode = 'disabled' if not WANDB_ONLINE else 'online')
+wandb.run.name = RUN_NAME
+wandb.run.save()
+
+# helpers
+
+def cycle(loader):
+    while True:
+        for data in loader:
+            yield data
+
+def decode_token(token):
+    return str(chr(max(32, token)))
+
+def decode_tokens(tokens):
+    return ''.join(list(map(decode_token, tokens)))
+
+# memory model
+
+if USE_MEM_ATTENTION_MODEL:
+    neural_memory_model = MemoryAttention(
+        dim = 64
+    )
+else:
+    neural_memory_model = MemoryMLP(
+        dim = 64,
+        depth = NEURAL_MEMORY_DEPTH
+    )
+
+# instantiate memory-as-context transformer
+
+model = MemoryAsContextTransformer(
+    num_tokens = 256,
+    dim = 384,
+    depth = 8,
+    segment_len = WINDOW_SIZE,
+    num_persist_mem_tokens = NUM_PERSIST_MEM,
+    num_longterm_mem_tokens = NUM_LONGTERM_MEM,
+    neural_memory_layers = NEURAL_MEM_LAYERS,
+    neural_memory_segment_len = NEURAL_MEM_SEGMENT_LEN,
+    neural_memory_batch_size = NEURAL_MEM_BATCH_SIZE,
+    neural_mem_gate_attn_output = NEURAL_MEM_GATE_ATTN_OUTPUT,
+    neural_mem_weight_residual = NEURAL_MEM_WEIGHT_RESIDUAL,
+    neural_memory_qkv_receives_diff_views = NEURAL_MEM_QKV_RECEIVES_DIFF_VIEW,
+    use_flex_attn = USE_FLEX_ATTN,
+    sliding_window_attn = SLIDING_WINDOWS,
+    neural_memory_model = neural_memory_model,
+    neural_memory_kwargs = dict(
+        dim_head = 64,
+        heads = 4,
+        attn_pool_chunks = STORE_ATTN_POOL_CHUNKS,
+        qk_rmsnorm = NEURAL_MEM_QK_NORM,
+        momentum = NEURAL_MEM_MOMENTUM,
+        momentum_order = NEURAL_MEM_MOMENTUM_ORDER,
+        default_step_transform_max_lr = NEURAL_MEM_MAX_LR,
+        use_accelerated_scan = USE_ACCELERATED_SCAN,
+        per_parameter_lr_modulation = MEMORY_MODEL_PER_LAYER_LEARNED_LR,
+        spectral_norm_surprises = NEURAL_MEM_SPEC_NORM_SURPRISES
+    )
+).cuda()
+
+# prepare enwik8 data
+
+with gzip.open('./data/enwik8.gz') as file:
+    data = np.frombuffer(file.read(int(95e6)), dtype = np.uint8).copy()
+    data_train, data_val = np.split(data, [int(90e6)])
+    data_train, data_val = map(torch.from_numpy, (data_train, data_val))
+
+class TextSamplerDataset(Dataset):
+    def __init__(self, data, seq_len):
+        super().__init__()
+        self.data = data
+        self.seq_len = seq_len
+
+    def __getitem__(self, index):
+        rand_start = torch.randint(0, self.data.size(0) - self.seq_len, (1,))
+        full_seq = self.data[rand_start: rand_start + self.seq_len + 1].long()
+        return full_seq.cuda()
+
+    def __len__(self):
+        return self.data.size(0) // self.seq_len
+
+train_dataset = TextSamplerDataset(data_train, SEQ_LEN)
+val_dataset   = TextSamplerDataset(data_val, SEQ_LEN)
+train_loader  = cycle(DataLoader(train_dataset, batch_size = BATCH_SIZE))
+val_loader    = cycle(DataLoader(val_dataset, batch_size = BATCH_SIZE))
+
+# optimizer
+
+optim = AdoptAtan2(model.parameters(), lr = LEARNING_RATE)
+
+# training
+
+for i in tqdm.tqdm(range(NUM_BATCHES), mininterval = 10., desc = 'training'):
+    model.train()
+
+    for __ in range(GRADIENT_ACCUMULATE_EVERY):
+        loss = model(next(train_loader), return_loss = True)
+        loss.backward()
+
+    print(f'training loss: {loss.item():.4f}')
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
+    optim.step()
+    optim.zero_grad()
+    wandb.log(dict(loss = loss.item()))
+
+    if i % VALIDATE_EVERY == 0:
+        model.eval()
+        with torch.no_grad():
+            loss = model(next(val_loader), return_loss = True)
+            print(f'validation loss: {loss.item():.4f}')
+
+    if SHOULD_GENERATE and i % GENERATE_EVERY == 0:
+        model.eval()
+        inp = random.choice(val_dataset)[:PRIME_LENGTH]
+        prime = decode_tokens(inp)
+        print(f'%s \n\n %s', (prime, '*' * 100))
+
+        sample = model.sample(inp[None, ...], GENERATE_LENGTH, use_cache = USE_FAST_INFERENCE)
+        output_str = decode_tokens(sample[0])
+        print(output_str)