code/spec_rag/perceiver_resampler.py

"""
Perceiver Resampler: compresses variable-length DreaMS features into fixed-size soft tokens.
Uses learnable latent queries that cross-attend to the spectrum features (Flamingo-style).
"""
from __future__ import annotations

import math
from typing import Optional

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


class PerceiverResampler(nn.Module):
    """
    Resample variable-length encoder features (B, num_peaks, d_model) into
    a fixed number of latent tokens (B, num_latents, llm_dim) via cross-attention.
    """

    def __init__(
        self,
        d_model: int,
        llm_dim: int,
        num_latents: int = 64,
        num_heads: int = 8,
        num_layers: int = 2,
        dropout: float = 0.1,
    ):
        super().__init__()
        self.num_latents = num_latents
        self.llm_dim = llm_dim
        self.d_model = d_model

        # Learnable latent query vectors (num_latents, llm_dim)
        self.latent_queries = nn.Parameter(torch.randn(1, num_latents, llm_dim) * 0.02)
        # Project encoder features to same dimension as queries for cross-attention
        self.kv_proj = nn.Linear(d_model, llm_dim * 2)  # key and value
        self.q_proj = nn.Linear(llm_dim, llm_dim)

        encoder_layer = nn.TransformerEncoderLayer(
            d_model=llm_dim,
            nhead=num_heads,
            dim_feedforward=llm_dim * 4,
            dropout=dropout,
            activation="gelu",
            batch_first=True,
            norm_first=True,
        )
        self.self_attn_layers = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
        self.norm = nn.LayerNorm(llm_dim)

    def forward(
        self,
        encoder_states: torch.Tensor,
        key_padding_mask: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        """
        Args:
            encoder_states: (B, num_peaks, d_model) from DreaMS or other encoder.
            key_padding_mask: (B, num_peaks) True where padding (ignore those positions).

        Returns:
            (B, num_latents, llm_dim) soft spectral tokens.
        """
        B, N, _ = encoder_states.shape
        device = encoder_states.device
        dtype = encoder_states.dtype

        # Expand latent queries for batch
        queries = self.latent_queries.expand(B, -1, -1).to(device=device, dtype=dtype)  # (B, L, llm_dim)

        # Project encoder states to K, V
        kv = self.kv_proj(encoder_states)  # (B, N, llm_dim*2)
        k, v = kv.chunk(2, dim=-1)
        q = self.q_proj(queries)  # (B, L, llm_dim)

        # Cross-attention: queries (L) attend to encoder states (N)
        # We treat the whole embedding as 1 head for this projection step
        # q: (B, 1, L, D), k: (B, 1, N, D), v: (B, 1, N, D)
        q_s = q.unsqueeze(1)
        k_s = k.unsqueeze(1)
        v_s = v.unsqueeze(1)

        mask = None
        if key_padding_mask is not None:
            # key_padding_mask is (B, N), True where padded
            # Create attn_mask (B, 1, L, N) with -inf where padded
            mask = torch.zeros((B, 1, 1, N), device=device, dtype=dtype)
            mask.masked_fill_(key_padding_mask.view(B, 1, 1, N), float("-inf"))

        if hasattr(F, "scaled_dot_product_attention"):
            attn_out = F.scaled_dot_product_attention(
                q_s, k_s, v_s,
                attn_mask=mask,
                dropout_p=0.0,
            )
            out = attn_out.squeeze(1) # (B, L, D)
        else:
            # Manual attention for PyTorch < 2.0
            scale = (self.llm_dim ** -0.5)
            # q: (B, L, D), k^T: (B, D, N) -> scores: (B, L, N)
            scores = torch.bmm(q, k.transpose(1, 2)) * scale
            
            if mask is not None:
                # mask is (B, 1, 1, N), squeeze to (B, 1, N) broadcastable to (B, L, N)
                scores = scores + mask.squeeze(1).squeeze(1).unsqueeze(1) 
            
            attn_weights = F.softmax(scores, dim=-1)
            # (B, L, N) x (B, N, D) -> (B, L, D)
            out = torch.bmm(attn_weights, v)

        # Self-attention over latents
        out = self.self_attn_layers(out)
        return self.norm(out)