""" 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)