code/spec_rag/spectra_reason_encoder.py

"""
Spectra-Reason-GCD encoder: DreaMS (frozen) + Perceiver Resampler.
Input: raw spectrum (peaks B,N,2 or binned B,spec_bins).
Output: (B, 64, llm_dim) soft spectral tokens for the LLM.
"""
from __future__ import annotations

from pathlib import Path
from typing import Any, Dict, Optional

import torch
import torch.nn as nn

from .perceiver_resampler import PerceiverResampler


def _load_dreams_backbone(
    dreams_ckpt: Optional[str] = None,
    specbridge_ckpt: Optional[str] = None,
    d_model: int = 1024,
    device: str = "cpu",
) -> tuple[nn.Module, int]:
    """Load DreaMS encoder that returns (B, num_peaks, d_model). Returns (model, d_model)."""
    import sys
    specbridge_root = Path(__file__).resolve().parents[2] / "SpecBridge"
    dreams_root = specbridge_root / "DreaMS"
    for p in (specbridge_root, dreams_root):
        if p.exists() and str(p) not in sys.path:
            sys.path.insert(0, str(p))

    # Try loading from SpecBridge checkpoint (extract .spec.dreams)
    if specbridge_ckpt:
        try:
            state = torch.load(specbridge_ckpt, map_location="cpu", weights_only=False)
        except TypeError:
            state = torch.load(specbridge_ckpt, map_location="cpu")
        model_state = state.get("model", state)
        if isinstance(model_state, dict) and "spec.proj.0.0.weight" in model_state:
            d_model = int(model_state["spec.proj.0.0.weight"].shape[1])
        try:
            from specbridge.models.mapper import DreamsToMolCondition
            from specbridge.adapters.dreams_adapter import load_dreams_encoder
            full = DreamsToMolCondition(
                load_dreams_encoder(dreams_ckpt, d_in=2048, d_out=d_model),
                d_out=d_model, mapper_hidden=512, n_blocks=4,
                chemberta_model="seyonec/ChemBERTa-zinc-base-v1",
                args=type("Args", (), {"n_blocks": 4, "random_mapper_init": False})(),
                freeze_backbone=True,
            )
            full.load_state_dict(model_state, strict=False)
            backbone = full.spec.dreams
            backbone.eval()
            for p in backbone.parameters():
                p.requires_grad = False
            d_model = getattr(backbone, "d_model", getattr(backbone, "embed_dim", d_model))
            return backbone, d_model
        except Exception:
            pass

    # Try load_dreams_encoder with DreaMS checkpoint
    if dreams_ckpt:
        try:
            from specbridge.adapters.dreams_adapter import load_dreams_encoder
            backbone = load_dreams_encoder(dreams_ckpt, d_in=2048, d_out=d_model)
            backbone.eval()
            for p in backbone.parameters():
                p.requires_grad = False
            d_model = getattr(backbone, "d_model", getattr(backbone, "embed_dim", d_model))
            return backbone, d_model
        except Exception:
            pass

    # Fallback: dummy encoder (B, 2048) -> (B, 60, d_model)
    class DummySequenceEncoder(nn.Module):
        def __init__(self, d_in: int = 2048, d_out: int = 1024, num_peaks: int = 60):
            super().__init__()
            self.d_model = d_out
            self.num_peaks = num_peaks
            self.net = nn.Sequential(
                nn.Linear(d_in, 512), nn.GELU(),
                nn.Linear(512, d_out),
            )
        def forward(self, x: torch.Tensor, meta: Optional[Dict] = None) -> torch.Tensor:
            if x.dim() == 3:
                x = x.flatten(1)
            h = self.net(x)
            return h.unsqueeze(1).expand(-1, self.num_peaks, -1)
    return DummySequenceEncoder(d_in=2048, d_out=d_model, num_peaks=60), d_model


class SpectraReasonEncoder(nn.Module):
    """
    Encoder for Spectra-Reason-GCD: DreaMS (frozen) -> per-peak features -> Perceiver Resampler -> 64 tokens.
    """

    def __init__(
        self,
        dreams_encoder: nn.Module,
        d_model: int,
        llm_dim: int = 4096,
        num_latents: int = 64,
        num_heads: int = 8,
        num_perceiver_layers: int = 2,
        dropout: float = 0.1,
    ):
        super().__init__()
        self.dreams = dreams_encoder
        self.perceiver = PerceiverResampler(
            d_model=d_model,
            llm_dim=llm_dim,
            num_latents=num_latents,
            num_heads=num_heads,
            num_layers=num_perceiver_layers,
            dropout=dropout,
        )
        self.d_model = d_model
        self.llm_dim = llm_dim
        self.num_latents = num_latents

    def forward(
        self,
        spectra_binned: Optional[torch.Tensor] = None,
        peaks: Optional[torch.Tensor] = None,
        meta: Optional[Dict[str, Any]] = None,
    ) -> torch.Tensor:
        """
        Args:
            spectra_binned: (B, spec_bins) optional binned spectrum.
            peaks: (B, N, 2) optional m/z, intensity pairs (takes precedence if present).
            meta: optional dict with 'peaks' or other keys for the backbone.

        Returns:
            (B, num_latents, llm_dim) soft spectral tokens.
        """
        if peaks is not None:
            # DreaMS expects (B, N, 2); padding is mz==0
            with torch.no_grad():
                encoder_out = self.dreams(peaks, meta)
        elif meta is not None and isinstance(meta, dict) and "peaks" in meta:
            p = meta["peaks"]
            if isinstance(p, torch.Tensor):
                with torch.no_grad():
                    encoder_out = self.dreams(p, meta)
                if encoder_out.dim() == 2:
                    encoder_out = encoder_out.unsqueeze(1)
            else:
                raise ValueError("meta['peaks'] must be tensor")
        elif spectra_binned is not None:
            with torch.no_grad():
                encoder_out = self.dreams(spectra_binned, meta or {})
            if encoder_out.dim() == 2:
                encoder_out = encoder_out.unsqueeze(1)
        else:
            raise ValueError("Provide either peaks, meta['peaks'], or spectra_binned.")

        # encoder_out: (B, N, d_model)
        if encoder_out.size(-1) != self.d_model:
            # Project if backbone dim differs
            if not hasattr(self, "proj_in"):
                self.proj_in = nn.Linear(encoder_out.size(-1), self.d_model).to(encoder_out.device)
            encoder_out = self.proj_in(encoder_out)
        key_padding_mask = None
        if peaks is not None:
            key_padding_mask = (peaks[:, :, 0] == 0)  # True = padding
        elif meta and "peaks" in meta and isinstance(meta["peaks"], torch.Tensor):
            key_padding_mask = (meta["peaks"][:, :, 0] == 0)
        return self.perceiver(encoder_out, key_padding_mask=key_padding_mask)


def build_spectra_reason_encoder(
    llm_dim: int = 4096,
    num_latents: int = 64,
    dreams_ckpt: Optional[str] = None,
    specbridge_ckpt: Optional[str] = None,
    device: str = "cpu",
) -> SpectraReasonEncoder:
    """Build encoder: load DreaMS then wrap with Perceiver."""
    backbone, d_model = _load_dreams_backbone(
        dreams_ckpt=dreams_ckpt,
        specbridge_ckpt=specbridge_ckpt,
        d_model=1024,
        device=device,
    )
    backbone = backbone.to(device)
    enc = SpectraReasonEncoder(
        dreams_encoder=backbone,
        d_model=d_model,
        llm_dim=llm_dim,
        num_latents=num_latents,
    )
    return enc.to(device)