Datasets:

PoorOtterBob
/

AutOmicScience-Reference

Tags:

License:

Dataset card Files Files and versions

xet

Community

AutOmicScience-Reference / external /SEA-AD /MJM /src /models /spatial_gnn.py

PoorOtterBob

Add files using upload-large-folder tool

653040f verified 5 months ago

Raw History Blame Contribute Delete

5.86 kB

"""
STELLAR-like Spatial GNN for hierarchical cell annotation.
Architecture:
  1. Build KNN spatial graph (precomputed)
  2. Gene expression encoder (Linear → hidden)
  3. GCN message passing layers (aggregate neighbor features)
  4. Hierarchical classification heads (same residual design as mjm_1)
  5. Reconstruction decoder
The spatial graph encodes cell neighborhood structure — cells that are
physically close share information through message passing, compensating
for the limited gene panel in MERFISH data.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from scipy.spatial import cKDTree


# ── Graph construction ──────────────────────────────────────────────────────

def build_knn_graph(spatial_coords, k=15):
    """
    Build a KNN spatial graph from 2D coordinates.
    Returns edge_index [2, E] as a LongTensor (COO format).
    """
    tree = cKDTree(spatial_coords)
    _, indices = tree.query(spatial_coords, k=k + 1)  # +1 because self is included
    n = len(spatial_coords)
    src = np.repeat(np.arange(n), k)
    dst = indices[:, 1:].flatten()  # exclude self-loop
    edge_index = np.stack([src, dst], axis=0)
    return torch.from_numpy(edge_index).long()


# ── GCN Layer (pure PyTorch) ────────────────────────────────────────────────

class GCNConv(nn.Module):
    """Simple GCN convolution: h' = D^{-1} A X W + b (mean aggregation)."""
    def __init__(self, in_dim, out_dim):
        super().__init__()
        self.linear = nn.Linear(in_dim, out_dim)

    def forward(self, x, edge_index):
        """
        x: [N, in_dim]
        edge_index: [2, E] (src → dst)
        """
        src, dst = edge_index
        N = x.size(0)

        # Transform
        h = self.linear(x)  # [N, out_dim]

        # Aggregate (mean of neighbors)
        # Use scatter_mean via index_add
        agg = torch.zeros_like(h)
        agg.index_add_(0, dst, h[src])

        # Degree normalization
        deg = torch.zeros(N, device=x.device)
        deg.index_add_(0, dst, torch.ones(dst.size(0), device=x.device))
        deg = deg.clamp(min=1).unsqueeze(-1)
        agg = agg / deg

        return agg


# ── Spatial GNN Model ───────────────────────────────────────────────────────

class SpatialGNN(nn.Module):
    """
    STELLAR-inspired spatial GNN for hierarchical cell annotation.
    Pipeline:
        X [B, 140] → gene_encoder → h0 [B, hidden]
        h0 → GCN_1 → h1 → GCN_2 → h2 (spatial context aggregation)
        h2 → head_class    → logits_class [B, 3]
        h2 → head_subclass → logits_subclass [B, 24]  (+ residual from class)
        h2 → head_supertype→ logits_supertype [B, 137] (+ residual from subclass)
        h2 → recon_decoder → x_hat [B, 140]
    """
    def __init__(self,
                 input_dim=140,
                 hidden_dim=256,
                 latent_dim=128,
                 n_gcn_layers=2,
                 dropout=0.3,
                 output_num=[3, 24, 137]):
        super().__init__()

        # Gene expression encoder
        self.gene_encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.LayerNorm(hidden_dim),
            nn.SiLU(),
            nn.Dropout(dropout),
        )

        # GCN layers
        self.gcn_layers = nn.ModuleList()
        self.gcn_norms = nn.ModuleList()
        for _ in range(n_gcn_layers):
            self.gcn_layers.append(GCNConv(hidden_dim, hidden_dim))
            self.gcn_norms.append(nn.LayerNorm(hidden_dim))
        self.gcn_dropout = nn.Dropout(dropout)

        # Projection to latent
        self.to_latent = nn.Linear(hidden_dim, latent_dim)

        # Hierarchical classification heads (with cross-level feature residual)
        dec_dim = latent_dim
        self.dec1 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))
        self.dec2 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))
        self.dec3 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))

        self.head1 = nn.Linear(dec_dim, output_num[0])
        self.head2 = nn.Linear(dec_dim, output_num[1])
        self.head3 = nn.Linear(dec_dim, output_num[2])

        # Reconstruction
        self.recon_decoder = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim),
            nn.SiLU(),
            nn.Linear(hidden_dim, input_dim),
        )

    def forward(self, x, edge_index):
        """
        Args:
            x: [N, input_dim] gene expression (log1p normalized)
            edge_index: [2, E] spatial KNN graph
        Returns:
            recon: [N, input_dim]
            logits: [logits_class, logits_subclass, logits_supertype]
            z: [N, latent_dim]
        """
        # Encode gene expression
        h = self.gene_encoder(x)

        # GCN message passing with residual connections
        for gcn, norm in zip(self.gcn_layers, self.gcn_norms):
            h_new = gcn(h, edge_index)
            h = norm(h + h_new)  # residual + norm
            h = F.silu(h)
            h = self.gcn_dropout(h)

        # Project to latent
        z = self.to_latent(h)

        # Hierarchical decoding with feature residuals
        c1 = self.dec1(z)
        logits1 = self.head1(c1)

        c2 = self.dec2(z) + c1
        logits2 = self.head2(c2)

        c3 = self.dec3(z) + c2
        logits3 = self.head3(c3)

        # Reconstruction
        recon = self.recon_decoder(z)

        return recon, [logits1, logits2, logits3], z

	"""
	STELLAR-like Spatial GNN for hierarchical cell annotation.

	Architecture:
	1. Build KNN spatial graph (precomputed)
	2. Gene expression encoder (Linear → hidden)
	3. GCN message passing layers (aggregate neighbor features)
	4. Hierarchical classification heads (same residual design as mjm_1)
	5. Reconstruction decoder

	The spatial graph encodes cell neighborhood structure — cells that are
	physically close share information through message passing, compensating
	for the limited gene panel in MERFISH data.
	"""
	import torch
	import torch.nn as nn
	import torch.nn.functional as F
	import numpy as np
	from scipy.spatial import cKDTree


	# ── Graph construction ──────────────────────────────────────────────────────

	def build_knn_graph(spatial_coords, k=15):
	"""
	Build a KNN spatial graph from 2D coordinates.
	Returns edge_index [2, E] as a LongTensor (COO format).
	"""
	tree = cKDTree(spatial_coords)
	_, indices = tree.query(spatial_coords, k=k + 1) # +1 because self is included
	n = len(spatial_coords)
	src = np.repeat(np.arange(n), k)
	dst = indices[:, 1:].flatten() # exclude self-loop
	edge_index = np.stack([src, dst], axis=0)
	return torch.from_numpy(edge_index).long()


	# ── GCN Layer (pure PyTorch) ────────────────────────────────────────────────

	class GCNConv(nn.Module):
	"""Simple GCN convolution: h' = D^{-1} A X W + b (mean aggregation)."""
	def __init__(self, in_dim, out_dim):
	super().__init__()
	self.linear = nn.Linear(in_dim, out_dim)

	def forward(self, x, edge_index):
	"""
	x: [N, in_dim]
	edge_index: [2, E] (src → dst)
	"""
	src, dst = edge_index
	N = x.size(0)

	# Transform
	h = self.linear(x) # [N, out_dim]

	# Aggregate (mean of neighbors)
	# Use scatter_mean via index_add
	agg = torch.zeros_like(h)
	agg.index_add_(0, dst, h[src])

	# Degree normalization
	deg = torch.zeros(N, device=x.device)
	deg.index_add_(0, dst, torch.ones(dst.size(0), device=x.device))
	deg = deg.clamp(min=1).unsqueeze(-1)
	agg = agg / deg

	return agg


	# ── Spatial GNN Model ───────────────────────────────────────────────────────

	class SpatialGNN(nn.Module):
	"""
	STELLAR-inspired spatial GNN for hierarchical cell annotation.

	Pipeline:
	X [B, 140] → gene_encoder → h0 [B, hidden]
	h0 → GCN_1 → h1 → GCN_2 → h2 (spatial context aggregation)
	h2 → head_class → logits_class [B, 3]
	h2 → head_subclass → logits_subclass [B, 24] (+ residual from class)
	h2 → head_supertype→ logits_supertype [B, 137] (+ residual from subclass)
	h2 → recon_decoder → x_hat [B, 140]
	"""
	def __init__(self,
	input_dim=140,
	hidden_dim=256,
	latent_dim=128,
	n_gcn_layers=2,
	dropout=0.3,
	output_num=[3, 24, 137]):
	super().__init__()

	# Gene expression encoder
	self.gene_encoder = nn.Sequential(
	nn.Linear(input_dim, hidden_dim),
	nn.LayerNorm(hidden_dim),
	nn.SiLU(),
	nn.Dropout(dropout),
	)

	# GCN layers
	self.gcn_layers = nn.ModuleList()
	self.gcn_norms = nn.ModuleList()
	for _ in range(n_gcn_layers):
	self.gcn_layers.append(GCNConv(hidden_dim, hidden_dim))
	self.gcn_norms.append(nn.LayerNorm(hidden_dim))
	self.gcn_dropout = nn.Dropout(dropout)

	# Projection to latent
	self.to_latent = nn.Linear(hidden_dim, latent_dim)

	# Hierarchical classification heads (with cross-level feature residual)
	dec_dim = latent_dim
	self.dec1 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))
	self.dec2 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))
	self.dec3 = nn.Sequential(nn.Linear(dec_dim, dec_dim), nn.SiLU(), nn.Dropout(dropout))

	self.head1 = nn.Linear(dec_dim, output_num[0])
	self.head2 = nn.Linear(dec_dim, output_num[1])
	self.head3 = nn.Linear(dec_dim, output_num[2])

	# Reconstruction
	self.recon_decoder = nn.Sequential(
	nn.Linear(latent_dim, hidden_dim),
	nn.SiLU(),
	nn.Linear(hidden_dim, input_dim),
	)

	def forward(self, x, edge_index):
	"""
	Args:
	x: [N, input_dim] gene expression (log1p normalized)
	edge_index: [2, E] spatial KNN graph
	Returns:
	recon: [N, input_dim]
	logits: [logits_class, logits_subclass, logits_supertype]
	z: [N, latent_dim]
	"""
	# Encode gene expression
	h = self.gene_encoder(x)

	# GCN message passing with residual connections
	for gcn, norm in zip(self.gcn_layers, self.gcn_norms):
	h_new = gcn(h, edge_index)
	h = norm(h + h_new) # residual + norm
	h = F.silu(h)
	h = self.gcn_dropout(h)

	# Project to latent
	z = self.to_latent(h)

	# Hierarchical decoding with feature residuals
	c1 = self.dec1(z)
	logits1 = self.head1(c1)

	c2 = self.dec2(z) + c1
	logits2 = self.head2(c2)

	c3 = self.dec3(z) + c2
	logits3 = self.head3(c3)

	# Reconstruction
	recon = self.recon_decoder(z)

	return recon, [logits1, logits2, logits3], z