"""Custom generation loop with per-step embedding-based prompt selection. Re-implements the MDM loop from ``get_incontext_generation`` but replaces random prompt selection with the two-stage embedding similarity approach at every generation step. """ from __future__ import annotations import logging import math from typing import Optional, Tuple import anndata as ad import numpy as np import pandas as pd from scipy.sparse import csr_matrix from stack.models.utils import align_result_to_adata_numpy from prompt_selection.prompt_selector import select_prompt_indices LOGGER = logging.getLogger("prompt_selection.custom_generation") def custom_generation_loop( model, query_adata: ad.AnnData, prompt_pert_adata: ad.AnnData, genelist_path: str, query_embeddings: np.ndarray, prompt_ctrl_embeddings: np.ndarray, predicted_pert_embeddings: np.ndarray, prompt_pert_embeddings: np.ndarray, *, num_steps: int = 5, prompt_ratio: float = 0.25, context_ratio: float = 0.4, context_ratio_min: float = 0.2, top_k1: int = 512, batch_size: int = 32, num_workers: int = 4, gene_name_col: Optional[str] = None, ) -> Tuple[csr_matrix, np.ndarray]: """Run MDM generation with per-step prompt re-selection. Parameters ---------- model : StateICLModel (ICL_FinetunedModel) Loaded ``bc_large_aligned`` model in eval mode. query_adata : AnnData Query cells (B cells, DMSO). Will be mutated in-place each step. prompt_pert_adata : AnnData Real perturbed prompt cells (T cells, Dabrafenib). genelist_path : str Path to pickled gene list. query_embeddings : (N_query, D) prompt_ctrl_embeddings : (N_ctrl, D) predicted_pert_embeddings : (N_ctrl, D) prompt_pert_embeddings : (N_pert, D) num_steps, prompt_ratio, context_ratio, context_ratio_min, top_k1 : Generation hyperparameters. batch_size, num_workers : DataLoader settings. gene_name_col : Optional gene name column. Returns ------- result : csr_matrix Final predicted expression (aligned to query_adata gene space). final_logit : np.ndarray Per-cell logit scores from the last step. """ n_cells = model.n_cells # 512 cell_names = query_adata.obs_names.copy() N = len(cell_names) # Global state indexed by obs_names is_masked = pd.Series(np.ones(N, dtype=bool), index=cell_names) test_logit = pd.Series(np.zeros(N, dtype=np.float32), index=cell_names) # MDM schedule (matches get_incontext_generation lines 869-875) t = (np.arange(num_steps, dtype=np.float32) + 1) / num_steps cr_list = np.linspace(context_ratio_min, context_ratio, num_steps, dtype=np.float32) mr_list = 1 - t mr_list[-1] = 0.0 LOGGER.info("Masking ratio schedule: %s", mr_list) LOGGER.info("Context ratio schedule: %s", cr_list) result = None for step_idx, (mr, cr) in enumerate(zip(mr_list, cr_list)): ratio = prompt_ratio + cr n_test_cells = max(1, int(n_cells * (1 - ratio))) n_base_cells = n_cells - n_test_cells num_batches = math.ceil(N / n_test_cells) LOGGER.info( "Step %d/%d: mr=%.3f cr=%.3f n_test=%d n_base=%d batches=%d", step_idx + 1, num_steps, mr, cr, n_test_cells, n_base_cells, num_batches, ) mixed_adata_list = [] is_test_cell_parts = [] flat_idx_to_cell_name = [] for i in range(num_batches): start = i * n_test_cells end = min((i + 1) * n_test_cells, N) batch_cell_names = cell_names[start:end] actual_len = len(batch_cell_names) # Pad last batch if needed if actual_len < n_test_cells: pad_names = cell_names[:n_test_cells - actual_len] current_test_slice = query_adata[list(batch_cell_names) + list(pad_names)] else: current_test_slice = query_adata[list(batch_cell_names)] # Two-stage prompt selection batch_global_indices = np.arange(start, end) selected_base_idx = select_prompt_indices( query_embeddings=query_embeddings, batch_global_indices=batch_global_indices, prompt_ctrl_embeddings=prompt_ctrl_embeddings, predicted_pert_embeddings=predicted_pert_embeddings, prompt_pert_embeddings=prompt_pert_embeddings, n_base_cells=n_base_cells, top_k1=top_k1, ) actual_base = len(selected_base_idx) # Build mixed sample: [base_cells, test_cells] sample_adata = ad.concat( [prompt_pert_adata[selected_base_idx], current_test_slice], join="inner", axis=0, ) mixed_adata_list.append(sample_adata) # Track test cell positions (only real cells, not padding) batch_mask = np.zeros(actual_base + n_test_cells, dtype=bool) batch_mask[actual_base : actual_base + actual_len] = True is_test_cell_parts.append(batch_mask) flat_idx_to_cell_name.extend(batch_cell_names) is_test_cell_mask = np.concatenate(is_test_cell_parts) # Concatenate all batches full_mixed_adata = ad.concat(mixed_adata_list, axis=0, join="inner") # Model forward pass mean_preds, disp_preds, count_preds, logit_preds = model.get_prediction( adata_path=full_mixed_adata, genelist_path=genelist_path, gene_name_col=gene_name_col, cell_ratio=prompt_ratio, context_ratio=cr, batch_size=batch_size, num_workers=num_workers, ) # Extract test cell results result_counts = count_preds[is_test_cell_mask] # (N, n_model_genes) new_logit = logit_preds[is_test_cell_mask] # (N,) result_cell_names = np.array(flat_idx_to_cell_name) # (N,) # ---- MDM unmasking logic (mirrors get_incontext_prediction lines 694-703) ---- cur_is_masked = is_masked.loc[result_cell_names].values.copy() cur_new_logit = new_logit.copy() cell_indices_to_keep = np.zeros(N, dtype=bool) # 1) Already unmasked cells keep their previous prediction cell_indices_to_keep[~cur_is_masked] = True # 2) Compute unmask_rate n_masked = cur_is_masked.sum() n_total = len(cur_is_masked) if n_masked > 0: unmask_rate = (n_masked / n_total - mr) * n_total / n_masked unmask_rate = np.clip(unmask_rate, 0.0, 1.0) else: unmask_rate = 1.0 # 3) Unmask cells with logit above quantile threshold if n_masked > 0: masked_logits = cur_new_logit[cur_is_masked] threshold = np.quantile(masked_logits, unmask_rate) cell_indices_to_keep[cur_is_masked] = cur_new_logit[cur_is_masked] > threshold # 4) Update global is_masked new_is_masked = cur_is_masked.copy() new_is_masked[~cell_indices_to_keep] = False new_is_masked[cur_new_logit > 0] = True is_masked.loc[result_cell_names] = new_is_masked # 5) Update global test_logit test_logit.loc[result_cell_names] = cur_new_logit LOGGER.info( "Step %d: unmasked fraction = %.3f", step_idx + 1, (cur_new_logit < 0).sum() / len(cur_new_logit), ) # Align to query_adata gene space aligned_result = align_result_to_adata_numpy( result_counts, query_adata, genelist_path, gene_name_col, cell_indices_to_keep=cell_indices_to_keep, ) result = csr_matrix(aligned_result) # Update query_adata for next step (consistent with original code) if query_adata.raw is not None: query_adata.raw.X = result else: query_adata.X = result final_logit = test_logit.loc[cell_names].values return result, final_logit