lfj-code / GRN /regfm /src /data /sparse_raw_cache.py

Upload folder using huggingface_hub

9f5e507 verified 7 months ago

7.62 kB

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

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