examples/qwen_mac_integration.py

"""
MAC (Memory-as-Context) 结构集成到 Qwen 的详细实现

=== MAC 结构核心原理 ===

1. 将长序列分成多个 segment（如每 128 个 token 一个 segment）
2. 在每个 segment 的【开头】插入 longterm_mem_tokens（如 16 个）
3. 这些 memory tokens 会参与 attention 计算
4. 使用 NeuralMemory 模块来动态更新这些 memory tokens 的内容

原始序列: [t1, t2, t3, ..., t128, t129, ..., t256, ...]
                 ↓
MAC 序列:  [M1..M16, t1...t128, M1..M16, t129...t256, ...]
            ↑                    ↑
         memory tokens       memory tokens

=== Qwen2 架构 ===

Qwen2DecoderLayer:
├── input_layernorm (RMSNorm)
├── self_attn (Qwen2Attention/Qwen2FlashAttention2)
│   ├── q_proj, k_proj, v_proj
│   ├── RoPE (rotary positional embedding)
│   └── o_proj
├── post_attention_layernorm (RMSNorm)
└── mlp (Qwen2MLP: gate_proj, up_proj, down_proj with SiLU)

我们需要在特定层添加 NeuralMemory 模块
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from typing import Optional, Tuple, List, Dict, Any
from copy import deepcopy
from functools import partial

from einops import rearrange, repeat, pack, unpack

# Titans 组件
from titans_pytorch import NeuralMemory, MemoryMLP
from titans_pytorch.neural_memory import NeuralMemState


# ============================================================================
# 辅助函数
# ============================================================================

def exists(v):
    return v is not None

def default(v, d):
    return v if exists(v) else d

def divisible_by(num, den):
    return (num % den) == 0

def round_up_multiple(seq, mult):
    return ((seq + mult - 1) // mult) * mult


# ============================================================================
# MAC 风格的 Qwen 实现
# ============================================================================

class QwenMACTransformer(nn.Module):
    """
    将 MAC 结构应用到 Qwen 模型的完整实现
    
    架构图:
    
    Input IDs
        │
        ▼
    ┌─────────────────┐
    │  Token Embed    │
    └────────┬────────┘
             │
             ▼
    ┌─────────────────────────────────────────┐
    │  插入 Memory Tokens 到每个 Segment 开头   │
    │  [M1..Mn, t1..t_seg, M1..Mn, ...]       │
    └────────┬────────────────────────────────┘
             │
             ▼
    ╔═════════════════════════════════════════╗
    ║         Qwen Decoder Layer 1            ║
    ║  ┌────────────────────────────────┐     ║
    ║  │ RMSNorm → Self-Attention → Add │     ║
    ║  └────────────────────────────────┘     ║
    ║  ┌────────────────────────────────┐     ║
    ║  │ RMSNorm → MLP → Add            │     ║
    ║  └────────────────────────────────┘     ║
    ╚═════════════════════════════════════════╝
             │
             ▼
    ╔═════════════════════════════════════════╗
    ║    Qwen Decoder Layer 2 (with Memory)   ║
    ║  ┌────────────────────────────────┐     ║
    ║  │ RMSNorm → Self-Attention → Add │     ║
    ║  └────────────────────────────────┘     ║
    ║  ┌──────────────────────────────────┐   ║
    ║  │  ★ NeuralMemory 记忆增强 ★        │   ║
    ║  │  retrieved = mem(hidden_states)  │   ║
    ║  │  hidden += gate * retrieved      │   ║
    ║  └──────────────────────────────────┘   ║
    ║  ┌────────────────────────────────┐     ║
    ║  │ RMSNorm → MLP → Add            │     ║
    ║  └────────────────────────────────┘     ║
    ╚═════════════════════════════════════════╝
             │
             ▼
          ... 更多层 ...
             │
             ▼
    ┌─────────────────┐
    │  Final RMSNorm  │
    └────────┬────────┘
             │
             ▼
    ┌─────────────────┐
    │    LM Head      │
    └────────┬────────┘
             │
             ▼
        Logits
    """
    
    def __init__(
        self,
        qwen_model,
        # === Segment 配置 ===
        segment_len: int = 128,              # 每个 segment 的长度
        num_longterm_mem_tokens: int = 16,   # 每个 segment 开头的 memory token 数量
        num_persist_mem_tokens: int = 4,     # 全局持久 memory token 数量
        
        # === NeuralMemory 配置 ===
        neural_memory_layers: Tuple[int, ...] = (2, 4, 6),  # 哪些层使用记忆
        memory_chunk_size: int = 64,         # 记忆模块的 chunk 大小
        memory_batch_size: int = 128,        # 记忆更新的批次大小
        memory_depth: int = 2,               # 记忆 MLP 的深度
        
        # === 其他配置 ===
        dim_head: int = 64,
        num_heads: int = None,               # 默认从模型配置读取
        use_momentum: bool = True,
        gate_memory_output: bool = False,    # 是否用记忆门控 attention 输出
    ):
        super().__init__()
        
        # 保存原始 Qwen 模型
        self.qwen = qwen_model
        self.config = qwen_model.config
        
        # 获取模型维度
        self.hidden_size = self.config.hidden_size
        self.num_layers = self.config.num_hidden_layers
        num_heads = default(num_heads, self.hidden_size // dim_head)
        
        # Segment 配置
        self.segment_len = segment_len
        self.num_longterm_mem_tokens = num_longterm_mem_tokens
        self.num_persist_mem_tokens = num_persist_mem_tokens
        self.total_segment_len = segment_len + num_longterm_mem_tokens
        
        # =====================================================================
        # Memory Tokens (这是 MAC 的核心!)
        # =====================================================================
        
        # 持久记忆 tokens - 放在序列最前面，所有 segment 共享
        # 用于存储全局上下文信息
        self.persist_mem_tokens = nn.Parameter(
            torch.randn(num_persist_mem_tokens, self.hidden_size) * 0.02
        )
        
        # 长期记忆 tokens - 插入到每个 segment 的开头
        # 这些 token 会被 NeuralMemory 动态更新
        self.longterm_mem_tokens = nn.Parameter(
            torch.randn(num_longterm_mem_tokens, self.hidden_size) * 0.02
        )
        
        # =====================================================================
        # NeuralMemory 模块
        # =====================================================================
        
        self.neural_memory_layers = neural_memory_layers
        self.gate_memory_output = gate_memory_output
        
        # 为每个指定层创建 NeuralMemory
        self.neural_memories = nn.ModuleDict()
        self.memory_projections = nn.ModuleDict()  # 投影层
        self.memory_gates = nn.ModuleDict()        # 门控层
        
        # 创建记忆网络模板
        memory_model_template = MemoryMLP(
            dim=dim_head,
            depth=memory_depth,
            expansion_factor=2.0
        )
        
        for layer_idx in neural_memory_layers:
            layer_key = str(layer_idx)
            
            # NeuralMemory 模块
            self.neural_memories[layer_key] = NeuralMemory(
                dim=self.hidden_size,
                chunk_size=memory_chunk_size,
                batch_size=memory_batch_size,
                dim_head=dim_head,
                heads=num_heads,
                model=deepcopy(memory_model_template),
                momentum=use_momentum,
                momentum_order=1,
                qk_rmsnorm=True,
                pre_rmsnorm=True,
                default_step_transform_max_lr=0.1,
            )
            
            # 门控层 - 控制记忆的影响程度
            self.memory_gates[layer_key] = nn.Sequential(
                nn.Linear(self.hidden_size, self.hidden_size),
                nn.Sigmoid()
            )
        
        print(f"[QwenMAC] 初始化完成:")
        print(f"  - 隐藏层大小: {self.hidden_size}")
        print(f"  - 层数: {self.num_layers}")
        print(f"  - Segment 长度: {segment_len}")
        print(f"  - Longterm Memory Tokens: {num_longterm_mem_tokens}")
        print(f"  - Persist Memory Tokens: {num_persist_mem_tokens}")
        print(f"  - 记忆层: {neural_memory_layers}")
    
    def _insert_memory_tokens(
        self,
        hidden_states: Tensor,  # [batch, seq_len, hidden]
        batch_size: int,
        seq_len: int,
    ) -> Tuple[Tensor, int]:
        """
        在序列中插入 memory tokens
        
        输入: [batch, seq_len, hidden]
        输出: [batch, new_seq_len, hidden]
        
        处理流程:
        原始: [t1, t2, ..., t128, t129, ..., t256]
        
        1. 分成 segments:
           Seg1: [t1, ..., t128]
           Seg2: [t129, ..., t256]
        
        2. 每个 segment 前插入 longterm_mem:
           Seg1: [M1, ..., M16, t1, ..., t128]
           Seg2: [M1, ..., M16, t129, ..., t256]
        
        3. 合并 + 前置 persist_mem:
           [P1, ..., P4, M1..M16, t1..t128, M1..M16, t129..t256]
        """
        segment_len = self.segment_len
        num_longterm = self.num_longterm_mem_tokens
        num_persist = self.num_persist_mem_tokens
        
        # 计算需要多少个 segment
        num_segments = (seq_len + segment_len - 1) // segment_len
        
        # Padding 到 segment_len 的整数倍
        padded_len = num_segments * segment_len
        if seq_len < padded_len:
            padding = padded_len - seq_len
            hidden_states = F.pad(hidden_states, (0, 0, 0, padding))
        
        # 重塑为 segments: [batch, num_segments, segment_len, hidden]
        hidden_states = rearrange(
            hidden_states,
            'b (s n) d -> b s n d',
            s=num_segments,
            n=segment_len
        )
        
        # 扩展 longterm memory tokens: [batch, num_segments, num_longterm, hidden]
        longterm_mem = repeat(
            self.longterm_mem_tokens,
            'n d -> b s n d',
            b=batch_size,
            s=num_segments
        )
        
        # 在每个 segment 前插入 memory tokens
        # [batch, num_segments, num_longterm + segment_len, hidden]
        hidden_states = torch.cat([longterm_mem, hidden_states], dim=2)
        
        # 展平 segments: [batch, num_segments * (num_longterm + segment_len), hidden]
        hidden_states = rearrange(hidden_states, 'b s n d -> b (s n) d')
        
        # 添加持久记忆 tokens 在最前面
        persist_mem = repeat(
            self.persist_mem_tokens,
            'n d -> b n d',
            b=batch_size
        )
        hidden_states = torch.cat([persist_mem, hidden_states], dim=1)
        
        new_seq_len = hidden_states.shape[1]
        
        return hidden_states, new_seq_len
    
    def _remove_memory_tokens(
        self,
        hidden_states: Tensor,
        original_seq_len: int,
    ) -> Tensor:
        """
        从输出中移除 memory tokens，恢复原始序列长度
        """
        segment_len = self.segment_len
        num_longterm = self.num_longterm_mem_tokens
        num_persist = self.num_persist_mem_tokens
        total_segment_len = segment_len + num_longterm
        
        batch_size = hidden_states.shape[0]
        
        # 移除 persist tokens
        hidden_states = hidden_states[:, num_persist:]
        
        # 计算 segments
        num_segments = (original_seq_len + segment_len - 1) // segment_len
        
        # 重塑为 segments
        hidden_states = rearrange(
            hidden_states,
            'b (s n) d -> b s n d',
            s=num_segments,
            n=total_segment_len
        )
        
        # 移除每个 segment 开头的 memory tokens
        hidden_states = hidden_states[:, :, num_longterm:, :]
        
        # 展平并截取原始长度
        hidden_states = rearrange(hidden_states, 'b s n d -> b (s n) d')
        hidden_states = hidden_states[:, :original_seq_len, :]
        
        return hidden_states
    
    def _create_mac_attention_mask(
        self,
        seq_len_with_mem: int,
        device: torch.device,
        dtype: torch.dtype,
    ) -> Tensor:
        """
        创建 MAC 风格的 attention mask
        
        MAC mask 的特点:
        1. Persist memory tokens 对所有位置可见
        2. 每个 segment 内部是 causal 的
        3. Memory tokens 可以 attend 到之前的 segment
        
        这是一个简化版本，完整版需要考虑更多细节
        """
        # 创建基础 causal mask
        mask = torch.ones(seq_len_with_mem, seq_len_with_mem, device=device, dtype=dtype)
        mask = torch.tril(mask)
        
        # Persist memory 对所有位置可见
        num_persist = self.num_persist_mem_tokens
        mask[:, :num_persist] = 1.0
        
        return mask
    
    def forward(
        self,
        input_ids: Tensor,
        attention_mask: Optional[Tensor] = None,
        position_ids: Optional[Tensor] = None,
        memory_states: Optional[Dict[str, NeuralMemState]] = None,
        return_memory_states: bool = True,
        **kwargs
    ) -> Dict[str, Any]:
        """
        前向传播
        
        Args:
            input_ids: [batch, seq_len]
            attention_mask: [batch, seq_len]
            memory_states: 各层的记忆状态（用于增量推理）
            
        Returns:
            dict with 'logits', 'hidden_states', 'memory_states'
        """
        batch_size, seq_len = input_ids.shape
        device = input_ids.device
        
        # =====================================================================
        # Step 1: Token Embedding
        # =====================================================================
        if hasattr(self.qwen.model, 'embed_tokens'):
            hidden_states = self.qwen.model.embed_tokens(input_ids)
        else:
            hidden_states = self.qwen.get_input_embeddings()(input_ids)
        
        # =====================================================================
        # Step 2: 插入 Memory Tokens
        # =====================================================================
        hidden_states, seq_len_with_mem = self._insert_memory_tokens(
            hidden_states, batch_size, seq_len
        )
        
        # =====================================================================
        # Step 3: 创建 Attention Mask (简化版)
        # =====================================================================
        # 注意: 完整实现需要更复杂的 mask 处理
        # 这里用 None 让模型使用默认 causal mask
        mac_attention_mask = None
        
        # =====================================================================
        # Step 4: 逐层处理
        # =====================================================================
        if memory_states is None:
            memory_states = {}
        next_memory_states = {}
        
        # 遍历 Qwen 的所有层
        for layer_idx, layer in enumerate(self.qwen.model.layers):
            layer_key = str(layer_idx)
            
            # -----------------------------------------------------------------
            # 4.1 标准的 Qwen Decoder Layer 前向传播
            # -----------------------------------------------------------------
            # Qwen2DecoderLayer.forward() 的简化版本
            
            residual = hidden_states
            
            # Input LayerNorm
            hidden_states = layer.input_layernorm(hidden_states)
            
            # Self Attention
            # 注意: 这里简化了 attention 的调用，实际可能需要更多参数
            attn_output = layer.self_attn(
                hidden_states=hidden_states,
                attention_mask=mac_attention_mask,
                position_ids=None,  # 会自动生成
            )
            
            # 处理不同返回格式
            if isinstance(attn_output, tuple):
                attn_output = attn_output[0]
            
            hidden_states = residual + attn_output
            
            # -----------------------------------------------------------------
            # 4.2 NeuralMemory 记忆增强 (仅在指定层)
            # -----------------------------------------------------------------
            if layer_key in self.neural_memories:
                neural_mem = self.neural_memories[layer_key]
                gate_fn = self.memory_gates[layer_key]
                
                # 获取该层的记忆状态
                mem_state = memory_states.get(layer_key)
                
                # 记忆检索和更新
                retrieved, next_mem_state = neural_mem(
                    hidden_states,
                    state=mem_state
                )
                
                # 门控融合
                gate = gate_fn(hidden_states)
                
                if self.gate_memory_output:
                    # 方式1: 用检索到的记忆门控后续输出
                    hidden_states = hidden_states * (1 + gate * retrieved.sigmoid())
                else:
                    # 方式2: 直接加上门控后的记忆（更常用）
                    hidden_states = hidden_states + gate * retrieved
                
                # 保存记忆状态
                next_memory_states[layer_key] = next_mem_state
            
            # -----------------------------------------------------------------
            # 4.3 Feed Forward Network
            # -----------------------------------------------------------------
            residual = hidden_states
            hidden_states = layer.post_attention_layernorm(hidden_states)
            hidden_states = layer.mlp(hidden_states)
            hidden_states = residual + hidden_states
        
        # =====================================================================
        # Step 5: Final LayerNorm
        # =====================================================================
        hidden_states = self.qwen.model.norm(hidden_states)
        
        # =====================================================================
        # Step 6: 移除 Memory Tokens
        # =====================================================================
        hidden_states = self._remove_memory_tokens(hidden_states, seq_len)
        
        # =====================================================================
        # Step 7: LM Head
        # =====================================================================
        logits = self.qwen.lm_head(hidden_states)
        
        # =====================================================================
        # 返回结果
        # =====================================================================
        result = {
            'logits': logits,
            'hidden_states': hidden_states,
        }
        
        if return_memory_states:
            result['memory_states'] = next_memory_states
            
        return result
    
    def generate(
        self,
        input_ids: Tensor,
        max_new_tokens: int = 100,
        temperature: float = 1.0,
        top_p: float = 0.9,
        memory_states: Optional[Dict] = None,
        **kwargs
    ) -> Tensor:
        """
        简单的生成函数
        """
        generated = input_ids.clone()
        
        for _ in range(max_new_tokens):
            outputs = self.forward(
                generated,
                memory_states=memory_states,
                return_memory_states=True
            )
            
            logits = outputs['logits'][:, -1, :]
            memory_states = outputs['memory_states']
            
            # 采样
            if temperature > 0:
                probs = F.softmax(logits / temperature, dim=-1)
                next_token = torch.multinomial(probs, num_samples=1)
            else:
                next_token = logits.argmax(dim=-1, keepdim=True)
            
            generated = torch.cat([generated, next_token], dim=-1)
            
            # 检查 EOS
            if hasattr(self.config, 'eos_token_id'):
                if (next_token == self.config.eos_token_id).all():
                    break
        
        return generated


# ============================================================================
# 使用示例
# ============================================================================

def main():
    """
    完整的使用示例
    """
    print("=" * 70)
    print("MAC (Memory-as-Context) 集成到 Qwen 的示例")
    print("=" * 70)
    
    # -------------------------------------------------------------------------
    # 方式 1: 使用 Hugging Face 的 Qwen 模型
    # -------------------------------------------------------------------------
    
    try:
        from transformers import AutoModelForCausalLM, AutoTokenizer
        
        print("\n[1] 加载 Qwen 模型...")
        model_name = "Qwen/Qwen2-0.5B"
        
        tokenizer = AutoTokenizer.from_pretrained(
            model_name,
            trust_remote_code=True
        )
        
        qwen_model = AutoModelForCausalLM.from_pretrained(
            model_name,
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
            device_map="auto" if torch.cuda.is_available() else None,
            trust_remote_code=True
        )
        
        print(f"  模型配置:")
        print(f"  - hidden_size: {qwen_model.config.hidden_size}")
        print(f"  - num_layers: {qwen_model.config.num_hidden_layers}")
        print(f"  - num_heads: {qwen_model.config.num_attention_heads}")
        
        # 创建 MAC 版本
        print("\n[2] 创建 QwenMAC 模型...")
        mac_model = QwenMACTransformer(
            qwen_model=qwen_model,
            segment_len=64,              # 每 64 个 token 一个 segment
            num_longterm_mem_tokens=8,   # 每个 segment 8 个 memory token
            num_persist_mem_tokens=4,    # 4 个全局 memory token
            neural_memory_layers=(1, 3, 5),  # 在第 1, 3, 5 层添加记忆
            memory_chunk_size=32,
            memory_batch_size=64,
        )
        
        if torch.cuda.is_available():
            mac_model = mac_model.cuda()
        
        # 测试前向传播
        print("\n[3] 测试前向传播...")
        test_text = "人工智能正在改变世界，它可以"
        inputs = tokenizer(test_text, return_tensors="pt")
        
        device = next(mac_model.parameters()).device
        input_ids = inputs.input_ids.to(device)
        
        with torch.no_grad():
            outputs = mac_model(input_ids)
            
        print(f"  输入形状: {input_ids.shape}")
        print(f"  输出 logits 形状: {outputs['logits'].shape}")
        print(f"  记忆状态数量: {len(outputs['memory_states'])}")
        
        # 测试生成
        print("\n[4] 测试文本生成...")
        with torch.no_grad():
            generated = mac_model.generate(
                input_ids,
                max_new_tokens=50,
                temperature=0.7
            )
        
        generated_text = tokenizer.decode(generated[0], skip_special_tokens=True)
        print(f"  生成文本: {generated_text}")
        
    except ImportError as e:
        print(f"\n注意: 需要安装 transformers")
        print(f"pip install transformers")
        print(f"错误: {e}")
    
    # -------------------------------------------------------------------------
    # 方式 2: 独立测试 NeuralMemory 组件
    # -------------------------------------------------------------------------
    
    print("\n" + "=" * 70)
    print("[独立测试] NeuralMemory 组件")
    print("=" * 70)
    
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    
    # 创建 NeuralMemory
    mem = NeuralMemory(
        dim=512,           # 隐藏维度
        chunk_size=32,     # 分块大小
        batch_size=64,     # 批次大小
        dim_head=64,       # 每个头的维度
        heads=8,           # 头数
        model=MemoryMLP(dim=64, depth=2),
        momentum=True,
        qk_rmsnorm=True,
    ).to(device)
    
    # 模拟输入
    batch_size = 2
    seq_len = 256
    hidden_dim = 512
    
    x = torch.randn(batch_size, seq_len, hidden_dim).to(device)
    
    print(f"\n输入形状: {x.shape}")
    
    # 第一次前向传播
    retrieved, state = mem(x)
    print(f"检索输出形状: {retrieved.shape}")
    print(f"记忆状态 seq_index: {state.seq_index}")
    
    # 第二次前向传播（传入之前的状态）
    x2 = torch.randn(batch_size, seq_len, hidden_dim).to(device)
    retrieved2, state2 = mem(x2, state=state)
    print(f"第二次检索输出形状: {retrieved2.shape}")
    print(f"更新后 seq_index: {state2.seq_index}")
    
    print("\n" + "=" * 70)
    print("完成!")
    print("=" * 70)


if __name__ == "__main__":
    main()