code/scripts/embed_spectra.py

#!/usr/bin/env python
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

from spec_rag.embeddings import SpectrumEmbedder
from spec_rag.io import load_jsonl, save_embeddings


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Embed spectra using SpecBridge.")
    parser.add_argument("--specbridge-ckpt", required=True)
    parser.add_argument("--spectra-npy", default=None, help="Binned spectra numpy array")
    parser.add_argument("--mgf-path", default=None, help="MGF file to bin into spectra")
    parser.add_argument("--out-npy", required=True)
    parser.add_argument("--dreams-ckpt", default=None)
    parser.add_argument("--chemberta-model", default="seyonec/ChemBERTa-zinc-base-v1")
    parser.add_argument("--meta-jsonl", default=None, help="Optional JSONL with 'peaks'")
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--no-normalize", action="store_true")
    parser.add_argument("--lightweight", action="store_true", help="Skip loading ChemBERTa weights")
    parser.add_argument("--spec-bins", type=int, default=None)
    parser.add_argument("--max-mz", type=float, default=2000.0)
    parser.add_argument("--max-peaks", type=int, default=60)
    parser.add_argument("--batch-size", type=int, default=16)
    return parser.parse_args()


def _build_meta(meta_rows: list[dict], max_peaks: int) -> dict:
    if not meta_rows:
        return {}
    if "peaks" not in meta_rows[0]:
        return {}
    peaks_list = []
    for row in meta_rows:
        peaks = row.get("peaks", [])
        if max_peaks and peaks:
            peaks = sorted(peaks, key=lambda x: float(x[1]), reverse=True)[:max_peaks]
        peaks_list.append(peaks)
    max_len = max(len(p) for p in peaks_list) if peaks_list else 0
    if max_len == 0:
        return {}
    peaks = np.zeros((len(peaks_list), max_len, 2), dtype=np.float32)
    for i, peaks_i in enumerate(peaks_list):
        for j, pair in enumerate(peaks_i[:max_len]):
            peaks[i, j, 0] = float(pair[0])
            peaks[i, j, 1] = float(pair[1])
    return {"peaks": torch.tensor(peaks)}


def _bin_peaks(mz, intensity, num_bins: int, max_mz: float) -> torch.Tensor:
    """Bin peaks to 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, device=mz.device, dtype=torch.float32)
    if mz.numel() == 0:
        return bins
    idx = torch.clamp((mz / max_mz) * num_bins, min=0, max=num_bins - 1e-6).long()
    idx = torch.min(idx, torch.tensor(num_bins - 1, device=mz.device))
    bins.index_add_(0, idx, intensity)
    return bins


def _load_mgf_binned(
    mgf_path: str,
    spec_bins: int,
    max_mz: float,
    max_peaks: int,
) -> tuple[np.ndarray, list[dict]]:
    try:
        from pyteomics import mgf  # type: ignore
    except Exception as e:
        raise ImportError(f"pyteomics is required to read MGF: {e}")
    spectra = []
    meta_rows: list[dict] = []
    with mgf.MGF(mgf_path) as reader:
        for spec in reader:
            mz = torch.tensor(spec.get("m/z array"), dtype=torch.float32)
            intensity = torch.tensor(spec.get("intensity array"), dtype=torch.float32)
            binned = _bin_peaks(mz, intensity, num_bins=spec_bins, max_mz=max_mz)
            spectra.append(binned.cpu().numpy())
            peaks = [[float(m), float(i)] for m, i in zip(mz.tolist(), intensity.tolist())]
            if max_peaks and peaks:
                peaks = sorted(peaks, key=lambda x: x[1], reverse=True)[:max_peaks]
            meta_rows.append({"peaks": peaks})
    if not spectra:
        return np.zeros((0, spec_bins), dtype=np.float32), []
    return np.stack(spectra, axis=0).astype(np.float32), meta_rows


def _infer_spec_bins(ckpt_path: str) -> int | None:
    try:
        state = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    except TypeError:
        state = torch.load(ckpt_path, map_location="cpu")
    if isinstance(state, dict):
        args = state.get("args", {})
        if isinstance(args, dict) and args.get("spec_bins"):
            return int(args["spec_bins"])
    return None


def main() -> None:
    args = parse_args()
    if args.device == "cuda" and not torch.cuda.is_available():
        print("CUDA not available; falling back to CPU.")
        args.device = "cpu"
    if args.spec_bins is None:
        args.spec_bins = _infer_spec_bins(args.specbridge_ckpt) or 2048
    if bool(args.spectra_npy) == bool(args.mgf_path):
        raise ValueError("Provide exactly one of --spectra-npy or --mgf-path.")
    if args.mgf_path:
        spectra, meta_rows = _load_mgf_binned(
            args.mgf_path,
            args.spec_bins,
            args.max_mz,
            args.max_peaks,
        )
    else:
        spectra = np.load(args.spectra_npy)
        meta_rows = load_jsonl(args.meta_jsonl) if args.meta_jsonl else []
    meta = _build_meta(meta_rows, args.max_peaks)

    embedder = SpectrumEmbedder(
        specbridge_ckpt=args.specbridge_ckpt,
        dreams_ckpt=args.dreams_ckpt,
        chemberta_model=args.chemberta_model,
        device=args.device,
        normalize=not args.no_normalize,
        use_lightweight=args.lightweight,
    )
    embeddings = embedder.encode(spectra, meta, batch_size=args.batch_size)
    save_embeddings(Path(args.out_npy), embeddings)
    print(f"Saved spectrum embeddings to {args.out_npy}")


if __name__ == "__main__":
    main()