GRN/grn_ccfm/scripts/precompute_attn_features.py

"""
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()