# Titans-PyTorch 代码分析报告

## 概述

Titans 是 Google 在 2024 年底提出的新型长期记忆机制，核心思想是**将神经网络的权重作为长期记忆**，通过**测试时训练（Test-Time Training, TTT）**来动态存储和检索信息。

## 核心组件分析

### 1. NeuralMemory (神经记忆模块)

```
位置: titans_pytorch/neural_memory.py
```

这是 Titans 的核心组件，主要特点：

#### 1.1 记忆存储机制
- **记忆载体**: 使用 MLP（或其他模型）的权重作为记忆存储
- **存储过程**: 通过计算梯度来"写入"记忆
  ```python
  # 损失函数：|M(k) - v|²
  # 其中 M 是记忆网络，k 是 key，v 是 value
  def default_loss_fn(pred, target):
      return (pred - target).pow(2).mean(dim = -1)
  ```

#### 1.2 记忆检索机制
- 将 query 输入到记忆网络，获取存储的信息
- 使用 `functional_call` 进行前向传播

#### 1.3 关键参数

| 参数 | 说明 | 建议值 |
|------|------|--------|
| `chunk_size` | 分块大小，控制记忆更新粒度 | 32-128 |
| `batch_size` | 批处理大小，控制权重更新频率 | 64-256 |
| `momentum` | 是否使用动量优化 | True |
| `momentum_order` | 动量阶数 | 1-2 |
| `dim_head` | 每个头的维度 | 64 |
| `heads` | 注意力头数 | 4-8 |

### 2. MemoryMLP (记忆网络)

```
位置: titans_pytorch/memory_models.py
```

Titans 提供了多种记忆网络架构：

| 模型 | 描述 | 适用场景 |
|------|------|----------|
| `MemoryMLP` | 基础 MLP，来自 TTT 论文 | 通用场景 |
| `MemorySwiGluMLP` | SwiGLU 激活的 MLP | 更强表达能力 |
| `FactorizedMemoryMLP` | 分解权重的 MLP | 降低参数量 |
| `MemoryAttention` | 使用注意力的记忆 | 复杂依赖关系 |
| `GatedResidualMemoryMLP` | 门控残差 MLP | 深层网络 |

### 3. MemoryAsContextTransformer (MAC Transformer)

```
位置: titans_pytorch/mac_transformer.py
```

将 NeuralMemory 集成到 Transformer 中的完整实现：

#### 核心设计
1. **Segment 分段**: 将长序列分成固定长度的 segment
2. **Longterm Memory Tokens**: 在每个 segment 开头添加记忆 token
3. **Persistent Memory**: 全局共享的持久记忆 token
4. **记忆更新**: 通过 NeuralMemory 动态更新记忆

## 将 Titans 集成到 Qwen 的三种方案

### 方案 1: 外部包装器（最简单）

```python
class TitansMemoryWrapper(nn.Module):
    def __init__(self, qwen_model, ...):
        self.qwen = qwen_model
        self.neural_memory = NeuralMemory(...)
        
    def forward(self, input_ids, memory_state=None):
        # 1. 获取 Qwen 隐藏状态
        hidden = self.qwen(..., output_hidden_states=True).hidden_states[-1]
        
        # 2. 记忆增强
        retrieved, next_state = self.neural_memory(hidden, state=memory_state)
        
        # 3. 融合输出
        enhanced = hidden + gate * retrieved
        return enhanced, next_state
```

**优点**: 不修改 Qwen 内部结构，易于实现
**缺点**: 记忆与模型的交互较浅

### 方案 2: 层级集成（中等复杂度）

```python
class QwenDecoderLayerWithMemory(nn.Module):
    def forward(self, hidden_states, memory_state=None):
        # 标准 attention
        attn_output = self.self_attn(hidden_states)
        hidden_states = residual + attn_output
        
        # Titans 记忆增强
        retrieved, next_state = self.neural_memory(hidden_states, state=memory_state)
        hidden_states = hidden_states + gate * retrieved
        
        # 标准 FFN
        hidden_states = self.mlp(hidden_states)
        return hidden_states, next_state
```

**优点**: 记忆与模型深度集成
**缺点**: 需要修改模型结构

### 方案 3: Memory-as-Context（最接近论文）

```python
class QwenWithMAC(nn.Module):
    def __init__(self, qwen_model, ...):
        self.qwen = qwen_model
        self.longterm_mem = nn.Parameter(...)  # 长期记忆 token
        self.persist_mem = nn.Parameter(...)   # 持久记忆 token
        self.neural_memories = nn.ModuleDict({
            '2': NeuralMemory(...),
            '4': NeuralMemory(...),
            '6': NeuralMemory(...),
        })
```

**优点**: 最接近论文实现，效果最好
**缺点**: 实现复杂，需要处理位置编码

## 关键实现细节

### 1. 梯度计算

Titans 使用 `torch.func.vmap` 和 `torch.func.grad` 进行高效的批量梯度计算：

```python
from torch.func import functional_call, vmap, grad

def forward_and_loss(params, inputs, loss_weights, target):
    pred = functional_call(self.memory_model, params, inputs)
    loss = (pred - target).pow(2).mean(dim=-1)
    return (loss * loss_weights).sum(), loss

grad_fn = grad(forward_and_loss, has_aux=True)
self.per_sample_grad_fn = vmap(grad_fn, in_dims=(0, 0, 0, 0))
```

### 2. Associative Scan（关联扫描）

用于高效计算动量和权重衰减：

```python
from assoc_scan import AssocScan

self.assoc_scan = AssocScan(use_accelerated=True)
# 用于计算: x[t] = α[t] * x[t-1] + (1-α[t]) * input[t]
```

### 3. 自适应学习率

每个 token 的学习率是动态学习的：

```python
adaptive_lr = self.to_adaptive_step(seq)
adaptive_lr = adaptive_lr.sigmoid() * max_lr  # 限制在 [0, max_lr]
```

## 性能优化建议

### 1. chunk_size 选择
- 较小的 chunk_size（如 32）: 更细粒度的记忆更新，但内存占用更大
- 较大的 chunk_size（如 128）: 更高效，但记忆粒度较粗

### 2. batch_size 选择
- 较小的 batch_size（如 64）: 更频繁的权重更新，可能更好地捕捉细节
- 较大的 batch_size（如 256）: 训练更稳定，但可能丢失细节

### 3. 使用加速扫描
```python
NeuralMemory(..., use_accelerated_scan=True)
```

### 4. 使用 FlexAttention（PyTorch 2.0+）
```python
MemoryAsContextTransformer(..., use_flex_attn=True)
```

## 安装和依赖

```bash
pip install titans-pytorch

# 完整依赖
pip install torch einops tensordict assoc-scan rotary-embedding-torch x-transformers hyper-connections axial-positional-embedding
```

## 参考文献

1. [Titans: Learning to Memorize at Test Time](https://arxiv.org/abs/2401.00000) - Google, 2024
2. [Learning to (Learn at Test Time): RNNs with Expressive Hidden States](https://arxiv.org/abs/2407.04620) - TTT Paper
3. [Gated Delta Networks](https://arxiv.org/abs/2401.00000) - Momentum 机制参考

## 示例代码位置

详细的集成示例代码请参考:
`examples/qwen_with_titans_memory.py`