#!/usr/bin/env python3 """Spider: MoE + RDT (Recurrent-Depth Transformer) architecture v5. Canonical architecture ported from mythos-fineweb-moe.py (SpiderPortal v5-Dense) with the following adaptations per Phase 02 decisions: - Full Spider rebrand (no SpiderPortal/SpiderPortal prefix) per D-07 - Byte-level vocab: 272 tokens (256 bytes + 16 specials) per D-06 - MLA (Multi-Latent Attention) with compressed KV cache per D-10 - Engram conditional memory at recurrent layers 1 and 4 - MoE: 16 routed experts + 1 shared expert, top-1 routing - Sliding window attention (sliding_window=8192) with 256k context (YaRN factor=8.0) - Weight-tied embeddings per v5 canonical config (tie_word_embeddings=True) - LTI Injection + ACT Halting + LoRA Adapter for RDT loops - BoundaryPredictor + downsample/upsample for FlexiToken integration - 272-token byte-level vocab with sentinel tokens for multimodal (D-11) Architecture: RDT (2 prelude + 6 recurrent + 2 coda) with: - 2x Prelude (MLA + dense FFN) - 6x Recurrent (MLA + Engram@L1,L4 + MoE) -- with gradient checkpointing - 2x Coda (MLA + dense FFN) - LTI Injection + ACT Halting + LoRA Adapter Config: hidden_size=2048, 6 recurrent layers, 32 experts, top-2 routing """ import math from dataclasses import dataclass, field from typing import Dict, List, Optional, Tuple import torch import torch.nn as nn import torch.nn.functional as F from torch.nn import CrossEntropyLoss # ============================================================================ # Spider Configuration # ============================================================================ @dataclass class SpiderConfig: """Spider model configuration (hidden_size=2048, byte-level vocab). Based on mythos-fineweb-moe.py SpiderPortalConfig with byte-level tokenization, MLA attention, and Engram memory. """ # Core architecture vocab_size: int = 272 # 256 bytes + 16 specials (D-06) hidden_size: int = 2048 num_hidden_layers: int = 6 # recurrent layers num_attention_heads: int = 16 num_key_value_heads: int = 4 # not used directly in MLA but kept for compat intermediate_size: int = 1024 hidden_act: str = "silu" # MoE configuration (D-20, D-21: shared-projection MoE) num_experts: int = 32 num_experts_per_tok: int = 2 num_shared_experts: int = 1 router_aux_loss_coef: float = 0.05 shared_intermediate_size: int = 6144 expert_core_rank: int = 256 shared_expert_intermediate_size: int = 7424 prelude_coda_intermediate_size: int = 4096 # RDT configuration max_loop_iters: int = 16 act_threshold: float = 0.5 prelude_layers: int = 2 coda_layers: int = 2 lora_rank: int = 128 loop_embed_dim: int = 128 # MLA parameters (DeepSeek-V2 style, scaled for hidden_size=2048) kv_lora_rank: int = 128 q_lora_rank: int = 256 qk_rope_head_dim: int = 64 qk_nope_head_dim: int = 64 v_head_dim: int = 64 # Engram parameters (DeepSeek conditional memory, offloaded to CPU) engram_layers: List[int] = field(default_factory=lambda: [1, 4]) engram_ngram_orders: Tuple[int, ...] = (2, 3) engram_hash_heads: int = 4 engram_table_size: int = 8191 # prime, sized for byte vocab=272 engram_conv_kernel: int = 4 engram_conv_dilation: int = 3 engram_dim: int = 128 # per-head embedding dimension engram_offload: bool = True # offload embed table to CPU (DeepSeek style) # Attention / RoPE max_position_embeddings: int = 262144 # 256k context rope_theta: float = 10000000.0 rope_scaling: Optional[Dict] = field(default_factory=lambda: { "type": "yarn", "factor": 8.0, "original_max_position_embeddings": 32768, }) sliding_window: int = 8192 # local attention window attention_dropout: float = 0.0 rms_norm_eps: float = 1e-6 initializer_range: float = 0.02 # Embeddings / head tie_word_embeddings: bool = True # per v5 canonical config # Multimodal vision_hidden_size: int = 2048 audio_hidden_size: int = 512 vision_num_frames: int = 60 vision_tokens_per_frame: int = 256 vision_temporal_tokens: int = 64 vision_temporal_layers: int = 2 # Metadata model_type: str = "spider" torch_dtype: str = "bfloat16" # BoundaryPredictor (for FlexiToken integration) bp_d_inner: int = 8192 @property def head_dim(self): return self.qk_nope_head_dim + self.qk_rope_head_dim # 128 def spider_flexitokens_997m() -> SpiderConfig: """Spider-FLEXITOKENS 995.1M config per D-20.""" return SpiderConfig() # ============================================================================ # Sentinel Token Vocabulary (D-06, D-11) # ============================================================================ # 272-token vocab: 256 bytes + 16 specials # Sentinel tokens at indices 259-264 mark modality region boundaries SENTINEL_TOKENS = { 'PAD': 256, 'BOS': 257, 'EOS': 258, 'IMG_START': 259, 'IMG_END': 260, 'AUD_START': 261, 'AUD_END': 262, 'VID_START': 263, 'VID_END': 264, 'MASK': 265, 'im_start': 266, 'im_end': 267, 'prefix': 268, 'suffix': 269, 'middle': 270, 'THINK': 271, } # Sentinel pairs for modality regions (start_id, end_id) _SENTINEL_PAIRS = [ (SENTINEL_TOKENS['IMG_START'], SENTINEL_TOKENS['IMG_END']), # (259, 260) (SENTINEL_TOKENS['AUD_START'], SENTINEL_TOKENS['AUD_END']), # (261, 262) (SENTINEL_TOKENS['VID_START'], SENTINEL_TOKENS['VID_END']), # (263, 264) ] # Set of modality sentinel token IDs (259-264 only) _MODALITY_SENTINEL_IDS = {259, 260, 261, 262, 263, 264} # Reverse mapping (computed once at module level, per IN-01) _TOKEN_NAMES_BY_ID = {v: k for k, v in SENTINEL_TOKENS.items()} def is_sentinel_token(token_id: int) -> bool: """Return True if token_id is one of the 6 modality sentinel tokens (259-264). These are the sentinel tokens that mark modality region boundaries: IMG_START/END, AUD_START/END, VID_START/END. Other special tokens (PAD, BOS, EOS, MASK, etc.) are NOT modality sentinels. """ return token_id in _MODALITY_SENTINEL_IDS def create_modality_mask(input_ids: torch.Tensor, strict: bool = True) -> torch.Tensor: """Create boolean mask (B×L) marking sentinel and modality token positions. Per D-11: Sentinel-gated passthrough ensures modality tokens bypass the BoundaryPredictor entirely. This mask marks positions where: - Sentinel tokens (IMG_START/END, AUD_START/END, VID_START/END) appear - Modality tokens (between sentinel pairs) appear The BoundaryPredictor uses this mask to force boundary=1.0 at these positions, ensuring no boundary merging across modality boundaries. Args: input_ids: Token IDs of shape [B, L] with values in 0-271 range. strict: If True, raise on mismatched sentinel pairs (training mode). If False, skip mismatched pairs gracefully (generation mode). Returns: Boolean tensor of shape [B, L], True at sentinel+modality positions. Raises: ValueError: If strict=True and sentinel pairs are mismatched. """ B, L = input_ids.shape mask = torch.zeros(B, L, dtype=torch.bool, device=input_ids.device) # Mark direct sentinel token positions for sid in _MODALITY_SENTINEL_IDS: mask |= (input_ids == sid) # Mark regions between sentinel pairs (inclusive of sentinels) for start_id, end_id in _SENTINEL_PAIRS: for b in range(B): starts = (input_ids[b] == start_id).nonzero(as_tuple=True)[0] ends = (input_ids[b] == end_id).nonzero(as_tuple=True)[0] # T-02-04 mitigation: validate sentinel pairs are matched (strict mode only) if strict and len(starts) != len(ends): raise ValueError( f"Batch {b}: mismatched sentinel pairs — " f"{len(starts)} {_TOKEN_NAMES_BY_ID[start_id]}(s) vs " f"{len(ends)} {_TOKEN_NAMES_BY_ID[end_id]}(s). " f"Every {_TOKEN_NAMES_BY_ID[start_id]} must have a matching " f"{_TOKEN_NAMES_BY_ID[end_id]}." ) # Match pairs min(starts, ends) — skip unmatched in non-strict mode n_pairs = min(len(starts), len(ends)) for i in range(n_pairs): s, e = starts[i].item(), ends[i].item() if s > e: if strict: raise ValueError( f"Batch {b}: {_TOKEN_NAMES_BY_ID[start_id]} at position {s} " f"appears after {_TOKEN_NAMES_BY_ID[end_id]} at position {e}. " f"Sentinel pairs must be properly ordered." ) continue mask[b, s:e + 1] = True return mask # ============================================================================ # RMSNorm # ============================================================================ class SpiderRMSNorm(nn.Module): """RMS normalization (bf16-only, no dtype conversions).""" def __init__(self, hidden_size, eps=1e-6): super().__init__() self.weight = nn.Parameter(torch.ones(hidden_size, dtype=torch.float32)) # IN-02: RMSNorm weight is float32 per convention self.variance_epsilon = eps def forward(self, hidden_states): variance = hidden_states.pow(2).mean(-1, keepdim=True) hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) return self.weight * hidden_states # ============================================================================ # MLA: Multi-Latent Attention (DeepSeek-V2 style) # ============================================================================ class SpiderMLA(nn.Module): """Multi-Latent Attention with compressed KV cache. For hidden_size=2048, num_heads=16: - qk_nope_head_dim=64, qk_rope_head_dim=64 -> total head_dim=128 - kv_lora_rank=128 -> 10.7x compression vs full 2048-dim KV - v_head_dim=64 -> value projection - sliding_window=8192 -> local attention window """ def __init__(self, config: SpiderConfig): super().__init__() self.config = config self.hidden_size = config.hidden_size self.num_heads = config.num_attention_heads self.kv_lora_rank = config.kv_lora_rank self.q_lora_rank = config.q_lora_rank self.qk_rope_head_dim = config.qk_rope_head_dim self.qk_nope_head_dim = config.qk_nope_head_dim self.v_head_dim = config.v_head_dim self.head_dim = self.qk_nope_head_dim + self.qk_rope_head_dim self.sliding_window = getattr(config, 'sliding_window', 0) # Q projection: optional low-rank -> full Q if self.q_lora_rank > 0: self.q_a_proj = nn.Linear(config.hidden_size, self.q_lora_rank, bias=False) self.q_a_layernorm = SpiderRMSNorm(self.q_lora_rank) self.q_b_proj = nn.Linear(self.q_lora_rank, self.num_heads * self.head_dim, bias=False) else: self.q_proj = nn.Linear(config.hidden_size, self.num_heads * self.head_dim, bias=False) # KV compression: hidden -> kv_lora_rank (shared latent) self.kv_a_proj_with_mqa = nn.Linear( config.hidden_size, self.kv_lora_rank + self.qk_rope_head_dim, bias=False, ) self.kv_a_layernorm = SpiderRMSNorm(self.kv_lora_rank) # Decompress: kv_lora_rank -> nope heads + v heads self.kv_b_proj = nn.Linear( self.kv_lora_rank, self.num_heads * (self.qk_nope_head_dim + self.v_head_dim), bias=False, ) # Output projection: [hidden_size, num_heads * v_head_dim] # Per D-08 and MLA architecture: o_proj maps from num_heads*v_head_dim back to hidden_size self.o_proj = nn.Linear(self.num_heads * self.v_head_dim, config.hidden_size, bias=False) # RoPE frequencies rope_scaling = getattr(config, 'rope_scaling', None) if rope_scaling and rope_scaling.get("type") == "yarn": factor = rope_scaling.get("factor", 1.0) orig_max_pos = rope_scaling.get( "original_max_position_embeddings", config.max_position_embeddings ) inv_freq = self._compute_yarn_inv_freq( self.qk_rope_head_dim, config.rope_theta, factor, orig_max_pos ) else: inv_freq = 1.0 / ( config.rope_theta ** (torch.arange(0, self.qk_rope_head_dim, 2).float() / self.qk_rope_head_dim) ) self.register_buffer("inv_freq", inv_freq, persistent=False) @staticmethod def _compute_yarn_inv_freq(head_dim, rope_theta, factor, orig_max, beta_fast=32.0, beta_slow=1.0): dim = head_dim orig_inv_freq = 1.0 / (rope_theta ** (torch.arange(0, dim, 2).float() / dim)) pos_freqs = torch.arange(0, dim, 2).float() / dim beta = (pos_freqs * math.log(rope_theta) / math.log(orig_max)) scale = torch.where( beta < beta_slow, torch.ones_like(beta), torch.where( beta > beta_fast, torch.ones_like(beta) / factor, 1.0 - (beta - beta_slow) / (beta_fast - beta_slow) * (1.0 - 1.0 / factor) ) ) return orig_inv_freq * scale def _rotate_half(self, x): x1 = x[..., :x.shape[-1] // 2] x2 = x[..., x.shape[-1] // 2:] return torch.cat((-x2, x1), dim=-1) def _apply_rotary(self, x, cos, sin): return (x * cos) + (self._rotate_half(x) * sin) def forward( self, hidden_states: torch.Tensor, attention_mask=None, position_ids=None, past_key_value=None, use_cache=False, ): bsz, q_len, _ = hidden_states.size() # Q projection if self.q_lora_rank > 0: q = self.q_b_proj(self.q_a_layernorm(self.q_a_proj(hidden_states))) else: q = self.q_proj(hidden_states) q = q.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) q_nope, q_rope = torch.split(q, [self.qk_nope_head_dim, self.qk_rope_head_dim], dim=-1) # KV: compress to latent, then decompress kv_hidden = self.kv_a_proj_with_mqa(hidden_states) kv_latent, k_rope = torch.split( kv_hidden, [self.kv_lora_rank, self.qk_rope_head_dim], dim=-1 ) kv_latent_norm = self.kv_a_layernorm(kv_latent) kv_b_out = self.kv_b_proj(kv_latent_norm) k_nope, v = torch.split( kv_b_out, [self.num_heads * self.qk_nope_head_dim, self.num_heads * self.v_head_dim], dim=-1, ) k_nope = k_nope.view(bsz, q_len, self.num_heads, self.qk_nope_head_dim).transpose(1, 2) v = v.view(bsz, q_len, self.num_heads, self.v_head_dim).transpose(1, 2) k_rope = k_rope.unsqueeze(1) # [B, 1, L, qk_rope_head_dim] # RoPE on Q and K rope parts if position_ids is None: position_ids = torch.arange(q_len, device=hidden_states.device).unsqueeze(0).expand(bsz, -1) max_pos = position_ids.max().item() + 1 seq_len = max(max_pos, q_len) t = torch.arange(seq_len, device=hidden_states.device, dtype=self.inv_freq.dtype) freqs = torch.outer(t, self.inv_freq) emb = torch.cat((freqs, freqs), dim=-1) cos, sin = emb.cos(), emb.sin() cos_full = cos[position_ids].unsqueeze(1) sin_full = sin[position_ids].unsqueeze(1) q_rope = self._apply_rotary(q_rope, cos_full, sin_full) k_rope = self._apply_rotary(k_rope, cos_full, sin_full) # Assemble full K k_rope_expanded = k_rope.expand(-1, self.num_heads, -1, -1) k_full = torch.cat([k_nope, k_rope_expanded], dim=-1) q_full = torch.cat([q_nope, q_rope], dim=-1) # KV cache past_kv = None if past_key_value is not None: k_full = torch.cat([past_key_value[0], k_full], dim=2) v = torch.cat([past_key_value[1], v], dim=2) if use_cache: past_kv = (k_full, v) # Attention with SDPA attn_mask = None if self.sliding_window > 0 and k_full.shape[2] > self.sliding_window: kv_len = k_full.shape[2] q_positions = torch.arange(kv_len - q_len, kv_len, device=q_full.device) k_positions = torch.arange(kv_len, device=q_full.device) diff = q_positions.unsqueeze(1) - k_positions.unsqueeze(0) causal = diff >= 0 window = diff < self.sliding_window attn_mask = (causal & window).float().unsqueeze(0).unsqueeze(0) attn_mask = attn_mask.masked_fill(attn_mask == 0, float('-inf')) attn_output = F.scaled_dot_product_attention( q_full, k_full, v, attn_mask=attn_mask, dropout_p=self.config.attention_dropout if self.training else 0.0, is_causal=(attn_mask is None), ) attn_output = attn_output.transpose(1, 2).contiguous() attn_output = attn_output.reshape(bsz, q_len, self.num_heads * self.v_head_dim) return self.o_proj(attn_output), past_kv # ============================================================================ # Engram: Conditional Memory via Scalable Lookup (DeepSeek style) # ============================================================================ def _tokenizer_compress(token_ids, vocab_size=272): """Simulate NFKC + lowercase canonical ID projection. Per D-06: vocab_size=272 for byte-level Spider vocab. """ return token_ids % (vocab_size * 77 // 100) class SpiderEngram(nn.Module): """Conditional memory module via NN-gram lookup. Applied only at specific recurrent layers (config.engram_layers). Ported from SpiderPortalEngram in mythos-fineweb-moe.py. """ def __init__(self, config: SpiderConfig): super().__init__() self.config = config self.ngram_orders = list(config.engram_ngram_orders) self.num_heads_per_order = config.engram_hash_heads self.table_size = config.engram_table_size self.d_mem = config.engram_dim self.total_mem_dim = len(self.ngram_orders) * self.num_heads_per_order * self.d_mem # Stacked embedding table with offsets: [orders, heads, table_size, d_mem] # Per DeepSeek Engram: static memory, offloaded to CPU, accessed via deterministic hash. embed_data = torch.randn(len(self.ngram_orders), self.num_heads_per_order, self.table_size, self.d_mem) * 0.02 if config.engram_offload: self.register_buffer("embed", embed_data, persistent=True) else: self.embed = nn.Parameter(embed_data) seeds = [] for _order in self.ngram_orders: for h in range(self.num_heads_per_order): seeds.append((h + 1) * 2654435761) self.register_buffer("hash_seeds", torch.tensor(seeds, dtype=torch.int64), persistent=False) self.W_k = nn.Linear(self.total_mem_dim, config.hidden_size, bias=False) self.W_v = nn.Linear(self.total_mem_dim, config.hidden_size, bias=False) self.conv = nn.Conv1d( config.hidden_size, config.hidden_size, kernel_size=config.engram_conv_kernel, padding=config.engram_conv_kernel - 1, groups=config.hidden_size, ) self.conv_dilation = config.engram_conv_dilation with torch.no_grad(): self.conv.weight.zero_() if self.conv.bias is not None: self.conv.bias.zero_() self.q_norm = SpiderRMSNorm(config.hidden_size) self.k_norm = SpiderRMSNorm(config.hidden_size) def _compute_hash(self, compressed, n, head_counter, bsz, seq_len): """Compute n-gram hash indices (PyTorch-only path, no Numba/CUDA dependency).""" pad = torch.zeros(bsz, n - 1, dtype=compressed.dtype, device=compressed.device) padded = torch.cat([pad, compressed], dim=1) ngrams = torch.stack([padded[:, i : i + seq_len] for i in range(n)], dim=-1) h_val = torch.zeros(bsz, seq_len, dtype=torch.int64, device=compressed.device) for i in range(n): h_val = h_val * 31 + ngrams[:, :, i].to(torch.int64) h_val = h_val % self.table_size return h_val def _retrieve(self, token_ids): """Retrieve memory vectors for a batch of token sequences.""" bsz, seq_len = token_ids.shape compressed = _tokenizer_compress(token_ids) # PyTorch fallback (CPU and GPU, no external kernel dependency) all_parts = [] head_counter = 0 for order_idx, n in enumerate(self.ngram_orders): h_val = self._compute_hash(compressed, n, head_counter, bsz, seq_len) seeds_slice = self.hash_seeds[head_counter : head_counter + self.num_heads_per_order] indices_pt = (h_val.unsqueeze(-1) * seeds_slice.view(1, 1, -1)) % self.table_size emb_table = self.embed[order_idx] idx = indices_pt.permute(0, 2, 1).unsqueeze(-1).expand(-1, -1, -1, self.d_mem) mem = torch.gather(emb_table.unsqueeze(0).expand(bsz, -1, -1, -1), dim=2, index=idx) mem = mem.permute(0, 2, 1, 3).reshape(bsz, seq_len, self.num_heads_per_order * self.d_mem) all_parts.append(mem) head_counter += self.num_heads_per_order return torch.cat(all_parts, dim=-1) def forward(self, hidden_states, token_ids, layer_id: int): mem = self._retrieve(token_ids) q = hidden_states k = self.W_k(mem) v = self.W_v(mem) q_norm = self.q_norm(q) k_norm = self.k_norm(k) alpha = torch.sigmoid( (q_norm * k_norm).sum(dim=-1, keepdim=True) / math.sqrt(q.shape[-1]) ) v_gated = alpha * v v_gated_t = v_gated.transpose(1, 2) conv_out = self.conv(v_gated_t) conv_out = conv_out[:, :, :v_gated_t.shape[-1]] conv_out = conv_out.transpose(1, 2) y = F.silu(conv_out) + v_gated return y # ============================================================================ # FFN Expert (SwiGLU) # ============================================================================ class SpiderExpert(nn.Module): """SwiGLU FFN expert for dense layers and MoE shared expert.""" def __init__(self, config: SpiderConfig, intermediate_size=None): super().__init__() inter_size = intermediate_size or config.intermediate_size self.gate_proj = nn.Linear(config.hidden_size, inter_size, bias=False) self.up_proj = nn.Linear(config.hidden_size, inter_size, bias=False) self.down_proj = nn.Linear(inter_size, config.hidden_size, bias=False) self.act_fn = nn.SiLU() def forward(self, hidden_states): return self.down_proj(self.act_fn(self.gate_proj(hidden_states)) * self.up_proj(hidden_states)) # ============================================================================ # Shared-Projection MoE (D-20, D-21: top-2 routing with shared projections) # ============================================================================ class SimpleMoE(nn.Module): """Mixture of Experts with top-1 routing and shared expert. This is a self-contained MoE implementation that does not depend on torchtitan's MoE. Used by SpiderRecurrentLayer when torchtitan is not available (e.g., during weight transfer and testing). """ def __init__(self, config: SpiderConfig): super().__init__() self.num_experts = config.num_experts self.num_experts_per_tok = config.num_experts_per_tok # Shared expert self.shared_expert = SpiderExpert(config, intermediate_size=config.intermediate_size) # Routed experts self.experts = nn.ModuleList([ SpiderExpert(config, intermediate_size=config.intermediate_size) for _ in range(config.num_experts) ]) # Router self.router = nn.Linear(config.hidden_size, config.num_experts, bias=True) self.router.bias = nn.Parameter(torch.zeros(config.num_experts, dtype=torch.float32)) def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: B, L, D = x.shape shared_out = self.shared_expert(x) router_logits = self.router(x) router_probs = F.softmax(router_logits, dim=-1) top1_indices = router_probs.argmax(dim=-1) top1_probs = router_probs.gather(-1, top1_indices.unsqueeze(-1)).squeeze(-1) x_flat = x.reshape(B * L, D) top1_flat = top1_indices.reshape(B * L) expert_outs = torch.zeros_like(x_flat) for e in range(self.num_experts): mask = (top1_flat == e) if mask.any(): expert_input = x_flat[mask] expert_out = self.experts[e](expert_input) expert_outs[mask] = expert_out expert_outs = expert_outs.reshape(B, L, D) routed_out = expert_outs * top1_probs.unsqueeze(-1) z_loss = (router_logits.logsumexp(dim=-1) ** 2).mean() return shared_out + routed_out, z_loss # ============================================================================ # Shared-Projection MoE (D-20, D-21: top-2 routing with shared projections) # ============================================================================ class SharedProjectionMoE(nn.Module): """Mixture of Experts with shared projections and low-rank expert cores. Per D-20: 32 experts, top-2 routing, shared_intermediate_size=6144. Per D-21: Shared up/down projections computed once per token, rank-192 expert cores specialize on the shared representation. Architecture: - shared_up: Linear(hidden, shared_inter) — computed once for all experts - shared_down: Linear(shared_inter, hidden) — computed once for all experts - W_gate: [num_experts, hidden, expert_core_rank] — per-expert gating - W_transform: [num_experts, expert_core_rank, shared_inter] — per-expert transform - shared_expert: SpiderExpert(hidden, shared_expert_inter=4096) — always active Forward: shared_hidden = SiLU(shared_up(x)) routed_out = sum(top2_weights * shared_down(core_i(shared_hidden))) output = routed_out + shared_expert(x) """ def __init__(self, config: SpiderConfig): super().__init__() self.num_experts = config.num_experts self.num_experts_per_tok = config.num_experts_per_tok self.shared_inter = config.shared_intermediate_size self.expert_core_rank = config.expert_core_rank self.hidden_size = config.hidden_size self.shared_up = nn.Linear(config.hidden_size, config.shared_intermediate_size, bias=False) self.shared_down = nn.Linear(config.shared_intermediate_size, config.hidden_size, bias=False) self.W_gate = nn.Parameter( torch.randn(config.num_experts, config.hidden_size, config.expert_core_rank) * 0.02 ) self.W_transform = nn.Parameter( torch.randn(config.num_experts, config.expert_core_rank, config.shared_intermediate_size) * 0.02 ) self.shared_expert = SpiderExpert(config, intermediate_size=config.shared_expert_intermediate_size) self.router = nn.Linear(config.hidden_size, config.num_experts, bias=True) self.router.bias = nn.Parameter(torch.zeros(config.num_experts, dtype=torch.float32)) def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: B, L, D = x.shape shared_hidden = F.silu(self.shared_up(x)) shared_out = self.shared_expert(x) router_logits = self.router(x) router_probs = F.softmax(router_logits, dim=-1) top2_probs, top2_indices = router_probs.topk(self.num_experts_per_tok, dim=-1) top2_probs = top2_probs / top2_probs.sum(dim=-1, keepdim=True) x_flat = x.reshape(B * L, D) shared_hidden_flat = shared_hidden.reshape(B * L, self.shared_inter) routed_out = torch.zeros(B * L, D, device=x.device, dtype=x.dtype) for k in range(self.num_experts_per_tok): expert_indices = top2_indices[:, :, k].reshape(B * L) expert_weights = top2_probs[:, :, k].reshape(B * L) for e in range(self.num_experts): mask = (expert_indices == e) if not mask.any(): continue expert_input = x_flat[mask] expert_sh = shared_hidden_flat[mask] gate = expert_input @ self.W_gate[e] core = gate @ self.W_transform[e] expert_output = self.shared_down(core * expert_sh) routed_out[mask] += expert_weights[mask].unsqueeze(-1) * expert_output routed_out = routed_out.reshape(B, L, D) z_loss = (router_logits.logsumexp(dim=-1) ** 2).mean() return shared_out + routed_out, z_loss # ============================================================================ # Prelude/Coda Dense Layer (uses MLA) # ============================================================================ class SpiderDenseLayer(nn.Module): """Prelude/coda dense layer with MLA attention.""" def __init__(self, config: SpiderConfig): super().__init__() self.self_attn = SpiderMLA(config) dense_intermediate = config.prelude_coda_intermediate_size self.ffn = SpiderExpert(config, intermediate_size=dense_intermediate) self.input_layernorm = SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.post_attention_layernorm = SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) def forward( self, hidden_states, attention_mask=None, position_ids=None, past_key_value=None, use_cache=False, ): attn_input = self.input_layernorm(hidden_states) attn_output, past_kv = self.self_attn( attn_input, attention_mask=attention_mask, position_ids=position_ids, past_key_value=past_key_value, use_cache=use_cache, ) hidden_states = hidden_states + attn_output ffn_input = self.post_attention_layernorm(hidden_states) ffn_output = self.ffn(ffn_input) hidden_states = hidden_states + ffn_output return hidden_states, past_kv # ============================================================================ # Recurrent Layer (uses MLA + optional Engram + MoE) # ============================================================================ class SpiderRecurrentLayer(nn.Module): """Recurrent layer with MLA attention, optional Engram memory, and MoE.""" def __init__(self, config: SpiderConfig, layer_idx: int, has_engram: bool = False): super().__init__() self.layer_idx = layer_idx self.has_engram = has_engram self.self_attn = SpiderMLA(config) if has_engram: self.engram = SpiderEngram(config) self.moe = SharedProjectionMoE(config) self.input_layernorm = SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.post_attention_layernorm = SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.post_engram_layernorm = ( SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) if has_engram else None ) def forward( self, hidden_states, token_ids=None, attention_mask=None, position_ids=None, past_key_value=None, use_cache=False, ): attn_input = self.input_layernorm(hidden_states) attn_output, past_kv = self.self_attn( attn_input, attention_mask=attention_mask, position_ids=position_ids, past_key_value=past_key_value, use_cache=use_cache, ) hidden_states = hidden_states + attn_output if self.has_engram and token_ids is not None: engram_out = self.engram(hidden_states, token_ids, layer_id=self.layer_idx) hidden_states = hidden_states + engram_out if self.post_engram_layernorm is not None: hidden_states = self.post_engram_layernorm(hidden_states) ffn_input = self.post_attention_layernorm(hidden_states) ffn_output, aux_loss = self.moe(ffn_input) hidden_states = hidden_states + ffn_output return hidden_states, aux_loss, past_kv # ============================================================================ # BoundaryPredictor (D-04, D-11) # ============================================================================ class BoundaryPredictor(nn.Module): """Boundary predictor for learnable byte-level tokenization. 2-layer MLP that predicts merge boundaries between tokens. Per D-11: When modality_mask is provided, forces boundary=1.0 at sentinel and modality token positions, preventing cross-modality merges. Architecture: Linear(d_model, d_inner) -> GELU -> Linear(d_inner, 1) Uses Gumbel-Softmax straight-through estimator for differentiable boundary decisions (ported from FLEXITOKENS fxt.py). """ def __init__( self, config: SpiderConfig, temp: float = 1.0, threshold: float = 0.5, ): super().__init__() self.temp = temp self.threshold = threshold self.boundary_predictor = nn.Sequential( nn.Linear(config.hidden_size, config.bp_d_inner), nn.GELU(), nn.Linear(config.bp_d_inner, 1), ) def forward(self, hidden, modality_mask=None): """Predict boundary decisions for token merging. Args: hidden: Hidden states of shape [B, L, D] (batch-first per D-08). modality_mask: Optional boolean tensor [B, L], True at positions where sentinel/modality tokens appear. Per D-11, forces boundary=1.0 at these positions. Returns: Tuple of (soft_boundaries, hard_boundaries), each [B, L]. - soft_boundaries: Differentiable boundary probabilities - hard_boundaries: Binary boundary decisions (straight-through) """ boundary_logits = self.boundary_predictor(hidden).squeeze(-1) boundary_probs = torch.sigmoid(boundary_logits) # Gumbel-Softmax straight-through for differentiable boundary decisions bernoulli = torch.distributions.relaxed_bernoulli.RelaxedBernoulli( temperature=self.temp, probs=boundary_probs, ) soft_boundaries = bernoulli.rsample() hard_boundaries = (soft_boundaries > self.threshold).float() # Straight-through estimator: gradient flows through soft, forward uses hard hard_boundaries = ( hard_boundaries - soft_boundaries.detach() + soft_boundaries ) # Per D-11: Force boundaries at sentinel/modality positions if modality_mask is not None: soft_boundaries = soft_boundaries.masked_fill(modality_mask, 1.0) hard_boundaries = hard_boundaries.masked_fill(modality_mask, 1.0) return soft_boundaries, hard_boundaries # ============================================================================ # Downsample / Upsample (D-05, D-08, D-11) # ============================================================================ def _downsample_common(boundaries: torch.Tensor, upsample: bool = False): """Common helper for downsample/upsample einsum weight computation. Computes the assignment matrix that maps original positions to groups. Based on FLEXITOKENS shortening.py, adapted for batch-first (B*L*D) layout. Args: boundaries: [B, L] binary boundary tensor (1 = new group starts) upsample: If True, compute upsample weights; else downsample weights Returns: Assignment tensor [B, L, S] or None if n_segments == 0 """ boundaries = boundaries.clone() n_segments = int(boundaries.sum(dim=-1).max().item()) if upsample: n_segments += 1 if n_segments == 0: return None tmp = torch.zeros_like(boundaries).unsqueeze(2) + torch.arange( start=0, end=n_segments, device=boundaries.device, dtype=boundaries.dtype ) hh1 = boundaries.cumsum(dim=-1) if not upsample: hh1 -= boundaries # Subtract current boundary so position belongs to previous group foo = tmp - hh1.unsqueeze(-1) # WR-01 fix: zero out unused columns for batch items with fewer segments # When n_segments is set to the max across the batch, items with fewer # segments have unused columns that would produce NaN on normalization. item_segment_counts = boundaries.sum(dim=-1) for b in range(boundaries.shape[0]): item_segs = int(item_segment_counts[b].item()) if upsample: item_segs += 1 if item_segs < n_segments: foo[b, :, item_segs:] = 0 return foo def _downsample_final(foo: torch.Tensor, upsample: bool = False) -> torch.Tensor: """Normalize assignment weights for downsample/upsample einsum.""" autoregressive = foo != 0 lel = 1.0 - foo.float() lel[autoregressive] = 0.0 dim = 2 if upsample else 1 lel = lel / (lel.sum(dim=dim, keepdim=True) + 1e-9) return lel.to(foo.dtype) def downsample(boundaries: torch.Tensor, hidden: torch.Tensor, null_group: torch.Tensor) -> torch.Tensor: """Downsample hidden states using boundary decisions. Per D-05: Exact einsum port from FLEXITOKENS shortening.py. Per D-08: Batch-first layout [B, L, D]. Per D-11: Sentinel tokens forced to boundary=1 by modality_mask -> downsample treats each sentinel+modality group as a separate merge group -> groups appear intact in shortened sequence. Args: boundaries: [B, L] binary boundary tensor (1 = new group starts) hidden: [B, L, D] hidden states (batch-first per D-08) null_group: [1, B, D] null group token prepended to output Returns: shortened_hidden: [S, B, D] shortened sequence (LBD format for compatibility with FLEXITOKENS upsample which expects SBD input) """ foo = _downsample_common(boundaries, upsample=False) if foo is None: return null_group.repeat(1, hidden.size(0), 1) else: bar = _downsample_final(foo, upsample=False) # Einsum: B*L*D @ B*L*S -> B*S*D, then transpose to S*B*D shortened_hidden = torch.einsum('bld,bls->bsd', hidden, bar.to(hidden.dtype)) shortened_hidden = shortened_hidden.permute(1, 0, 2) # Prepend null_group: [1, B, D] -> cat along dim=0 -> [S+1, B, D] shortened_hidden = torch.cat([null_group, shortened_hidden], dim=0) return shortened_hidden def upsample(boundaries: torch.Tensor, shortened_hidden: torch.Tensor) -> torch.Tensor: """Upsample shortened hidden states back to original sequence length. Per D-05: Exact einsum port from FLEXITOKENS shortening.py. Per D-08: Batch-first layout. Args: boundaries: [B, L] binary boundary tensor shortened_hidden: [S, B, D] shortened sequence Returns: upsampled_hidden: [B, L, D] upsampled sequence """ foo = _downsample_common(boundaries, upsample=True) bar = _downsample_final(foo, upsample=True) upsampled_hidden = torch.einsum('sbd,bls->bld', shortened_hidden, bar.to(shortened_hidden.dtype)) return upsampled_hidden # ============================================================================ # LTI Injection, ACT Halting, LoRA Adapter # ============================================================================ class LTIInjection(nn.Module): """Linear Time-Invariant injection module.""" def __init__(self, config: SpiderConfig): super().__init__() self.hidden_size = config.hidden_size self.log_A = nn.Parameter(torch.full((config.hidden_size,), -2.0)) self.delta_t = nn.Parameter(torch.tensor(1.0)) self.B = nn.Linear(config.hidden_size, config.hidden_size, bias=False) with torch.no_grad(): self.B.weight.data.normal_(mean=0.0, std=0.01) def get_A(self): return -torch.exp(self.log_A) def forward(self, h_t, e): A = self.get_A() return A * h_t + self.B(e) class ACTHalting(nn.Module): """Adaptive Computation Time halting module.""" def __init__(self, config: SpiderConfig): super().__init__() self.halt_predictor = nn.Linear(config.hidden_size, 1) self.threshold = config.act_threshold def forward(self, hidden_states): return torch.sigmoid(self.halt_predictor(hidden_states)) class LoRAAdapter(nn.Module): """LoRA adapter for per-loop adaptation in recurrent layers. Per CR-01 fix: up-projection (self.B) is initialized to EXACTLY ZERO so that LoRA adapter output is zero at initialization -- meaning the model starts behaving identically to the base model. This follows standard LoRA convention (Hu et al., 2021). """ def __init__(self, config: SpiderConfig): super().__init__() rank = config.lora_rank self.down = nn.Linear(config.hidden_size, rank, bias=False) self.B = nn.Parameter(torch.zeros(rank, config.hidden_size, dtype=torch.float32)) # CR-01 fix: zeros, not randn*0.02; IN-02 self.scale = nn.Embedding(config.max_loop_iters, rank) with torch.no_grad(): self.scale.weight.data.zero_() self.down.weight.data.normal_(mean=0.0, std=0.001) def forward(self, x, loop_t): max_t = self.scale.num_embeddings - 1 t_idx = min(loop_t, max_t) s = self.scale(torch.tensor(t_idx, device=x.device)) down = self.down(x) * s return down @ self.B def _loop_index_embedding(h, loop_t, loop_dim, theta=10000.0): """Sinusoidal loop index embedding for RDT depth differentiation.""" freqs = 1.0 / (theta ** (torch.arange(0, loop_dim, 2, device=h.device, dtype=h.dtype) / loop_dim)) angles = loop_t * freqs emb = torch.cat([angles.sin(), angles.cos()], dim=-1)[:loop_dim] emb_full = torch.zeros(h.shape[-1], device=h.device, dtype=h.dtype) emb_full[:loop_dim] = emb return h + emb_full.unsqueeze(0).unsqueeze(0) def _checkpoint(func, *args, **kwargs): """Gradient checkpointing wrapper -- saves VRAM at ~20% compute cost.""" if torch.is_grad_enabled(): return torch.utils.checkpoint.checkpoint(func, *args, use_reentrant=False, **kwargs) return func(*args, **kwargs) # ============================================================================ # Full Spider Model (with FlexiToken integration) # ============================================================================ class SpiderModel(nn.Module): """Full RDT model with MLA attention + Engram memory + FlexiToken. Architecture: 2x Prelude (MLA + dense FFN) 6x Recurrent (MLA + Engram@L1,L4 + MoE) -- with gradient checkpointing 2x Coda (MLA + dense FFN) LTI Injection + ACT Halting + LoRA Adapter BoundaryPredictor + downsample/upsample for FlexiToken """ def __init__(self, config: SpiderConfig): super().__init__() self.config = config self.prelude_layers = nn.ModuleList([ SpiderDenseLayer(config) for _ in range(config.prelude_layers) ]) self.recurrent_layers = nn.ModuleList([ SpiderRecurrentLayer(config, i, has_engram=(i in config.engram_layers)) for i in range(config.num_hidden_layers) ]) self.coda_layers = nn.ModuleList([ SpiderDenseLayer(config) for _ in range(config.coda_layers) ]) self.norm = SpiderRMSNorm(config.hidden_size, eps=config.rms_norm_eps) self.injection = LTIInjection(config) self.act_halting = ACTHalting(config) self.lora_adapter = LoRAAdapter(config) self.loop_embed_dim = config.loop_embed_dim self._gradient_checkpointing = False def gradient_checkpointing_enable(self): self._gradient_checkpointing = True def gradient_checkpointing_disable(self): self._gradient_checkpointing = False def forward( self, hidden_states, input_embedding=None, attention_mask=None, position_ids=None, past_key_values=None, use_cache=False, n_loops=None, token_ids=None, hard_boundaries=None, ): n_loops = n_loops or 1 input_embedding = input_embedding if input_embedding is not None else hidden_states # Prelude layers for layer in self.prelude_layers: if self._gradient_checkpointing and torch.is_grad_enabled(): hidden_states, _ = _checkpoint( layer, hidden_states, attention_mask=attention_mask, position_ids=position_ids, ) else: hidden_states, _ = layer( hidden_states, attention_mask=attention_mask, position_ids=position_ids, ) # FlexiToken: if hard_boundaries provided, downsample before recurrent core if hard_boundaries is not None: # Apply norm before downsample hidden_normed = self.norm(hidden_states) null_group = torch.zeros( 1, hidden_states.shape[0], hidden_states.shape[-1], device=hidden_states.device, dtype=hidden_states.dtype, ) shortened = downsample(hard_boundaries, hidden_normed, null_group) # shortened: [S, B, D] -> [B, S, D] hidden_states = shortened.permute(1, 0, 2) # Shorten token_ids to match downsampled sequence length. # Take the first token in each boundary group so the Engram # hash-based lookup gets a representative token per group. # hard_boundaries: [B, L], cumsum gives group index per position. # Pick the first position (where boundary=1) of each group. if token_ids is not None: group_ids = hard_boundaries.cumsum(dim=-1) # [B, L], 1-based group indices n_groups = int(group_ids.max().item()) # number of groups B = hard_boundaries.shape[0] # For each group g (1..n_groups), find the first position where group_ids == g short_ids = torch.zeros(B, n_groups, device=token_ids.device, dtype=token_ids.dtype) for g in range(1, n_groups + 1): # mask of positions belonging to group g mask = (group_ids == g) # first position in group g first_pos = mask.float().argmax(dim=-1) # [B] short_ids[:, g - 1] = token_ids.gather(1, first_pos.unsqueeze(1)).squeeze(1) # Prepend a dummy token (0) for the null_group entry null_token = torch.zeros(B, 1, device=token_ids.device, dtype=token_ids.dtype) token_ids = torch.cat([null_token, short_ids], dim=1) # [B, S+1] # After downsample, input_embedding must match the shortened sequence length input_embedding = hidden_states.clone() # Recurrent core with RDT looping e = hidden_states.clone() B, T_seq, D = hidden_states.shape halted = torch.zeros(B, T_seq, device=hidden_states.device, dtype=torch.bool) cumulative_p = torch.zeros(B, T_seq, device=hidden_states.device, dtype=hidden_states.dtype) h_out = torch.zeros_like(hidden_states) total_aux_loss = 0.0 past_key_values = past_key_values if past_key_values is not None else [None] * len(self.recurrent_layers) for t in range(n_loops): h_loop = _loop_index_embedding(hidden_states, t, self.loop_embed_dim) if t > 0: injection = self.injection(hidden_states, input_embedding) hidden_states = hidden_states + injection new_past_key_values = [] for i, layer in enumerate(self.recurrent_layers): hidden_states, aux_loss, past_kv = _checkpoint( layer, hidden_states, token_ids=token_ids, attention_mask=attention_mask, position_ids=position_ids, past_key_value=past_key_values[i] if t == 0 else None, use_cache=use_cache, ) total_aux_loss = total_aux_loss + aux_loss new_past_key_values.append(past_kv) lora_delta = self.lora_adapter(hidden_states, t) hidden_states = hidden_states + lora_delta halt_prob = self.act_halting(hidden_states).squeeze(-1) still_running = ~halted remainder = (1.0 - cumulative_p).clamp(min=0) weight = torch.where( cumulative_p + halt_prob >= self.config.act_threshold, remainder, halt_prob, ) weight = weight * still_running.to(hidden_states.dtype) h_out = h_out + weight.unsqueeze(-1) * hidden_states cumulative_p = cumulative_p + halt_prob * still_running.to(hidden_states.dtype) halted = halted | (cumulative_p >= self.config.act_threshold) if halted.all() and not self.training: break never_halted = (~halted).to(hidden_states.dtype).unsqueeze(-1) hidden_states = h_out + never_halted * hidden_states # FlexiToken: if hard_boundaries provided, upsample after recurrent core if hard_boundaries is not None: hidden_states_sbd = hidden_states.permute(1, 0, 2) # [S, B, D] hidden_states = upsample(hard_boundaries, hidden_states_sbd) # [B, L, D] # Coda layers for layer in self.coda_layers: if self._gradient_checkpointing and torch.is_grad_enabled(): hidden_states, _ = _checkpoint( layer, hidden_states, attention_mask=attention_mask, position_ids=position_ids, ) else: hidden_states, _ = layer( hidden_states, attention_mask=attention_mask, position_ids=position_ids, ) hidden_states = self.norm(hidden_states) return hidden_states, total_aux_loss, new_past_key_values # ============================================================================ # SpiderForConditionalGeneration # ============================================================================ class SpiderForConditionalGeneration(nn.Module): """Spider model with embedding, LM head, and FlexiToken boundary prediction. Forward flow: 1. embed_tokens(input_ids) -> hidden_states 2. Inject modality features at sentinel positions 3. Prelude layers 4. BoundaryPredictor with modality_mask -> boundaries 5. SpiderModel (downsample -> recurrent -> upsample -> coda) 6. lm_head -> logits """ def __init__(self, config: SpiderConfig): super().__init__() self.config = config self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size) self.boundary_predictor = BoundaryPredictor(config) self.model = SpiderModel(config) self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) if config.tie_word_embeddings: self.lm_head.weight = self.embed_tokens.weight self.apply(self._init_weights) def gradient_checkpointing_enable(self): self.model.gradient_checkpointing_enable() def gradient_checkpointing_disable(self): self.model.gradient_checkpointing_disable() def enable_input_require_grads(self): def _make_inputs_require_grad(module, input, output): output.requires_grad_(True) self.embed_tokens.register_forward_hook(_make_inputs_require_grad) def _init_weights(self, module): if isinstance(module, nn.Linear): if hasattr(self, 'model') and module is self.model.injection.B: return # LTI injection B has its own init module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) if module.bias is not None: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) def _inject_modality_features( self, hidden_states: torch.Tensor, input_ids: torch.Tensor, features: list, modality: str = 'IMG', ) -> torch.Tensor: """Replace placeholder embeddings with actual encoder features at modality regions. Per D-11: Modality tokens (vision, audio, video) are injected at sentinel-marked positions. Between sentinel pairs, the initial embeddings are placeholders -- this method replaces them with the actual encoder features. T-02-06 mitigation: Validates feature shape and sentinel pair count. """ start_token = SENTINEL_TOKENS[f'{modality}_START'] end_token = SENTINEL_TOKENS[f'{modality}_END'] for b in range(hidden_states.shape[0]): starts = (input_ids[b] == start_token).nonzero(as_tuple=True)[0] ends = (input_ids[b] == end_token).nonzero(as_tuple=True)[0] if len(starts) != len(ends): raise ValueError( f"Batch {b}: mismatched {modality} sentinel pairs -- " f"{len(starts)} {_TOKEN_NAMES_BY_ID[start_token]}(s) vs " f"{len(ends)} {_TOKEN_NAMES_BY_ID[end_token]}(s)." ) if len(starts) != len(features): raise ValueError( f"Batch {b}: {modality} sentinel pair count ({len(starts)}) " f"doesn't match feature count ({len(features)})." ) for s, e, feat in zip(starts, ends, features): num_tokens = e - s - 1 if feat.shape[0] != num_tokens: raise ValueError( f"Batch {b}: {modality} feature has {feat.shape[0]} tokens " f"but sentinel region has {num_tokens} positions " f"(from pos {s+1} to {e-1})." ) if feat.shape[1] != hidden_states.shape[-1]: raise ValueError( f"Batch {b}: {modality} feature hidden_size {feat.shape[1]} " f"doesn't match model hidden_size {hidden_states.shape[-1]}." ) hidden_states[b, s + 1:e] = feat.to(hidden_states.dtype) return hidden_states def forward( self, input_ids: torch.Tensor, attention_mask=None, position_ids=None, labels=None, n_loops=None, use_cache=False, vision_features=None, audio_features=None, video_features=None, **kwargs, ): hidden_states = self.embed_tokens(input_ids) model_dtype = next(self.model.parameters()).dtype hidden_states = hidden_states.to(model_dtype) input_embedding = hidden_states.clone() # Inject modality features at sentinel positions if vision_features is not None: hidden_states = self._inject_modality_features( hidden_states, input_ids, vision_features, 'IMG' ) if audio_features is not None: hidden_states = self._inject_modality_features( hidden_states, input_ids, audio_features, 'AUD' ) if video_features is not None: hidden_states = self._inject_modality_features( hidden_states, input_ids, video_features, 'VID' ) # Create modality mask and predict boundaries modality_mask = create_modality_mask(input_ids, strict=(labels is not None)) soft_boundaries, hard_boundaries = self.boundary_predictor( hidden_states, modality_mask=modality_mask ) # Run model with FlexiToken boundaries hidden_states, aux_loss, past_kv = self.model( hidden_states, input_embedding=input_embedding, attention_mask=None, position_ids=position_ids, use_cache=use_cache, n_loops=n_loops, token_ids=input_ids, hard_boundaries=hard_boundaries, ) logits = self.lm_head(hidden_states) loss = None if labels is not None: shift_logits = logits[..., :-1, :].contiguous() shift_labels = labels[..., 1:].contiguous() loss_fct = CrossEntropyLoss() loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)) return { "loss": loss, "logits": logits, "aux_loss": aux_loss, "past_key_values": past_kv, "soft_boundaries": soft_boundaries, "hard_boundaries": hard_boundaries, } @torch.inference_mode() def generate( self, input_ids: torch.Tensor, max_new_tokens: int = 100, temperature: float = 1.0, top_k: Optional[int] = None, n_loops: int = 1, use_cache: bool = True, boundary_mode: str = 'adaptive', ) -> torch.Tensor: """Token-level generation with compressed-prefix KV cache per D-28. Strategy: Encode the prefix through prelude + BP + downsample to get a compressed KV cache, then autoregressively decode byte-by-byte using that cached prefix. The speedup comes from the prefix being shorter in the KV cache (~3.3x fewer entries for English text). Flow: 1. Embed prefix → prelude layers → BP → downsample → recurrent core → collect KV cache for compressed prefix 2. Coda + lm_head on last position → sample first new byte 3. For each subsequent byte: embed → recurrent (with KV cache) → coda → lm_head → sample → append 4. Stop at max_new_tokens or EOS Args: input_ids: Prefix token IDs [B, L] (byte values 0-255 + BOS/EOS) max_new_tokens: Maximum number of new bytes to generate temperature: Sampling temperature (0 = greedy, 1.0 = default) top_k: If set, only sample from top-k logits n_loops: Number of recurrent loops during generation use_cache: Use KV cache for incremental decoding boundary_mode: 'adaptive' (threshold) or 'fixed' (top-k) for BP Returns: Generated token IDs [B, N] where N ≤ max_new_tokens """ B = input_ids.shape[0] device = input_ids.device model_dtype = next(self.model.parameters()).dtype # --- Step 1: Encode prefix and collect KV cache --- hidden_states = self.embed_tokens(input_ids).to(model_dtype) # Prelude layers (byte-level, no compression) for layer in self.model.prelude_layers: hidden_states, _ = layer(hidden_states) # Boundary prediction on prefix (strict=False for generation) modality_mask = create_modality_mask(input_ids, strict=False) soft_boundaries, hard_boundaries = self.boundary_predictor( hidden_states, modality_mask=modality_mask ) # Apply boundary mode if boundary_mode == 'adaptive': hard_boundaries = (soft_boundaries > 0.5).float() hard_boundaries = hard_boundaries - soft_boundaries.detach() + soft_boundaries elif boundary_mode == 'fixed': k = max(1, int(soft_boundaries.shape[-1] / 3.3)) topk_vals, topk_idx = soft_boundaries.topk(k, dim=-1) hard_boundaries = torch.zeros_like(soft_boundaries) hard_boundaries.scatter_(-1, topk_idx, 1.0) hard_boundaries = hard_boundaries - soft_boundaries.detach() + soft_boundaries # Downsample prefix for compressed KV cache hidden_normed = self.model.norm(hidden_states) null_group = torch.zeros( 1, B, hidden_states.shape[-1], device=device, dtype=hidden_states.dtype ) shortened = downsample(hard_boundaries, hidden_normed, null_group) hidden_states = shortened.permute(1, 0, 2) # [B, S, D] input_embedding = hidden_states.clone() # Run through recurrent core + coda (hard_boundaries=None skips downsample/upsample) hidden_states, _, past_key_values = self.model( hidden_states, input_embedding=input_embedding, use_cache=use_cache, n_loops=n_loops, hard_boundaries=None, ) # Get logits for last position of prefix (norm + lm_head only, coda already applied) logits = self.lm_head(hidden_states[:, -1:, :]) # [B, 1, vocab] next_token = self._sample_token(logits, temperature, top_k) # [B, 1] generated = [next_token] # --- Step 2: Autoregressive byte-level decoding with KV cache --- for _ in range(max_new_tokens - 1): # Check EOS if (next_token == SENTINEL_TOKENS['EOS']).all(): break # Embed the last generated token hidden_states = self.embed_tokens(next_token).to(model_dtype) # [B, 1, D] input_embedding = hidden_states.clone() if use_cache: # Incremental forward: 1 new token, cached prefix in past_key_values hidden_states, _, past_key_values = self.model( hidden_states, input_embedding=input_embedding, past_key_values=past_key_values, use_cache=True, n_loops=n_loops, hard_boundaries=None, ) else: # Naive: re-run full forward from scratch (no KV cache) all_ids = torch.cat([input_ids, torch.cat(generated, dim=1)], dim=1) output = self.forward( all_ids, n_loops=n_loops, use_cache=False, ) logits_full = output['logits'] next_logits = logits_full[:, -1, :] / max(temperature, 1e-8) if top_k is not None and top_k > 0: v, _ = torch.topk(next_logits, min(top_k, next_logits.size(-1))) next_logits = next_logits.masked_fill(next_logits < v[:, [-1]], float('-inf')) if temperature < 1e-8: next_token = next_logits.argmax(dim=-1, keepdim=True) else: probs = torch.softmax(next_logits, dim=-1) next_token = torch.multinomial(probs, num_samples=1) generated.append(next_token) continue # lm_head on last position (coda + norm already applied by self.model) logits = self.lm_head(hidden_states[:, -1:, :]) # [B, 1, vocab] next_token = self._sample_token(logits, temperature, top_k) generated.append(next_token) return torch.cat(generated, dim=1) # [B, N] @staticmethod def _sample_token(logits: torch.Tensor, temperature: float, top_k: Optional[int]) -> torch.Tensor: """Sample next token from logits with temperature and top-k.""" logits = logits.squeeze(1) # [B, vocab] if temperature < 1e-8: return logits.argmax(dim=-1, keepdim=True) # greedy logits = logits / temperature if top_k is not None and top_k > 0: v, _ = torch.topk(logits, min(top_k, logits.size(-1))) logits = logits.masked_fill(logits < v[:, [-1]], float('-inf')) probs = torch.softmax(logits, dim=-1) return torch.multinomial(probs, num_samples=1) # [B, 1] def get_num_params(self): total = sum(p.numel() for p in self.parameters()) return {"total": total, "trainable": total}