code/scripts/train_mapper.py

#!/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()