Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install hiyenwong-ai-collection-collection-skills-connectomediffuser-dti-brain-networkgit clone https://github.com/hiyenwong/ai_collection.gitcp ai_collection/SKILL.MD ~/.claude/skills/hiyenwong-ai-collection-collection-skills-connectomediffuser-dti-brain-network/SKILL.md---
name: connectomediffuser-generative-ai-for-brain-network
description: **Source:** arXiv:2505.22683
---
# ConnectomeDiffuser: Generative AI for Brain Network Construction
**Source:** arXiv:2505.22683
**Utility:** 0.94
**Created:** 2026-03-25
## Activation Keywords
- ConnectomeDiffuser
- DTI brain network construction
- diffusion model brain network
- generative AI brain connectivity
- DTI structural network
- automated brain network
## Description
A diffusion-based framework for automated end-to-end brain network construction from Diffusion Tensor Imaging (DTI), combining template networks, diffusion models, and GCN classifiers for improved neurodegenerative disease diagnosis.
## Core Methodology
### 1. Problem: Limitations of Existing DTI Analysis
**Challenges:**
- Operator subjectivity in network construction
- Labor-intensive workflows
- Limited capacity to capture complex topological features
- Restricted disease-specific biomarker detection
**Solution:** Automated, end-to-end generative AI pipeline
### 2. ConnectomeDiffuser Architecture
**Three Key Components:**
1. **Template Network**
- Extracts topological features from 3D DTI scans
- Uses Riemannian geometric principles
- Captures structural connectivity patterns
2. **Diffusion Model**
- Generates comprehensive brain networks
- Enhanced topological fidelity
- Captures broader structural connectivity
3. **GCN Classifier**
- Incorporates disease-specific markers
- Improves diagnostic accuracy
- Sensitive to individual variations
### 3. Key Innovations
- **End-to-end automation** - No manual intervention
- **Topology-aware generation** - Preserves structural features
- **Disease-specific optimization** - Biomarker-driven
- **Generalizable framework** - Multiple neurodegenerative conditions
## Implementation Framework
```python
# Conceptual ConnectomeDiffuser architecture
import torch
import torch.nn as nn
class TemplateNetwork(nn.Module):
"""
Extracts topological features from DTI using Riemannian geometry
"""
def __init__(self, in_channels=3, hidden_dim=64):
super().__init__()
# 3D convolution for DTI volumes
self.conv3d = nn.Sequential(
nn.Conv3d(in_channels, hidden_dim, kernel_size=3, padding=1),
nn.BatchNorm3d(hidden_dim),
nn.ReLU(),
nn.Conv3d(hidden_dim, hidden_dim * 2, kernel_size=3, padding=1),
nn.BatchNorm3d(hidden_dim * 2),
nn.ReLU(),
)
# Riemannian feature extraction
self.riemannian_encoder = RiemannianEncoder(hidden_dim * 2)
def forward(self, dti_volume):
"""
Args:
dti_volume: [batch, 3, H, W, D] - DTI tensor components
Returns:
topological_features: [batch, feature_dim]
"""
features = self.conv3d(dti_volume)
topo_features = self.riemannian_encoder(features)
return topo_features
class BrainNetworkDiffusion(nn.Module):
"""
Diffusion model for brain network generation
"""
def __init__(self, node_dim, hidden_dim=128, num_steps=1000):
super().__init__()
self.num_steps = num_steps
# U-Net style denoiser
self.denoiser = nn.ModuleList([
nn.Linear(node_dim, hidden_dim),
nn.Linear(hidden_dim, hidden_dim),
nn.Linear(hidden_dim, node_dim)
])
# Time embedding
self.time_embed = nn.Sequential(
nn.Linear(1, hidden_dim),
nn.SiLU(),
nn.Linear(hidden_dim, hidden_dim)
)
def forward(self, adjacency, t, template_features):
"""
Denoise brain network at timestep t
Args:
adjacency: [batch, num_nodes, num_nodes] - Noisy adjacency
t: [batch] - Timestep
template_features: [batch, feature_dim] - Template guidance
Returns:
denoised: [batch, num_nodes, num_nodes]
"""
# Time conditioning
t_emb = self.time_embed(t.unsqueeze(-1).float() / self.num_steps)
# Denoise with template guidance
# ... (simplified)
return adjacency
def generate(self, template_features, num_nodes):
"""Generate brain network from template features"""
# Start from noise
adjacency = torch.randn(1, num_nodes, num_nodes)
# Iterative denoising
for t in reversed(range(self.num_steps)):
adjacency = self.forward(adjacency, t, template_features)
return adjacency
class DiseaseClassifierGCN(nn.Module):
"""
GCN classifier for disease diagnosis
"""
def __init__(self, node_dim, hidden_dim=64, num_classes=2):
super().__init__()
from torch_geometric.nn import GCNConv
self.conv1 = GCNConv(node_dim, hidden_dim)
self.conv2 = GCNConv(hidden_dim, hidden_dim)
self.classifier = nn.Linear(hidden_dim, num_classes)
def forward(self, x, edge_index, edge_weight):
"""
Args:
x: Node features
edge_index: Graph connectivity
edge_weight: Edge weights from generated network
Returns:
logits: Disease classification
"""
x = torch.relu(self.conv1(x, edge_index, edge_weight))
x = torch.relu(self.conv2(x, edge_index, edge_weight))
x = x.mean(dim=0) # Graph pooling
return self.classifier(x)
class ConnectomeDiffuser(nn.Module):
"""
Complete ConnectomeDiffuser pipeline
"""
def __init__(self):
super().__init__()
self.template_net = TemplateNetwork()
self.diffusion = BrainNetworkDiffusion(node_dim=90) # AAL atlas
self.classifier = DiseaseClassifierGCN(node_dim=90)
def construct_network(self, dti_volume):
"""End-to-end brain network construction"""
# Extract template features
template_features = self.template_net(dti_volume)
# Generate brain network
adjacency = self.diffusion.generate(template_features, num_nodes=90)
return adjacency
def diagnose(self, dti_volume):
"""Disease diagnosis from DTI"""
adjacency = self.construct_network(dti_volume)
# Convert to edge_index, edge_weight
# ...
logits = self.classifier(x, edge_index, edge_weight)
return logits
```
## Applications
### 1. Neurodegenerative Disease Diagnosis
- Alzheimer's disease (AD)
- Parkinson's disease
- Multiple sclerosis
### 2. Brain Network Analysis
- Structural connectivity mapping
- Topological feature extraction
- Individual variation analysis
### 3. Therapeutic Monitoring
- Disease progression tracking
- Treatment response assessment
- Biomarker identification
## Key Results
- **Superior performance** over existing brain network methods
- **Broader structural connectivity** capture
- **Disease-specific biomarker** enhancement
- **Validated on two distinct** neurodegenerative conditions
## When to Use
- DTI-based brain network construction
- Neurodegenerative disease diagnosis
- Automated brain connectivity analysis
- When topological fidelity matters
- Biomarker discovery
## Tools Used
- `read` - Read documentation and references
- `web_search` - Search for related information
- `web_fetch` - Fetch paper or documentation
## Instructions for Agents
Follow these steps when applying this skill:
### Step 1: Template Network
### Step 2: Diffusion Model
### Step 3: GCN Classifier
### Step 4: Understand the Request
### Step 5: Search for Information
### When to Apply
- DTI-based brain network construction
- Neurodegenerative disease diagnosis
- Automated brain connectivity analysis
## Examples
### Example 1: Basic Application
**User:** I need to apply ConnectomeDiffuser: Generative AI for Brain Network Construction to my analysis.
**Agent:** I'll help you apply connectomediffuser-dti-brain-network. First, let me understand your specific use case...
**Context:** Problem: Limitations of Existing DTI Analysis
### Example 2: Advanced Scenario
**User:** DTI-based brain network construction
**Agent:** Based on the methodology, I'll guide you through the advanced application...
### Example 2: Advanced Application
**User:** What are the key considerations for connectomediffuser-dti-brain-network?
**Agent:** Let me search for the latest research and best practices...
## Related Skills
- `graph-autoencoder-brain-network` - Graph autoencoders for brain networks
- `multimodal-brain-connectivity-gnn` - Multi-modal brain connectivity
- `brain-graph-augmentation-template` - Brain graph templates
## References
- Wang, S., et al. "ConnectomeDiffuser: Generative AI Enables Brain Network Construction from Diffusion Tensor Imaging." arXiv:2505.22683 (2025)
- Diffusion models for graph generation
- Riemannian geometry in neuroimaging