#!/usr/bin/env python """ Retrieval + generation: Variants A (SMI-TED only), B (ChemBERTa retrieval + SMI-TED gen), C (ChemBERTa only). Plan ยง3. Input: MGF or binned spectra. Output: candidate SMILES per spectrum. """ from __future__ import annotations import argparse import json import sys from functools import lru_cache 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 SMILESEmbedder, SpectrumEmbedder, l2_normalize from spec_rag.faiss_index import load_index, index_search def _bin_peaks(mz, intensity, num_bins: int, max_mz: float): """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, 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(mgf_path: str, spec_bins: int = 2048, max_mz: float = 2000.0, max_peaks: int = 60): try: from pyteomics import mgf except ImportError: raise ImportError("pyteomics required") out = [] with mgf.MGF(mgf_path) as reader: for spec in reader: params = spec.get("params", {}) smi_gt = (params.get("SMILES") or params.get("smiles") or "").strip() formula_gt = (params.get("FORMULA") or params.get("formula") or "").strip() 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_gt": smi_gt, "formula": formula_gt}) 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 load_meta(library_dir: Path): meta_path = library_dir / "meta.parquet" if meta_path.exists(): import pandas as pd try: df = pd.read_parquet(meta_path, columns=["smiles", "formula"]) except Exception: df = pd.read_parquet(meta_path) return df meta_path = library_dir / "meta.jsonl" if meta_path.exists(): rows = [] with open(meta_path) as f: for line in f: if line.strip(): rows.append(json.loads(line)) import pandas as pd return pd.DataFrame(rows) raise FileNotFoundError(f"No meta.parquet or meta.jsonl in {library_dir}") def _normalize_formula(value) -> str: if value is None: return "" text = str(value).strip() return "" if text.lower() == "nan" else text def _build_query_formula_index(formulas, target_formulas): if formulas is None or not target_formulas: return {} lookup = {formula: [] for formula in target_formulas} for i, value in enumerate(formulas): bucket = lookup.get(_normalize_formula(value)) if bucket is not None: bucket.append(i) return { formula: np.asarray(indices, dtype=np.int64) for formula, indices in lookup.items() if indices } def _exact_subset_search(query, candidate_idx, k: int, vector_store): if candidate_idx is None or vector_store is None: return None candidate_idx = np.asarray(candidate_idx, dtype=np.int64) if candidate_idx.size == 0: return None vectors = np.asarray(vector_store[candidate_idx], dtype=np.float32) vectors = l2_normalize(vectors) q = np.asarray(query, dtype=np.float32).reshape(-1) top_k = min(int(k), int(candidate_idx.shape[0])) if top_k <= 0: return [] scores = vectors @ q if top_k >= scores.shape[0]: order = np.argsort(-scores, kind="mergesort") else: part = np.argpartition(-scores, top_k - 1)[:top_k] order = part[np.argsort(-scores[part], kind="mergesort")] return candidate_idx[order].astype(np.int64).tolist() def _exact_formula_subset_search(query, k: int, target_formula: str, formula_lookup, vector_store): target = _normalize_formula(target_formula) if not target or not formula_lookup: return None return _exact_subset_search(query, formula_lookup.get(target), k, vector_store) def _normalize_candidate_key(value) -> str: if value is None: return "" return str(value).strip() @lru_cache(maxsize=200000) def _canonicalize_smiles(smiles: str) -> str: text = str(smiles or "").strip() if not text: return "" try: from rdkit import Chem except ImportError: return text mol = Chem.MolFromSmiles(text) if mol is None: return text return Chem.MolToSmiles(mol, canonical=True) def _load_candidate_map(path: str): with open(path) as f: data = json.load(f) if not isinstance(data, dict): raise SystemExit(f"Candidate map must be a JSON object: {path}") out = {} for key, values in data.items(): if not isinstance(values, list): continue norm_key = _normalize_candidate_key(key) if not norm_key: continue out[norm_key] = [_normalize_candidate_key(v) for v in values if _normalize_candidate_key(v)] return out @lru_cache(maxsize=200000) def _smiles_to_formula(smiles: str) -> str: text = str(smiles or "").strip() if not text: return "" try: from rdkit import Chem from rdkit.Chem import rdMolDescriptors except ImportError: return "" mol = Chem.MolFromSmiles(text) if mol is None: return "" return rdMolDescriptors.CalcMolFormula(mol) def _looks_like_formula(text: str) -> bool: if not text: return False try: import re except ImportError: return False return bool(re.fullmatch(r"(?:[A-Z][a-z]?\d*)+", text)) def _coerce_candidate_map_to_formula(candidate_map: dict) -> dict: """Convert a candidate map keyed by SMILES or formula into a formula-keyed map.""" out = {} for key, values in candidate_map.items(): formula_key = _normalize_formula(key) if not _looks_like_formula(formula_key): formula_key = _smiles_to_formula(formula_key) if not formula_key: continue bucket = out.setdefault(formula_key, []) seen = set(bucket) for smi in values: clean = _normalize_candidate_key(smi) if not clean or clean in seen: continue seen.add(clean) bucket.append(clean) return out def _build_partial_smiles_index(smiles_values, target_smiles): if not target_smiles: return {} remaining = set(target_smiles) found = {} for i, value in enumerate(smiles_values): smi = str(value) if smi not in remaining: continue found[smi] = i remaining.remove(smi) if not remaining: break return found def _build_query_candidate_index(candidate_map, query_keys, smiles_values): active_keys = [_normalize_candidate_key(k) for k in query_keys if _normalize_candidate_key(k) in candidate_map] if not active_keys: return {} required_smiles = set() for key in active_keys: required_smiles.update(candidate_map.get(key, [])) smiles_to_index = _build_partial_smiles_index(smiles_values, required_smiles) lookup = {} for key in active_keys: idx = [ smiles_to_index[smi] for smi in candidate_map.get(key, []) if smi in smiles_to_index ] if idx: lookup[key] = np.asarray(idx, dtype=np.int64) return lookup def _build_formula_canonical_index(target_formula: str, formula_lookup, smiles_values, cache): target = _normalize_formula(target_formula) if not target or not formula_lookup: return {} cached = cache.get(target) if cached is not None: return cached idx = formula_lookup.get(target) if idx is None or len(idx) == 0: cache[target] = {} return cache[target] canon_map = {} for lib_idx in idx.tolist(): smi = str(smiles_values[int(lib_idx)]) canon = _canonicalize_smiles(smi) if not canon: continue canon_map.setdefault(canon, []).append(int(lib_idx)) cache[target] = canon_map return canon_map def _candidate_pool_indices( query_key: str, target_formula: str, candidate_lookup, candidate_map, formula_lookup, smiles_values, formula_canonical_cache, ): raw_idx = candidate_lookup.get(query_key) raw_list = raw_idx.tolist() if raw_idx is not None else [] if not candidate_map or query_key not in candidate_map: return raw_list or None canon_map = _build_formula_canonical_index(target_formula, formula_lookup, smiles_values, formula_canonical_cache) if not canon_map: return raw_list or None merged = [] seen = set() for lib_idx in raw_list: lib_idx = int(lib_idx) if lib_idx in seen: continue seen.add(lib_idx) merged.append(lib_idx) for candidate_smiles in candidate_map.get(query_key, []): canon = _canonicalize_smiles(candidate_smiles) if not canon: continue for lib_idx in canon_map.get(canon, []): lib_idx = int(lib_idx) if lib_idx in seen: continue seen.add(lib_idx) merged.append(lib_idx) return merged or None def _rank_candidate_smiles_direct( query_vec: np.ndarray, candidate_smiles: list, k: int, variant: str, device: str, chemberta_model: str, despecbridge_path: str | None, candidate_embedding_cache: dict, chem_candidate_embedder, smi_candidate_encoder, ): ordered = [] seen = set() for smi in candidate_smiles: clean = _normalize_candidate_key(smi) if not clean or clean in seen: continue seen.add(clean) ordered.append(clean) if not ordered: return None, chem_candidate_embedder, smi_candidate_encoder missing = [smi for smi in ordered if smi not in candidate_embedding_cache] if missing: if variant in ("B", "C"): if chem_candidate_embedder is None: chem_candidate_embedder = SMILESEmbedder( model_name=chemberta_model, device=device, batch_size=256, normalize=False, ) emb = chem_candidate_embedder.encode(missing) emb = l2_normalize(emb).astype(np.float32) else: if smi_candidate_encoder is None: from spec_rag.smited_encoder import load_smited_encoder smi_candidate_encoder = load_smited_encoder( despecbridge_path=despecbridge_path, device=device, ) if smi_candidate_encoder is None: return None, chem_candidate_embedder, smi_candidate_encoder emb = smi_candidate_encoder(missing, batch_size=256) emb = l2_normalize(emb).astype(np.float32) for smi, vec in zip(missing, emb): candidate_embedding_cache[smi] = vec vectors = np.stack([candidate_embedding_cache[smi] for smi in ordered], axis=0).astype(np.float32) q = np.asarray(query_vec, dtype=np.float32).reshape(-1) top_k = min(int(k), len(ordered)) if top_k <= 0: return [], chem_candidate_embedder, smi_candidate_encoder scores = vectors @ q if top_k >= scores.shape[0]: order = np.argsort(-scores, kind="mergesort") else: part = np.argpartition(-scores, top_k - 1)[:top_k] order = part[np.argsort(-scores[part], kind="mergesort")] ranked = [] for pos in order[:top_k]: smi = ordered[int(pos)] ranked.append({"smiles": smi, "formula": _smiles_to_formula(smi)}) return ranked, chem_candidate_embedder, smi_candidate_encoder def _search_with_formula_backfill( index, query: np.ndarray, k: int, formulas, target_formula: str, min_fetch: int, max_fetch: int, fetch_multiplier: int, ): target = _normalize_formula(target_formula) if not target or formulas is None: _, idx = index_search(index, query, k) return idx[0].tolist() ntotal = min(int(getattr(index, "ntotal", len(formulas))), len(formulas)) if ntotal <= 0: return [] fetch_k = min(ntotal, max(int(k), int(min_fetch), int(k) * int(fetch_multiplier))) filtered = [] filtered_seen = set() fallback = [] fallback_seen = set() while True: _, idx = index_search(index, query, fetch_k) filtered = [] filtered_seen.clear() fallback = [] fallback_seen.clear() for raw_j in idx[0].tolist(): j = int(raw_j) if j < 0 or j >= len(formulas): continue if j not in fallback_seen: fallback_seen.add(j) fallback.append(j) if _normalize_formula(formulas[j]) != target or j in filtered_seen: continue filtered_seen.add(j) filtered.append(j) if len(filtered) >= k: return filtered if fetch_k >= ntotal or fetch_k >= max_fetch: break next_fetch = min(ntotal, max(fetch_k * 2, fetch_k + int(k))) if next_fetch <= fetch_k: break fetch_k = next_fetch for j in fallback: if j in filtered_seen: continue filtered.append(j) if len(filtered) >= k: break return filtered[:k] def _load_global_index_or_die(index_path: Path, ef_search: int | None = None): if not index_path.exists(): raise SystemExit(f"Missing retrieval index: {index_path}") try: return load_index(index_path, ef_search=ef_search) except ModuleNotFoundError as exc: raise SystemExit( f"FAISS python module is not available, so {index_path.name} cannot be loaded for global ANN fallback. " f"Use --formula-filter and/or --candidate-json so retrieval stays in exact subset mode, or install faiss." ) from exc def parse_args(): p = argparse.ArgumentParser(description="Retrieve + generate (Variants A/B/C)") p.add_argument("--mgf-path", required=True, help="Query MGF (e.g. MassSpecGym test)") p.add_argument("--library-dir", required=True, help="vectors_smi, vectors_chem, meta, indices") p.add_argument( "--mapper-dir", default=None, help="Directory with mappers.pt (Spec-RAG-trained M_smi/M_chem). Optional when using pretrained mappers.", ) p.add_argument("--specbridge-ckpt", required=True) p.add_argument("--dreams-ckpt", default=None) p.add_argument("--variant", choices=["A", "B", "C"], required=True) p.add_argument("--K", type=int, default=100, help="Number of candidates to retrieve per spectrum") p.add_argument( "--ef-search", type=int, default=512, help="FAISS HNSW ef_search at retrieval time; higher improves recall (default 512).", ) p.add_argument("--out-jsonl", required=True, help="Output: one JSON object per spectrum") 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("--chemberta-model", default="Derify/ChemBERTa_augmented_pubchem_13m") p.add_argument( "--formula-filter", action="store_true", help="Prefer same-formula candidates by adaptively over-fetching from the global index.", ) p.add_argument( "--formula-min-fetch", type=int, default=512, help="Minimum FAISS fetch size when --formula-filter is enabled.", ) p.add_argument( "--formula-max-fetch", type=int, default=32768, help="Maximum FAISS fetch size when --formula-filter is enabled before falling back to global hits.", ) p.add_argument( "--formula-fetch-multiplier", type=int, default=16, help="Initial fetch size multiplier for --formula-filter (fetch = max(K*multiplier, formula-min-fetch)).", ) p.add_argument( "--candidate-json", default=None, help="Optional JSON mapping query key -> candidate SMILES list; exact rerank happens inside that pool.", ) p.add_argument( "--candidate-key-field", choices=["smiles_gt", "formula"], default="formula", help="Record field used to look up candidate pools in --candidate-json. Use `formula` for non-oracle retrieval; `smiles_gt` is oracle-only benchmarking.", ) p.add_argument("--device", default="cuda") p.add_argument("--limit", type=int, default=None) p.add_argument( "--smited-mapper-ckpt", default=None, help="Optional De-SpecBridge SMI-TED mapper checkpoint (e.g. runs/smited_mapper_final/mapper_best.pt).", ) p.add_argument( "--despecbridge-path", default=None, help="Path to De-SpecBridge repo when using --smited-mapper-ckpt.", ) 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) lib = Path(args.library_dir) use_pretrained_smited = args.smited_mapper_ckpt is not None # Spec-RAG mappers.pt only needed for Variant A when not using pretrained SMI-TED mapper. M_smi = None M_chem = None d_spec = d_smi = d_chem = None if args.variant == "A" and not use_pretrained_smited: if args.mapper_dir is None: raise SystemExit("mapper-dir is required for Variant A when --smited-mapper-ckpt is not provided.") mapper_dir = Path(args.mapper_dir) try: ckpt = torch.load(mapper_dir / "mappers.pt", map_location="cpu", weights_only=False) except TypeError: ckpt = torch.load(mapper_dir / "mappers.pt", map_location="cpu") d_spec = ckpt["d_spec"] d_smi = ckpt["d_smi"] d_chem = ckpt["d_chem"] class MapperHead(torch.nn.Module): def __init__(self, d_in, d_out): super().__init__() self.proj = torch.nn.Linear(d_in, d_out) def forward(self, x): return self.proj(x) M_smi = MapperHead(d_spec, d_smi) M_chem = MapperHead(d_spec, d_chem) M_smi.load_state_dict(ckpt["M_smi"]) M_chem.load_state_dict(ckpt["M_chem"]) M_smi.to(device).eval() M_chem.to(device).eval() # E_mist / ChemBERTa (SpecBridge mapper to ChemBERTa space) # NOTE: For Variant A with a pretrained SMI-TED mapper, we do NOT need SpectrumEmbedder at all. spec_embedder = None # Optional spec -> SMI-TED mapper from De-SpecBridge (DreamsToSmiTed, uses existing mapper_best.pt) smited_mapper_model = None if use_pretrained_smited: despec_root = Path(args.despecbridge_path or "/cluster/tufts/liulab/yiwan01/De-SpecBridge").resolve() if str(despec_root) not in sys.path: sys.path.insert(0, str(despec_root)) from despecbridge.models.dreams_to_smited import ( build_dreams_adapter_for_smited, build_mapper, DreamsToSmiTed, ) from despecbridge.models.smited_decoder import load_smited mapper_ckpt_path = Path(args.smited_mapper_ckpt) ckpt = torch.load(mapper_ckpt_path, map_location="cpu") ckpt_args = ckpt.get("args", {}) if not ckpt_args: raise SystemExit(f"Mapper checkpoint {mapper_ckpt_path} missing 'args' dict.") cond_dim = int(ckpt_args.get("cond_dim", 512)) spec_bins = int(ckpt_args.get("spec_bins", 2048)) dreams_ckpt = ckpt_args.get( "dreams_ckpt", "/cluster/tufts/liulab/yiwan01/SpecBridge/data/ssl_model.ckpt" ) # Build spec encoder (DreaMS adapter) as in De-SpecBridge eval scripts spec_encoder = build_dreams_adapter_for_smited( dreams_ckpt=dreams_ckpt, cond_dim=cond_dim, spec_bins=spec_bins, ) if "spec_encoder" in ckpt: spec_encoder.load_state_dict(ckpt["spec_encoder"], strict=False) d_smited = int(ckpt_args.get("d_smited", 768)) mapper = build_mapper( cond_dim, d_smited, n_blocks=int(ckpt_args.get("mapper_blocks", 2)), hidden=int(ckpt_args.get("mapper_hidden", 512)), ) mapper_state = ckpt["mapper"] if mapper_state and list(mapper_state.keys())[0].startswith("module."): mapper_state = {k.replace("module.", ""): v for k, v in mapper_state.items()} mapper.load_state_dict(mapper_state, strict=True) smited_wrapper = load_smited( model_name=ckpt_args.get("smited_model", "ibm-research/materials.smi-ted"), device=device, use_original_weights=bool(ckpt_args.get("use_original_weights", False)), ) smited_wrapper.eval() smited_mapper_model = DreamsToSmiTed( spec_encoder=spec_encoder, mapper=mapper, smited=smited_wrapper, freeze_spec=True, freeze_decoder=True, ).to(device) smited_mapper_model.eval() # Library meta and vectors meta_df = load_meta(lib) smiles_values = meta_df["smiles"].to_numpy(copy=False) formula_values = meta_df["formula"].to_numpy(copy=False) if "formula" in meta_df.columns else None index_smi_path = lib / "index_smi.faiss" index_chem_path = lib / "index_chem.faiss" index_smi = None index_chem = None candidate_map = _load_candidate_map(args.candidate_json) if args.candidate_json else None if candidate_map and args.candidate_key_field == "formula": raw_key_count = len(candidate_map) raw_formula_key_count = sum(1 for key in candidate_map if _looks_like_formula(_normalize_formula(key))) candidate_map = _coerce_candidate_map_to_formula(candidate_map) if raw_formula_key_count != raw_key_count: print( f"Coerced candidate map from {raw_key_count} raw keys to {len(candidate_map)} formula buckets " f"for non-oracle retrieval." ) else: print(f"Loaded formula-keyed candidate map with {len(candidate_map)} formula buckets.") elif candidate_map and args.candidate_key_field == "smiles_gt": print( "Warning: --candidate-key-field smiles_gt is oracle-only; it uses ground-truth SMILES " "to choose the candidate pool." ) records = load_mgf_spectra( 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 usable spectra found in {args.mgf_path}") spectra_binned = np.stack([r["binned"] for r in records], axis=0).astype(np.float32) meta = build_meta_peaks(records, args.max_peaks) # Instantiate SpectrumEmbedder only when needed (avoid double-loading DreaMS for Variant A + pretrained SMI-TED) if args.variant in ("B", "C") or (args.variant == "A" and smited_mapper_model is None): spec_embedder = SpectrumEmbedder( specbridge_ckpt=args.specbridge_ckpt, dreams_ckpt=args.dreams_ckpt, device=args.device, normalize=False, use_lightweight=False, chemberta_model=getattr(args, "chemberta_model", "Derify/ChemBERTa_augmented_pubchem_13m"), ) else: spec_embedder = None # ChemBERTa queries: use SpecBridge chemberta mapper directly (no M_chem needed) if args.variant in ("B", "C"): if spec_embedder is None: raise SystemExit("Internal error: SpectrumEmbedder missing for ChemBERTa variants.") q_chem = spec_embedder.encode(spectra_binned, meta, batch_size=32) q_chem = l2_normalize(q_chem) else: q_chem = None # SMI-TED queries (Variant A only) q_smi = None if args.variant == "A": if smited_mapper_model is not None: # Use existing De-SpecBridge DreamsToSmiTed mapper directly on spectra + meta, # but in manageable batches to avoid GPU OOM. all_latents = [] batch_size = 32 total = spectra_binned.shape[0] with torch.no_grad(): for start in range(0, total, batch_size): end = min(total, start + batch_size) spectra_t = torch.tensor( spectra_binned[start:end], dtype=torch.float32, device=device ) meta_t: dict[str, torch.Tensor] = {} for k, v in meta.items(): if isinstance(v, torch.Tensor) and v.shape[0] == total: meta_t[k] = v[start:end].to(device) else: meta_t[k] = v z_smited = smited_mapper_model(spectra_t, meta_t) all_latents.append(z_smited.detach().cpu().numpy().astype(np.float32)) if all_latents: q_smi = np.concatenate(all_latents, axis=0) else: q_smi = np.zeros((0, 0), dtype=np.float32) else: if M_smi is None or d_spec is None or spec_embedder is None: raise SystemExit("Variant A requires either --smited-mapper-ckpt or Spec-RAG M_smi in mappers.pt (with SpectrumEmbedder).") x_spec = spec_embedder.encode_spec_only(spectra_binned, meta, batch_size=32) with torch.no_grad(): x = torch.tensor(x_spec, dtype=torch.float32, device=device) q_smi = M_smi(x).cpu().numpy() q_smi = l2_normalize(q_smi) use_direct_candidate_pool = candidate_map is not None and args.variant in ("B", "C") exact_vectors = None vector_path = lib / ("vectors_smi.npy" if args.variant == "A" else "vectors_chem.npy") if (args.formula_filter or (candidate_map and not use_direct_candidate_pool)) and vector_path.exists(): exact_vectors = np.load(vector_path, mmap_mode="r") candidate_lookup = {} if candidate_map: query_keys = [ _normalize_candidate_key(rec.get(args.candidate_key_field, "")) for rec in records ] if use_direct_candidate_pool: covered = sum(1 for key in query_keys if key in candidate_map) print( f"Using direct candidate-pool reranking from {args.candidate_json} " f"with `{args.candidate_key_field}` for {covered}/{len(query_keys)} queries." ) else: print(f"Building candidate lookup from {args.candidate_json} using `{args.candidate_key_field}`...") candidate_lookup = _build_query_candidate_index(candidate_map, query_keys, smiles_values) covered = sum(1 for key in query_keys if key in candidate_lookup) print(f"Candidate pools available for {covered}/{len(query_keys)} queries.") if exact_vectors is None: print(f"{vector_path.name} not found; candidate pool reranking is disabled.") formula_lookup = {} formula_canonical_cache = {} if args.formula_filter and formula_values is not None: target_formulas = { _normalize_formula(rec.get("formula", "")) for rec in records if _normalize_formula(rec.get("formula", "")) } if target_formulas and exact_vectors is not None: print(f"Building formula lookup for {len(target_formulas)} query formulas...") formula_lookup = _build_query_formula_index(formula_values, target_formulas) print(f"Using exact same-formula reranking via {vector_path.name} (memory-mapped).") elif target_formulas: print(f"{vector_path.name} not found; formula filter will fall back to adaptive FAISS over-fetch.") out_path = Path(args.out_jsonl) out_path.parent.mkdir(parents=True, exist_ok=True) mode_counts = {"candidate_pool_direct": 0, "candidate_pool": 0, "formula_exact": 0, "global_faiss": 0} candidate_embedding_cache = {} chem_candidate_embedder = None smi_candidate_encoder = None with open(out_path, "w") as f: for i, rec in enumerate(records): res = {"smiles_gt": rec.get("smiles_gt", ""), "candidates": [], "variant": args.variant} target_formula = rec.get("formula", "") if args.formula_filter else "" query_vec = q_smi[i] if args.variant == "A" else q_chem[i] query_batch = q_smi[i : i + 1] if args.variant == "A" else q_chem[i : i + 1] idx = None retrieval_mode = None query_key = _normalize_candidate_key(rec.get(args.candidate_key_field, "")) if candidate_map else "" if candidate_map and use_direct_candidate_pool: candidate_smiles = candidate_map.get(query_key) if candidate_smiles: direct_candidates, chem_candidate_embedder, smi_candidate_encoder = _rank_candidate_smiles_direct( query_vec=query_vec, candidate_smiles=candidate_smiles, k=args.K, variant=args.variant, device=args.device, chemberta_model=args.chemberta_model, despecbridge_path=args.despecbridge_path, candidate_embedding_cache=candidate_embedding_cache, chem_candidate_embedder=chem_candidate_embedder, smi_candidate_encoder=smi_candidate_encoder, ) if direct_candidates is not None: res["candidates"].extend(direct_candidates) retrieval_mode = "candidate_pool_direct" idx = [] if idx is None and candidate_lookup: candidate_idx = _candidate_pool_indices( query_key=query_key, target_formula=target_formula, candidate_lookup=candidate_lookup, candidate_map=candidate_map, formula_lookup=formula_lookup, smiles_values=smiles_values, formula_canonical_cache=formula_canonical_cache, ) idx = _exact_subset_search(query_vec, candidate_idx, args.K, exact_vectors) if idx is not None: retrieval_mode = "candidate_pool" if idx is None: idx = _exact_formula_subset_search(query_vec, args.K, target_formula, formula_lookup, exact_vectors) if idx is not None: retrieval_mode = "formula_exact" if idx is None: if args.variant == "A": if index_smi is None: index_smi = _load_global_index_or_die(index_smi_path, ef_search=getattr(args, "ef_search", None)) else: if index_chem is None: index_chem = _load_global_index_or_die(index_chem_path, ef_search=getattr(args, "ef_search", None)) idx = _search_with_formula_backfill( index=index_smi if args.variant == "A" else index_chem, query=query_batch, k=args.K, formulas=formula_values, target_formula=target_formula, min_fetch=args.formula_min_fetch, max_fetch=args.formula_max_fetch, fetch_multiplier=args.formula_fetch_multiplier, ) retrieval_mode = "global_faiss" mode_counts[retrieval_mode] = mode_counts.get(retrieval_mode, 0) + 1 res["retrieval_mode"] = retrieval_mode if retrieval_mode != "candidate_pool_direct": for j in idx: j = int(j) if j < 0 or j >= len(smiles_values): continue smi = str(smiles_values[j]) formula = _normalize_formula(formula_values[j]) if formula_values is not None else "" res["candidates"].append({"smiles": smi, "formula": formula}) f.write(json.dumps(res, ensure_ascii=False) + "\n") print(f"Wrote {out_path} ({len(records)} spectra)") print("Retrieval mode counts:", json.dumps(mode_counts, sort_keys=True)) if __name__ == "__main__": main()