thinker/emca.py

"""
Enhanced Multi-scale Cross-Attention (EMCA) in the Poincaré ball.

================================================================================
V1 (2B): radii_per_scale and p_fuse are no longer .detach()'d. Crucially, the
radii used for L_radius are computed from `attended` (post Einstein-midpoint
cross-attention), NOT from `ball_features` (the bare exp_map output).

WHY:
  poincare_radius(exp_0^c(h), c) = (2/√c) · artanh(√c · tanh(√c‖h‖)/√c)
                                 = 2‖h‖           — c CANCELS OUT.
  poincare_radius(attended, c)   has no such cancellation because `attended`
  is the output of einstein_midpoint, whose Lorentz factor γ = (1-c‖k‖²)^(-1/2)
  is genuinely c-dependent and not invertible by the outer artanh.

So under V1:
  - L_radius has real gradient flow (no .detach())
  - L_radius's gradient w.r.t. c_work is non-zero (radii truly depend on c)
  - L_radius's gradient also reaches HGA's (s, b, c^(l)) via the
    multi_scale_features → attended path
================================================================================
"""
import logging
from typing import Dict, List, Any

import torch
import torch.nn as nn
import torch.nn.functional as F

from .hyperbolic_ops import (
    exp_map_zero, log_map_zero, clamp_norm,
    hyperbolic_distance, einstein_midpoint,
    poincare_radius, LearnableCurvature,
)

logger = logging.getLogger(__name__)


class RMSNorm(nn.Module):
    """Root Mean Square Normalization (preserves direction, controls magnitude)."""
    def __init__(self, dim: int, eps: float = 1e-6):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(dim))
        self.eps = eps

    def forward(self, x):
        x_f = x.float()
        rms = torch.sqrt(x_f.pow(2).mean(-1, keepdim=True) + self.eps)
        return ((x_f / rms) * self.weight.float()).to(x.dtype)


class EMCA(nn.Module):
    """Enhanced Multi-scale Cross-Attention.

    Forward pipeline:
      1. Per-scale exp_map into working Poincaré ball (c_work).
      2. Pairwise hyperbolic distance → softmax → cross-scale attention scores.
      3. Einstein midpoint per query scale → `attended` (B, T, S, d) in ball.
         ↑ This is where c truly affects values (via Lorentz factor γ).
      4. Final aggregation across scales (Einstein midpoint, scale_weights) → p_fuse.
      5. log_map → projector → RMSNorm → audio_tokens (Euclidean).

    Outputs:
      audio_tokens: (B, T, llm_dim) Euclidean — feeds LLM.
      p_fuse:       (B, T, d) in ball — available for future hyperbolic losses.
      radii_per_scale: (S,) — mean poincare_radius(attended[..., i, :], c_work).
                       Gradient flows through this; L_radius uses it.
    """

    def __init__(self,
                 encoder_dim: int = 1280,
                 llm_dim: int = 3584,
                 num_scales: int = 8,
                 c_work_init: float = 0.5,
                 c_work_min: float = 0.01,
                 c_work_max: float = 4.0,
                 projector_hidden: int = 4096):
        super().__init__()
        self.encoder_dim = encoder_dim
        self.num_scales = num_scales

        # Working curvature for the EMCA ball (separate from HGA's per-layer c^(l))
        self.c_work = LearnableCurvature(
            init_value=c_work_init, c_min=c_work_min, c_max=c_work_max
        )

        # Learnable temperature for attention
        self.log_temperature = nn.Parameter(torch.tensor(1.0).log())

        # Learnable scale weights for final aggregation
        self.scale_logits = nn.Parameter(torch.zeros(num_scales))

        # Output projection: encoder_dim → llm_dim
        self.projector = nn.Sequential(
            nn.Linear(encoder_dim, projector_hidden),
            nn.GELU(),
            nn.Linear(projector_hidden, llm_dim),
        )
        self.output_norm = RMSNorm(llm_dim)

    @property
    def temperature(self):
        return self.log_temperature.float().exp()

    def forward(self, multi_scale_features: List[torch.Tensor]
                ) -> Dict[str, Any]:
        """
        Args:
            multi_scale_features: list of S tensors, each (B, T, d).
                S = num_scales, features from different Whisper layers
                (already pooled to target frame rate by ThinkerModel).

        Returns:
            dict containing audio_tokens (for LLM), p_fuse (for future use),
            radii_per_scale (for L_radius, WITH gradient), and diagnostics.
        """
        S = len(multi_scale_features)
        assert S == self.num_scales, f"Expected {self.num_scales} scales, got {S}"

        B, T, d = multi_scale_features[0].shape
        c = self.c_work().float()

        # 1. Map each scale into the working Poincaré ball
        ball_features = []
        for i in range(S):
            h = multi_scale_features[i].float()
            p = exp_map_zero(h, c)         # (B, T, d) in ball
            ball_features.append(p)
        # Stack: (B, T, S, d)
        ball_stack = torch.stack(ball_features, dim=2)

        # 2. Pairwise hyperbolic distances for cross-attention
        q = ball_stack.unsqueeze(3).expand(B, T, S, S, d).reshape(-1, d)
        k = ball_stack.unsqueeze(2).expand(B, T, S, S, d).reshape(-1, d)
        dists = hyperbolic_distance(q, k, c).reshape(B, T, S, S)

        # Attention scores: -distance / temperature, mask diagonal
        scores = -dists / self.temperature
        diag_mask = torch.eye(S, device=scores.device, dtype=torch.bool)
        scores = scores.masked_fill(
            diag_mask.unsqueeze(0).unsqueeze(0), float('-inf')
        )
        attn_weights = F.softmax(scores, dim=-1)  # (B, T, S, S)

        # 3. Einstein midpoint cross-attention per query scale
        points_exp = ball_stack.unsqueeze(2).expand(B, T, S, S, d)
        attended = einstein_midpoint(points_exp, attn_weights, c)  # (B, T, S, d)

        # 3b. Radii from `attended` — c truly affects values here (no cancellation)
        # Note: NO .detach() — radii carry gradient back to c_work, scale weights,
        # and through multi_scale_features to HGA parameters.
        radii_per_scale = []
        for i in range(S):
            radii_per_scale.append(
                poincare_radius(attended[:, :, i, :], c).mean()
            )
        radii_per_scale = torch.stack(radii_per_scale)  # (S,)

        # 4. Final aggregation across scales
        scale_w = F.softmax(self.scale_logits.float(), dim=0)  # (S,)
        scale_w_exp = scale_w.unsqueeze(0).unsqueeze(0).expand(B, T, -1)
        p_fuse = einstein_midpoint(attended, scale_w_exp, c)   # (B, T, d)

        # 5. Log map back to Euclidean, project to LLM dim
        z = log_map_zero(p_fuse, c)  # (B, T, d)
        proj_dtype = next(self.projector.parameters()).dtype
        audio_tokens = self.projector(z.to(proj_dtype))
        audio_tokens = self.output_norm(audio_tokens)

        return {
            "audio_tokens": audio_tokens,
            # p_fuse kept in graph (no detach) — available for future losses.
            "p_fuse": p_fuse,
            # radii_per_scale carries gradient → real L_radius signal.
            "radii_per_scale": radii_per_scale,
            # Below are diagnostics only; .detach() is fine here.
            "c_work": c.detach(),
            "scale_weights": scale_w.detach(),
            "scale_entropy": -(scale_w * (scale_w + 1e-8).log()).sum().detach(),
            "attention_temp": self.temperature.detach(),
        }