transfer/code/adaptive_prompt_selection/run_bcell_experiment.py

#!/usr/bin/env python3
"""
B-cell experiment: Adaptive Prompt Selection vs Random Baseline.

Uses B cells (lymphocyte of b lineage) as query, other cells as prompt.
Compares adaptive prompt selection vs random baseline.
Evaluates with cell-eval metrics suite.

Usage:
    python code/adaptive_prompt_selection/run_bcell_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/bcell_experiment_results \
        --show-progress
"""

from __future__ import annotations

import argparse
import json
import logging
import sys
from pathlib import Path

import anndata as ad
import numpy as np
import pandas as pd
from scipy.sparse import issparse

# ---------------------------------------------------------------------------
# Path setup
# ---------------------------------------------------------------------------
REPO_ROOT = Path(__file__).resolve().parents[2]  # lfj/
for _p in [
    str(REPO_ROOT / "code" / "stack" / "src"),
    str(Path(__file__).resolve().parent),
    str(REPO_ROOT / "code" / "cell-eval" / "src"),
]:
    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("bcell_experiment")

# ---------------------------------------------------------------------------
# Constants for the openproblems_donor1 dataset
# ---------------------------------------------------------------------------
QUERY_CELL_TYPE_BROAD = "lymphocyte of b lineage"  # broad_cell_class value
QUERY_CELL_TYPE_FINE = "B cells"                    # cell_type value
CONTROL_NAME = "Dimethyl Sulfoxide"
CELL_TYPE_COL = "broad_cell_class"     # broad classes for arm grouping
PERTURBATION_COL = "sm_name"
CONTROL_COL = "control"


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

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 run_celleval(adata_pred, adata_real, outdir, label, num_threads=4):
    """Run cell-eval MetricsEvaluator and return (results, agg_results)."""
    from cell_eval import MetricsEvaluator

    eval_dir = str(Path(outdir) / f"celleval_{label}")
    evaluator = MetricsEvaluator(
        adata_pred=adata_pred,
        adata_real=adata_real,
        control_pert=CONTROL_NAME,
        pert_col=PERTURBATION_COL,
        outdir=eval_dir,
        allow_discrete=True,
        num_threads=num_threads,
    )
    results, agg_results = evaluator.compute(
        profile="full",
        write_csv=True,
        break_on_error=False,
    )
    return results, agg_results


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def build_parser():
    p = argparse.ArgumentParser(
        description="B-cell adaptive prompt experiment with cell-eval evaluation"
    )
    p.add_argument("--checkpoint", required=True,
                   help="Path to Stack-Large-Aligned checkpoint (.ckpt)")
    p.add_argument("--data", required=True,
                   help="Path to openproblems_donor1.h5ad")
    p.add_argument("--genelist", required=True,
                   help="Path to gene list pickle")
    p.add_argument("--output-dir", required=True,
                   help="Output directory")
    p.add_argument("--drugs", nargs="*", default=None,
                   help="Specific drugs to test (default: all non-DMSO)")
    # Stack generation params
    p.add_argument("--batch-size", type=int, default=16)
    p.add_argument("--num-steps", type=int, default=5)
    p.add_argument("--mode", default="mdm")
    p.add_argument("--random-seed", type=int, default=42)
    p.add_argument("--show-progress", action="store_true")
    # Bandit params
    p.add_argument("--n-clusters-per-type", type=int, default=5)
    p.add_argument("--zoom-ratio", type=float, default=0.25)
    p.add_argument("--top-ratio", type=float, default=0.2)
    p.add_argument("--temperature", type=float, default=0.06)
    # cell-eval params
    p.add_argument("--num-threads", type=int, default=4,
                   help="Threads for cell-eval DE computation")
    p.add_argument("--celleval-profile", default="full",
                   choices=["full", "minimal", "vcc", "de", "anndata"])
    return p


def main():
    parsed = build_parser().parse_args()
    output_dir = Path(parsed.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s %(name)s %(levelname)s %(message)s",
        handlers=[
            logging.StreamHandler(),
            logging.FileHandler(output_dir / "experiment.log"),
        ],
    )

    # ---- Load model ----
    LOGGER.info("Loading model from %s", parsed.checkpoint)
    model = load_model_from_checkpoint(
        parsed.checkpoint, model_class="ICL_FinetunedModel"
    )
    LOGGER.info("Model n_cells=%d", model.n_cells)

    # ---- Load data ----
    LOGGER.info("Loading data from %s", parsed.data)
    full_adata = ad.read_h5ad(parsed.data)
    obs = full_adata.obs
    LOGGER.info("Data shape: %s", full_adata.shape)
    LOGGER.info("Cell types (broad): %s",
                obs[CELL_TYPE_COL].value_counts().to_dict())
    LOGGER.info("Cell types (fine):  %s",
                obs["cell_type"].value_counts().to_dict())

    # ---- Identify drugs ----
    all_drugs = sorted(
        d for d in obs[PERTURBATION_COL].unique() if d != CONTROL_NAME
    )
    drugs = (
        [d for d in parsed.drugs if d in all_drugs]
        if parsed.drugs else all_drugs
    )
    LOGGER.info("Testing %d drugs: %s", len(drugs), drugs)

    # ---- B-cell subsets ----
    b_mask = obs["cell_type"] == QUERY_CELL_TYPE_FINE
    control_B_mask = b_mask & (obs[CONTROL_COL] == True)
    control_B = full_adata[control_B_mask].copy()
    LOGGER.info("Control B cells: %d", control_B.n_obs)

    # ---- Per-drug prediction loop ----
    adaptive_preds = {}   # drug -> AnnData
    baseline_preds = {}   # drug -> AnnData
    ground_truths = {}    # drug -> AnnData
    bandit_details = {}

    for drug in drugs:
        LOGGER.info("=" * 60)
        LOGGER.info("Drug: %s", drug)
        LOGGER.info("=" * 60)

        # Ground truth: perturbed B cells
        gt_mask = b_mask & (obs[PERTURBATION_COL] == drug)
        if gt_mask.sum() == 0:
            LOGGER.warning("No ground truth B cells for %s, skipping", drug)
            continue
        LOGGER.info("Ground truth B cells: %d", gt_mask.sum())
        ground_truths[drug] = full_adata[gt_mask].copy()

        # ---- Adaptive ----
        try:
            LOGGER.info("[Adaptive] Starting...")
            pred_a, details = adaptive_prompt_selection(
                model=model,
                full_adata=full_adata,
                genelist_path=parsed.genelist,
                query_cell_type=QUERY_CELL_TYPE_BROAD,
                perturbation=drug,
                control_name=CONTROL_NAME,
                cell_type_col=CELL_TYPE_COL,
                perturbation_col=PERTURBATION_COL,
                control_col=CONTROL_COL,
                n_clusters_per_type=parsed.n_clusters_per_type,
                zoom_ratio=parsed.zoom_ratio,
                top_ratio=parsed.top_ratio,
                temperature=parsed.temperature,
                batch_size=parsed.batch_size,
                num_steps=parsed.num_steps,
                mode=parsed.mode,
                random_seed=parsed.random_seed,
                show_progress=parsed.show_progress,
            )
            pred_a.obs[PERTURBATION_COL] = drug
            pred_a.obs[CONTROL_COL] = False
            adaptive_preds[drug] = pred_a
            bandit_details[drug] = details
            LOGGER.info("[Adaptive] Done: %d cells", pred_a.n_obs)
        except Exception as e:
            LOGGER.error("[Adaptive] Failed: %s", e, exc_info=True)

        # ---- Baseline (random prompt) ----
        try:
            LOGGER.info("[Baseline] Starting...")
            ctx_mask = (~b_mask) & (obs[PERTURBATION_COL] == drug)
            context = full_adata[ctx_mask].copy()
            LOGGER.info("[Baseline] Context cells (non-B, %s): %d",
                        drug, context.n_obs)

            pred_b = run_baseline(
                model=model,
                context_adata=context,
                query_adata=control_B.copy(),
                genelist_path=parsed.genelist,
                batch_size=parsed.batch_size,
                num_steps=parsed.num_steps,
                mode=parsed.mode,
                random_seed=parsed.random_seed,
                show_progress=parsed.show_progress,
            )
            pred_b.obs[PERTURBATION_COL] = drug
            pred_b.obs[CONTROL_COL] = False
            baseline_preds[drug] = pred_b
            LOGGER.info("[Baseline] Done: %d cells", pred_b.n_obs)
        except Exception as e:
            LOGGER.error("[Baseline] Failed: %s", e, exc_info=True)

    # ---- Keep only drugs where both methods succeeded ----
    ok_drugs = sorted(
        set(adaptive_preds) & set(baseline_preds) & set(ground_truths)
    )
    LOGGER.info("Drugs with both methods OK: %d / %d: %s",
                len(ok_drugs), len(drugs), ok_drugs)
    if not ok_drugs:
        LOGGER.error("No drugs succeeded for both methods, exiting")
        return

    # ---- Save bandit details ----
    for drug, det in bandit_details.items():
        safe = drug.replace(" ", "_")
        with open(output_dir / f"bandit_{safe}.json", "w") as f:
            json.dump(det, f, indent=2, default=str)

    # ---- Assemble combined AnnData for cell-eval ----
    LOGGER.info("Assembling combined AnnData for cell-eval...")

    real_combined = ad.concat(
        [control_B] + [ground_truths[d] for d in ok_drugs], join="inner"
    )
    adaptive_combined = ad.concat(
        [control_B] + [adaptive_preds[d] for d in ok_drugs], join="inner"
    )
    baseline_combined = ad.concat(
        [control_B] + [baseline_preds[d] for d in ok_drugs], join="inner"
    )

    LOGGER.info("Real:     %d cells x %d genes, perts=%s",
                real_combined.n_obs, real_combined.n_vars,
                real_combined.obs[PERTURBATION_COL].value_counts().to_dict())
    LOGGER.info("Adaptive: %d cells x %d genes",
                adaptive_combined.n_obs, adaptive_combined.n_vars)
    LOGGER.info("Baseline: %d cells x %d genes",
                baseline_combined.n_obs, baseline_combined.n_vars)

    # ---- Align genes between pred and real ----
    adaptive_al, real_for_a = align_genes(adaptive_combined, real_combined)
    baseline_al, real_for_b = align_genes(baseline_combined, real_combined)

    # ---- Save intermediate h5ad ----
    adaptive_al.write_h5ad(output_dir / "adaptive_combined.h5ad")
    baseline_al.write_h5ad(output_dir / "baseline_combined.h5ad")
    real_for_a.write_h5ad(output_dir / "real_combined.h5ad")

    # ---- Run cell-eval ----
    agg_a, agg_b = None, None

    LOGGER.info("Running cell-eval for ADAPTIVE...")
    try:
        _, agg_a = run_celleval(
            adaptive_al, real_for_a, output_dir, "adaptive",
            num_threads=parsed.num_threads,
        )
    except Exception as e:
        LOGGER.error("cell-eval (adaptive) failed: %s", e, exc_info=True)

    LOGGER.info("Running cell-eval for BASELINE...")
    try:
        _, agg_b = run_celleval(
            baseline_al, real_for_b, output_dir, "baseline",
            num_threads=parsed.num_threads,
        )
    except Exception as e:
        LOGGER.error("cell-eval (baseline) failed: %s", e, exc_info=True)

    # ---- Print & save comparison ----
    print("\n" + "=" * 70)
    print("CELL-EVAL RESULTS")
    print("=" * 70)

    if agg_a is not None:
        print("\n--- Adaptive (aggregated) ---")
        print(agg_a)
        agg_a.write_csv(str(output_dir / "agg_adaptive.csv"))

    if agg_b is not None:
        print("\n--- Baseline (aggregated) ---")
        print(agg_b)
        agg_b.write_csv(str(output_dir / "agg_baseline.csv"))

    if agg_a is not None and agg_b is not None:
        # Build side-by-side comparison on mean column
        import polars as pl
        try:
            mean_a = agg_a.filter(pl.col("statistic") == "mean").drop("statistic")
            mean_b = agg_b.filter(pl.col("statistic") == "mean").drop("statistic")
            # Melt to long format for comparison
            a_long = mean_a.unpivot(variable_name="metric", value_name="adaptive")
            b_long = mean_b.unpivot(variable_name="metric", value_name="baseline")
            comparison = a_long.join(b_long, on="metric")
            comparison = comparison.with_columns(
                (pl.col("adaptive") - pl.col("baseline")).alias("diff")
            )
            print("\n--- Comparison (mean across perturbations) ---")
            print(comparison)
            comparison.write_csv(str(output_dir / "comparison_mean.csv"))
        except Exception as e:
            LOGGER.warning("Could not build comparison table: %s", e)

    LOGGER.info("Experiment complete. Results saved to %s", output_dir)


if __name__ == "__main__":
    main()