transfer/code/adaptive_prompt_selection/cell_bandit.py

"""
CellBandit: FOCUS-inspired multi-armed bandit for cell prompt selection.

Adapted from FOCUS (Frame-Optimistic Confidence Upper-bound Selection).
Removes all temporal/video concepts; keeps the Bernstein UCB formula
and coarse-fine-select three-stage structure.
"""

import math
from typing import Callable, Dict, List, Optional, Tuple

import numpy as np


class CellBandit:
    """
    Multi-armed bandit for selecting optimal cells from a candidate pool.

    Each arm is a (cell_type, cluster_id) group. The algorithm:
      1. Coarse: sample a few cells per arm, score via similarity_fn
      2. UCB: rank arms by mean + confidence bound (Bernstein)
      3. Fine: sample more cells from top arms
      4. Select: top_ratio direct picks + softmax-weighted sampling
    """

    def __init__(
        self,
        similarity_fn: Callable[[np.ndarray, List[int]], List[float]],
        zoom_ratio: float = 0.25,
        min_zoom_arms: int = 2,
        coarse_samples_per_arm: int = 10,
        coarse_ratio: float = 0.2,
        extra_fine_samples_per_arm: int = 10,
        min_variance_threshold: float = 1e-6,
        exploration_weight: float = 1.0,
        top_ratio: float = 0.2,
        temperature: float = 0.06,
    ):
        """
        Args:
            similarity_fn: fn(query_embedding, cell_indices) -> List[float]
            zoom_ratio: Fraction of arms to zoom into for fine sampling.
            min_zoom_arms: Minimum number of arms to zoom into.
            coarse_samples_per_arm: Minimum coarse samples per arm.
            coarse_ratio: Minimum fraction of each arm to sample in coarse phase.
            extra_fine_samples_per_arm: Extra samples per arm in fine phase.
            min_variance_threshold: Floor for variance in UCB.
            exploration_weight: Scales the exploration bonus (lower = more exploitation).
            top_ratio: Fraction of k selected directly from top scores.
            temperature: Softmax temperature for within-arm sampling.
        """
        self.similarity_fn = similarity_fn
        self.zoom_ratio = zoom_ratio
        self.min_zoom_arms = min_zoom_arms
        self.coarse_samples_per_arm = coarse_samples_per_arm
        self.coarse_ratio = coarse_ratio
        self.extra_fine_samples_per_arm = extra_fine_samples_per_arm
        self.min_variance_threshold = min_variance_threshold
        self.exploration_weight = exploration_weight
        self.top_ratio = top_ratio
        self.temperature = temperature

    def select_cells(
        self,
        query_embedding: np.ndarray,
        arms: List[Dict],
        k: int,
        rng: Optional[np.random.Generator] = None,
    ) -> Tuple[List[int], Dict]:
        """
        Select k cells from the pool using FOCUS-style bandit.

        Args:
            query_embedding: Mean embedding of query cells.
            arms: List of arm dicts, each with 'cell_indices' and metadata.
            k: Number of cells to select.
            rng: Random number generator.

        Returns:
            (selected_indices, details) where selected_indices are pool indices.
        """
        if rng is None:
            rng = np.random.default_rng()

        # Reset arm statistics
        for arm in arms:
            arm["samples"] = 0
            arm["mean_sim"] = 0.0
            arm["variance"] = 0.0
            arm["focus_score"] = 0.0
            arm["sampled_indices"] = []
            arm["sampled_scores"] = []

        # Stage 1: Coarse sampling
        coarse_indices = self._coarse_sampling(arms, rng)
        if coarse_indices:
            coarse_scores = self.similarity_fn(query_embedding, coarse_indices)
            self._update_arms_with_scores(arms, coarse_indices, coarse_scores)
            self._update_focus_scores(arms)

        for arm in arms:
            arm["focus_after_coarse"] = float(arm["focus_score"])

        # Stage 2: Choose promising arms
        selected_arms = self._choose_promising_arms(arms)

        # Stage 3: Fine sampling in promising arms
        coarse_set = set(coarse_indices)
        fine_indices = self._fine_sampling(selected_arms, coarse_set, rng)
        if fine_indices:
            fine_scores = self.similarity_fn(query_embedding, fine_indices)
            self._update_arms_with_scores(arms, fine_indices, fine_scores)
            self._update_focus_scores(arms)

        for arm in arms:
            arm["focus_after_fine"] = float(arm["focus_score"])

        # Merge all scores
        all_scores: Dict[int, float] = {}
        for arm in arms:
            for idx, score in arm["sampled_scores"]:
                all_scores[idx] = score

        # Stage 4a: Top picks
        selected = self._select_top_cells(all_scores, k)

        # Stage 4b: Remaining via softmax within top arms
        remaining = k - len(selected)
        if remaining > 0:
            additional = self._select_remaining_cells(
                arms, remaining, all_scores, set(selected), rng
            )
            selected.extend(additional)

        selected = selected[:k]

        details = self._prepare_details(arms, selected, coarse_indices, fine_indices)
        return selected, details

    # ------------------------------------------------------------------
    # Internal stages
    # ------------------------------------------------------------------

    def _coarse_sampling(self, arms: List[Dict], rng: np.random.Generator) -> List[int]:
        """Sample cells from each arm. Uses max(coarse_samples_per_arm, coarse_ratio * arm_size)."""
        all_indices: List[int] = []
        for arm in arms:
            cell_indices = arm["cell_indices"]
            # Adaptive: sample at least coarse_ratio of each arm
            n_from_ratio = max(1, int(np.ceil(len(cell_indices) * self.coarse_ratio)))
            n_sample = min(max(self.coarse_samples_per_arm, n_from_ratio), len(cell_indices))
            if n_sample == 0:
                continue
            sampled = rng.choice(cell_indices, size=n_sample, replace=False).tolist()
            arm["sampled_indices"] = sampled
            all_indices.extend(sampled)
        return all_indices

    def _update_arms_with_scores(
        self, arms: List[Dict], indices: List[int], scores: List[float]
    ) -> None:
        """Update arms with new scores and recompute statistics."""
        idx_to_score = dict(zip(indices, scores))

        for arm in arms:
            existing_idx_set = {idx for idx, _ in arm["sampled_scores"]}
            for idx in arm["sampled_indices"]:
                if idx in idx_to_score and idx not in existing_idx_set:
                    arm["sampled_scores"].append((idx, idx_to_score[idx]))
                    existing_idx_set.add(idx)

            if arm["sampled_scores"]:
                all_arm_scores = [s for _, s in arm["sampled_scores"]]
                arm["samples"] = len(all_arm_scores)
                arm["mean_sim"] = float(np.mean(all_arm_scores))
                arm["variance"] = (
                    float(np.var(all_arm_scores)) if len(all_arm_scores) > 1 else 0.0
                )

    def _update_focus_scores(self, arms: List[Dict]) -> None:
        """Compute FOCUS UCB scores (Bernstein confidence bound).

        Formula: mean + w * [sqrt(2*log(N)*var/n) + 3*log(N)/n]
        Based on FOCUS focus.py:424-453, with exploration_weight (w) scaling.
        """
        total_samples = sum(arm["samples"] for arm in arms)
        w = self.exploration_weight

        for arm in arms:
            n_i = arm["samples"]
            mean = arm["mean_sim"]
            var = max(arm["variance"], self.min_variance_threshold)

            focus_score = mean
            if total_samples > 1 and n_i > 0:
                focus_score += w * math.sqrt(
                    max(0.0, 2 * math.log(total_samples) * var / n_i)
                )
                focus_score += w * 3 * math.log(total_samples) / n_i
            arm["focus_score"] = focus_score

    def _choose_promising_arms(self, arms: List[Dict]) -> List[Dict]:
        """Select top zoom_ratio fraction of arms by FOCUS score."""
        arms_sorted = sorted(arms, key=lambda x: x["focus_score"], reverse=True)
        n_select = max(self.min_zoom_arms, int(np.ceil(len(arms) * self.zoom_ratio)))
        n_select = min(n_select, len(arms))
        return arms_sorted[:n_select]

    def _fine_sampling(
        self,
        selected_arms: List[Dict],
        coarse_set: set,
        rng: np.random.Generator,
    ) -> List[int]:
        """Sample extra cells from promising arms."""
        fine: List[int] = []
        for arm in selected_arms:
            available = [i for i in arm["cell_indices"] if i not in coarse_set]
            n_sample = min(self.extra_fine_samples_per_arm, len(available))
            if n_sample > 0:
                sampled = rng.choice(available, size=n_sample, replace=False).tolist()
                arm["sampled_indices"].extend(sampled)
                fine.extend(sampled)
        return fine

    def _select_top_cells(
        self, all_scores: Dict[int, float], k: int
    ) -> List[int]:
        """Select top_ratio * k cells with highest scores."""
        if not all_scores or k <= 0:
            return []
        k_top = int(round(self.top_ratio * min(k, len(all_scores))))
        sorted_scores = sorted(all_scores.items(), key=lambda x: x[1], reverse=True)
        return [idx for idx, _ in sorted_scores[:k_top]]

    def _select_remaining_cells(
        self,
        arms: List[Dict],
        count: int,
        all_scores: Dict[int, float],
        selected_set: set,
        rng: np.random.Generator,
    ) -> List[int]:
        """Softmax-weighted sampling within top arms (no temporal gap).

        Final selection ranks arms by mean_sim (exploitation-focused),
        not focus_score, since we want the best cells, not exploration.
        """
        if count <= 0 or not arms:
            return []

        total_arms = len(arms)
        S = int(np.ceil(total_arms * max(0.0, min(1.0, self.zoom_ratio))))
        S = max(self.min_zoom_arms, S)
        S = min(S, total_arms)

        # Use mean_sim for final arm ranking (exploitation)
        arms_sorted = sorted(
            enumerate(arms), key=lambda x: x[1]["mean_sim"], reverse=True
        )
        top_arm_entries = arms_sorted[:S]

        # Even allocation across top arms
        base_alloc = count // S
        rem = count % S
        per_arm_need = [base_alloc + (1 if i < rem else 0) for i in range(S)]

        new_cells: List[int] = []
        current_selected = set(selected_set)

        for rank, (_, arm) in enumerate(top_arm_entries):
            needed = per_arm_need[rank]
            if needed == 0:
                continue

            available = [i for i in arm["cell_indices"] if i not in current_selected]
            if not available:
                continue

            # Collect scores for available candidates
            scored = [(c, all_scores[c]) for c in available if c in all_scores]
            unscored = [c for c in available if c not in all_scores]

            if scored:
                candidates, scores_arr = zip(*scored)
                candidates = list(candidates)
                scores_arr = np.array(scores_arr, dtype=np.float64)

                # Normalize to [0, 1]
                if scores_arr.max() > scores_arr.min():
                    scores_arr = (scores_arr - scores_arr.min()) / (
                        scores_arr.max() - scores_arr.min()
                    )
                else:
                    scores_arr = np.ones_like(scores_arr)

                # Softmax with temperature
                logits = scores_arr / max(1e-12, self.temperature)
                logits = logits - logits.max()
                probs = np.exp(logits)
                probs = probs / probs.sum()

                actual = min(needed, len(candidates))
                if actual > 0:
                    chosen_pos = rng.choice(
                        len(candidates), size=actual, p=probs, replace=False
                    )
                    for pos in chosen_pos:
                        idx = candidates[pos]
                        new_cells.append(idx)
                        current_selected.add(idx)
                    needed -= actual

            # Fill remaining from unscored candidates randomly
            if needed > 0 and unscored:
                actual = min(needed, len(unscored))
                chosen = rng.choice(unscored, size=actual, replace=False).tolist()
                new_cells.extend(chosen)
                for c in chosen:
                    current_selected.add(c)

        return new_cells

    def _prepare_details(
        self,
        arms: List[Dict],
        selected: List[int],
        coarse_indices: List[int],
        fine_indices: List[int],
    ) -> Dict:
        """Prepare sampling details for analysis."""
        arms_info = []
        for arm in arms:
            arms_info.append(
                {
                    "arm_id": arm["arm_id"],
                    "cell_type": arm.get("cell_type", ""),
                    "cluster_id": arm.get("cluster_id", -1),
                    "n_cells_in_arm": len(arm["cell_indices"]),
                    "focus_score": float(arm["focus_score"]),
                    "focus_after_coarse": arm.get("focus_after_coarse"),
                    "focus_after_fine": arm.get("focus_after_fine"),
                    "mean_similarity": float(arm["mean_sim"]),
                    "variance": float(arm["variance"]),
                    "samples_count": int(arm["samples"]),
                }
            )

        return {
            "n_coarse_samples": len(coarse_indices),
            "n_fine_samples": len(fine_indices),
            "n_selected": len(selected),
            "arms_info": arms_info,
            "selected_indices": selected,
        }