GRN/regfm/src/data/sparse_raw_cache.py

"""
SparseRawDeltaCache — Reconstructs raw Δ_attn (B, G_sub, G_sub) from sparse attention cache.

No scGPT forward required. No normalization needed (rank-normed values in [0,1], delta in [-1,1]).

Multi-process safe: each DataLoader worker lazily opens its own HDF5 handle (PID-based detection).

HDF5 layout (from precompute_sparse_attn.py):
    /attn_values        (N, G_full, K) float16  — top-K attention values per row
    /attn_indices       (N, G_full, K) int16    — column indices in G_full space
    /cell_names         (N,) string
    /valid_gene_mask    (G_full,) bool
"""

import os
import h5py
import numpy as np
import torch


def _read_sparse_batch(h5_values, h5_indices, name_to_idx,
                       src_cell_names, tgt_cell_names, gene_idx_np=None):
    """
    Shared HDF5 reading logic for sparse caches.

    Returns:
        src_vals, src_idxs, tgt_vals, tgt_idxs: numpy arrays (B, G_sub, K)
    """
    seen = {}
    unique_names = []
    for n in src_cell_names + tgt_cell_names:
        if n not in seen:
            seen[n] = len(unique_names)
            unique_names.append(n)

    unique_h5_idx = [name_to_idx[n] for n in unique_names]
    sorted_order = np.argsort(unique_h5_idx)
    sorted_h5_idx = [unique_h5_idx[i] for i in sorted_order]

    raw_vals = h5_values[sorted_h5_idx]
    raw_idxs = h5_indices[sorted_h5_idx]

    unsort = np.argsort(sorted_order)
    raw_vals = raw_vals[unsort]
    raw_idxs = raw_idxs[unsort]

    if gene_idx_np is not None:
        raw_vals = raw_vals[:, gene_idx_np, :]
        raw_idxs = raw_idxs[:, gene_idx_np, :]

    src_map = [seen[n] for n in src_cell_names]
    tgt_map = [seen[n] for n in tgt_cell_names]
    return raw_vals[src_map], raw_idxs[src_map], raw_vals[tgt_map], raw_idxs[tgt_map]


class SparseRawDeltaCache:
    """
    Reconstructs raw Δ_attn (B, G_sub, G_sub) from sparse attention cache.

    Multi-process safe: HDF5 handles are lazily opened per-process (PID-tracked).
    Safe for use in DataLoader workers with persistent_workers=True.

    Lookup flow:
    1. Read src/tgt sparse attention: (G_full, K=300) values + indices
    2. Select gene subset rows
    3. Scatter to dense: (B, G_sub, G_full) — chunked to avoid OOM
    4. Select columns: (B, G_sub, G_sub)
    5. Delta = tgt_dense - src_dense -> (B, G_sub, G_sub)
    """

    def __init__(self, h5_path, delta_top_k=None):
        self.h5_path = h5_path
        self.delta_top_k = delta_top_k

        # Read metadata only, then close — safe for fork
        with h5py.File(h5_path, "r") as h5:
            self.G_full = h5["attn_values"].shape[1]
            self.K_sparse = h5["attn_values"].shape[2]
            cell_names = h5["cell_names"].asstr()[:]
            self.name_to_idx = {name: i for i, name in enumerate(cell_names)}
            if "valid_gene_mask" in h5:
                self.valid_gene_mask = h5["valid_gene_mask"][:].astype(bool)
            else:
                self.valid_gene_mask = np.ones(self.G_full, dtype=bool)

        # Per-process HDF5 handle (lazily opened)
        self._h5 = None
        self._attn_values = None
        self._attn_indices = None
        self._pid = None

        print(f"  SparseRawDeltaCache: {len(self.name_to_idx)} cells, "
              f"G_full={self.G_full}, K_sparse={self.K_sparse}")
        print(f"  valid genes: {self.valid_gene_mask.sum()}/{self.G_full}")

    def _ensure_h5_open(self):
        """Ensure current process has its own HDF5 file handle."""
        pid = os.getpid()
        if self._h5 is None or self._pid != pid:
            # PID changed (fork) or first access — close stale handle, open new one
            if self._h5 is not None:
                try:
                    self._h5.close()
                except Exception:
                    pass
            self._h5 = h5py.File(self.h5_path, "r")
            self._attn_values = self._h5["attn_values"]
            self._attn_indices = self._h5["attn_indices"]
            self._pid = pid

    def get_missing_gene_mask(self, gene_indices=None):
        """
        Return missing gene mask (True = missing/invalid).
        Pure numpy operation — no HDF5 I/O needed.

        Args:
            gene_indices: (G_sub,) tensor or None (all genes)

        Returns:
            (G_sub,) or (G_full,) bool tensor — True where gene is missing
        """
        mask = torch.from_numpy(~self.valid_gene_mask)  # True = missing
        if gene_indices is not None:
            return mask[gene_indices.cpu()]
        return mask

    def lookup_delta(self, src_cell_names, tgt_cell_names, gene_indices, device=None):
        """
        Reconstruct raw Δ_attn (B, G_sub, G_sub) from sparse cache.

        Args:
            src_cell_names: list of str, control cell identifiers
            tgt_cell_names: list of str, perturbation cell identifiers
            gene_indices: (G_sub,) tensor, gene subset indices
            device: target torch device

        Returns:
            (B, G_sub, G_sub) tensor — raw delta attention, values in [-1, 1]
        """
        self._ensure_h5_open()

        if device is None:
            device = torch.device("cpu")

        B = len(src_cell_names)
        gene_idx_np = gene_indices.cpu().numpy()
        G_sub = len(gene_idx_np)

        # Read sparse data from HDF5 (uses per-process handle)
        sv_np, si_np, tv_np, ti_np = _read_sparse_batch(
            self._attn_values, self._attn_indices, self.name_to_idx,
            src_cell_names, tgt_cell_names, gene_idx_np)

        src_vals = torch.from_numpy(sv_np.astype(np.float32)).to(device)  # (B, G_sub, K)
        src_idxs = torch.from_numpy(si_np.astype(np.int64)).to(device)
        tgt_vals = torch.from_numpy(tv_np.astype(np.float32)).to(device)
        tgt_idxs = torch.from_numpy(ti_np.astype(np.int64)).to(device)

        # Process in chunks (100 rows per chunk) to limit memory
        chunk_size = 100
        output = torch.zeros(B, G_sub, G_sub, device=device)

        for c_start in range(0, G_sub, chunk_size):
            c_end = min(c_start + chunk_size, G_sub)

            sv = src_vals[:, c_start:c_end, :]  # (B, c_len, K)
            si = src_idxs[:, c_start:c_end, :]
            tv = tgt_vals[:, c_start:c_end, :]
            ti = tgt_idxs[:, c_start:c_end, :]
            c_len = c_end - c_start

            # Scatter sparse entries to dense attention rows: (B, c_len, G_full)
            src_dense = torch.zeros(B, c_len, self.G_full, device=device)
            tgt_dense = torch.zeros(B, c_len, self.G_full, device=device)
            src_dense.scatter_(-1, si, sv)
            tgt_dense.scatter_(-1, ti, tv)

            # Select columns for gene subset + compute delta
            delta = tgt_dense[:, :, gene_idx_np] - src_dense[:, :, gene_idx_np]  # (B, c_len, G_sub)

            # Per-row top-K sparsification on delta
            if self.delta_top_k is not None and self.delta_top_k < delta.size(-1):
                _, topk_idx = delta.abs().topk(self.delta_top_k, dim=-1)
                sparse_delta = torch.zeros_like(delta)
                sparse_delta.scatter_(-1, topk_idx, delta.gather(-1, topk_idx))
                delta = sparse_delta

            output[:, c_start:c_end, :] = delta

        return output  # (B, G_sub, G_sub), values in [-1, 1]

    def close(self):
        if self._h5 is not None:
            try:
                self._h5.close()
            except Exception:
                pass
            self._h5 = None
            self._attn_values = None
            self._attn_indices = None

    def __del__(self):
        self.close()