Spaces:
Sleeping
Sleeping
File size: 4,578 Bytes
71fbc82 50c6714 71fbc82 b507484 71fbc82 50c6714 71fbc82 50c6714 71fbc82 50c6714 71fbc82 50c6714 71fbc82 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 |
#!/usr/bin/env python
"""
Direct FC Matrix Visualization Script.
This script creates and visualizes FC matrices directly, without relying on fMRI data.
It uses the consolidated visualization utilities.
"""
import os
import numpy as np
# Configure matplotlib for headless environment
import matplotlib
matplotlib.use('Agg') # Use non-interactive backend
import matplotlib.pyplot as plt
from visualization import vector_to_matrix, plot_fc_matrices
def create_synthetic_fc_matrices(n_subjects=10, n_rois=264, seed=42):
"""
Create synthetic FC matrices for visualization.
Args:
n_subjects: Number of synthetic subjects
n_rois: Number of regions of interest
seed: Random seed for reproducibility
Returns:
dict: Dictionary with original FC matrices, latent features, and reconstructions
"""
np.random.seed(seed)
# Calculate the size of upper triangular part
n_triu = n_rois * (n_rois - 1) // 2
# Create synthetic FC matrices
print(f"Creating {n_subjects} synthetic FC matrices with {n_rois} ROIs each")
# Create original FC matrices (upper triangular vectors)
original_fc_vectors = []
for i in range(n_subjects):
# Create random correlation values
np.random.seed(seed + i) # For reproducibility
# Generate values between -0.8 and 0.8 (typical FC range)
fc_triu = np.random.rand(n_triu) * 1.6 - 0.8
original_fc_vectors.append(fc_triu)
# Simulate latent features (much lower dimensional)
latent_dim = 16
latent_features = np.random.randn(n_subjects, latent_dim)
# Simulate reconstructions with some error
reconstructed_fc_vectors = []
for i in range(n_subjects):
# Add some noise to original to simulate reconstruction error
recon = original_fc_vectors[i] + np.random.randn(n_triu) * 0.1
# Clip to realistic correlation range
recon = np.clip(recon, -0.99, 0.99)
reconstructed_fc_vectors.append(recon)
# Simulate a newly generated FC matrix
generated_fc_vector = np.random.rand(n_triu) * 1.6 - 0.8
return {
'original_vectors': original_fc_vectors,
'reconstructed_vectors': reconstructed_fc_vectors,
'generated_vector': generated_fc_vector,
'latent_features': latent_features
}
def calculate_metrics(original, reconstructed):
"""
Calculate reconstruction metrics
Args:
original: Original FC matrix
reconstructed: Reconstructed FC matrix
Returns:
dict: Dictionary of metrics
"""
from sklearn.metrics import mean_squared_error, r2_score
# Flatten matrices
orig_flat = original.flatten()
recon_flat = reconstructed.flatten()
# Calculate metrics
mse = mean_squared_error(orig_flat, recon_flat)
rmse = np.sqrt(mse)
r2 = r2_score(orig_flat, recon_flat)
corr = np.corrcoef(orig_flat, recon_flat)[0, 1]
return {
'MSE': mse,
'RMSE': rmse,
'R²': r2,
'Correlation': corr
}
def main():
"""Run the visualization script"""
print("Creating direct FC matrix visualization without fMRI data")
# Create synthetic FC data
fc_data = create_synthetic_fc_matrices(n_subjects=10)
# Get the vectors for visualization
original_vector = fc_data['original_vectors'][0]
reconstructed_vector = fc_data['reconstructed_vectors'][0]
generated_vector = fc_data['generated_vector']
# Create visualization using the consolidated function
fig = plot_fc_matrices(original_vector, reconstructed_vector, generated_vector)
# Save the figure
output_file = "fc_visualization.png"
fig.savefig(output_file, dpi=300, bbox_inches='tight')
print(f"Saved visualization to {output_file}")
# Save matrices for inspection
original_matrix = vector_to_matrix(original_vector)
reconstructed_matrix = vector_to_matrix(reconstructed_vector)
generated_matrix = vector_to_matrix(generated_vector)
np.save('original_fc.npy', original_matrix)
np.save('reconstructed_fc.npy', reconstructed_matrix)
np.save('generated_fc.npy', generated_matrix)
print("Saved matrices to NPY files")
# Calculate and display metrics
metrics = calculate_metrics(original_matrix, reconstructed_matrix)
print("\nFC Reconstruction Metrics:")
for name, value in metrics.items():
print(f" {name}: {value:.6f}")
print("\nVisualization complete!")
if __name__ == "__main__":
main() |