File size: 7,346 Bytes
db32e07 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 | """
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)
|