""" Precompute per-cell scGPT attention features (attn @ gene_emb) to HDF5. Uses ALL valid genes (no random sampling) for deterministic features. Stores raw features (no normalization) + pre-computed delta stats. Output HDF5 layout: /features (N, G_full, D) float16 — raw attn @ gene_emb per cell /norm_mean (D,) float32 — mean of delta features (for normalization) /norm_var (D,) float32 — var of delta features /cell_names (N,) string — cell identifiers (adata.obs_names) """ import sys import os import argparse # Set up paths _SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) _PROJECT_ROOT = os.path.dirname(_SCRIPT_DIR) sys.path.insert(0, _PROJECT_ROOT) # Bootstrap scDFM import _bootstrap_scdfm # noqa: F401 import numpy as np import torch import h5py from tqdm import tqdm from src.data.data import get_data_classes from src.data.scgpt_extractor import FrozenScGPTExtractor _REPO_ROOT = os.path.normpath(os.path.join(_PROJECT_ROOT, "..", "..", "transfer", "code")) def extract_per_cell_attn_features( extractor: FrozenScGPTExtractor, expression_batch: torch.Tensor, # (B, G_full) attn_layer: int = 11, use_rank_norm: bool = True, ) -> torch.Tensor: """ Extract attn @ gene_emb for each cell using ALL valid genes. Unlike the online extract_attention_delta(), this: - Uses all valid genes (no random sampling) → deterministic - Processes one condition at a time (not control-target pairs) - Returns raw features (no normalization) Args: extractor: FrozenScGPTExtractor (must have max_seq_len >= n_valid + 1) expression_batch: (B, G_full) expression values attn_layer: which transformer layer use_rank_norm: whether to apply rank normalization to attention scores Returns: (B, G_full, D) raw features, zeros at missing gene positions """ B, G_full = expression_batch.shape device = expression_batch.device D = extractor.scgpt_d_model # Use all HVG genes (no gene_indices subset) hvg_ids = extractor.hvg_to_scgpt_id # (G_full,) valid_mask = hvg_ids >= 0 valid_scgpt_ids = hvg_ids[valid_mask] # (G_valid,) n_valid = valid_scgpt_ids.shape[0] valid_positions = torch.where(valid_mask)[0] # Verify we can fit all valid genes + CLS in max_seq_len assert n_valid + 1 <= extractor.max_seq_len, ( f"n_valid ({n_valid}) + 1 CLS > max_seq_len ({extractor.max_seq_len}). " f"Increase max_seq_len to at least {n_valid + 1}." ) # Expression for valid genes expr_valid = expression_batch[:, valid_positions] # (B, G_valid) # Build scGPT input: CLS + all valid gene tokens cls_ids = torch.full((B, 1), extractor.cls_token_id, dtype=torch.long, device=device) gene_ids_expanded = valid_scgpt_ids.unsqueeze(0).expand(B, -1) src = torch.cat([cls_ids, gene_ids_expanded], dim=1) # (B, G_valid + 1) cls_val = torch.zeros(B, 1, device=device) values = torch.cat([cls_val, expr_valid], dim=1) # (B, G_valid + 1) seq_len = n_valid + 1 pad_mask = torch.zeros(B, seq_len, dtype=torch.bool, device=device) # Gene embeddings (static, same for all cells) gene_emb = extractor.scgpt_model.encoder(valid_scgpt_ids.unsqueeze(0)) # (1, G_valid, D) gene_emb = gene_emb.squeeze(0) # (G_valid, D) # Forward to target layer hidden = extractor._forward_to_layer(src, values, pad_mask, attn_layer) # Compute attention at target layer attn = extractor._compute_attention(hidden, attn_layer, use_rank_norm) # (B, S, S) # Remove CLS row/column attn = attn[:, 1:, 1:] # (B, G_valid, G_valid) # Features = attn @ gene_emb → (B, G_valid, D) features = torch.matmul(attn, gene_emb.unsqueeze(0).expand(B, -1, -1)) # Scatter to full G positions output = torch.zeros(B, G_full, D, device=device, dtype=features.dtype) idx = valid_positions.unsqueeze(0).unsqueeze(-1).expand(B, -1, D) output.scatter_(1, idx, features) return output def compute_delta_stats( h5_features, # HDF5 dataset (N, G_full, D) cell_names, # list of cell names adata, # AnnData with obs columns for control/perturbation n_pairs: int = 10000, seed: int = 42, ): """ Sample (control, perturbation) cell pairs and compute delta feature statistics. Returns: norm_mean: (D,) float32 norm_var: (D,) float32 """ rng = np.random.RandomState(seed) # Build name -> index mapping name_to_idx = {name: i for i, name in enumerate(cell_names)} # Identify control and perturbation cells obs = adata.obs if "perturbation_covariates" in obs.columns: is_control = obs["perturbation_covariates"].str.contains("control", case=False) elif "treatment" in obs.columns: is_control = obs["treatment"] == "control" else: raise ValueError("Cannot identify control cells from adata.obs columns") ctrl_names = list(obs.index[is_control]) pert_names = list(obs.index[~is_control]) # Filter to cells that exist in the HDF5 ctrl_names = [n for n in ctrl_names if n in name_to_idx] pert_names = [n for n in pert_names if n in name_to_idx] print(f"Delta stats: {len(ctrl_names)} control, {len(pert_names)} perturbation cells") n_pairs = min(n_pairs, len(ctrl_names), len(pert_names)) ctrl_sample = rng.choice(ctrl_names, n_pairs, replace=True) pert_sample = rng.choice(pert_names, n_pairs, replace=True) # Compute deltas in chunks to manage memory chunk_size = 500 running_sum = None running_sq_sum = None total_count = 0 for start in tqdm(range(0, n_pairs, chunk_size), desc="Computing delta stats"): end = min(start + chunk_size, n_pairs) ctrl_idx = np.array([name_to_idx[n] for n in ctrl_sample[start:end]]) pert_idx = np.array([name_to_idx[n] for n in pert_sample[start:end]]) # Read from HDF5 (sorted for efficient access) ctrl_unique, ctrl_inv = np.unique(ctrl_idx, return_inverse=True) pert_unique, pert_inv = np.unique(pert_idx, return_inverse=True) ctrl_raw = h5_features[ctrl_unique.tolist()] # (U, G, D) fp16 pert_raw = h5_features[pert_unique.tolist()] ctrl_raw = ctrl_raw[ctrl_inv] # (chunk, G, D) pert_raw = pert_raw[pert_inv] # Delta: (chunk, G, D), only non-zero positions matter delta = (pert_raw.astype(np.float32) - ctrl_raw.astype(np.float32)) # Flatten to (chunk * G, D), then filter non-zero rows delta_flat = delta.reshape(-1, delta.shape[-1]) nonzero_mask = np.abs(delta_flat).sum(axis=-1) > 0 delta_valid = delta_flat[nonzero_mask] if delta_valid.shape[0] == 0: continue if running_sum is None: running_sum = delta_valid.sum(axis=0) running_sq_sum = (delta_valid ** 2).sum(axis=0) else: running_sum += delta_valid.sum(axis=0) running_sq_sum += (delta_valid ** 2).sum(axis=0) total_count += delta_valid.shape[0] mean = running_sum / total_count var = running_sq_sum / total_count - mean ** 2 var = np.maximum(var, 1e-8) # floor print(f"Delta stats computed from {total_count} non-zero entries") print(f" mean range: [{mean.min():.6f}, {mean.max():.6f}]") print(f" std range: [{np.sqrt(var).min():.6f}, {np.sqrt(var).max():.6f}]") return mean.astype(np.float32), var.astype(np.float32) def main(): parser = argparse.ArgumentParser(description="Precompute scGPT attention features") parser.add_argument("--data-name", type=str, default="norman") parser.add_argument("--n-top-genes", type=int, default=5000) parser.add_argument("--fold", type=int, default=1) parser.add_argument("--split-method", type=str, default="additive") parser.add_argument("--topk", type=int, default=30) parser.add_argument("--use-negative-edge", action="store_true", default=True) parser.add_argument("--scgpt-model-dir", type=str, default="transfer/data/scGPT_pretrained") parser.add_argument("--max-seq-len", type=int, default=5000, help="scGPT max_seq_len, must be >= n_valid_genes + 1") parser.add_argument("--attn-layer", type=int, default=11) parser.add_argument("--attn-use-rank-norm", action="store_true", default=True) parser.add_argument("--batch-size", type=int, default=2, help="Batch size for extraction (rank norm is memory-intensive)") parser.add_argument("--output", type=str, default="cache/norman_attn_L11.h5") parser.add_argument("--n-delta-pairs", type=int, default=10000, help="Number of (ctrl, pert) pairs for delta stats") parser.add_argument("--device", type=str, default="cuda") args = parser.parse_args() device = torch.device(args.device if torch.cuda.is_available() else "cpu") print(f"Device: {device}") # === Data loading === Data, PerturbationDataset, TrainSampler, TestDataset = get_data_classes() scdfm_data_path = os.path.join(_REPO_ROOT, "scDFM", "data") data_manager = Data(scdfm_data_path) data_manager.load_data(args.data_name) # Convert var_names if needed if "gene_name" in data_manager.adata.var.columns and data_manager.adata.var_names[0].startswith("ENSG"): data_manager.adata.var_names = data_manager.adata.var["gene_name"].values data_manager.adata.var_names_make_unique() print(f"Converted var_names to gene symbols, sample: {list(data_manager.adata.var_names[:5])}") data_manager.process_data( n_top_genes=args.n_top_genes, split_method=args.split_method, fold=args.fold, use_negative_edge=args.use_negative_edge, k=args.topk, ) # Get all cell expression data adata = data_manager.adata N = adata.n_obs G_full = adata.n_vars print(f"Dataset: {N} cells × {G_full} genes") # === Build extractor === hvg_gene_names = list(adata.var_names) scgpt_model_dir = os.path.join( os.path.dirname(_REPO_ROOT), # transfer/ args.scgpt_model_dir.replace("transfer/", ""), ) extractor = FrozenScGPTExtractor( model_dir=scgpt_model_dir, hvg_gene_names=hvg_gene_names, device=device, max_seq_len=args.max_seq_len, target_std=1.0, warmup_batches=0, # no need for running stats ) extractor = extractor.to(device) extractor.eval() n_valid = (extractor.hvg_to_scgpt_id >= 0).sum().item() D = extractor.scgpt_d_model print(f"Valid genes in scGPT vocab: {n_valid}/{G_full}") print(f"Sequence length: {n_valid + 1} (with CLS), max_seq_len: {args.max_seq_len}") print(f"Feature dim: {D}") # === Create output HDF5 === output_path = os.path.join(_PROJECT_ROOT, args.output) os.makedirs(os.path.dirname(output_path), exist_ok=True) cell_names = list(adata.obs_names) # Get expression matrix X = adata.X if hasattr(X, "toarray"): # Sparse matrix — we'll convert per-batch is_sparse = True else: is_sparse = False print(f"Output: {output_path}") print(f"Estimated size: {N * G_full * D * 2 / 1e9:.1f} GB (fp16, uncompressed)") print(f"Batch size: {args.batch_size}, total batches: {(N + args.batch_size - 1) // args.batch_size}") with h5py.File(output_path, "w") as h5: # Pre-allocate datasets feat_ds = h5.create_dataset( "features", shape=(N, G_full, D), dtype="float16", chunks=(1, G_full, D), # chunk per cell for row-wise access ) h5.create_dataset("cell_names", data=np.array(cell_names, dtype="S")) # Placeholder for norm stats (will be filled after extraction) h5.create_dataset("norm_mean", shape=(D,), dtype="float32") h5.create_dataset("norm_var", shape=(D,), dtype="float32") # === Batch extraction === batch_size = args.batch_size for start in tqdm(range(0, N, batch_size), desc="Extracting features"): end = min(start + batch_size, N) if is_sparse: expr_np = X[start:end].toarray() else: expr_np = X[start:end] expr = torch.from_numpy(expr_np.astype(np.float32)).to(device) with torch.no_grad(): features = extract_per_cell_attn_features( extractor, expr, attn_layer=args.attn_layer, use_rank_norm=args.attn_use_rank_norm, ) # (B, G_full, D) # Store as fp16 feat_ds[start:end] = features.cpu().half().numpy() # === Compute delta normalization stats === print("\nComputing delta normalization statistics...") norm_mean, norm_var = compute_delta_stats( feat_ds, cell_names, adata, n_pairs=args.n_delta_pairs, ) h5["norm_mean"][:] = norm_mean h5["norm_var"][:] = norm_var print(f"\nDone! Output saved to {output_path}") if __name__ == "__main__": main()