multi-view-o-information-brain-dynamics

name

multi-view-o-information-brain-dynamics

description

Multi-view O-Information framework for analyzing higher-order brain interactions in fMRI data. Combines O-information measures with information bottleneck principles for psychiatric diagnosis. Includes O-information computation, Gaussian approximation, and Rényi entropy estimators. Activation: O-information brain, higher-order brain interactions, multi-view brain connectivity, O-information dynamics, brain synergy redundancy, psychiatric diagnosis fMRI.

Multi-View O-Information Framework for Brain Dynamics

Overview

This skill implements the Multi-View O-Information Framework for analyzing higher-order interactions (HOIs) in brain networks from fMRI data. Traditional brain connectivity analysis relies on pairwise connections, but higher-order interactions (triadic, tetradic) are central to complex brain dynamics. This framework uses O-information (a signed measure) to characterize whether interactions are synergy-dominated or redundancy-dominated.

Key Concepts

O-Information (Synergy vs. Redundancy)

O-information quantifies the nature of higher-order interactions:

• Positive O-information: Redundancy-dominated (shared information)
• Negative O-information: Synergy-dominated (emergent information)
• Near zero: Independent contributions

Multi-View Architecture

Integrates three views of brain connectivity:

1. Pairwise View: Traditional pairwise functional connectivity
2. Triadic View: Third-order (three-region) interactions
3. Tetradic View: Fourth-order (four-region) interactions

Mathematical Framework

O-Information Definition

For a set of N variables, O-information is defined as:

Ω(X₁, ..., Xₙ) = (n-2) · H({Xᵢ}) - Σᵢ H(Xᵢ | X_{\i})

Where:

• H({Xᵢ}): Joint entropy of all variables
• H(Xᵢ | X_{\i}): Conditional entropy of variable i given all others

Interpretation:

• Ω > 0: Redundancy dominates
• Ω < 0: Synergy dominates
• Ω ≈ 0: Mixed or independent

Information Bottleneck Framework

The multi-view architecture uses information bottleneck principles:

L = Σᵢ αᵢ · I(Z; Y|Vᵢ) - β · Σᵢⱼ I(Vᵢ; Vⱼ)

Where:

• Vᵢ: View i (pairwise, triadic, tetradic)
• Z: Latent representation
• Y: Diagnosis label
• I(Vᵢ; Vⱼ): Mutual information between views (redundancy penalty)

Implementation

O-Information Computation

import numpy as np
from scipy import stats
from scipy.spatial.distance import cdist
import torch
import torch.nn as nn

class OInformationCalculator:
    """
    O-Information calculator for higher-order brain interactions
    
    Implements both exact computation (Gaussian) and 
    approximate methods (Rényi entropy estimator)
    """
    def __init__(self, method='gaussian', n_bootstrap=100):
        """
        Args:
            method: 'gaussian' for analytical, 'renyi' for estimator
            n_bootstrap: Number of bootstrap samples for Rényi method
        """
        self.method = method
        self.n_bootstrap = n_bootstrap
        
    def compute_joint_entropy_gaussian(self, X: np.ndarray) -> float:
        """
        Compute joint entropy assuming Gaussian distribution
        
        H(X) = 0.5 * log((2πe)^d · |Σ|)
        
        Args:
            X: Data matrix (samples × dimensions)
            
        Returns:
            Joint entropy in nats
        """
        n_samples, n_vars = X.shape
        
        # Compute covariance matrix
        cov = np.cov(X.T)
        
        # Add small regularization for stability
        cov += np.eye(n_vars) * 1e-6
        
        # Compute determinant
        sign, logdet = np.linalg.slogdet(cov)
        if sign <= 0:
            # Add more regularization if needed
            cov += np.eye(n_vars) * 1e-4
            sign, logdet = np.linalg.slogdet(cov)
        
        # Entropy of Gaussian: 0.5 * log((2πe)^d * |Σ|)
        d = n_vars
        entropy =  * (d * np.log( * np.pi * np.e) + logdet)
        
         entropy
        
     () -> :
        
        n_vars = X.shape[]
        
        
        joint_H = .compute_joint_entropy_gaussian(X)
        
        
        others_idx = [i  i  (n_vars)  i != target_idx]
        X_others = X[:, others_idx]
        marginal_H = .compute_joint_entropy_gaussian(X_others)
        
        
        conditional_H = joint_H - marginal_H
        
         conditional_H
        
     () -> :
        
        n_samples, n_vars = X.shape
        
        
        joint_entropy = .compute_joint_entropy_gaussian(X)
        
        
        conditional_sum = 
         i  (n_vars):
            cond_H = .compute_conditional_entropy_gaussian(X, i)
            conditional_sum += cond_H
        
        
        o_info = (n_vars - ) * joint_entropy - conditional_sum
        
         o_info
        
     () -> :
        
        n_samples = X.shape[]
        
        
        dists = cdist(X, X, metric=)
        
        
        sigma = np.median(dists) / np.sqrt()  
        K = np.exp(-dists** / ( * sigma**))
        
        
        K = K / K.(axis=, keepdims=)
        
        
        
        K_power = np.linalg.matrix_power(K, (alpha))
        trace = np.trace(K_power)
        
        entropy = ( / ( - alpha)) * np.log(trace + )
        
         entropy

 :
    
     ():
        
        .n_regions = n_regions
        .order = order
        .calculator = OInformationCalculator(method=)
        
        
         itertools  combinations
        .region_combinations = (combinations((n_regions), order))
        
     () -> np.ndarray:
        
        n_timepoints = fmri_data.shape[-]
        time_series = np.zeros((n_timepoints, .n_regions))
        
         region_idx  (.n_regions):
            mask = (atlas_labels == region_idx)
             mask.() > :
                time_series[:, region_idx] = fmri_data[mask].mean(axis=)
        
        
        time_series = (time_series - time_series.mean(axis=)) / \
                      (time_series.std(axis=) + )
        
         time_series
        
     () -> np.ndarray:
        
        oi_values = []
        
         regions  .region_combinations:
            
            X = time_series[:, (regions)]
            
            
            oi = .calculator.compute_o_information_gaussian(X)
            oi_values.append(oi)
        
         np.array(oi_values)

Multi-View Information Bottleneck Network

class MultiViewOInformationNet(nn.Module):
    """
    Tri-view neural network for multi-modal brain connectivity analysis
    Fuses pairwise, triadic, and tetradic O-information
    """
    def __init__(
        self,
        n_regions: int,
        hidden_dim: int = 256,
        n_classes: int = 2,
        dropout: float = 0.5
    ):
        super().__init__()
        
        self.n_regions = n_regions
        self.hidden_dim = hidden_dim
        
        # Pairwise view encoder
        n_pairwise = n_regions * (n_regions - 1) // 2
        self.pairwise_encoder = nn.Sequential(
            nn.Linear(n_pairwise, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU()
        )
        
        # Triadic view encoder (3rd order O-information)
        n_triadic = len(list(itertools.combinations(range(n_regions), 3)))
        self.triadic_encoder = nn.Sequential(
            nn.Linear(n_triadic, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU()
        )
        
        # Tetradic view encoder (4th order O-information)
        n_tetradic = len(list(itertools.combinations(range(n_regions), 4)))
        self.tetradic_encoder = nn.Sequential(
            nn.Linear(n_tetradic, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // ),
            nn.ReLU()
        )
        
        
        view_dim = hidden_dim // 
        .fusion = nn.Sequential(
            nn.Linear(view_dim * , hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // ),
            nn.ReLU()
        )
        
        
        .classifier = nn.Linear(hidden_dim // , n_classes)
        
     () -> torch.Tensor:
        
        
        z_pairwise = .pairwise_encoder(pairwise_features)
        z_triadic = .triadic_encoder(triadic_features)
        z_tetradic = .tetradic_encoder(tetradic_features)
        
        
        z_fused = torch.cat([z_pairwise, z_triadic, z_tetradic], dim=)
        
        
        z = .fusion(z_fused)
        
        
        logits = .classifier(z)
        
         logits

 (nn.Module):
    
     ():
        ().__init__()
        .beta = beta
        
     () -> torch.Tensor:
        
        
        ce_loss = F.cross_entropy(z, labels)
        
        
        redundancy = 
         i  ((views)):
             j  (i+, (views)):
                
                redundancy += torch.mean((views[i] - views[j])**)
        
        total_loss = ce_loss + .beta * redundancy
        
         total_loss

Usage Pipeline

Complete Analysis Workflow

def analyze_brain_hois(
    fmri_files: List[str],
    atlas_file: str,
    labels: np.ndarray,
    n_regions: int = 116  # AAL atlas
) -> dict:
    """
    Complete pipeline for higher-order brain interaction analysis
    
    Args:
        fmri_files: List of fMRI data files
        atlas_file: Atlas parcellation file
        labels: Diagnostic labels
        n_regions: Number of brain regions
        
    Returns:
        Results dictionary with HOI features and model
    """
    from nilearn import image, datasets
    
    # Load atlas
    atlas_img = image.load_img(atlas_file)
    atlas_data = atlas_img.get_fdata()
    
    # Initialize analyzers
    pairwise_analyzer = PairwiseConnectivity(n_regions)
    triadic_analyzer = BrainOInformationAnalyzer(n_regions, order=3)
    tetradic_analyzer = BrainOInformationAnalyzer(n_regions, order=4)
    
    features = {
        'pairwise': [],
        'triadic': [],
        'tetradic': []
    }
    
    # Process each subject
    for fmri_file in fmri_files:
        # Load fMRI data
        fmri_img = image.load_img(fmri_file)
        fmri_data = fmri_img.get_fdata()
        
        # Extract time series
        time_series = triadic_analyzer.extract_roi_timeseries(
            fmri_data, atlas_data
        )
        
        # Compute features
        pairwise_conn = pairwise_analyzer.compute(time_series)
        triadic_oi = triadic_analyzer.compute_hoi_matrix(time_series)
        tetradic_oi = tetradic_analyzer.compute_hoi_matrix(time_series)
        
        features['pairwise'].append(pairwise_conn)
        features['triadic'].append(triadic_oi)
        features['tetradic'].append(tetradic_oi)
    
    # Convert to arrays
    for key  features:
        features[key] = np.array(features[key])
    
    
    model = MultiViewOInformationNet(n_regions)
    
    
    
    
     {
        : features,
        : model,
        : interpret_hois(features)
    }

 () -> :
    
    interpretation = {}
    
    
    triadic_mean = features[].mean(axis=)
    synergy_regions = np.where(triadic_mean < -)[]  
    redundancy_regions = np.where(triadic_mean > )[]  
    
    interpretation[] = synergy_regions
    interpretation[] = redundancy_regions
    
    
    tetradic_mean = features[].mean(axis=)
    interpretation[] = np.where(tetradic_mean < -)[]
    interpretation[] = np.where(tetradic_mean > )[]
    
     interpretation

Performance Metrics

From paper evaluation on benchmark datasets:

Dataset	Baseline SOTA	Multi-View O-Info	Improvement
REST-meta-MDD	0.72 AUC	0.78 AUC	+8.3%
ABIDE	0.75 AUC	0.81 AUC	+8.0%
UCLA	0.70 AUC	0.76 AUC	+8.6%
ADNI	0.73 AUC	0.79 AUC	+8.2%

Computational Speedup:

• Gaussian approximation: ~30x faster than conventional estimators
• Rényi matrix estimator: Additional 2x speedup

Applications

• Psychiatric Diagnosis: MDD, ASD, ADHD classification
• Neurodegenerative Disease: Alzheimer's, Parkinson's
• Brain Network Analysis: Understanding complex interactions
• Biomarker Discovery: Synergy/redundancy patterns as features

References

• Paper: "Modeling Higher-Order Brain Interactions via a Multi-View Information Bottleneck Framework for fMRI-based Psychiatric Diagnosis" (arXiv:2604.17713)
• Authors: Zhang et al., 2026
• Categories: cs.LG

Related Skills

• brain-higher-order-structures: Topological data analysis for brain networks
• brain-graph-neural: Graph neural networks for brain connectivity
• functional-connectome-fingerprint: Individual brain fingerprinting

Last updated: 2026-04-27