#!/usr/bin/env python """ Evaluate retrieval baselines against library indices. Supported modes: 1) Oracle molecule-query retrieval (ChemBERTa / SMI-TED / FLARE-mol). 2) FLARE spectrum-query retrieval (query from FLARE spec encoder -> index_flare.faiss). """ 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 from tqdm import tqdm from spec_rag.embeddings import SMILESEmbedder, l2_normalize from spec_rag.faiss_index import load_index, index_search from spec_rag.flare_encoder import FLAREMolEmbedder, FLARESpecEmbedder from spec_rag.smited_encoder import load_smited_encoder def load_meta(library_dir: Path): if (library_dir / "meta.parquet").exists(): import pandas as pd return pd.read_parquet(library_dir / "meta.parquet") if (library_dir / "meta.jsonl").exists(): rows = [] with open(library_dir / "meta.jsonl") 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}") @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 recall_at_k(indices: list, meta_df, gt_smiles: str, k: int) -> bool: if not gt_smiles or not indices or meta_df is None: return False gt_canon = canonicalize_smiles(gt_smiles) for i in indices[:k]: if i < len(meta_df) and canonicalize_smiles(meta_df.iloc[i]["smiles"]) == gt_canon: return True return False def tanimoto_at_1(top_smiles: str, gt_smiles: str) -> float | None: try: from rdkit import Chem from rdkit.Chem import DataStructs from rdkit.Chem.AllChem import GetMorganFingerprintAsBitVect except ImportError: return None if not top_smiles or not gt_smiles: return None mol_gt = Chem.MolFromSmiles(gt_smiles) mol_pred = Chem.MolFromSmiles(top_smiles) if mol_gt is None or mol_pred is None: return None fp_gt = GetMorganFingerprintAsBitVect(mol_gt, 2, nBits=2048) fp_pred = GetMorganFingerprintAsBitVect(mol_pred, 2, nBits=2048) return DataStructs.TanimotoSimilarity(fp_gt, fp_pred) def parse_args(): p = argparse.ArgumentParser(description="Evaluate retrieval baselines against library indices") p.add_argument("--pred-jsonl", required=True, help="JSONL from retrieve_generate (has smiles_gt per line)") p.add_argument("--library-dir", required=True, help="Library with index_chem.faiss, index_smi.faiss, meta") p.add_argument("--despecbridge-path", default=None, help="De-SpecBridge path for SMI-TED encoder") p.add_argument("--chemberta-model", default="Derify/ChemBERTa_augmented_pubchem_13m") p.add_argument("--flare-repo", default=str(ROOT / "FLARE")) p.add_argument("--flare-hparams", default=str(ROOT / "FLARE" / "experiments" / "20250913_optimized_filip-model" / "lightning_logs" / "version_0" / "hparams.yaml")) p.add_argument("--flare-checkpoint", default=str(ROOT / "FLARE" / "pretrained_models" / "flare.ckpt")) p.add_argument("--flare-batch-size", type=int, default=256) p.add_argument("--with-flare-oracle", action="store_true", help="Run oracle retrieval using FLARE mol encoder + index_flare") p.add_argument("--spec-tsv", default=None, help="TSV with spectra rows (for FLARE spec encoder eval)") p.add_argument("--subformula-dir", default=None, help="Subformula directory for FLARE spec encoder eval") p.add_argument("--spec-fold", default="test", help="Fold to evaluate in --spec-tsv (default: test)") p.add_argument("--with-flare-spec", action="store_true", help="Run FLARE spectrum-encoder retrieval + index_flare") p.add_argument("--K", type=int, default=100) p.add_argument("--batch-size", type=int, default=64) p.add_argument("--report", default=None, help="Write metrics JSON here") p.add_argument("--device", default="cuda") return p.parse_args() def main(): args = parse_args() library_dir = Path(args.library_dir) meta_df = load_meta(library_dir) rows = [] with open(args.pred_jsonl) as f: for line in f: if line.strip(): rows.append(json.loads(line)) smiles_gt_list = [r.get("smiles_gt", "") for r in rows] n = len(smiles_gt_list) if n == 0: raise SystemExit("No rows in pred-jsonl") index_chem = load_index(library_dir / "index_chem.faiss") if (library_dir / "index_chem.faiss").exists() else None index_smi = load_index(library_dir / "index_smi.faiss") if (library_dir / "index_smi.faiss").exists() else None index_flare = load_index(library_dir / "index_flare.faiss") if (library_dir / "index_flare.faiss").exists() else None device = args.device if device == "cuda": try: import torch if not torch.cuda.is_available(): device = "cpu" except Exception: device = "cpu" q_chem = None if index_chem is not None: print("Encoding test SMILES with ChemBERTa...") embedder_chem = SMILESEmbedder( model_name=args.chemberta_model, device=device, batch_size=args.batch_size, normalize=False, ) q_chem = embedder_chem.encode(smiles_gt_list) q_chem = l2_normalize(q_chem).astype(np.float32) q_smi = None if index_smi is not None: encode_smi = load_smited_encoder(despecbridge_path=args.despecbridge_path, device=device) if encode_smi is None: print("SMI-TED not available; skipping oracle_smi metrics.") else: print("Encoding test SMILES with SMI-TED...") q_smi = encode_smi(smiles_gt_list, batch_size=args.batch_size) q_smi = l2_normalize(q_smi).astype(np.float32) K = args.K results_chem = {"r1": 0, "r10": 0, "r50": 0, "tan": []} results_smi = {"r1": 0, "r10": 0, "r50": 0, "tan": []} if q_chem is not None and index_chem is not None: scores_chem, indices_chem = index_search(index_chem, q_chem, K) for i in range(n): idx_list = indices_chem[i].tolist() gt = smiles_gt_list[i] if recall_at_k(idx_list, meta_df, gt, 1): results_chem["r1"] += 1 if recall_at_k(idx_list, meta_df, gt, 10): results_chem["r10"] += 1 if recall_at_k(idx_list, meta_df, gt, 50): results_chem["r50"] += 1 if idx_list and idx_list[0] < len(meta_df): top_smi = meta_df.iloc[idx_list[0]]["smiles"] t = tanimoto_at_1(top_smi, gt) if t is not None: results_chem["tan"].append(t) # SMI-TED oracle if q_smi is not None and index_smi is not None: scores_smi, indices_smi = index_search(index_smi, q_smi, K) for i in range(n): idx_list = indices_smi[i].tolist() gt = smiles_gt_list[i] if recall_at_k(idx_list, meta_df, gt, 1): results_smi["r1"] += 1 if recall_at_k(idx_list, meta_df, gt, 10): results_smi["r10"] += 1 if recall_at_k(idx_list, meta_df, gt, 50): results_smi["r50"] += 1 if idx_list and idx_list[0] < len(meta_df): top_smi = meta_df.iloc[idx_list[0]]["smiles"] t = tanimoto_at_1(top_smi, gt) if t is not None: results_smi["tan"].append(t) metrics = { "n": n, "K": K, "oracle_chem": None, "oracle_smi": None, "oracle_flare": None, "flare_spec_query": None, } if q_chem is not None and index_chem is not None: metrics["oracle_chem"] = { "Recall@1": results_chem["r1"] / n, "Recall@10": results_chem["r10"] / n, "Recall@50": results_chem["r50"] / n, "Tanimoto@1_mean": sum(results_chem["tan"]) / len(results_chem["tan"]) if results_chem["tan"] else None, } if q_smi is not None: metrics["oracle_smi"] = { "Recall@1": results_smi["r1"] / n, "Recall@10": results_smi["r10"] / n, "Recall@50": results_smi["r50"] / n, "Tanimoto@1_mean": sum(results_smi["tan"]) / len(results_smi["tan"]) if results_smi["tan"] else None, } if args.with_flare_oracle: if index_flare is None: print("index_flare.faiss not found; skipping oracle_flare.") else: print("Encoding test SMILES with FLARE mol encoder...") flare_mol = FLAREMolEmbedder( flare_repo=args.flare_repo, hparams_pth=args.flare_hparams, checkpoint_pth=args.flare_checkpoint, device=device, batch_size=args.flare_batch_size, normalize=True, ) q_flare = flare_mol.encode(smiles_gt_list).astype(np.float32) scores_flare, indices_flare = index_search(index_flare, q_flare, K) results_flare = {"r1": 0, "r10": 0, "r50": 0, "tan": []} for i in range(n): idx_list = indices_flare[i].tolist() gt = smiles_gt_list[i] if recall_at_k(idx_list, meta_df, gt, 1): results_flare["r1"] += 1 if recall_at_k(idx_list, meta_df, gt, 10): results_flare["r10"] += 1 if recall_at_k(idx_list, meta_df, gt, 50): results_flare["r50"] += 1 if idx_list and idx_list[0] < len(meta_df): top_smi = meta_df.iloc[idx_list[0]]["smiles"] t = tanimoto_at_1(top_smi, gt) if t is not None: results_flare["tan"].append(t) metrics["oracle_flare"] = { "Recall@1": results_flare["r1"] / n, "Recall@10": results_flare["r10"] / n, "Recall@50": results_flare["r50"] / n, "Tanimoto@1_mean": sum(results_flare["tan"]) / len(results_flare["tan"]) if results_flare["tan"] else None, } if args.with_flare_spec: if index_flare is None: print("index_flare.faiss not found; skipping flare_spec_query.") elif not args.spec_tsv or not args.subformula_dir: print("Need --spec-tsv and --subformula-dir for --with-flare-spec; skipping.") else: print("Encoding spectra with FLARE spec encoder...") flare_spec = FLARESpecEmbedder( flare_repo=args.flare_repo, hparams_pth=args.flare_hparams, checkpoint_pth=args.flare_checkpoint, dataset_pth=args.spec_tsv, subformula_dir_pth=args.subformula_dir, fold=args.spec_fold, device=device, batch_size=args.batch_size, normalize=True, ) q_spec, gt_smiles, ids = flare_spec.encode() if q_spec.shape[0] == 0: print("No spectra encoded for flare_spec_query.") else: scores_spec, indices_spec = index_search(index_flare, q_spec.astype(np.float32), K) m = q_spec.shape[0] results_spec = {"n": m, "r1": 0, "r10": 0, "r50": 0, "tan": []} for i in range(m): idx_list = indices_spec[i].tolist() gt = gt_smiles[i] if recall_at_k(idx_list, meta_df, gt, 1): results_spec["r1"] += 1 if recall_at_k(idx_list, meta_df, gt, 10): results_spec["r10"] += 1 if recall_at_k(idx_list, meta_df, gt, 50): results_spec["r50"] += 1 if idx_list and idx_list[0] < len(meta_df): top_smi = meta_df.iloc[idx_list[0]]["smiles"] t = tanimoto_at_1(top_smi, gt) if t is not None: results_spec["tan"].append(t) metrics["flare_spec_query"] = { "n": results_spec["n"], "fold": args.spec_fold, "Recall@1": results_spec["r1"] / results_spec["n"], "Recall@10": results_spec["r10"] / results_spec["n"], "Recall@50": results_spec["r50"] / results_spec["n"], "Tanimoto@1_mean": sum(results_spec["tan"]) / len(results_spec["tan"]) if results_spec["tan"] else None, } print("Oracle retrieval metrics:", json.dumps(metrics, indent=2)) if args.report: with open(args.report, "w") as f: json.dump(metrics, f, indent=2) print(f"Wrote {args.report}") if __name__ == "__main__": main()