ADNI Dataset

class FC_ADNIDataset(InMemoryDataset):
    def __init__(self, root, threshold=0.2, label_csv='TADPOLE_TEMPORAL.csv', 
                 var_name='arr_0', transform=None, pre_transform=None):
        self.threshold = threshold
        self.label_csv = label_csv
        self.var_name = var_name
        self.subject_graph_dict = None
        super().__init__(root, transform, pre_transform)
        self.data, self.slices = torch.load(self.processed_paths[0], weights_only=False)

from FC_ADNIDataset import FC_ADNIDataset

# Load dataset
dataset = FC_ADNIDataset(
    root='data/',
    threshold=0.2,
    label_csv='TADPOLE_TEMPORAL.csv',
    var_name='arr_0'
)

# Access graphs
print(f"Total graphs: {len(dataset)}")
first_graph = dataset[0]
print(f"Nodes: {first_graph.x.shape[0]}")
print(f"Edges: {first_graph.edge_index.shape[1]}")
print(f"Label: {first_graph.y.item()}")
print(f"Subject ID: {first_graph.subj_id}")
print(f"Visit: {first_graph.visit_code}")
print(f"Months from baseline: {first_graph.visit_months}")

def fc_to_graph(self, matrix, node_features=None, subj_id=None):
    A = matrix.copy()
    N = A.shape[0]
    
    # Threshold edges
    A[np.abs(A) < self.threshold] = 0
    
    # Extract edges
    edge_index = np.array(np.nonzero(A))
    edge_attr = A[edge_index[0], edge_index[1]]
    
    # Convert to PyTorch tensors
    edge_index = torch.tensor(edge_index, dtype=torch.long)
    edge_attr = torch.tensor(edge_attr, dtype=torch.float).unsqueeze(1)
    
    # Node features (identity matrix by default)
    if node_features is None:
        x = torch.eye(N, dtype=torch.float) * 1.0
    else:
        x = torch.tensor(node_features, dtype=torch.float)
    
    data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr)
    if subj_id is not None:
        data.subj_id = subj_id
    return data

def process(self):
    base_path = os.path.join(self.root, 'FC_Matrices')
    label_path = os.path.join(self.root, self.label_csv)
    
    # Load labels and visit information
    label_dict, visit_dict = self.load_subject_labels_and_visits(label_path)
    
    fc_graphs = self.load_fc_graphs(base_path)
    
    data_list = []
    for subj_id, graph in fc_graphs.items():
        base_id = subj_id.split('_run')[0]
        graph.y = torch.tensor([label_dict.get(base_id, 0)], dtype=torch.long)
        graph.subj_id = subj_id
        
        # Add visit information if available
        if subj_id in visit_dict:
            visit_info = visit_dict[subj_id]
            graph.visit_code = visit_info.get('visit_code', 'unknown')
            graph.visit_months = visit_info.get('visit_months', 0)
            graph.months_to_next = visit_info.get('months_to_next', -1)
        # ... fallback logic ...
        
        data_list.append(graph)

def load_subject_labels_and_visits(self, label_csv_path, label_col='Label_CS_Num'):
    df = pd.read_csv(label_csv_path)
    df['Subject'] = df['Subject'].str.replace('_', '', regex=False)
    
    # Sort by subject and visit order
    df = df.sort_values(['Subject', 'Visit_Order'])
    
    # Create label dictionary (use last visit's label)
    label_dict = {}
    for subject in df['Subject'].unique():
        subject_data = df[df['Subject'] == subject]
        label_dict[subject] = subject_data.iloc[-1][label_col]
    
    # Create visit info dictionary
    visit_dict = {}
    for subject in df['Subject'].unique():
        subject_data = df[df['Subject'] == subject].sort_values('Visit_Order')
        
        # Map each run number to chronologically ordered visits
        for run_idx, (_, visit_row) in enumerate(subject_data.iterrows()):
            run_key = f"{subject}_run{run_idx + 1:02d}"  # run01, run02, etc.
            
            visit_dict[run_key] = {
                'visit_code': visit_row['Visit'],
                'visit_months': visit_row['Months_From_Baseline'],
                'months_to_next': visit_row.get('Months_To_Next_Original', -1)
            }

A[np.abs(A) < self.threshold] = 0

# Sparse graph (only strong connections)
dataset_sparse = FC_ADNIDataset(root='data/', threshold=0.5)

# Dense graph (include weak connections)
dataset_dense = FC_ADNIDataset(root='data/', threshold=0.1)

# No thresholding (keep all edges)
dataset_full = FC_ADNIDataset(root='data/', threshold=0.0)

import torch
from FC_ADNIDataset import FC_ADNIDataset
import numpy as np

# Load dataset
print("Loading ADNI FC dataset...")
dataset = FC_ADNIDataset(root='data/', threshold=0.2)

print(f"\nDataset Statistics:")
print(f"Total graphs: {len(dataset)}")
print(f"Number of node features: {dataset[0].x.shape[1]}")
print(f"Number of ROIs: {dataset[0].x.shape[0]}")

# Analyze graph structure
edges_per_graph = [data.edge_index.shape[1] for data in dataset]
print(f"\nGraph Connectivity:")
print(f"Average edges per graph: {np.mean(edges_per_graph):.1f}")
print(f"Min edges: {np.min(edges_per_graph)}")
print(f"Max edges: {np.max(edges_per_graph)}")

# Analyze labels
labels = [data.y.item() for data in dataset]
print(f"\nLabel Distribution:")
print(f"Stable (0): {labels.count(0)} ({100*labels.count(0)/len(labels):.1f}%)")
print(f"Converter (1): {labels.count(1)} ({100*labels.count(1)/len(labels):.1f}%)")

# Analyze temporal information
visit_months = [data.visit_months for data in dataset if hasattr(data, 'visit_months')]
print(f"\nTemporal Information:")
print(f"Average months from baseline: {np.mean(visit_months):.1f}")
print(f"Max follow-up time: {np.max(visit_months):.1f} months")

# Inspect a single graph
print(f"\nExample Graph (index 0):")
graph = dataset[0]
print(f"Subject ID: {graph.subj_id}")
print(f"Visit code: {graph.visit_code}")
print(f"Label: {'Converter' if graph.y.item() == 1 else 'Stable'}")
print(f"Nodes: {graph.x.shape[0]}")
print(f"Edges: {graph.edge_index.shape[1]}")
print(f"Edge weight range: [{graph.edge_attr.min():.3f}, {graph.edge_attr.max():.3f}]")

@property
def processed_file_names(self):
    return ['data.pt']

def download(self):
    pass