File size: 5,845 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 | #!/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()
|