""" SparseDeltaCache — Returns sparse delta triplets (indices, values) for SVD projection. Each gene row's delta attention is computed across ALL G_full=5035 columns, then per-row top-K sparsification selects the K most important interactions. The SVD projection (delta @ W) happens on GPU, not here. Multi-process safe: each DataLoader worker lazily opens its own HDF5 handle. 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 SparseDeltaCache: """ Returns sparse delta triplets for GPU-side SVD projection. 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. Delta = tgt_dense - src_dense (full G_full columns, NOT G_sub) 5. Per-row top-K on G_full columns 6. Return (delta_values, delta_indices) sparse triplets """ def __init__(self, h5_path, delta_top_k=30): 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" SparseDeltaCache: {len(self.name_to_idx)} cells, " f"G_full={self.G_full}, K_sparse={self.K_sparse}, delta_topk={self.delta_top_k}") 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: 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. """ 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): """ Compute sparse delta attention triplets for SVD projection. 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 row indices device: target torch device (usually CPU for DataLoader workers) Returns: delta_values: (B, G_sub, delta_topk) float32 — top-K delta values per row delta_indices: (B, G_sub, delta_topk) int16 — column indices in G_full space """ 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) K = self.delta_top_k # Read sparse data from HDF5 (uses per-process handle) # gene_idx_np selects ROWS only — we keep all G_full columns 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_sparse) 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) # Output sparse triplets out_values = torch.zeros(B, G_sub, K, device=device) out_indices = torch.zeros(B, G_sub, K, dtype=torch.int16, device=device) # Process in chunks (100 rows per chunk) to limit memory chunk_size = 100 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_sparse) 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) # Delta on FULL G_full columns (no column subsetting!) delta = tgt_dense - src_dense # (B, c_len, G_full) # Per-row top-K on G_full columns _, topk_idx = delta.abs().topk(K, dim=-1) # (B, c_len, K) topk_vals = delta.gather(-1, topk_idx) # (B, c_len, K) out_values[:, c_start:c_end, :] = topk_vals out_indices[:, c_start:c_end, :] = topk_idx.short() return out_values, out_indices # (B, G_sub, K) float32, (B, G_sub, K) int16 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()