#!/usr/bin/env python3 """ Experiment script: Adaptive Prompt Selection vs. Random Baseline. Runs both methods on openproblems_donor1.h5ad and compares predictions against ground truth perturbed cells. Usage: source stack_env/bin/activate python code/adaptive_prompt_selection/run_experiment.py \ --checkpoint data/tutorial-pred-model/bc_large_aligned.ckpt \ --data data/tutorial-pred-data/openproblems_donor1.h5ad \ --genelist data/tutorial-pred-model/basecount_1000per_15000max.pkl \ --output-dir data/adaptive_prompt_results \ --show-progress """ from __future__ import annotations import argparse import json import logging import sys from pathlib import Path from typing import Dict, List, Optional import anndata as ad import numpy as np import pandas as pd from scipy.sparse import issparse from scipy.stats import pearsonr # Ensure stack package is importable REPO_ROOT = Path(__file__).resolve().parents[2] # lfj/ STACK_SRC = REPO_ROOT / "code" / "stack" / "src" THIS_DIR = Path(__file__).resolve().parent for p in [str(STACK_SRC), str(THIS_DIR)]: if p not in sys.path: sys.path.insert(0, p) from stack.model_loading import load_model_from_checkpoint from adaptive_prompt import adaptive_prompt_selection, run_baseline LOGGER = logging.getLogger("run_experiment") def compute_metrics( pred_adata: ad.AnnData, real_adata: ad.AnnData, ) -> Dict[str, float]: """Compute evaluation metrics between predicted and real expression. Aligns genes by var index, then computes: - mean_pearson: mean per-gene Pearson correlation - mean_mse: mean squared error across all genes - mean_mae: mean absolute error across all genes """ # Get dense matrices pred_X = pred_adata.X if issparse(pred_X): pred_X = pred_X.toarray() pred_X = np.asarray(pred_X, dtype=np.float64) real_X = real_adata.X if issparse(real_X): real_X = real_X.toarray() real_X = np.asarray(real_X, dtype=np.float64) # Align genes pred_genes = pred_adata.var_names real_genes = real_adata.var_names common_genes = pred_genes.intersection(real_genes) if len(common_genes) == 0: LOGGER.warning("No common genes found between predicted and real data") return {"mean_pearson": float("nan"), "mean_mse": float("nan"), "mean_mae": float("nan")} pred_X = pred_X[:, pred_genes.isin(common_genes)] real_X = real_X[:, real_genes.isin(common_genes)] # Mean expression per gene (average across cells) pred_mean = pred_X.mean(axis=0) real_mean = real_X.mean(axis=0) # Per-gene Pearson on mean expression profiles valid_mask = (np.std(pred_mean) > 0) and (np.std(real_mean) > 0) if valid_mask: overall_pearson, _ = pearsonr(pred_mean, real_mean) else: overall_pearson = float("nan") # MSE and MAE on mean expression mse = float(np.mean((pred_mean - real_mean) ** 2)) mae = float(np.mean(np.abs(pred_mean - real_mean))) return { "mean_pearson": float(overall_pearson), "mean_mse": mse, "mean_mae": mae, "n_common_genes": len(common_genes), "n_pred_cells": pred_adata.n_obs, "n_real_cells": real_adata.n_obs, } def run_experiment( model, full_adata: ad.AnnData, genelist_path: str, output_dir: Path, query_cell_types: List[str], perturbations: Optional[List[str]] = None, cell_type_col: str = "cell_type", perturbation_col: str = "sm_name", control_col: str = "control", control_name: str = "Dimethyl Sulfoxide", gene_name_col: Optional[str] = None, batch_size: int = 16, num_steps: int = 5, mode: str = "mdm", random_seed: int = 42, show_progress: bool = True, # Bandit params n_clusters_per_type: int = 5, zoom_ratio: float = 0.25, top_ratio: float = 0.2, temperature: float = 0.06, ) -> pd.DataFrame: """Run adaptive vs baseline comparison across conditions.""" output_dir.mkdir(parents=True, exist_ok=True) # Determine perturbations to test if perturbations is None: all_perts = full_adata.obs[perturbation_col].unique() perturbations = [p for p in all_perts if p != control_name] LOGGER.info("Auto-detected %d perturbations: %s", len(perturbations), perturbations) results_rows = [] for query_ct in query_cell_types: for drug in perturbations: LOGGER.info("=" * 60) LOGGER.info("Experiment: query=%s, perturbation=%s", query_ct, drug) LOGGER.info("=" * 60) # Check if ground truth exists obs = full_adata.obs gt_mask = (obs[cell_type_col] == query_ct) & (obs[perturbation_col] == drug) if gt_mask.sum() == 0: LOGGER.warning("No ground truth cells for %s + %s, skipping", query_ct, drug) continue ground_truth = full_adata[gt_mask].copy() # Check if perturbed pool exists for this drug (non-query cell types) perturbed_pool_mask = (obs[cell_type_col] != query_ct) & (obs[perturbation_col] == drug) if perturbed_pool_mask.sum() == 0: LOGGER.warning("No perturbed pool for %s (non-%s), skipping", drug, query_ct) continue safe_name = f"{query_ct}_{drug}".replace(" ", "_") # --- Adaptive --- try: adaptive_pred, bandit_details = adaptive_prompt_selection( model=model, full_adata=full_adata, genelist_path=genelist_path, query_cell_type=query_ct, perturbation=drug, control_name=control_name, cell_type_col=cell_type_col, perturbation_col=perturbation_col, control_col=control_col, n_clusters_per_type=n_clusters_per_type, zoom_ratio=zoom_ratio, top_ratio=top_ratio, temperature=temperature, batch_size=batch_size, num_steps=num_steps, mode=mode, gene_name_col=gene_name_col, random_seed=random_seed, show_progress=show_progress, ) adaptive_metrics = compute_metrics(adaptive_pred, ground_truth) LOGGER.info("Adaptive metrics: %s", adaptive_metrics) # Save adaptive prediction adaptive_pred.write_h5ad(output_dir / f"adaptive_{safe_name}.h5ad") # Save bandit details with open(output_dir / f"bandit_details_{safe_name}.json", "w") as f: json.dump(bandit_details, f, indent=2, default=str) except Exception as e: LOGGER.error("Adaptive failed for %s + %s: %s", query_ct, drug, e, exc_info=True) adaptive_metrics = { "mean_pearson": float("nan"), "mean_mse": float("nan"), "mean_mae": float("nan"), } # --- Baseline --- try: # Baseline uses all perturbed non-query cells as context baseline_context = full_adata[perturbed_pool_mask].copy() query_mask = (obs[cell_type_col] == query_ct) & (obs[control_col] == True) query_cells = full_adata[query_mask].copy() baseline_pred = run_baseline( model=model, context_adata=baseline_context, query_adata=query_cells, genelist_path=genelist_path, batch_size=batch_size, num_steps=num_steps, mode=mode, gene_name_col=gene_name_col, random_seed=random_seed, show_progress=show_progress, ) baseline_metrics = compute_metrics(baseline_pred, ground_truth) LOGGER.info("Baseline metrics: %s", baseline_metrics) baseline_pred.write_h5ad(output_dir / f"baseline_{safe_name}.h5ad") except Exception as e: LOGGER.error("Baseline failed for %s + %s: %s", query_ct, drug, e, exc_info=True) baseline_metrics = { "mean_pearson": float("nan"), "mean_mse": float("nan"), "mean_mae": float("nan"), } # Record results row = { "query_cell_type": query_ct, "perturbation": drug, "n_ground_truth": gt_mask.sum(), } for key in ["mean_pearson", "mean_mse", "mean_mae"]: row[f"adaptive_{key}"] = adaptive_metrics.get(key, float("nan")) row[f"baseline_{key}"] = baseline_metrics.get(key, float("nan")) results_rows.append(row) results_df = pd.DataFrame(results_rows) results_df.to_csv(output_dir / "comparison_results.csv", index=False) LOGGER.info("Results saved to %s", output_dir / "comparison_results.csv") return results_df def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser( description="Adaptive Prompt Selection experiment for Stack" ) parser.add_argument("--checkpoint", required=True, help="Path to Stack checkpoint (.ckpt)") parser.add_argument("--data", required=True, help="Path to full AnnData (.h5ad)") parser.add_argument("--genelist", required=True, help="Path to gene list pickle") parser.add_argument("--output-dir", required=True, help="Output directory") parser.add_argument("--cell-type-col", default="cell_type") parser.add_argument("--perturbation-col", default="sm_name") parser.add_argument("--control-col", default="control") parser.add_argument("--control-name", default="Dimethyl Sulfoxide") parser.add_argument("--gene-name-col", default=None) parser.add_argument( "--query-cell-types", nargs="*", default=None, help="Cell types to use as query (default: all non-T cell types)", ) parser.add_argument( "--perturbations", nargs="*", default=None, help="Perturbations to test (default: all non-control)", ) parser.add_argument("--batch-size", type=int, default=16) parser.add_argument("--num-steps", type=int, default=5) parser.add_argument("--mode", default="mdm") parser.add_argument("--random-seed", type=int, default=42) parser.add_argument("--show-progress", action="store_true") # Bandit params parser.add_argument("--n-clusters-per-type", type=int, default=5) parser.add_argument("--zoom-ratio", type=float, default=0.25) parser.add_argument("--top-ratio", type=float, default=0.2) parser.add_argument("--temperature", type=float, default=0.06) return parser def main(args=None): parser = build_parser() parsed = parser.parse_args(args=args) logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s") LOGGER.info("Loading model from %s", parsed.checkpoint) model = load_model_from_checkpoint(parsed.checkpoint, model_class="ICL_FinetunedModel") LOGGER.info("Loading data from %s", parsed.data) full_adata = ad.read_h5ad(parsed.data) # Default query cell types: non-T cell types if parsed.query_cell_types is None: all_types = full_adata.obs[parsed.cell_type_col].unique().tolist() # Exclude T-cell-like types (those used as context in the tutorial) t_cell_keywords = ["t cell", "t regulatory", "nk"] query_cell_types = [ ct for ct in all_types if not any(kw in ct.lower() for kw in t_cell_keywords) ] if not query_cell_types: query_cell_types = all_types[:1] LOGGER.info("Auto-selected query cell types: %s", query_cell_types) else: query_cell_types = parsed.query_cell_types output_dir = Path(parsed.output_dir) results = run_experiment( model=model, full_adata=full_adata, genelist_path=parsed.genelist, output_dir=output_dir, query_cell_types=query_cell_types, perturbations=parsed.perturbations, cell_type_col=parsed.cell_type_col, perturbation_col=parsed.perturbation_col, control_col=parsed.control_col, control_name=parsed.control_name, gene_name_col=parsed.gene_name_col, batch_size=parsed.batch_size, num_steps=parsed.num_steps, mode=parsed.mode, random_seed=parsed.random_seed, show_progress=parsed.show_progress, n_clusters_per_type=parsed.n_clusters_per_type, zoom_ratio=parsed.zoom_ratio, top_ratio=parsed.top_ratio, temperature=parsed.temperature, ) print("\n" + "=" * 70) print("RESULTS SUMMARY") print("=" * 70) print(results.to_string(index=False)) # Summary statistics if len(results) > 0: print("\n--- Aggregated ---") for metric in ["mean_pearson", "mean_mse", "mean_mae"]: a_col = f"adaptive_{metric}" b_col = f"baseline_{metric}" if a_col in results.columns and b_col in results.columns: a_mean = results[a_col].mean() b_mean = results[b_col].mean() print(f" {metric}: adaptive={a_mean:.4f} baseline={b_mean:.4f} diff={a_mean - b_mean:+.4f}") if __name__ == "__main__": main()