transfer/code/adaptive_prompt_selection/adaptive_prompt.py

"""
Adaptive Prompt Selection pipeline for Stack.

Orchestrates the full pipeline:
  Step 0: Data splitting
  Step 1: Embedding extraction
  Step 2: Arm construction (cell type x sub-cluster)
  Step 3: CellBandit selection of unperturbed prompt cells
  Step 4: Bridge prediction (unperturbed -> predicted perturbed)
  Step 5: TopK retrieval of real perturbed cells
  Step 6: Final generation with selected prompts
"""

from __future__ import annotations

import logging
from typing import Dict, List, Optional, Tuple

import anndata as ad
import numpy as np
from scipy.sparse import issparse
from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import cosine_similarity

try:
    from .cell_bandit import CellBandit
except ImportError:
    from cell_bandit import CellBandit

LOGGER = logging.getLogger("adaptive_prompt_selection")


# ---------------------------------------------------------------------------
# Similarity function factory
# ---------------------------------------------------------------------------

def create_cell_similarity_fn(precomputed_embeddings: np.ndarray):
    """Create a closure that computes cosine similarity to query embedding.

    Pre-normalizes all embeddings once. Each call is just index lookup + dot product.

    Args:
        precomputed_embeddings: (n_cells, embedding_dim) array.

    Returns:
        fn(query_embedding, cell_indices) -> List[float]
    """
    norms = np.linalg.norm(precomputed_embeddings, axis=1, keepdims=True)
    norms = np.maximum(norms, 1e-12)
    normed = precomputed_embeddings / norms

    def similarity_fn(query_embedding: np.ndarray, cell_indices: List[int]) -> List[float]:
        q = query_embedding.ravel()
        q_norm = np.linalg.norm(q)
        if q_norm < 1e-12:
            return [0.0] * len(cell_indices)
        q_normed = q / q_norm
        subset = normed[cell_indices]  # (n, dim)
        sims = subset @ q_normed  # (n,)
        # Clamp to [0, 1] for bandit
        sims = np.clip(sims, 0.0, 1.0)
        return sims.tolist()

    return similarity_fn


# ---------------------------------------------------------------------------
# Arm construction
# ---------------------------------------------------------------------------

def setup_cell_arms(
    pool_adata: ad.AnnData,
    pool_embeddings: np.ndarray,
    cell_type_col: str = "cell_type",
    n_clusters_per_type: int = 5,
    random_state: int = 42,
) -> Tuple[List[Dict], np.ndarray]:
    """Cluster unperturbed pool cells by cell type then k-means.

    Each (cell_type, cluster_id) = one arm.

    Args:
        pool_adata: AnnData of unperturbed pool cells.
        pool_embeddings: (n_cells, dim) embeddings aligned with pool_adata.
        cell_type_col: Column in pool_adata.obs for cell type.
        n_clusters_per_type: Max sub-clusters per cell type.
        random_state: Random seed for k-means.

    Returns:
        (arms, cluster_labels) where cluster_labels[i] = arm_id for cell i.
    """
    cell_types = pool_adata.obs[cell_type_col].values
    unique_types = sorted(set(cell_types))

    arms: List[Dict] = []
    cluster_labels = np.full(len(pool_adata), -1, dtype=int)
    arm_id = 0

    for ct in unique_types:
        ct_mask = cell_types == ct
        ct_indices = np.where(ct_mask)[0]
        n_cells_ct = len(ct_indices)

        if n_cells_ct == 0:
            continue

        # Adaptive cluster count to avoid degenerate clusters
        n_clust = min(n_clusters_per_type, max(1, n_cells_ct // 10))

        ct_embeddings = pool_embeddings[ct_indices]

        if n_clust <= 1:
            # Single cluster for this cell type
            arms.append({
                "arm_id": arm_id,
                "cell_type": str(ct),
                "cluster_id": 0,
                "cell_indices": ct_indices.tolist(),
                "samples": 0,
                "mean_sim": 0.0,
                "variance": 0.0,
                "focus_score": 0.0,
                "sampled_indices": [],
                "sampled_scores": [],
            })
            cluster_labels[ct_indices] = arm_id
            arm_id += 1
        else:
            km = KMeans(n_clusters=n_clust, random_state=random_state, n_init=10)
            km_labels = km.fit_predict(ct_embeddings)

            for cid in range(n_clust):
                members = ct_indices[km_labels == cid]
                if len(members) == 0:
                    continue
                arms.append({
                    "arm_id": arm_id,
                    "cell_type": str(ct),
                    "cluster_id": int(cid),
                    "cell_indices": members.tolist(),
                    "samples": 0,
                    "mean_sim": 0.0,
                    "variance": 0.0,
                    "focus_score": 0.0,
                    "sampled_indices": [],
                    "sampled_scores": [],
                })
                cluster_labels[members] = arm_id
                arm_id += 1

    LOGGER.info(
        "Created %d arms from %d cell types (%d total pool cells)",
        len(arms), len(unique_types), len(pool_adata),
    )
    return arms, cluster_labels


# ---------------------------------------------------------------------------
# Main pipeline
# ---------------------------------------------------------------------------

def adaptive_prompt_selection(
    model,
    full_adata: ad.AnnData,
    genelist_path: str,
    query_cell_type: str,
    perturbation: str,
    control_name: str = "Dimethyl Sulfoxide",
    cell_type_col: str = "cell_type",
    perturbation_col: str = "sm_name",
    control_col: str = "control",
    # Bandit params
    n_clusters_per_type: int = 5,
    zoom_ratio: float = 0.25,
    coarse_samples_per_arm: int = 10,
    coarse_ratio: float = 0.2,
    extra_fine_samples_per_arm: int = 10,
    exploration_weight: float = 1.0,
    top_ratio: float = 0.2,
    temperature: float = 0.06,
    # Prediction params
    n_prompt_cells: Optional[int] = None,
    top_k_real: Optional[int] = None,
    prompt_ratio: float = 0.25,
    context_ratio: float = 0.4,
    context_ratio_min: float = 0.2,
    num_steps: int = 5,
    mode: str = "mdm",
    gene_name_col: Optional[str] = None,
    batch_size: int = 16,
    num_workers: int = 4,
    random_seed: int = 42,
    show_progress: bool = True,
) -> Tuple[ad.AnnData, Dict]:
    """Full adaptive prompt selection pipeline.

    Args:
        model: Loaded Stack model (ICL_FinetunedModel).
        full_adata: Complete dataset with all cell types and conditions.
        genelist_path: Path to gene list pickle.
        query_cell_type: Cell type to predict for (e.g. "B cells").
        perturbation: Target perturbation (e.g. drug name).
        control_name: Name of control condition in perturbation_col.
        cell_type_col: obs column for cell type.
        perturbation_col: obs column for perturbation name.
        control_col: obs column for control flag (bool).

    Returns:
        (pred_adata, details) — predicted AnnData and bandit selection details.
    """
    import torch

    # ----- Step 0: Data splitting -----
    LOGGER.info("Step 0: Splitting data...")
    obs = full_adata.obs

    query_mask = (obs[cell_type_col] == query_cell_type) & (obs[control_col] == True)
    query_cells = full_adata[query_mask].copy()
    LOGGER.info("  Query cells (%s, control): %d", query_cell_type, query_cells.n_obs)

    unperturbed_pool_mask = (obs[cell_type_col] != query_cell_type) & (obs[control_col] == True)
    unperturbed_pool = full_adata[unperturbed_pool_mask].copy()
    LOGGER.info("  Unperturbed pool (non-%s, control): %d", query_cell_type, unperturbed_pool.n_obs)

    perturbed_pool_mask = (obs[cell_type_col] != query_cell_type) & (obs[perturbation_col] == perturbation)
    perturbed_pool = full_adata[perturbed_pool_mask].copy()
    LOGGER.info("  Perturbed pool (non-%s, %s): %d", query_cell_type, perturbation, perturbed_pool.n_obs)

    if query_cells.n_obs == 0:
        raise ValueError(f"No query cells found for {query_cell_type} under control")
    if unperturbed_pool.n_obs == 0:
        raise ValueError("No unperturbed pool cells found")
    if perturbed_pool.n_obs == 0:
        raise ValueError(f"No perturbed pool cells found for {perturbation}")

    # Default prompt cell count
    # Stack's get_incontext_prediction uses n_base_cells = n_cells * (prompt_ratio + context_ratio)
    # per batch, and cycles through base_adata. We need enough cells to avoid
    # excessive repetition. Use multiplier to provide diversity across batches.
    n_base_per_batch = int(model.n_cells * (prompt_ratio + context_ratio))
    n_test_per_batch = model.n_cells - n_base_per_batch
    num_batches = max(1, int(np.ceil(query_cells.n_obs / n_test_per_batch)))
    if n_prompt_cells is None:
        # Match Stack's per-batch ratio: each batch needs n_base_per_batch prompts.
        # Scale linearly with num_batches so every batch gets unique prompts.
        n_prompt_cells = min(unperturbed_pool.n_obs, n_base_per_batch * num_batches)
    if top_k_real is None:
        top_k_real = min(perturbed_pool.n_obs, n_base_per_batch * num_batches)
    LOGGER.info("  n_base_per_batch=%d, n_test_per_batch=%d, num_batches=%d",
                n_base_per_batch, n_test_per_batch, num_batches)
    LOGGER.info("  n_prompt_cells=%d, top_k_real=%d", n_prompt_cells, top_k_real)

    # ----- Step 1: Extract embeddings -----
    LOGGER.info("Step 1: Extracting embeddings...")
    query_emb, _ = model.get_latent_representation(
        adata_path=query_cells, genelist_path=genelist_path,
        gene_name_col=gene_name_col, batch_size=batch_size,
        show_progress=show_progress, num_workers=num_workers,
    )
    query_mean = query_emb.mean(axis=0)
    LOGGER.info("  Query mean embedding shape: %s", query_mean.shape)

    pool_emb, _ = model.get_latent_representation(
        adata_path=unperturbed_pool, genelist_path=genelist_path,
        gene_name_col=gene_name_col, batch_size=batch_size,
        show_progress=show_progress, num_workers=num_workers,
    )
    LOGGER.info("  Pool embeddings shape: %s", pool_emb.shape)

    # ----- Step 2: Build arms -----
    LOGGER.info("Step 2: Building arms (clustering)...")
    arms, cluster_labels = setup_cell_arms(
        unperturbed_pool, pool_emb, cell_type_col,
        n_clusters_per_type=n_clusters_per_type, random_state=random_seed,
    )

    # ----- Step 3: Bandit selection -----
    LOGGER.info("Step 3: Running CellBandit selection...")
    sim_fn = create_cell_similarity_fn(pool_emb)
    bandit = CellBandit(
        similarity_fn=sim_fn,
        zoom_ratio=zoom_ratio,
        coarse_samples_per_arm=coarse_samples_per_arm,
        coarse_ratio=coarse_ratio,
        extra_fine_samples_per_arm=extra_fine_samples_per_arm,
        exploration_weight=exploration_weight,
        top_ratio=top_ratio,
        temperature=temperature,
    )
    selected_indices, bandit_details = bandit.select_cells(
        query_embedding=query_mean,
        arms=arms,
        k=n_prompt_cells,
        rng=np.random.default_rng(random_seed),
    )
    matched_unperturbed = unperturbed_pool[selected_indices].copy()
    LOGGER.info("  Bandit selected %d unperturbed cells", len(selected_indices))

    # ----- Step 4: Bridge prediction -----
    LOGGER.info("Step 4: Bridge prediction (unperturbed -> predicted perturbed)...")
    intermediate_pred = model.get_incontext_prediction(
        base_adata_or_path=perturbed_pool,
        test_adata_or_path=matched_unperturbed,
        genelist_path=genelist_path,
        prompt_ratio=prompt_ratio,
        context_ratio=context_ratio,
        mode="predict",
        gene_name_col=gene_name_col,
        batch_size=batch_size,
        show_progress=show_progress,
        num_workers=num_workers,
        random_seed=random_seed,
    )
    # intermediate_pred is a sparse matrix
    if issparse(intermediate_pred):
        intermediate_pred_dense = intermediate_pred.toarray()
    else:
        intermediate_pred_dense = np.asarray(intermediate_pred)
    LOGGER.info("  Intermediate prediction shape: %s", intermediate_pred_dense.shape)

    # ----- Step 5: Find real perturbed prompts -----
    LOGGER.info("Step 5: Retrieving TopK real perturbed cells...")

    # Build AnnData from intermediate predictions for embedding extraction
    pred_adata_tmp = ad.AnnData(
        X=intermediate_pred_dense,
        obs=matched_unperturbed.obs.copy(),
        var=matched_unperturbed.var.copy() if hasattr(matched_unperturbed, 'var') else None,
    )

    pred_emb, _ = model.get_latent_representation(
        adata_path=pred_adata_tmp, genelist_path=genelist_path,
        gene_name_col=gene_name_col, batch_size=batch_size,
        show_progress=show_progress, num_workers=num_workers,
    )

    perturbed_emb, _ = model.get_latent_representation(
        adata_path=perturbed_pool, genelist_path=genelist_path,
        gene_name_col=gene_name_col, batch_size=batch_size,
        show_progress=show_progress, num_workers=num_workers,
    )

    # Per-cluster mean of predicted embeddings, then find closest real perturbed
    # Group selected cells by which arm they came from
    selected_arm_map: Dict[int, List[int]] = {}  # arm_id -> list of positions in selected_indices
    for pos, cell_idx in enumerate(selected_indices):
        arm_label = cluster_labels[cell_idx]
        selected_arm_map.setdefault(arm_label, []).append(pos)

    # Per-arm retrieval: each arm computes its own mean predicted embedding,
    # then retrieves its proportional share of real perturbed cells.
    # This preserves the diversity that the bandit selection identified.
    n_arms_with_cells = len(selected_arm_map)
    LOGGER.info("  %d arms contributed to selection", n_arms_with_cells)

    # Allocate top_k_real proportionally to arm size
    arm_sizes = {aid: len(positions) for aid, positions in selected_arm_map.items()}
    total_selected = sum(arm_sizes.values())
    arm_quotas: Dict[int, int] = {}
    allocated = 0
    sorted_arms = sorted(arm_sizes.items(), key=lambda x: x[1], reverse=True)
    for i, (aid, size) in enumerate(sorted_arms):
        if i == len(sorted_arms) - 1:
            # Last arm gets remainder to ensure exact total
            arm_quotas[aid] = top_k_real - allocated
        else:
            quota = max(1, int(round(top_k_real * size / total_selected)))
            arm_quotas[aid] = quota
            allocated += quota

    # Retrieve real perturbed cells per arm
    all_retrieved_idx: List[int] = []
    all_retrieved_sims: List[float] = []
    already_selected: set = set()
    per_arm_retrieval_info = []

    for aid, positions in selected_arm_map.items():
        quota = arm_quotas[aid]
        # Mean embedding of this arm's predicted perturbed profiles
        arm_pred_emb = pred_emb[positions]  # (n_arm_cells, dim)
        arm_mean = arm_pred_emb.mean(axis=0, keepdims=True)  # (1, dim)

        sims = cosine_similarity(arm_mean, perturbed_emb)[0]  # (n_perturbed,)
        # Exclude already-selected cells
        for idx in already_selected:
            sims[idx] = -1.0
        top_idx = np.argsort(sims)[-quota:]
        retrieved_sims = sims[top_idx]

        all_retrieved_idx.extend(top_idx.tolist())
        all_retrieved_sims.extend(retrieved_sims.tolist())
        already_selected.update(top_idx.tolist())

        arm_ct = arms[aid]["cell_type"] if aid < len(arms) else "unknown"
        per_arm_retrieval_info.append({
            "arm_id": int(aid),
            "cell_type": arm_ct,
            "n_selected_unperturbed": len(positions),
            "n_retrieved_perturbed": int(quota),
            "mean_similarity": float(np.mean(retrieved_sims)),
        })
        LOGGER.info("    Arm %d (%s): %d unperturbed → %d perturbed (mean_sim=%.4f)",
                     aid, arm_ct, len(positions), quota, float(np.mean(retrieved_sims)))

    final_prompts = perturbed_pool[all_retrieved_idx].copy()
    LOGGER.info("  Selected %d real perturbed cells as final prompts", final_prompts.n_obs)

    bandit_details["n_final_prompts"] = final_prompts.n_obs
    bandit_details["per_arm_retrieval"] = per_arm_retrieval_info
    bandit_details["top_k_similarities"] = all_retrieved_sims

    # ----- Step 6: Final generation -----
    LOGGER.info("Step 6: Final generation with adaptive prompts...")
    result = model.get_incontext_generation(
        base_adata_or_path=final_prompts,
        test_adata_or_path=query_cells,
        genelist_path=genelist_path,
        prompt_ratio=prompt_ratio,
        context_ratio=context_ratio,
        context_ratio_min=context_ratio_min,
        num_steps=num_steps,
        mode=mode,
        gene_name_col=gene_name_col,
        batch_size=batch_size,
        show_progress=show_progress,
        num_workers=num_workers,
        random_seed=random_seed,
    )

    if isinstance(result, tuple):
        predictions, test_logit = result
    else:
        predictions, test_logit = result, None

    pred_adata = ad.AnnData(
        X=predictions,
        obs=query_cells.obs.copy(),
        var=query_cells.var.copy(),
    )
    if test_logit is not None:
        pred_adata.obs["gen_logit"] = np.asarray(test_logit)

    LOGGER.info("Adaptive prompt selection complete. Prediction shape: %s", pred_adata.shape)
    return pred_adata, bandit_details


# ---------------------------------------------------------------------------
# Baseline: random prompt generation
# ---------------------------------------------------------------------------

def run_baseline(
    model,
    context_adata: ad.AnnData,
    query_adata: ad.AnnData,
    genelist_path: str,
    prompt_ratio: float = 0.25,
    context_ratio: float = 0.4,
    context_ratio_min: float = 0.2,
    num_steps: int = 5,
    mode: str = "mdm",
    gene_name_col: Optional[str] = None,
    batch_size: int = 16,
    num_workers: int = 4,
    random_seed: int = 42,
    show_progress: bool = True,
) -> ad.AnnData:
    """Run standard random-prompt Stack generation for comparison."""
    LOGGER.info("Running baseline (random prompt) generation...")

    result = model.get_incontext_generation(
        base_adata_or_path=context_adata,
        test_adata_or_path=query_adata,
        genelist_path=genelist_path,
        prompt_ratio=prompt_ratio,
        context_ratio=context_ratio,
        context_ratio_min=context_ratio_min,
        num_steps=num_steps,
        mode=mode,
        gene_name_col=gene_name_col,
        batch_size=batch_size,
        show_progress=show_progress,
        num_workers=num_workers,
        random_seed=random_seed,
    )

    if isinstance(result, tuple):
        predictions, test_logit = result
    else:
        predictions, test_logit = result, None

    pred_adata = ad.AnnData(
        X=predictions,
        obs=query_adata.obs.copy(),
        var=query_adata.var.copy(),
    )
    if test_logit is not None:
        pred_adata.obs["gen_logit"] = np.asarray(test_logit)

    LOGGER.info("Baseline generation complete. Prediction shape: %s", pred_adata.shape)
    return pred_adata