#!/usr/bin/env python """ Train M_smi and M_chem: E_mist(spec) -> t_smi, t_chem. Plan ยง2. Data: MassSpecGym train MGF (spectrum, SMILES). Loss: ||normalize(M(x)) - t||^2. """ from __future__ import annotations import argparse import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) import numpy as np import torch import torch.nn as nn from tqdm import tqdm from spec_rag.embeddings import SMILESEmbedder, SpectrumEmbedder, l2_normalize from spec_rag.smited_encoder import load_smited_encoder def _bin_peaks(mz, intensity, num_bins: int, max_mz: float): """Bin peaks to a fixed-length spectrum. Accepts list or numpy arrays and converts to torch tensors. """ if not isinstance(mz, torch.Tensor): mz = torch.tensor(mz, dtype=torch.float32) if not isinstance(intensity, torch.Tensor): intensity = torch.tensor(intensity, dtype=torch.float32) bins = torch.zeros(num_bins, dtype=torch.float32) if mz.numel() == 0: return bins.numpy() idx = torch.clamp((mz / max_mz) * num_bins, min=0, max=num_bins - 1e-6).long() idx = torch.clamp(idx, max=num_bins - 1) bins.index_add_(0, idx, intensity) return bins.numpy() def load_mgf_spectra_smiles(mgf_path: str, spec_bins: int = 2048, max_mz: float = 2000.0, max_peaks: int = 60): """Load MGF (MassSpecGym style) -> list of {binned, peaks, smiles}.""" try: from pyteomics import mgf except ImportError: raise ImportError("pyteomics required: pip install pyteomics") out = [] with mgf.MGF(mgf_path) as reader: for spec in reader: params = spec.get("params", {}) smi = (params.get("SMILES") or params.get("smiles") or "").strip() if not smi: continue mz = spec.get("m/z array", []) inten = spec.get("intensity array", []) if len(mz) == 0 or len(inten) == 0: continue binned = _bin_peaks(mz, inten, num_bins=spec_bins, max_mz=max_mz) peaks = [[float(m), float(i)] for m, i in zip(mz, inten)] if max_peaks and peaks: peaks = sorted(peaks, key=lambda x: x[1], reverse=True)[:max_peaks] out.append({"binned": binned, "peaks": peaks, "smiles": smi}) return out def build_meta_peaks(records, max_peaks: int): if not records or "peaks" not in records[0]: return {} peaks_list = [r["peaks"] for r in records] max_len = min(max(len(p) for p in peaks_list), max_peaks) if max_peaks else max(len(p) for p in peaks_list) arr = np.zeros((len(peaks_list), max_len, 2), dtype=np.float32) for i, p in enumerate(peaks_list): for j, pair in enumerate(p[:max_len]): arr[i, j, 0] = pair[0] arr[i, j, 1] = pair[1] return {"peaks": torch.tensor(arr)} def parse_args(): p = argparse.ArgumentParser(description="Train M_smi and M_chem mappers") p.add_argument("--mgf-path", required=True, help="MassSpecGym train MGF (spectrum + SMILES)") p.add_argument("--specbridge-ckpt", required=True) p.add_argument("--dreams-ckpt", default=None) p.add_argument("--out-dir", required=True) p.add_argument("--despecbridge-path", default=None, help="De-SpecBridge path for SMI-TED") p.add_argument("--chemberta-model", default="seyonec/ChemBERTa-zinc-base-v1") p.add_argument("--spec-bins", type=int, default=2048) p.add_argument("--max-mz", type=float, default=2000.0) p.add_argument("--max-peaks", type=int, default=60) p.add_argument("--epochs", type=int, default=20) p.add_argument("--batch-size", type=int, default=64) p.add_argument("--lr", type=float, default=1e-3) p.add_argument("--val-split", type=float, default=0.05) p.add_argument("--device", default="cuda") p.add_argument("--limit", type=int, default=None) return p.parse_args() def main(): args = parse_args() if args.device == "cuda" and not torch.cuda.is_available(): args.device = "cpu" device = torch.device(args.device) out_dir = Path(args.out_dir) out_dir.mkdir(parents=True, exist_ok=True) records = load_mgf_spectra_smiles( args.mgf_path, spec_bins=args.spec_bins, max_mz=args.max_mz, max_peaks=args.max_peaks ) if args.limit: records = records[: args.limit] if not records: raise SystemExit(f"No spectrum-SMILES pairs in {args.mgf_path}") spectra_binned = np.stack([r["binned"] for r in records], axis=0).astype(np.float32) smiles_list = [r["smiles"] for r in records] meta = build_meta_peaks(records, args.max_peaks) # E_mist: spectrum -> d_spec spec_embedder = SpectrumEmbedder( specbridge_ckpt=args.specbridge_ckpt, dreams_ckpt=args.dreams_ckpt, device=args.device, use_lightweight=True, ) print("Computing E_mist(spec)...") x_spec = spec_embedder.encode_spec_only(spectra_binned, meta, batch_size=args.batch_size) d_spec = x_spec.shape[1] del spec_embedder # Targets: t_smi, t_chem embedder_chem = SMILESEmbedder( model_name=args.chemberta_model, device=args.device, batch_size=args.batch_size, normalize=True, ) print("Computing t_chem...") t_chem = embedder_chem.encode(smiles_list) d_chem = t_chem.shape[1] del embedder_chem encode_smi = load_smited_encoder(despecbridge_path=args.despecbridge_path, device=args.device) if encode_smi is None: raise SystemExit("SMI-TED required for mapper training. Set DESPECBRIDGE_PATH or --despecbridge-path.") print("Computing t_smi...") t_smi = encode_smi(smiles_list, batch_size=args.batch_size) d_smi = t_smi.shape[1] x_spec = torch.tensor(x_spec, dtype=torch.float32, device=device) t_smi = torch.tensor(t_smi, dtype=torch.float32, device=device) t_chem = torch.tensor(t_chem, dtype=torch.float32, device=device) n = len(records) perm = torch.randperm(n, device=device) nval = max(1, int(n * args.val_split)) val_idx = perm[:nval] train_idx = perm[nval:] class MapperHead(nn.Module): def __init__(self, d_in: int, d_out: int): super().__init__() self.proj = nn.Linear(d_in, d_out) def forward(self, x): return self.proj(x) M_smi = MapperHead(d_spec, d_smi).to(device) M_chem = MapperHead(d_spec, d_chem).to(device) opt = torch.optim.Adam( list(M_smi.parameters()) + list(M_chem.parameters()), lr=args.lr, ) def loss_fn(pred, target): pred_n = pred / (pred.norm(dim=-1, keepdim=True) + 1e-8) return ((pred_n - target) ** 2).sum(dim=-1).mean() for ep in range(args.epochs): M_smi.train() M_chem.train() tr_idx = train_idx[torch.randperm(len(train_idx), device=device)] total_loss = 0.0 for start in range(0, len(tr_idx), args.batch_size): idx = tr_idx[start : start + args.batch_size] x = x_spec[idx] opt.zero_grad() pred_smi = M_smi(x) pred_chem = M_chem(x) l_smi = loss_fn(pred_smi, t_smi[idx]) l_chem = loss_fn(pred_chem, t_chem[idx]) loss = l_smi + l_chem loss.backward() opt.step() total_loss += loss.item() M_smi.eval() M_chem.eval() with torch.no_grad(): xv = x_spec[val_idx] lv_smi = loss_fn(M_smi(xv), t_smi[val_idx]).item() lv_chem = loss_fn(M_chem(xv), t_chem[val_idx]).item() print(f"Epoch {ep+1} train_loss={total_loss/max(1, len(tr_idx)//args.batch_size):.4f} val_smi={lv_smi:.4f} val_chem={lv_chem:.4f}") torch.save( { "M_smi": M_smi.state_dict(), "M_chem": M_chem.state_dict(), "d_spec": d_spec, "d_smi": d_smi, "d_chem": d_chem, }, out_dir / "mappers.pt", ) print(f"Saved {out_dir / 'mappers.pt'}") if __name__ == "__main__": main()