hyperbolic-gcn-brain-network

name	hyperbolic-gcn-brain-network
description	Hyperbolic Graph Convolutional Network (Brain-HGCN) for brain functional network analysis using Lorentz model and signed aggregation for excitatory/inhibitory connections. Activation triggers: hyperbolic GNN, brain network, fMRI analysis, geometric deep learning, Lorentz model.

Brain-HGCN: Hyperbolic Graph Convolutional Network for Brain Functional Network Analysis

Geometric deep learning framework leveraging hyperbolic geometry and negatively curved space to model hierarchical brain network structures with high fidelity.

Metadata

• Source: arXiv:2509.14965 [cs.CV] (Accepted by ICASSP 2026)
• Authors: Junhao Jia, Yunyou Liu, Cheng Yang, Yifei Sun, Feiwei Qin, Changmiao Wang, Yong Peng
• Published: 2025-09-18

Core Methodology

Key Innovation

Standard Euclidean GNNs struggle to represent brain networks' hierarchical topologies without high distortion. Brain-HGCN leverages hyperbolic geometry (specifically the Lorentz model) to naturally embed hierarchical structures with minimal distortion, inspired by the tree-like organization of brain functional networks.

Technical Framework

1. Lorentz Model Foundation

• Manifold: $\mathbb{L}^n = {x \in \mathbb{R}^{n+1} : \langle x, x \rangle_\mathcal{L} = -1, x_0 > 0}$
• Lorentz Inner Product: $\langle x, y \rangle_\mathcal{L} = -x_0y_0 + \sum_{i=1}^n x_iy_i$
• Distance Metric: $d_\mathcal{L}(x, y) = \text{arccosh}(-\langle x, y \rangle_\mathcal{L})$

2. Hyperbolic Graph Attention Layer

• Operates directly in hyperbolic space
• Preserves hierarchical relationships
• Avoids distortion from Euclidean projections

3. Signed Aggregation Mechanism

• Excitatory connections: Positive weights (activation enhancement)
• Inhibitory connections: Negative weights (activation suppression)
• Distinct processing pathways preserve biological interpretation

4. Fréchet Mean Readout

• Geometrically principled graph-level aggregation
• Computes centroid in hyperbolic space
• Preserves hierarchical information during pooling

Implementation Guide

Prerequisites

• Python 3.8+
• PyTorch with autograd support
• geoopt or similar hyperbolic optimization library
• NumPy, SciPy, NetworkX

Step-by-Step Implementation

import torch
import torch.nn as nn
import torch.nn.functional as F
from geoopt import Lorentz  # Hyperbolic manifold operations
import geoopt.manifolds as manifolds

class BrainHGCN(nn.Module):
    """
    Brain-HGCN: Hyperbolic GCN for brain functional network analysis
    """
    def __init__(self, in_features, hidden_dim, num_classes, curvature=1.0):
        super().__init__()
        self.curvature = curvature
        self.manifold = Lorentz(k=curvature)  # Lorentz model with curvature k
        
        # Dimension of hyperbolic space (ambient dimension = hyperbolic_dim + 1)
        self.hyperbolic_dim = hidden_dim
        
        # Input transformation (Euclidean to Hyperbolic)
        self.input_proj = nn.Linear(in_features, hidden_dim)
        
        # Hyperbolic graph convolution layers
        self.hgc_layers = nn.ModuleList([
            HyperbolicGraphConv(hidden_dim, hidden_dim, self.manifold)
            for _ in range(2)
        ])
        
        # Signed aggregation for excitatory/inhibitory connections
        self.signed_agg = SignedAggregation(self.manifold)
        
        # Fréchet mean pooling
        self.frechet_pool = FrechetMeanPooling(self.manifold)
        
        
        .classifier = nn.Linear(hidden_dim, num_classes)
    
     ():
        
         .manifold.expmap0(x)
    
     ():
        
         .manifold.logmap0(x)
    
     ():
        
        
        
        
        
        h = .input_proj(x)
        h = .expmap0(h)  
        
        
         hgc_layer  .hgc_layers:
            h = hgc_layer(h, edge_index, edge_type)
            h = .manifold.expmap0(F.relu(.manifold.logmap0(h)))
        
        
        h_graph = .frechet_pool(h, batch)  
        
        
        h_euclidean = .logmap0(h_graph)
        
         .classifier(h_euclidean)

 (nn.Module):
    
     ():
        ().__init__()
        .manifold = manifold
        .linear = nn.Linear(in_dim, out_dim)
        
     ():
        
        src, dst = edge_index
        
        
        x_tangent = .manifold.logmap0(x)
        
        
        messages = x_tangent[src]
        
        
         edge_type   :
            messages = messages * edge_type.unsqueeze()
        
        
        aggr = torch.zeros_like(x_tangent)
        aggr.index_add_(, dst, messages)
        count = torch.bincount(dst, minlength=x.size()).().unsqueeze()
        aggr = aggr / (count + )
        
        
        aggr = .linear(aggr)
        
        
        out = .manifold.expmap0(aggr)
        
         out

 (nn.Module):
    
     ():
        ().__init__()
        .manifold = manifold
        
     ():
        
        excitatory_mask = edge_type > 
        inhibitory_mask = edge_type < 
        
        
        exc_src = edge_index[][excitatory_mask]
        exc_dst = edge_index[][excitatory_mask]
        
        
        inh_src = edge_index[][inhibitory_mask]
        inh_dst = edge_index[][inhibitory_mask]
        
        
         x  

 (nn.Module):
    
     ():
        ().__init__()
        .manifold = manifold
        .max_iter = max_iter
        
     ():
        
         batch  :
             .frechet_mean(x.unsqueeze()).squeeze()
        
        
        num_graphs = batch.().item() + 
        means = []
        
         i  (num_graphs):
            mask = batch == i
            x_graph = x[mask]
            mean = .frechet_mean(x_graph.unsqueeze())
            means.append(mean.squeeze())
        
         torch.stack(means)
    
     ():
        
        
        mean = .manifold.expmap0(x.mean(dim=, keepdim=))
        
         _  (.max_iter):
            
            v = .manifold.logmap(mean, x)
            
            
            v_mean = v.mean(dim=, keepdim=)
            
            
            mean = .manifold.expmap(mean, v_mean)
            
             v_mean.norm(dim=-).mean() < eps:
                
        
         mean

Constructing Brain Networks for HGCN

import numpy as np
import torch
from scipy import stats

def construct_brain_functional_network(fmri_time_series, atlas_regions, 
                                       correlation_threshold=0.5):
    """
    Construct functional brain network from fMRI time series
    
    Args:
        fmri_time_series: [num_regions, num_timepoints] BOLD signals
        atlas_regions: List of region names
        correlation_threshold: Threshold for binarizing connectivity
    
    Returns:
        edge_index: [2, num_edges] connectivity
        edge_type: [num_edges] 1 for excitatory, -1 for inhibitory
        node_features: [num_regions, feature_dim] regional features
    """
    num_regions = len(atlas_regions)
    
    # Compute correlation matrix (functional connectivity)
    corr_matrix = np.corrcoef(fmri_time_series)
    
    # Threshold to create edges
    edges = []
    edge_types = []
    
    for i in range(num_regions):
        for j in range(i+1, num_regions):
            if abs(corr_matrix[i, j]) > correlation_threshold:
                edges.append([i, j])
                edges.append([j, i])  # Undirected graph
                
                # Classify as excitatory or inhibitory
                edge_type = 1 if corr_matrix[i, j] > 0 else -1
                edge_types.extend([edge_type, edge_type])
    
    edge_index = torch.tensor(edges, dtype=torch.long).t()
    edge_type = torch.tensor(edge_types, dtype=torch.float)
    
    # Node features: regional time series statistics
    node_features = torch.tensor([
        [
            fmri_time_series[i].mean(),
            fmri_time_series[i].std(),
            stats.entropy(np.(fmri_time_series[i]) + ),
            np.percentile(fmri_time_series[i], ),
            np.percentile(fmri_time_series[i], )
        ]
         i  (num_regions)
    ], dtype=torch.)
    
     edge_index, edge_type, node_features

Applications

1. Psychiatric Disorder Classification

• Autism Spectrum Disorder (ASD): Classify ASD from healthy controls
• Major Depressive Disorder (MDD): Identify depression-related connectivity patterns
• Schizophrenia: Detect disrupted hierarchical organization
• ADHD: Characterize attention network alterations

2. Brain Network Hierarchy Analysis

• Hierarchical Modularity: Quantify multi-scale organization
• Hub Identification: Find connector and provincial hubs
• Network Resilience: Assess robustness to targeted attacks
• Developmental Trajectories: Track hierarchy changes across lifespan

3. Connectome Fingerprinting

• Individual Identification: Unique connectivity signatures
• Twin Studies: Genetic vs. environmental influences
• Longitudinal Tracking: Stability of individual differences

Pitfalls

1. Numerical Stability: Hyperbolic operations can be numerically unstable

   • Mitigation: Use tangent space operations, clamp values, check for NaN

2. Curvature Selection: Curvature parameter affects embedding quality

   • Mitigation: Treat curvature as learnable parameter or cross-validate

3. Computational Complexity: Fréchet mean computation is iterative

   • Mitigation: Limit iterations, use approximate methods for large graphs

4. Edge Type Assignment: fMRI correlations don't directly map to excitatory/inhibitory

   • Mitigation: Use structural connectivity (DWI) to inform sign, or learn from data

5. Small Sample Sizes: fMRI datasets often limited

   • Mitigation: Data augmentation, transfer learning, or self-supervised pretraining

Related Skills

• functional-connectivity-graph-neural-networks: Combining structural and functional connectivity
• brain-graph-neural: General GNN methods for brain networks
• geometry-aware-spiking-gnn: Geometric methods in spiking networks
• graph-laplacian-denoising: Denoising for brain connectivity

References

@article{jia2025brain,
  title={Brain-HGCN: A Hyperbolic Graph Convolutional Network for Brain Functional Network Analysis},
  author={Jia, Junhao and Liu, Yunyou and Yang, Cheng and Sun, Yifei and Qin, Feiwei and Wang, Changmiao and Peng, Yong},
  journal={arXiv preprint arXiv:2509.14965},
  year={2025},
  note={Accepted by ICASSP 2026}
}

Further Reading

• Hyperbolic Neural Networks: Ganea et al., "Hyperbolic Neural Networks" (NeurIPS 2018)
• Lorentz Model: Nickel & Kiela, "Learning Continuous Hierarchies in the Lorentz Model"
• Brain Hierarchy: Meunier et al., "Modular and Hierarchically Modular Organization of Brain Networks"