Add v4 Qwen3+Titans code snapshot and README

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+*.log

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Phil Wang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,98 @@
+---
+license: mit
+---
+
+## 这里是什么
+
+这是一个**最小代码快照**：只包含运行 `examples/train_qwen_titans_babilong_v4.py`（Qwen3 + Titans v4，BABILong QA1 32k，跨 chunk 梯度）所需的仓库内代码文件。
+
+- **不包含**：Qwen 权重、BABILong 数据集文件、以及原项目中 v4 未使用的其它模块
+- **用途**：方便复现实验/对照、归档 v4 代码与配置要点
+
+---
+
+## 代码清单（仅 v4 用到的仓库内代码）
+
+- `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）
+
+---
+
+## 权重目录与数据集目录（v4 默认配置）
+
+`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`
+
+说明：
+- 这两个路径**不会被上传到本仓库**，这里只做“路径与配置说明”。
+- v4 脚本当前**没有**提供 `--model_path/--data_path` 命令行参数；如需改路径，请直接改 `TrainingConfig` 里的默认值。
+
+---
+
+## 程序特性（v4 重点）
+
+v4 的目标是：在 32k 长序列 chunk streaming 的训练中，尽可能实现**跨 chunk 的梯度流动**，并在显存可控的前提下训练“记忆模块 + 少量底座参数”。
+
+- **跨 chunk 梯度（核心）**
+  - `chunkwise_backward=False`：整段序列（32k）一起反传（而不是每个 chunk 独立反传）
+  - `detach_mem_state=False`：记忆 state 不 detach，使梯度图能跨 chunk 连接
+  - `cross_chunk_gradient_steps`：限制梯度回传穿过多少个历史 chunk（控制显存/稳定性）
+
+- **冻结策略（v4 header 描述）**
+  - 冻结 Qwen backbone 的大部分参数
+  - **保留可训练**：`embed_tokens`（输入适配）、`lm_head`（必要时解开 tied weights）、以及 Titans 记忆模块相关参数
+
+- **学习率分组（v4：更细粒度）**
+  - `lr_memory` / `lr_memory_attention`：记忆模块（含 deep integration 相关）
+  - `lr_embed`：`embed_tokens`
+  - `lr_lm_head`：`lm_head`
+
+- **稳定性与兼容性**
+  - 脚本开头主动禁用/模拟 `torchao`，避免 `transformers` 导入时的版本冲突
+  - 建议开启 `gradient_checkpointing=True`（v4 默认开启），缓解 32k full backward 的显存压力
+  - 支持 DDP/FSDP（FSDP auto-wrap `Qwen3DecoderLayer` 与 v4 自定义层）
+
+- **评估与保存**
+  - 评估指标为 **answer-only**（只在 `labels != -100` 的答案 token 上计算 loss/acc）
+  - 输出：
+    - `eval_metrics.jsonl`
+    - `final_memory_checkpoint.pt`（仅保存 requires_grad 且属于记忆/门控/embed/head 的参数）
+    - `final_full_checkpoint.pt`（可选保存完整 state_dict）
+
+---
+
+## 运行方式（示例）
+
+以下命令仅作参考；请先在脚本中把 `model_path/data_path` 改成你机器上的真实路径。
+
+- **单机多卡（FSDP）训练**：
+
+```bash
+torchrun --standalone --nproc_per_node=4 examples/train_qwen_titans_babilong_v4.py --fsdp
+```
+
+- **评估（eval_only）**：
+
+```bash
+python examples/train_qwen_titans_babilong_v4.py --eval_only --ckpt_path ./outputs/qwen_titans_babilong_v4/final_memory_checkpoint.pt
+```
+
+---
+
+## 依赖提示（非完整列表）
+
+该脚本依赖的关键 Python 包包括：`torch`、`transformers`、`einops`、`tqdm`、`tensordict`、`assoc-scan`、`einx` 等。
+
+---
+
+## 许可证与来源
+
+本仓库内的 `titans_pytorch/*` 代码来自上游 `titans-pytorch`（MIT License），对应许可见 `LICENSE`。
+

examples/train_qwen_titans_babilong_v4.py

@@ -0,0 +1,1902 @@
+"""
+Qwen3 + Titans v4 - BABILong QA1 (32k) with Cross-Chunk Gradients
+
+Key design:
+1. Freeze Qwen backbone EXCEPT embed_tokens (trainable for input adaptation)
+2. Untie lm_head from embed_tokens if they share weights
+3. Train: Memory modules + embed_tokens + lm_head
+4. Use chunkwise_backward=False + detach_mem_state=False for TRUE cross-chunk gradients
+5. Enable gradient_checkpointing to manage memory usage
+
+Cross-chunk gradient flow:
+- chunkwise_backward=False: entire sequence backward together
+- detach_mem_state=False: memory state keeps gradient graph
+- cross_chunk_gradient_steps: controls how many chunks back gradient flows
+"""
+
+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_v4"
+
+    # training
+    num_epochs: int = 10
+    batch_size: int = 1
+    gradient_accumulation_steps: int = 16
+    max_grad_norm: float = 1.0
+
+    # learning rates (v4: separate rates for memory, embed, head)
+    lr_memory: float = 1e-4
+    lr_memory_attention: float = 5e-5
+    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 / memory
+    chunk_size: int = 4096
+    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
+
+    # Memory state detachment - controls cross-chunk gradient flow
+    # False = allow gradient flow through memory state (requires chunkwise_backward=False)
+    # True = detach memory state each chunk (no cross-chunk gradients)
+    detach_mem_state: bool = False  # Enable cross-chunk gradients!
+    deep_memory_integration: bool = False
+    memory_as_context: bool = False
+    num_memory_tokens: int = 16
+    memory_gate_bias: float = -2.0
+    use_momentum: bool = True
+    momentum_order: int = 1
+
+    # Gradient flow control - NOW ACTIVE with chunkwise_backward=False
+    # cross_chunk_gradient_steps: how many chunks back gradient can flow through memory
+    gradient_checkpoint_memory: bool = False
+    cross_chunk_gradient_steps: int = 2  # Allow gradient through 2 recent chunks
+
+    # 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  # Enable to manage memory with full-sequence backward
+    chunkwise_backward: bool = False  # Disable for cross-chunk gradients
+
+    # 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"
+    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 (from 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 (from v3, with cross-chunk gradient flow)
+# =============================================================================
+
+class QwenDecoderLayerWithDeepMemory(nn.Module):
+    """
+    v4: Uses v3's deep memory integration with cross-chunk gradient flow.
+    The base Qwen layer will be frozen in v4.
+    """
+    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 (v3 feature)
+        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,
+            max_grad_norm=1.0,
+            spectral_norm_surprises=True,
+            use_accelerated_scan=False,
+        )
+
+        # Layer-level memory gate
+        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)
+
+        # Deep attention integration (from v3)
+        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
+
+        # Pre-attention memory projection (from v3)
+        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 (v3 feature)."""
+        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 (v3 feature).
+
+        FIXED logic:
+        - If detach_mem_state=True: Always detach (blocks all cross-chunk gradients)
+        - If detach_mem_state=False: Allow gradient flow through N recent chunks
+          where N = _gradient_steps_back (controlled by cross_chunk_gradient_steps)
+
+        For cross-chunk gradient flow to work, must set detach_mem_state=False!
+        """
+        if self.detach_mem_state:
+            return True  # Legacy behavior: always detach
+        # 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 (v3 feature)
+        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,
+                )
+
+            # 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 (v4 with frozen backbone)
+# =============================================================================
+
+class QwenTitansForBABILongV4(nn.Module):
+    """
+    v4: Qwen3 with deep Titans memory integration and cross-chunk gradients.
+    Trains: memory modules + embed_tokens + lm_head
+    Frozen: Qwen transformer layers (attention, MLP, etc.)
+    """
+    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 = []
+
+        # ===== v4 FREEZING LOGIC =====
+        self._freeze_backbone()
+
+        if self.use_memory:
+            logger.info("[QwenTitansForBABILongV4] Initialized with FROZEN backbone")
+            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("[QwenTitansForBABILongV4] 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 (v3 feature)
+        for layer in self._memory_layers:
+            layer.set_gradient_steps_back(config.cross_chunk_gradient_steps)
+
+    def _freeze_backbone(self):
+        """
+        v4: Freeze Qwen transformer layers, keep embed_tokens + lm_head trainable.
+
+        Trainable:
+        - memory modules (neural_memory, mem_gate, memory_attention)
+        - embed_tokens (for input adaptation)
+        - lm_head (for output adaptation)
+
+        Frozen:
+        - All transformer layers (attention, MLP, layernorm)
+        """
+        frozen_count = 0
+        trainable_count = 0
+        embed_count = 0
+        lm_head_count = 0
+
+        # CRITICAL: Untie lm_head from embed_tokens if they share weights
+        # This allows them to be trained independently
+        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("[v4] Detected tied weights - untying lm_head from embed_tokens")
+                # Create independent lm_head with copied weights
+                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,
+                )
+                # Copy weights
+                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)
+                # Replace lm_head
+                self.qwen.lm_head = new_lm_head
+                logger.info(f"[v4] Created independent lm_head: {new_lm_head.weight.shape}")
+
+        # Freeze/unfreeze parameters
+        for name, param in self.named_parameters():
+            is_memory = "neural_memory" in name or "mem_gate" in name
+            is_memory_attention = "memory_attention" in name or "memory_context_proj" in name
+            is_embed_tokens = "embed_tokens" in name
+            is_lm_head = "lm_head" in name
+
+            if is_memory or is_memory_attention:
+                param.requires_grad = True
+                trainable_count += 1
+            elif is_embed_tokens:
+                # embed_tokens is TRAINABLE for input adaptation
+                param.requires_grad = True
+                trainable_count += 1
+                embed_count += 1
+                logger.info(f"[v4] embed_tokens trainable: {name}")
+            elif is_lm_head:
+                # lm_head is TRAINABLE for output adaptation
+                param.requires_grad = True
+                trainable_count += 1
+                lm_head_count += 1
+                logger.info(f"[v4] lm_head trainable: {name}")
+            else:
+                # Freeze transformer layers
+                param.requires_grad = False
+                frozen_count += 1
+
+        logger.info(f"[v4] Frozen {frozen_count} transformer layer parameters")
+        logger.info(f"[v4] Trainable {trainable_count} parameters (memory + embed: {embed_count} + lm_head: {lm_head_count})")
+
+    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):
+        """
+        v4: Four parameter groups with different learning rates.
+        - memory_core: neural_memory, mem_gate
+        - memory_attention: memory_attention, memory_context_proj (if exists)
+        - embed_tokens: input embeddings
+        - lm_head: output head
+        """
+        memory_core_params = []
+        memory_attention_params = []
+        embed_params = []
+        lm_head_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)
+            elif "embed_tokens" in name:
+                embed_params.append(param)
+            elif "lm_head" in name:
+                lm_head_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(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"[v4 Param groups] memory_core={len(memory_core_params)}, "
+                   f"memory_attention={len(memory_attention_params)}, "
+                   f"embed_tokens={len(embed_params)}, lm_head={len(lm_head_params)}")
+        return param_groups
+
+
+# =============================================================================
+# Distributed Training Utilities (unchanged from v3)
+# =============================================================================
+
+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.
+    This allows cross-chunk gradients to work with multi-GPU training.
+
+    Key insight: DDP fails because it tracks parameter usage during forward.
+    By not wrapping the model with DDP, we avoid this tracking.
+    We then manually all-reduce gradients before optimizer step.
+    """
+    if world_size <= 1:
+        return
+
+    # Collect all gradients that need syncing
+    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
+
+    # Flatten all gradients into a single buffer for efficiency
+    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)
+
+    # Pack gradients into flat buffer
+    offset = 0
+    for grad in grads_to_reduce:
+        numel = grad.numel()
+        flat_grads[offset:offset + numel] = grad.view(-1)
+        offset += numel
+
+    # All-reduce (sum) then divide by world_size
+    dist.all_reduce(flat_grads, op=dist.ReduceOp.SUM)
+    flat_grads.div_(world_size)
+
+    # Unpack gradients back
+    offset = 0
+    for grad in grads_to_reduce:
+        numel = grad.numel()
+        grad.copy_(flat_grads[offset:offset + numel].view_as(grad))
+        offset += numel
+
+
+# =============================================================================
+# Trainer (unchanged from v3, works with v4's frozen backbone)
+# =============================================================================
+
+class Trainer:
+    def __init__(
+        self,
+        model: QwenTitansForBABILongV4,
+        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,  # v4: for cross-chunk gradients with multi-GPU
+    ):
+        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  # v4: manual gradient sync mode
+
+        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 v4 training with 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
+                            # no_sync only available when model is wrapped with DDP/FSDP
+                            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"]
+                                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:
+                        # For manual grad sync mode, no_sync is not available (model not wrapped)
+                        # For DDP/FSDP, use no_sync during gradient accumulation
+                        use_no_sync = (
+                            self.is_distributed and
+                            not sync_gradients and
+                            not self.use_manual_grad_sync and  # no_sync not available in manual mode
+                            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
+
+                    # v4: Manual gradient sync for cross-chunk gradients with multi-GPU
+                    # This replaces DDP's automatic gradient sync
+                    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:  # Only unscale if not already done
+                            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_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_mem={lr_mem:.2e} | 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:
+                            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 and trainable parameters
+        memory_sd = {
+            name: p.detach().cpu()
+            for name, p in base_model.named_parameters()
+            if p.requires_grad and (
+                ("neural_memory" in name) or ("mem_gate" in name) or
+                ("memory_attention" in name) or ("memory_context_proj" in name) or
+                ("embed_tokens" in name) or ("lm_head" 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) or
+                   ("embed_tokens" in k) or ("lm_head" 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 v4 - 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("--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")
+
+    # v4 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("--lr_embed", type=float, default=None,
+                       help="Learning rate for embed_tokens")
+    parser.add_argument("--lr_lm_head", type=float, default=None,
+                       help="Learning rate for lm_head")
+
+    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_v4"
+    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
+
+    # v4 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.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
+
+    # Note: gradient_checkpointing is REQUIRED for full-sequence backward with 32k tokens
+    # Keeping it enabled even with DDP for v4's cross-chunk gradient mode
+    if is_distributed and (not config.use_fsdp) and config.gradient_checkpointing:
+        if is_main:
+            logger.info("gradient_checkpointing enabled for cross-chunk gradient mode")
+
+    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 v4 Training (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(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}")
+        logger.info("=" * 70)
+        logger.info("v4 FEATURE: Cross-chunk gradients enabled")
+        logger.info(f"chunkwise_backward={config.chunkwise_backward}, detach_mem_state={config.detach_mem_state}")
+        logger.info("Trainable: Memory + 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 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
+        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 = QwenTitansForBABILongV4(qwen_model, config)
+    model.to(device)
+
+    # ==========================================================================
+    # v4 Multi-GPU Strategy for Cross-Chunk Gradients
+    # ==========================================================================
+    # DDP is incompatible with cross-chunk gradients because it tracks parameter
+    # usage during forward. Memory modules are used multiple times across chunks,
+    # causing "ready twice" errors.
+    #
+    # Solution: Manual gradient synchronization
+    # - Don't wrap model with DDP when chunkwise_backward=False
+    # - Manually call all_reduce on gradients before optimizer step
+    # - This allows true cross-chunk gradient flow with multi-GPU training
+    # ==========================================================================
+
+    use_ddp = is_distributed and world_size > 1
+    use_manual_grad_sync = False  # Track if we're using manual sync
+
+    if use_ddp and not config.chunkwise_backward:
+        # Cross-chunk gradients mode: use manual gradient sync instead of DDP
+        if is_main:
+            logger.info("=" * 70)
+            logger.info("Cross-chunk gradients with multi-GPU: using MANUAL gradient sync")
+            logger.info("Model NOT wrapped with DDP - gradients will be all-reduced manually")
+            logger.info("=" * 70)
+        use_ddp = False  # Don't wrap with DDP
+        use_manual_grad_sync = True  # Use manual gradient sync instead
+        # Keep is_distributed=True for DistributedSampler to work
+
+    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, 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,  # Keep True for DistributedSampler
+        tokenizer=tokenizer,
+        use_manual_grad_sync=use_manual_grad_sync,  # v4: manual gradient sync for cross-chunk
+    )
+
+    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()

titans_pytorch/__init__.py

@@ -0,0 +1,17 @@
+"""
+Minimal `titans_pytorch` exports for `train_qwen_titans_babilong_v4.py`.
+
+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.neural_memory import NeuralMemState, NeuralMemory, mem_state_detach
+from titans_pytorch.memory_models import MemoryMLP
+
+__all__ = [
+    "NeuralMemory",
+    "NeuralMemState",
+    "mem_state_detach",
+    "MemoryMLP",
+]

titans_pytorch/memory_models.py

@@ -0,0 +1,248 @@
+import torch
+from torch import nn, cat
+import torch.nn.functional as F
+from torch.nn import Module, ModuleList, Parameter, ParameterList
+
+from einops import rearrange
+
+# functions
+
+def l2norm(t):
+    return F.normalize(t, dim = -1)
+
+# norms
+
+class LayerNorm(Module):
+    def __init__(
+        self,
+        dim
+    ):
+        super().__init__()
+
+        self.ln = nn.LayerNorm(dim, elementwise_affine = False)
+        self.gamma = Parameter(torch.zeros(dim))
+
+    def forward(self, x):
+        gamma = self.gamma
+
+        if gamma.ndim == 2:
+            gamma = rearrange(gamma, 'b d -> b 1 d')
+
+        return self.ln(x) * (gamma + 1.)
+
+# norm + residual wrapper, as used in original TTT paper
+# but could be removed
+
+class ResidualNorm(Module):
+    def __init__(
+        self,
+        dim,
+        model: Module
+    ):
+        super().__init__()
+        self.norm = LayerNorm(dim)
+        self.model = model
+
+    def forward(self, x):
+
+        out = self.model(x)
+
+        return self.norm(out) + x
+
+# memory mlp proposed in TTT
+
+class MemoryMLP(Module):
+    def __init__(
+        self,
+        dim,
+        depth,
+        expansion_factor = 2.
+    ):
+        super().__init__()
+        dim_hidden = int(dim * expansion_factor)
+        dims = (dim, *((dim_hidden,) * (depth - 1)), dim)
+
+        self.weights = ParameterList([Parameter(torch.randn(dim_in, dim_out)) for dim_in, dim_out in zip(dims[:-1], dims[1:])])
+
+        for weight in self.weights:
+            nn.init.xavier_uniform_(weight)
+
+    def forward(
+        self,
+        x
+    ):
+        for ind, weight in enumerate(self.weights):
+            is_first = ind == 0
+
+            if not is_first:
+                x = F.gelu(x)
+
+            x = x @ weight
+
+        return x
+
+# memory mlp, but with gated residual + final projection
+
+class GatedResidualMemoryMLP(Module):
+    def __init__(
+        self,
+        dim,
+        depth,
+        expansion_factor = 4.
+    ):
+        super().__init__()
+        dim_hidden = int(dim * expansion_factor)
+
+        self.weights = ParameterList([
+            ParameterList([
+                Parameter(torch.randn(dim, dim_hidden)),
+                Parameter(torch.randn(dim_hidden, dim)),
+                Parameter(torch.randn(dim * 2, dim)),
+            ]) for _ in range(depth)
+        ])
+
+        self.final_proj = Parameter(torch.randn(dim, dim))
+
+        for param in self.parameters():
+            nn.init.xavier_uniform_(param)
+
+    def forward(
+        self,
+        x
+    ):
+
+        for weight1, weight2, to_gates in self.weights:
+            res = x
+
+            hidden = x @ weight1
+            hidden = F.gelu(hidden)
+            branch_out = hidden @ weight2
+
+            # gated residual
+
+            gates = cat((branch_out, res), dim = -1) @ to_gates
+            x = res.lerp(branch_out, gates.sigmoid())
+
+        return x @ self.final_proj
+
+# memory mlp with factorized weights
+# so can tradeoff capacity for smaller chunk sizes
+
+class FactorizedMemoryMLP(Module):
+    def __init__(
+        self,
+        dim,
+        depth,
+        k = 32
+    ):
+        super().__init__()
+        self.weights = ParameterList([
+            ParameterList([
+                Parameter(torch.randn(dim, k)),
+                Parameter(torch.randn(k, dim)),
+            ]) for _ in range(depth)
+        ])
+
+        for weight1, weight2 in self.weights:
+            nn.init.xavier_uniform_(weight1)
+            nn.init.xavier_uniform_(weight2)
+
+    def forward(
+        self,
+        x
+    ):
+
+        for ind, (weight1, weight2) in enumerate(self.weights):
+            is_first = ind == 0
+
+            if not is_first:
+                x = F.gelu(x)
+
+            x = x @ weight1 @ weight2
+
+        return x
+
+# an MLP modelled after the popular swiglu ff in modern transformers
+
+class MemorySwiGluMLP(Module):
+    def __init__(
+        self,
+        dim,
+        depth = 1, # default to 2 layer MLP from TTT, depth of 2 would be 4 layer MLP, but done as 2 feedforwards with residual
+        expansion_factor = 4.
+    ):
+        super().__init__()
+
+        dim_inner = int(dim * expansion_factor * 2 / 3)
+
+        weights = []
+
+        for _ in range(depth):
+            weights.append(ParameterList([
+                Parameter(torch.randn(dim, dim_inner * 2)),
+                Parameter(torch.randn(dim_inner, dim)),
+            ]))
+
+        self.weights = ParameterList(weights)
+        self.norm = LayerNorm(dim)
+
+    def forward(self, x):
+
+        for w1, w2 in self.weights:
+            residual = x
+
+            x, gates = (x @ w1).chunk(2, dim = -1)
+
+            x = x * F.gelu(gates)
+
+            x = x @ w2
+
+            x = x + residual
+
+        return self.norm(x)
+
+# improvised attention as memory module
+
+class MemoryAttention(Module):
+    def __init__(
+        self,
+        dim,
+        scale = 8.,
+        expansion_factor = 2.
+    ):
+        super().__init__()
+        self.scale = scale
+        dim_ff_hidden = int(dim * expansion_factor)
+
+        self.weights = ParameterList([
+            Parameter(torch.randn(dim, dim)), # queries
+            Parameter(torch.randn(dim, dim)), # keys
+            Parameter(torch.randn(dim, dim)), # values
+            Parameter(torch.randn(dim, dim_ff_hidden)), # ff w1
+            Parameter(torch.randn(dim_ff_hidden, dim)), # ff w2
+        ])
+
+        for weight in self.weights:
+            nn.init.xavier_uniform_(weight)
+
+    def forward(self, x):
+
+        wq, wk, wv, ffw1, ffw2 = self.weights
+
+        q = l2norm(x @ wq)
+        k = l2norm(x @ wk)
+        v = x @ wv
+
+        attn_out = F.scaled_dot_product_attention(
+            q, k, v,
+            scale = self.scale,
+            is_causal = True
+        )
+
+        # parallel attention + feedforward block
+        # as in PaLM + Gpt-J
+
+        h = F.gelu(x @ ffw1)
+        ff_out = h @ ffw2
+
+        return attn_out + ff_out

titans_pytorch/neural_memory.py

@@ -0,0 +1,1087 @@
+from __future__ import annotations
+from typing import Callable
+
+import math
+from functools import partial
+from itertools import zip_longest
+from collections import namedtuple
+
+import torch
+from torch import nn, stack, cat, is_tensor, tensor, Tensor
+import torch.nn.functional as F
+from torch.nn import Linear, Module, Parameter, ParameterList, ParameterDict
+from torch.func import functional_call, vmap, grad
+from torch.utils._pytree import tree_map, tree_flatten, tree_unflatten
+
+from tensordict import TensorDict
+
+from assoc_scan import AssocScan
+
+from titans_pytorch.memory_models import(
+    MemoryMLP,
+    ResidualNorm
+)
+
+import einx
+from einops import einsum, rearrange, repeat, reduce, pack, unpack
+from einops.layers.torch import Rearrange, Reduce
+
+"""
+ein notation:
+b - batch
+h - heads
+bh - batch and heads
+n - sequence
+d - feature dimension
+c - intra-chunk
+w - num memory network weight parameters
+o - momentum orders
+u - key / value updates - allowing a token to emit multiple key / values
+"""
+
+LinearNoBias = partial(Linear, bias = False)
+
+# neural mem state related
+
+NeuralMemState = namedtuple('NeuralMemState', [
+    'seq_index',
+    'weights',
+    'cache_store_segment',
+    'states',
+    'updates',
+])
+
+def mem_state_detach(
+    state: NeuralMemState
+):
+    assert isinstance(state, NeuralMemState)
+    state = tree_map(lambda t: t.detach() if is_tensor(t) else t, tuple(state))
+    return NeuralMemState(*state)
+
+# functions
+
+def exists(v):
+    return v is not None
+
+def default(*args):
+    for arg in args:
+        if exists(arg):
+            return arg
+    return None
+
+def identity(t):
+    return t
+
+def xnor(x, y):
+    return not (x ^ y)
+
+def divisible_by(num, den):
+    return (num % den) == 0
+
+def safe_cat(inputs, dim = -2):
+    inputs = tuple(filter(exists, inputs))
+
+    if len(inputs) == 0:
+        return None
+    elif len(inputs) == 1:
+        return inputs[0]
+
+    return cat(inputs, dim = dim)
+
+def is_empty_tensor(t):
+    return t.numel() == 0
+
+def dict_get_value_shapes(td):
+    return [v.shape for k, v in td.items()]
+
+def rearrange_dict_values(td, pattern, **kwargs):
+    return td.apply(lambda t: rearrange(t, pattern, **kwargs))
+
+def repeat_dict_values(td, pattern, **kwargs):
+    return td.apply(lambda t: repeat(t, pattern, **kwargs))
+
+def pair(v):
+    return (v, v) if not isinstance(v, tuple) else v
+
+def round_down_multiple(seq, mult):
+    return seq // mult * mult
+
+def round_up_multiple(seq, mult):
+    return math.ceil(seq / mult) * mult
+
+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 pack_one_with_inverse(t, pattern):
+    packed, packed_shape = pack([t], pattern)
+
+    def inverse(out, inv_pattern = None):
+        inv_pattern = default(inv_pattern, pattern)
+        return unpack(out, packed_shape, inv_pattern)[0]
+
+    return packed, inverse
+
+def Sequential(*modules):
+    modules = [*filter(exists, modules)]
+
+    if len(modules) == 0:
+        return nn.Identity()
+
+    if len(modules) == 1:
+        return modules[0]
+
+    return nn.Sequential(*modules)
+
+# softclamping gradients
+
+def softclamp_max(t, max_value):
+    half_max_value = max_value / 2
+    return ((t / half_max_value).tanh() * half_max_value) + half_max_value
+
+def softclamp_grad_norm(t, max_value, eps: float = 1e-6):
+    if is_empty_tensor(t):
+        return t
+
+    t, inverse = pack_one_with_inverse(t, 'bn *')
+
+    norm = t.norm(dim = -1, keepdim = True).clamp(min = eps)
+    clamped_norm = softclamp_max(norm, max_value)
+
+    t = t * (clamped_norm / norm)
+    return inverse(t)
+
+# spectral norming the surprise update w/ newton schulz matrix iter
+# Keller Jordan et al. from OSS w/ nanogpt, now being used for two works, Atlas and 'TTT done right'
+
+def newtonschulz5(
+    t,
+    steps = 5,
+    eps = 1e-7,
+    coefs = (3.4445, -4.7750, 2.0315)
+):
+    if t.ndim <= 3:
+        return t
+
+    shape = t.shape
+    should_transpose = shape[-2] > shape[-1]
+
+    if should_transpose:
+        t = t.transpose(-1, -2)
+
+    t, inv_pack = pack_one_with_inverse(t, '* i j')
+    t = t / t.norm(dim = (-1, -2), keepdim = True).clamp(min = eps)
+
+    a, b, c = coefs
+
+    for _ in range(steps):
+        A = t @ t.transpose(-1, -2)
+        B = b * A + c * A @ A
+        t = a * t + B @ t
+
+    if should_transpose:
+        t = t.transpose(-1, -2)
+
+    return inv_pack(t)
+
+# multi head rmsnorm
+
+class MultiheadRMSNorm(Module):
+    def __init__(self, dim, heads):
+        super().__init__()
+        self.rmsnorm = nn.RMSNorm(dim, elementwise_affine = False)
+        self.gamma = Parameter(torch.zeros(heads, 1, dim))
+
+    def forward(self, x):
+        return self.rmsnorm(x) * (self.gamma + 1.)
+
+# chunk pooling
+
+class AveragePool(Module):
+    def __init__(
+        self,
+        chunk_size
+    ):
+        super().__init__()
+        self.chunk_size = chunk_size
+
+    def forward(
+        self,
+        x,
+        chunk_size = None
+    ):
+        chunk_size = default(chunk_size, self.chunk_size)
+        return reduce(x, 'b (n c) d -> b n d', 'mean', c = chunk_size)
+
+class AttentionPool(Module):
+    def __init__(
+        self,
+        dim,
+        chunk_size
+    ):
+        """
+        taken from Enformer https://www.nature.com/articles/s41592-021-01252-x , in turn taken from somewhere else
+        """
+        super().__init__()
+        self.chunk_size = chunk_size
+        self.to_attn_logits = nn.Linear(dim, dim)
+
+        # default to average pool
+
+        nn.init.zeros_(self.to_attn_logits.weight)
+        nn.init.zeros_(self.to_attn_logits.bias)
+
+    def forward(
+        self,
+        x,
+        chunk_size = None
+    ):
+        chunk_size = default(chunk_size, self.chunk_size)
+
+        x = rearrange(x, 'b (n c) d -> b n c d', c = chunk_size)
+
+        attn_logits = self.to_attn_logits(x)
+
+        attn = attn_logits.softmax(dim = -2)
+
+        return reduce(x * attn, 'b n c d -> b n d', 'sum')
+
+# main neural memory
+
+def default_adaptive_step_transform(adaptive_step, max_lr = 1e-2):
+    return adaptive_step.sigmoid() * max_lr
+
+def default_loss_fn(pred, target):
+    return (pred - target).pow(2).mean(dim = -1)
+
+class NeuralMemory(Module):
+    def __init__(
+        self,
+        dim,
+        chunk_size: int | tuple[int, int] = 1,
+        batch_size = None,
+        dim_head = None,
+        heads = 1,
+        model: Module | None = None,
+        store_memory_loss_fn: Callable = default_loss_fn,
+        adaptive_step_transform: Callable | None = None,
+        default_step_transform_max_lr = 1.,
+        per_parameter_lr_modulation = False, # allow outer network to control learning rate per weight matrix of memory network
+        max_mem_layer_modulation = 1., # max of 10.
+        per_head_learned_parameters = True,
+        attn_pool_chunks = False,
+        momentum = True,
+        momentum_order = 1,
+        learned_momentum_combine = False,
+        learned_combine_include_zeroth = False,
+        num_kv_per_token = 1, # whether a single token can do multiple updates to the memory model
+        qkv_receives_diff_views = False, # to address an issue raised by a phd student (who will be credited if experiments are green). basically the issue raised is that the memory MLP is only learning Wk @ Wv linear mapping and that may not be expressive enough. we will use hyper connections to allow the network to choose different previous layer inputs as keys / values and see if that does anything
+        pre_rmsnorm = True,
+        post_rmsnorm = False,
+        qk_rmsnorm = False,
+        max_grad_norm: float | None = None,
+        use_accelerated_scan = False,
+        activation: Module | None = None,
+        init_adaptive_step_bias = None,
+        init_momentum_bias = None,
+        init_decay_bias = None,
+        accept_weight_residual = False,
+        spectral_norm_surprises = False,
+        gated_transition = False,
+        mem_model_norm_add_residual = True, # by default, layernorm output and add residual as proposed in TTT paper, but could be removed
+        default_model_kwargs: dict = dict(
+            depth = 2,
+            expansion_factor = 4.
+        )
+    ):
+        super().__init__()
+        dim_head = default(dim_head, dim)
+        assert not (heads == 1 and dim_head != dim)
+
+        self.retrieve_chunk_size, self.store_chunk_size = pair(chunk_size)
+
+        # batch size
+
+        if exists(batch_size):
+            assert divisible_by(batch_size, self.store_chunk_size)
+
+        self.batch_size = batch_size
+
+        # associative scan
+
+        self.assoc_scan = AssocScan(use_accelerated = use_accelerated_scan)
+
+        # key values receiving different views
+
+        self.qkv_receives_diff_views = qkv_receives_diff_views
+
+        # norms
+
+        self.retrieve_norm = nn.RMSNorm(dim) if pre_rmsnorm else nn.Identity()
+        self.store_norm = nn.RMSNorm(dim) if pre_rmsnorm else nn.Identity()
+
+        self.multihead_rmsnorm = MultiheadRMSNorm(dim_head, heads) if post_rmsnorm else nn.Identity()
+
+        self.q_norm = MultiheadRMSNorm(dim_head, heads) if qk_rmsnorm else nn.Identity()
+        self.k_norm = MultiheadRMSNorm(dim_head, heads) if qk_rmsnorm else nn.Identity()
+
+        # maybe multi-headed
+
+        dim_inner = dim_head * heads
+
+        self.heads = heads
+
+        self.split_heads = Rearrange('b n (h d) -> b h n d', h = heads)
+        self.split_kv_heads = Rearrange('b n (h u d) -> b h (n u) d', h = heads, u = num_kv_per_token)
+
+        self.merge_heads = Rearrange('b h n d -> b n (h d)')
+        self.combine_heads = LinearNoBias(dim_inner, dim) if heads > 1 else nn.Identity()
+
+        self.retrieve_gate = Sequential(
+            LinearNoBias(dim, heads),
+            Rearrange('b n h -> b h n 1'),
+            nn.Sigmoid()
+        ) if heads > 1 else None
+
+        # memory model
+
+        if not exists(model):
+            model = MemoryMLP(dim_head, **default_model_kwargs)
+
+        # validate memory model
+
+        assert not exists(next(model.buffers(), None)), 'model cannot have buffers for now'
+
+        test_shape = (3, 2, dim_head)
+
+        with torch.no_grad():
+            try:
+                test_input = torch.randn(test_shape)
+                mem_model_output = model(test_input)
+            except:
+                raise RuntimeError(f'memory model unable to accept a tensor of shape {test_shape}')
+
+            assert mem_model_output.shape == test_shape, 'output of memory model needs to be same shape as input'
+
+        # the memory is the weights of the model
+
+        if mem_model_norm_add_residual:
+            model = ResidualNorm(dim = dim_head, model = model)
+
+        self.memory_model = model
+
+        mem_model_params = dict(model.named_parameters())
+
+        self.num_memory_parameter_tensors = len(mem_model_params)
+
+        self.memory_model_parameter_names = [*mem_model_params.keys()]
+
+        memory_model_parameters = [*mem_model_params.values()]
+
+        if per_head_learned_parameters:
+            memory_model_parameters = [repeat(p, '... -> h ...', h = heads) for p in memory_model_parameters]
+
+        self.init_weight_shape = [p.shape for p in memory_model_parameters]
+
+        self.memory_model_parameters = ParameterList(memory_model_parameters)
+        self.per_head_learned_parameters = per_head_learned_parameters
+
+        # the chunk size within the paper where adaptive step, momentum, weight decay are shared
+
+        self.chunk_size = chunk_size
+
+        # prepare function for per sample gradients from model above, using torch.func
+
+        def forward_and_loss(params, inputs, loss_weights, target):
+            pred = functional_call(self.memory_model, params, inputs)
+            loss = self.store_memory_loss_fn(pred, target) # simple mse loss in paper - eq (12) - |M(k) - v|²
+            weighted_loss = loss * loss_weights
+            return weighted_loss.sum(), loss
+
+        # two functions
+
+        grad_fn = grad(forward_and_loss, has_aux = True)
+
+        self.per_sample_grad_fn = vmap(grad_fn, in_dims = (0, 0, 0, 0))
+
+        # queries for retrieving from the model
+
+        self.to_queries = Sequential(LinearNoBias(dim, dim_inner), activation)
+
+        # keys and values for storing to the model
+
+        assert num_kv_per_token > 0
+
+        self.to_keys = Sequential(
+            LinearNoBias(dim, dim_inner * num_kv_per_token),
+            activation,
+        )
+
+        self.to_values = Sequential(
+            LinearNoBias(dim, dim_inner * num_kv_per_token),
+            activation,
+        )
+
+        self.store_memory_loss_fn = store_memory_loss_fn
+
+        self.num_kv_per_token = num_kv_per_token
+
+        # `chunk_size` refers to chunk size used for storing to memory model weights
+
+        chunk_size = self.store_chunk_size
+
+        # whether to use averaging of chunks, or attention pooling
+
+        assert not (attn_pool_chunks and chunk_size == 1), '`attn_pool_chunks` cannot be set to True if `chunk_size` is set to 1'
+
+        if not attn_pool_chunks:
+            self.reduce_to_chunk_rep = AveragePool(chunk_size = chunk_size)
+        else:
+            self.reduce_to_chunk_rep = AttentionPool(dim, chunk_size = chunk_size)
+
+        # learned adaptive learning rate
+
+        self.to_adaptive_step = Sequential(
+            nn.Linear(dim, heads * num_kv_per_token),
+            Rearrange('b n (h u) -> (b h) (n u)', u = num_kv_per_token)
+        )
+
+        if not exists(adaptive_step_transform):
+            adaptive_step_transform = partial(default_adaptive_step_transform, max_lr = default_step_transform_max_lr)
+
+        self.adaptive_step_transform = adaptive_step_transform
+
+        # momentum related
+
+        self.to_momentum = Sequential(
+            nn.Linear(dim, heads * momentum_order),
+            Rearrange('b n (h o) -> o (b h) n 1', o = momentum_order)
+        ) if momentum else None
+
+        self.momentum_order = momentum_order
+        self.to_learned_momentum_combine = None
+
+        if learned_momentum_combine:
+            assert momentum
+            assert momentum_order > 1, 'only second order momentum allowed for now, but may allow learned combination of zeroth'
+
+            if learned_combine_include_zeroth:
+                momentum_order += 1
+
+            self.to_learned_momentum_combine = Sequential(
+                nn.Linear(dim, heads * momentum_order),
+                Rearrange('b n (h o) -> o (b h) n', h = heads),
+                nn.Softmax(dim = 0),
+            )
+
+            self.learned_combine_include_zeroth = learned_combine_include_zeroth
+
+        # per layer learning rate modulation
+
+        self.to_layer_modulation = Sequential(
+            nn.Linear(dim, heads * self.num_memory_parameter_tensors),
+            Rearrange('b n (h w) -> w (b h) n', h = heads),
+            nn.Sigmoid()
+        ) if per_parameter_lr_modulation else None
+
+        self.max_mem_layer_modulation = max_mem_layer_modulation
+
+        # learned weight residual
+
+        self.to_learned_weight_residual_mix = Sequential(
+            nn.Linear(dim, heads),
+            Rearrange('b n h -> b h n'),
+            nn.Sigmoid()
+        ) if accept_weight_residual else None
+
+        # allow for softclamp the gradient norms for storing memories
+
+        self.max_grad_norm = max_grad_norm
+
+        # spectral norming the surprises before update, a la Muon from Jordan et al.
+
+        self.spectral_norm_surprises = spectral_norm_surprises
+
+        # weight decay factor
+
+        self.to_decay_factor = Sequential(
+            nn.Linear(dim, heads),
+            Rearrange('b n h -> (b h) n 1')
+        )
+
+        # learned transition, as seeing instability when decreasing neural mem batch size
+        # perhaps it can slowly learn to adjust from early residual to fully transitioning to new weights every batch size
+
+        self.transition_gate = nn.Parameter(tensor(-5.)) if gated_transition else None
+
+        # inits
+
+        if exists(init_adaptive_step_bias):
+            linear = self.to_adaptive_step[0]
+            nn.init.zeros_(linear.weight)
+            nn.init.constant_(linear.bias, init_adaptive_step_bias)
+
+        if exists(init_momentum_bias):
+            linear = self.to_momentum[0]
+            nn.init.zeros_(linear.weight)
+            nn.init.constant_(linear.bias, init_momentum_bias)
+
+        if exists(init_decay_bias):
+            linear = self.to_decay_factor[0]
+            nn.init.zeros_(linear.weight)
+            nn.init.constant_(linear.bias, init_decay_bias)
+
+        # maybe use accelerated scan
+
+        self.use_accelerated_scan = use_accelerated_scan
+
+        self.register_buffer('zero', torch.tensor(0.), persistent = False)
+
+    @property
+    def memory_model_parameter_dict(self):
+        return TensorDict(dict(zip(self.memory_model_parameter_names, self.memory_model_parameters)))
+
+    def init_weights(
+        self,
+        batch,
+    ):
+        if self.per_head_learned_parameters:
+            weights = repeat_dict_values(self.memory_model_parameter_dict, 'h ... -> (b h) ...', b = batch)
+        else:
+            weights = repeat_dict_values(self.memory_model_parameter_dict, '... -> bh ...', bh = batch * self.heads)
+
+        return weights
+
+    def init_momentum(
+        self,
+        batch,
+    ):
+        zeros = self.memory_model_parameter_dict.clone().zero_()
+
+        if self.per_head_learned_parameters:
+            zeros = repeat_dict_values(zeros, 'h ... -> o (b h) ...', b = batch, o = self.momentum_order)
+        else:
+            zeros = repeat_dict_values(zeros, '... -> o bh ...', bh = batch * self.heads, o = self.momentum_order)
+
+        return zeros
+
+    def store_memories(
+        self,
+        seq,
+        weights: dict[str, Tensor] | None = None,
+        past_state: tuple[dict[str, Tensor], dict[str, Tensor]] | None = None,
+        seq_index = 0,
+        prev_weights = None,
+        mask: Tensor | None = None,
+        return_surprises = True
+    ):
+        if self.qkv_receives_diff_views:
+            _, batch, seq_len = seq.shape[:3]
+        else:
+            batch, seq_len = seq.shape[:2]
+
+        # shapes and variables
+
+        heads, chunk_size, num_updates = self.heads, self.store_chunk_size, self.num_kv_per_token
+
+        # curtail sequence by multiple of the chunk size
+        # only a complete chunk of the sequence provides the memory for the next chunk
+
+        round_down_seq_len = round_down_multiple(seq_len, chunk_size)
+        num_chunks = round_down_seq_len // chunk_size
+
+        seq, remainder = seq[..., :round_down_seq_len, :], seq[..., round_down_seq_len:, :]
+
+        next_seq_len_index = seq_index + round_down_seq_len
+
+        # init weights if needed
+        # weights of the memory network
+
+        if not exists(weights):
+            weights = self.init_weights(batch)
+
+        weights = TensorDict(weights)
+
+        # allow for neural memory of a previous layer to influence surprise of current layer
+
+        weights_for_surprise = repeat_dict_values(weights, 'b ... -> b n ...', n = num_chunks)
+
+        # initial norm
+
+        seq = self.store_norm(seq)
+
+        # handle keys and values coming from different sequences from hyper connection
+
+        values_seq = seq
+
+        if self.qkv_receives_diff_views:
+            seq, values_seq = seq
+
+        # derive learned hparams for optimization of memory network
+
+        adaptive_lr = self.to_adaptive_step(seq)
+        adaptive_lr = self.adaptive_step_transform(adaptive_lr)
+
+        chunked_seq = self.reduce_to_chunk_rep(seq, chunk_size = chunk_size)
+
+        decay_factor = self.to_decay_factor(chunked_seq).sigmoid()
+
+        need_layer_lr_mod = exists(self.to_layer_modulation) and num_chunks > 0
+        has_momentum = exists(self.to_momentum)
+
+        if has_momentum:
+            adaptive_momentum = self.to_momentum(chunked_seq).sigmoid()
+
+            learned_combine = exists(self.to_learned_momentum_combine)
+
+            if learned_combine:
+                combine_momentums = self.to_learned_momentum_combine(chunked_seq)
+
+        if need_layer_lr_mod:
+            layer_lr_mod = self.to_layer_modulation(chunked_seq) * self.max_mem_layer_modulation
+
+        # keys and values
+
+        keys = self.to_keys(seq)
+        values = self.to_values(values_seq)
+
+        # maybe multi head
+
+        keys, values = map(self.split_kv_heads, (keys, values))
+
+        # maybe keys rmsnorm
+
+        keys = self.k_norm(keys)
+
+        # take care of chunking
+
+        keys, values = tuple(rearrange(t, 'b h (n c u) d -> (b h n) (c u) d', c = chunk_size, u = num_updates) for t in (keys, values))
+
+        # adaptive lr
+
+        adaptive_lr = rearrange(adaptive_lr, 'b (n c u) -> (b n) (c u)', c = chunk_size, u = num_updates)
+
+        # optionally a storing memories mask can be passed in. if False, will set the learning rate to 0. for those positions
+
+        if exists(mask):
+            mask = mask[..., :round_down_seq_len]
+            mask = repeat(mask, 'b (n c) -> (b h n) (c u)', h = heads, u = num_updates, c = chunk_size)
+
+            adaptive_lr = torch.where(mask, adaptive_lr, 0.)
+
+        # maybe add previous layer weight
+
+        assert xnor(exists(self.to_learned_weight_residual_mix), exists(prev_weights))
+
+        if exists(prev_weights):
+
+            start_index = math.ceil(seq_index / chunk_size)
+            end_index = start_index + num_chunks
+
+            prev_weights = prev_weights.apply(lambda t: t[:, start_index:end_index])
+
+            if exists(self.to_learned_weight_residual_mix) and num_chunks > 0:
+                mix = self.to_learned_weight_residual_mix(chunked_seq)
+                mix = rearrange(mix, 'b h n -> (b h) n')
+                prev_weights = prev_weights.apply(lambda t: einx.multiply('bh n, bh n ... -> bh n ...', mix, t))
+
+            weights_for_surprise = weights_for_surprise + prev_weights
+
+        # flatten batch and time if surprise depends on previous layer memory model
+
+        weights_for_surprise = rearrange_dict_values(weights_for_surprise, 'b n ... -> (b n) ...')
+
+        # get grads and extra auxiliary loss (for backwarding through qkv projection in base neural memory module)
+
+        grads, unweighted_mem_model_loss = self.per_sample_grad_fn(dict(weights_for_surprise), keys, adaptive_lr, values)
+
+        grads = TensorDict(grads)
+
+        # surprises
+
+        adaptive_lr = rearrange(adaptive_lr, '(b h n) c -> b h (n c)', b = batch, h = heads)
+        unweighted_mem_model_loss = rearrange(unweighted_mem_model_loss, '(b h n) c -> b h (n c)', b = batch, h = heads)
+
+        # maybe softclamp grad norm
+
+        if exists(self.max_grad_norm):
+            grads = grads.apply(lambda t: softclamp_grad_norm(t, self.max_grad_norm))
+
+        # restore batch and sequence dimension
+
+        grads = rearrange_dict_values(grads, '(b n) ... -> b n ...', b = batch * heads)
+
+        # maybe per layer modulation
+
+        if need_layer_lr_mod:
+            grads = TensorDict({name: einx.multiply('b h, b h ... -> b h ...', layer_lr_mod, t) for layer_lr_mod, (name, t) in zip(layer_lr_mod, grads.items())})
+
+        # negative gradients, adaptive lr already applied as loss weight
+
+        surprises = grads.mul(-1)
+
+        # past states
+
+        if not exists(past_state):
+            # minibatch_init_weight corresponds to W0 in figure 7 of TTT paper
+
+            minibatch_init_weight = weights
+            init_momentum = self.init_momentum(batch)
+
+            past_state = (minibatch_init_weight, init_momentum)
+
+        past_last_update, past_last_momentum = past_state
+
+        # early return if sequence length less than chunk size
+
+        if num_chunks == 0:
+            updates = rearrange_dict_values(weights, 'bh ... -> bh 1 ...')
+            next_store_state = NeuralMemState(next_seq_len_index, weights, remainder, past_state, updates)
+
+            output = (updates, next_store_state)
+
+            if not return_surprises:
+                return output
+
+            return (*output, (unweighted_mem_model_loss, adaptive_lr))
+
+        # momentum + weight decay - momentum is the new contribution, as most linear RNNs have learned forgetting gates
+
+        updates = TensorDict()
+
+        next_last_update = TensorDict()
+        next_last_momentum = TensorDict()
+
+        for (param_name, surprise), (_, last_update) in zip(surprises.items(), past_last_update.items()):
+
+            update = surprise
+
+            # derive momentum with associative scan - eq (10)
+
+            if has_momentum:
+                momentum = surprise
+
+                momentums = [] # stores all momentum orders starting with first, to generalize to Nth order momentum
+
+                last_momentum = past_last_momentum[param_name]
+
+                # go from first order momentum all the way to the Nth
+
+                for one_adaptive_momentum, one_last_momentum in zip_longest(adaptive_momentum, last_momentum):
+                    momentum = self.assoc_scan(one_adaptive_momentum, momentum, prev = one_last_momentum) # momentum is S / surprise in the paper
+
+                    momentums.append(momentum)
+
+                momentums = stack(momentums)
+
+                next_last_momentum[param_name] = momentums[:, :, -1] # momentums shape is Float['o bh n 1']
+
+                if learned_combine and self.learned_combine_include_zeroth:
+                    # add the original surprise if learned combination of momentums
+                    momentums = cat((rearrange(surprise, '... -> 1 ...'), momentums), dim = 0)
+
+                if not learned_combine:
+                    update = momentums[-1]
+                else:
+                    update = einsum(combine_momentums, momentums, 'o b n, o b n ... -> b n ...')
+
+            # maybe spectral norm surprises
+
+            if self.spectral_norm_surprises:
+                update = newtonschulz5(update)
+
+            # use associative scan again for learned forgetting (weight decay) - eq (13)
+
+            update = self.assoc_scan(1. - decay_factor, update, prev = last_update, remove_prev = False)
+
+            updates[param_name] = update
+            next_last_update[param_name] = update[:, -1]
+
+        # determine next state for the storing of memories
+
+        next_state = (next_last_update, next_last_momentum)
+
+        next_store_state = NeuralMemState(next_seq_len_index, weights, remainder, next_state, updates)
+
+        # return updates to neural memory at all chunked timesteps + neural mem cache / state to be fed back
+
+        if not return_surprises:
+            return updates, next_store_state
+
+        return updates, next_store_state, (unweighted_mem_model_loss, adaptive_lr)
+
+    def retrieve_memories(
+        self,
+        seq,
+        weights: dict[str, Tensor],
+    ):
+        chunk_size = self.retrieve_chunk_size
+
+        weights_have_expanded_shape = dict_get_value_shapes(weights) != self.init_weight_shape
+
+        batch, seq_len = seq.shape[:2]
+
+        # auto infer single token decoding, if there are only 1 set of weights and 1 token
+
+        is_one_token = seq_len == 1
+        is_one_weight = (not weights_have_expanded_shape) or next(iter(weights.values())).shape[1] == 1
+
+        is_single_token_decode = is_one_token and is_one_weight
+
+        if is_single_token_decode:
+            chunk_size = 1
+
+        # padding related, for chunked processing
+
+        need_pad = chunk_size > 1 or not is_one_weight
+
+        if need_pad:
+            seq = pad_at_dim(seq, (1, 0), dim = 1)
+
+        seq_len_plus_one = seq.shape[-2]
+
+        next_seq_len = round_up_multiple(seq_len_plus_one, chunk_size)
+
+        padding = next_seq_len - seq_len_plus_one
+        seq = pad_at_dim(seq, (0, padding), dim = 1)
+
+        # the parameters of the memory model stores the memories of the key / values
+        # when the MLP has only 1 weight matrix, it is equivalent to `kv` fast weight memories from linear attention literature (recall fetching of memories is q @ (kv)) / schmidhuber's paper
+
+        weights = TensorDict(weights)
+
+        # pre norm
+
+        seq = self.retrieve_norm(seq)
+
+        # sequence Float['b n d'] to queries
+
+        queries = self.to_queries(seq)
+
+        # maybe multihead
+
+        queries = self.split_heads(queries)
+
+        # maybe qk rmsnorm
+
+        queries = self.q_norm(queries)
+
+        # fetch values from memory model
+
+        if weights_have_expanded_shape:
+            weights = rearrange_dict_values(weights, 'b n ... -> (b n) ...')
+
+        queries = rearrange(queries, 'b h (n c) d -> (b h n) c d', c = chunk_size)
+
+        # forward functional call
+
+        values = functional_call(self.memory_model, dict(weights), queries)
+
+        # reconstitute batch dimension
+
+        values = rearrange(values, '(b h n) c d -> b h (n c) d', b = batch, h = self.heads)
+
+        values = self.multihead_rmsnorm(values)
+
+        # maybe gate
+
+        if exists(self.retrieve_gate):
+            values = values * self.retrieve_gate(seq)
+
+        # maybe merge heads and combine
+
+        values = self.merge_heads(values)
+
+        values = self.combine_heads(values)
+
+        # restore, pad with empty memory embed
+
+        if need_pad:
+            values = values[:, 1:]
+
+        return values[:, :seq_len]
+
+    def forward(
+        self,
+        seq,
+        store_seq = None,
+        state: NeuralMemState | None = None,
+        detach_mem_state = False,
+        prev_weights = None,
+        store_mask: Tensor | None = None,
+        return_surprises = False,
+        ttt_batch_size: int | None = None
+    ):
+        is_multi_input = self.qkv_receives_diff_views
+
+        # handle single token
+
+        if seq.ndim == 2 or (is_multi_input and seq.ndim == 3):
+            seq = rearrange(seq, '... b d -> ... b 1 d')
+
+        is_single_token = seq.shape[-2] == 1
+
+        # if different views for qkv, then
+
+        if is_multi_input:
+            retrieve_seq, seq = seq[0], seq[1:]
+        else:
+            retrieve_seq = seq
+
+        # handle previous state init
+
+        if not exists(state):
+            state = (0, None, None, None, None)
+
+        seq_index, weights, cache_store_seq, past_state, updates = state
+
+        # store
+
+        store_seq = default(store_seq, seq)
+
+        # take care of cache
+
+        if exists(cache_store_seq):
+            store_seq = safe_cat((cache_store_seq, store_seq))
+            if exists(store_mask):
+                cache_len = cache_store_seq.shape[-2]
+                if cache_len > 0:
+                    cache_mask = torch.ones(
+                        (*store_mask.shape[:-1], cache_len),
+                        device=store_mask.device,
+                        dtype=store_mask.dtype,
+                    )
+                    store_mask = torch.cat((cache_mask, store_mask), dim=-1)
+
+        if exists(store_mask) and store_mask.shape[-1] != store_seq.shape[-2]:
+            diff = store_seq.shape[-2] - store_mask.shape[-1]
+            if diff > 0:
+                store_seq = store_seq[..., diff:, :]
+            elif diff < 0:
+                store_mask = store_mask[..., (-diff):]
+
+        # compute split sizes of sequence
+        # for now manually update weights to last update at the correct boundaries
+
+        store_seq_len, chunk_size, batch_size = store_seq.shape[-2], self.chunk_size, default(ttt_batch_size, self.batch_size)
+
+        need_update_weights = exists(batch_size)
+
+        # determine split sizes and when to update
+
+        if need_update_weights:
+            update_after_final_store = divisible_by(seq_index + store_seq_len, batch_size)
+
+            seq_range = torch.arange(store_seq_len) + seq_index + 1
+            batch_boundary = divisible_by(seq_range, batch_size)
+
+            indices = seq_range[batch_boundary] - seq_index
+
+            indices = F.pad(indices, (1, 0), value = 0)
+
+            if indices[-1] != store_seq_len:
+                indices = F.pad(indices, (0, 1), value = store_seq_len)
+
+            split_sizes = (indices[1:] - indices[:-1]).tolist()
+
+            assert sum(split_sizes) == store_seq_len
+        else:
+            split_sizes = (store_seq_len,)
+            update_after_final_store = False
+
+        # accumulate updates
+
+        updates = None
+
+        def accum_updates(past_updates, future_updates):
+            if not exists(past_updates):
+                return future_updates
+
+            return TensorDict({param_name: cat((past_update[:, :-1], future_update), dim = 1) for (param_name, past_update), (_, future_update) in zip(past_updates.items(), future_updates.items())})
+
+        # loop through chunks of store sequences
+
+        store_seqs = store_seq.split(split_sizes, dim = -2)
+
+        if exists(store_mask):
+            store_masks = store_mask.split(split_sizes, dim = -1)
+        else:
+            store_masks = (None,) * len(split_sizes)
+
+        # whether to allow network to slowly adjust from initial weight throughout (residual path) to fully updating weights every batch
+
+        surprises = (None, None)
+        gate = None
+
+        if exists(self.transition_gate):
+            gate = self.transition_gate.sigmoid()
+
+        for ind, (store_seq_chunk, maybe_store_mask) in enumerate(zip(store_seqs, store_masks)):
+            is_last = ind == (len(store_seqs) - 1)
+
+            # store
+
+            next_updates, next_neural_mem_state, chunk_surprises = self.store_memories(
+                store_seq_chunk,
+                weights,
+                seq_index = seq_index,
+                past_state = past_state,
+                prev_weights = prev_weights,
+                mask = maybe_store_mask,
+                return_surprises = True
+            )
+
+            weights = next_neural_mem_state.weights
+            seq_index = next_neural_mem_state.seq_index
+            past_state = next_neural_mem_state.states
+
+            updates = accum_updates(updates, next_updates)
+
+            surprises = tuple(safe_cat(args, dim = -1) for args in zip(surprises, chunk_surprises))
+
+            if is_last and not update_after_final_store:
+                continue
+
+            # update weights once batch size is fulfilled
+
+            last_update, last_momentum = past_state
+
+            if exists(gate):
+                last_update = TensorDict({param_name: one_weight.lerp(one_last_update, gate) for (param_name, one_weight), (_, one_last_update) in zip(weights.items(), last_update.items())})
+
+            past_state = (last_update, last_momentum)
+
+            # set weights to the last updated weights for the last minibatch
+
+            weights = last_update
+
+            next_neural_mem_state = next_neural_mem_state._replace(
+                weights = weights,
+                states = past_state,
+            )
+
+        next_neural_mem_state = next_neural_mem_state._replace(updates = updates)
+
+        # retrieve
+
+        if is_single_token:
+            last_update, _ = next_neural_mem_state.states
+            updates = rearrange_dict_values(last_update, 'b ... -> b 1 ...')
+
+        retrieved = self.retrieve_memories(
+            retrieve_seq,
+            updates
+        )
+
+        # maybe detach
+
+        if detach_mem_state:
+            next_neural_mem_state = mem_state_detach(next_neural_mem_state)
+
+        # returning
+
+        if not return_surprises:
+            return retrieved, next_neural_mem_state
+
+        return retrieved, next_neural_mem_state, surprises