| |
| """ |
| 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) |
|
|
| |
| 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() |
|
|
