#!/usr/bin/env python3 """Evaluate Prompt Selection vs Random Baseline using cell-eval. Compares predicted B-cell perturbation results from two methods: 1. Prompt Selection (embedding-based prompt ordering) 2. Random Baseline (default Stack random prompt ordering) Usage: python code/prompt_selection/evaluate_results.py --perturbation Dabrafenib """ from __future__ import annotations import gc import logging import sys from pathlib import Path _THIS_DIR = Path(__file__).resolve().parent _REPO_ROOT = _THIS_DIR.parents[1] # lfj/transfer/ for _p in [ str(_REPO_ROOT / "code" / "cell-eval" / "src"), str(_THIS_DIR.parent), ]: if _p not in sys.path: sys.path.insert(0, _p) import argparse import anndata as ad import numpy as np import polars as pl from scipy.sparse import issparse from cell_eval import MetricsEvaluator from prompt_selection import config as cfg logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(name)s] %(levelname)s: %(message)s", ) LOGGER = logging.getLogger("evaluate_results") # --------------------------------------------------------------------------- # Constants # --------------------------------------------------------------------------- PERTURBATION_COL = "sm_name" CONTROL_NAME = "Dimethyl Sulfoxide" CELL_TYPE_FILTER = {"broad_cell_class": "lymphocyte of b lineage"} # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- def build_real_combined(pert_name: str, output_dir: Path) -> ad.AnnData: """Extract ground truth B cells (control + perturbation) from source data.""" LOGGER.info("Loading source data: %s", cfg.SOURCE_ADATA) source = ad.read_h5ad(str(cfg.SOURCE_ADATA)) LOGGER.info("Source shape: %s", source.shape) broad = source.obs["broad_cell_class"] sm = source.obs[PERTURBATION_COL] b_lineage = CELL_TYPE_FILTER["broad_cell_class"] ctrl_mask = (broad == b_lineage) & (sm == CONTROL_NAME) pert_mask = (broad == b_lineage) & (sm == pert_name) control_B = source[ctrl_mask].copy() real_pert_B = source[pert_mask].copy() del source gc.collect() LOGGER.info("Control B cells (DMSO): %d", control_B.n_obs) LOGGER.info("Real perturbed B cells (%s): %d", pert_name, real_pert_B.n_obs) if real_pert_B.n_obs == 0: raise ValueError(f"No ground truth B cells found for {pert_name}") real_combined = ad.concat([control_B, real_pert_B], join="inner") LOGGER.info( "real_combined: %d cells, sm_name: %s", real_combined.n_obs, real_combined.obs[PERTURBATION_COL].value_counts().to_dict(), ) real_path = output_dir / "real_combined.h5ad" real_combined.write_h5ad(real_path) LOGGER.info("Saved real_combined to %s", real_path) return real_combined def build_pred_combined(pred_path: Path, label: str) -> ad.AnnData: """Combine control B cells with predictions into a single AnnData.""" ctrl = ad.read_h5ad(str(cfg.RESULTS_DIR / cfg.QUERY_CTRL_H5AD)) pred = ad.read_h5ad(str(pred_path)) LOGGER.info("[%s] Control: %d cells, Pred: %d cells", label, ctrl.n_obs, pred.n_obs) combined = ad.concat([ctrl, pred], join="inner") combined.obs_names_make_unique() LOGGER.info( "[%s] combined: %d cells, sm_name: %s", label, combined.n_obs, combined.obs[PERTURBATION_COL].value_counts().to_dict(), ) return combined def align_genes(adata_pred: ad.AnnData, adata_real: ad.AnnData): """Ensure pred and real have identical var_names in the same order.""" common = adata_pred.var_names.intersection(adata_real.var_names) if len(common) == 0: raise ValueError("No common genes between predicted and real data") LOGGER.info( "Gene alignment: pred=%d, real=%d, common=%d", adata_pred.n_vars, adata_real.n_vars, len(common), ) return adata_pred[:, common].copy(), adata_real[:, common].copy() def densify_X(adata: ad.AnnData) -> None: """Convert sparse X to dense in-place to avoid repeated sparse→dense.""" if issparse(adata.X): adata.X = np.asarray(adata.X.todense(), dtype=np.float32) def evaluate_one(pred_path, real_combined, label, output_dir): """Build pred_combined, align genes, run cell-eval, free memory.""" LOGGER.info("=" * 60) LOGGER.info("Evaluating: %s", label) LOGGER.info("=" * 60) pred_combined = build_pred_combined(pred_path, label) pred_al, real_al = align_genes(pred_combined, real_combined) del pred_combined gc.collect() LOGGER.info("[%s] Densifying expression matrices...", label) densify_X(pred_al) densify_X(real_al) eval_dir = str(output_dir / f"celleval_{label}") evaluator = MetricsEvaluator( adata_pred=pred_al, adata_real=real_al, control_pert=CONTROL_NAME, pert_col=PERTURBATION_COL, outdir=eval_dir, allow_discrete=True, num_threads=4, ) results, agg_results = evaluator.compute( profile="full", write_csv=True, break_on_error=False, ) del pred_al, real_al, evaluator gc.collect() return results, agg_results # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): parser = argparse.ArgumentParser(description="Evaluate Prompt Selection vs Random Baseline") parser.add_argument( "--perturbation", type=str, required=True, help="Perturbation name (e.g., Dabrafenib).", ) parser.add_argument( "--output-dir", type=Path, default=None, help="Output directory for evaluation results (default: eval_results/).", ) args = parser.parse_args() pert_name = args.perturbation pcfg = cfg.get_pert_config(pert_name) output_dir = args.output_dir if args.output_dir else pcfg.eval_dir output_dir.mkdir(parents=True, exist_ok=True) pred_ps_path = pcfg.results_dir / pcfg.final_result_h5ad pred_bl_path = pcfg.baseline_dir / pcfg.baseline_result_h5ad # ---- Step 1: Build ground truth ---- LOGGER.info("Step 1: Preparing ground truth data for %s", pert_name) real_combined = build_real_combined(pert_name, output_dir) # ---- Step 2+3: Evaluate each method ---- agg_ps = None agg_bl = None if pred_ps_path.exists(): try: _, agg_ps = evaluate_one(pred_ps_path, real_combined, "prompt_selection", output_dir) except Exception as e: LOGGER.error("Evaluation (prompt_selection) failed: %s", e, exc_info=True) else: LOGGER.warning("Prompt selection result not found: %s", pred_ps_path) if pred_bl_path.exists(): try: _, agg_bl = evaluate_one(pred_bl_path, real_combined, "baseline", output_dir) except Exception as e: LOGGER.error("Evaluation (baseline) failed: %s", e, exc_info=True) else: LOGGER.warning("Baseline result not found: %s", pred_bl_path) # ---- Step 4: Compare results ---- LOGGER.info("=" * 60) LOGGER.info("Comparing results for %s", pert_name) LOGGER.info("=" * 60) if agg_ps is not None: print(f"\n--- Prompt Selection ({pert_name}, aggregated) ---") print(agg_ps) if agg_bl is not None: print(f"\n--- Random Baseline ({pert_name}, aggregated) ---") print(agg_bl) if agg_ps is not None and agg_bl is not None: try: mean_ps = agg_ps.filter(pl.col("statistic") == "mean").drop("statistic") mean_bl = agg_bl.filter(pl.col("statistic") == "mean").drop("statistic") ps_long = mean_ps.unpivot(variable_name="metric", value_name="prompt_selection") bl_long = mean_bl.unpivot(variable_name="metric", value_name="random_baseline") comparison = ps_long.join(bl_long, on="metric") comparison = comparison.with_columns( (pl.col("prompt_selection") - pl.col("random_baseline")).alias("diff") ) comparison_path = output_dir / "comparison_mean.csv" comparison.write_csv(str(comparison_path)) print("\n" + "=" * 70) print(f"COMPARISON ({pert_name}): Prompt Selection vs Random Baseline (mean)") print("=" * 70) print(comparison) print(f"\nSaved to: {comparison_path}") except Exception as e: LOGGER.warning("Could not build comparison table: %s", e) LOGGER.info("Evaluation complete for %s. Results in %s", pert_name, output_dir) if __name__ == "__main__": main()