Upload 36 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+fc_visualization.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1868,7 +1868,7 @@ def create_interface():
                     with gr.Column(scale=1):
                         fmri_file = gr.File(label="Patient fMRI Data (NIfTI file)")
                     with gr.Column(scale=1):
-                        with gr.Group("Patient Demographics"):
+                        with gr.Group(label="Patient Demographics"):
                             age = gr.Number(label="Age at Stroke", value=60)
                             sex = gr.Dropdown(choices=["M", "F"], label="Sex", value="M")
                             months = gr.Number(label="Months Post Stroke", value=12)

app_fixed.py

@@ -195,7 +195,7 @@ def run_demo():
         with gr.Row():
             with gr.Column(scale=1):
                 # Configuration inputs
-                with gr.Group():
+                with gr.Box():  # Switched to Box to avoid any Group issues
                     gr.Markdown("### Configuration")
                     data_source = gr.Textbox(value="SreekarB/OSFData", label="Data Source (HuggingFace dataset or directory)")
                     use_hf_checkbox = gr.Checkbox(value=True, label="Use HuggingFace Dataset API")
@@ -212,8 +212,8 @@ def run_demo():
                 status_text = gr.Textbox(label="Status", lines=10, interactive=False)
                 
             with gr.Column(scale=2):
-                # Output plot
-                output_plot = gr.Plot(label="FC Matrix Analysis", height=400)
+                # Output plot 
+                output_plot = gr.Plot(label="FC Matrix Analysis")
                 accuracy_box = gr.Markdown("### Accuracy Metrics\nRun analysis to see reconstruction accuracy metrics here")
         
         # Link the training button to the analysis function

direct_fc_visualization.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+"""
+Direct FC Matrix Visualization Script.
+
+This script creates and visualizes FC matrices directly, without relying on fMRI data.
+"""
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from visualization import vector_to_matrix
+
+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(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 visualize_fc_matrices(fc_data, subject_idx=0):
+    """
+    Create visualizations of FC matrices.
+    
+    Args:
+        fc_data: Dictionary with FC data
+        subject_idx: Subject index to visualize
+    
+    Returns:
+        fig: Matplotlib figure
+    """
+    # Get the vectors
+    original_vector = fc_data['original_vectors'][subject_idx]
+    reconstructed_vector = fc_data['reconstructed_vectors'][subject_idx]
+    generated_vector = fc_data['generated_vector']
+    
+    # Convert to matrices
+    original_matrix = vector_to_matrix(original_vector)
+    reconstructed_matrix = vector_to_matrix(reconstructed_vector)
+    generated_matrix = vector_to_matrix(generated_vector)
+    
+    # Create visualization
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+    
+    vmin, vmax = -1, 1
+    
+    # Original FC matrix
+    im1 = axes[0].imshow(original_matrix, cmap='RdBu_r', vmin=vmin, vmax=vmax)
+    axes[0].set_title('Original FC')
+    plt.colorbar(im1, ax=axes[0])
+    
+    # Reconstructed FC matrix
+    im2 = axes[1].imshow(reconstructed_matrix, cmap='RdBu_r', vmin=vmin, vmax=vmax)
+    axes[1].set_title('Reconstructed FC')
+    plt.colorbar(im2, ax=axes[1])
+    
+    # Generated FC matrix
+    im3 = axes[2].imshow(generated_matrix, cmap='RdBu_r', vmin=vmin, vmax=vmax)
+    axes[2].set_title('Generated FC')
+    plt.colorbar(im3, ax=axes[2])
+    
+    plt.tight_layout()
+    return fig
+
+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)
+    
+    # Visualize FC matrices
+    fig = visualize_fc_matrices(fc_data)
+    
+    # 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(fc_data['original_vectors'][0])
+    reconstructed_matrix = vector_to_matrix(fc_data['reconstructed_vectors'][0])
+    generated_matrix = vector_to_matrix(fc_data['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()

fix_group.py

@@ -0,0 +1,28 @@
+#\!/usr/bin/env python
+"""
+Simple script to fix the gr.Group error in app.py
+"""
+
+import os
+import re
+
+# Path to the app.py file
+app_path = "/home/user/app/app.py" 
+
+# Read the file
+with open(app_path, "r") as f:
+    content = f.read()
+
+# Fix the gr.Group initialization
+fixed_content = re.sub(
+    r'gr\.Group\("([^"]+)"\)',
+    r'gr.Group(label="\1")',
+    content
+)
+
+# Write the fixed content back
+with open(app_path, "w") as f:
+    f.write(fixed_content)
+
+print("Fixed the gr.Group initialization in app.py")
+print("You can now run: python app.py")

generated_fc.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6c87c8e143da0dccdc7c5653e237c36b13644b2ba6eb2596e518dac95d664b1
+size 557696

original_fc.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a30451cf7faabae45932e550fee6746bdd6e8c5d887f5559ae4af7921507196e
+size 557696

reconstructed_fc.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10f10843c4ef0be793b0737240e3a34e7c5263fc36b38a22286a66d794d2e684
+size 557696

temp_demographics.csv

@@ -0,0 +1,31 @@
+ID,age_at_stroke,sex,months_post_stroke,wab_score
+P01,66,F,13,51
+P02,67,M,14,52
+P03,68,F,15,53
+P04,69,M,16,54
+P05,70,F,17,55
+P06,71,M,18,56
+P07,72,F,19,57
+P08,73,M,20,58
+P09,74,F,21,59
+P10,65,M,22,60
+P11,66,F,23,61
+P12,67,M,24,62
+P13,68,F,25,63
+P14,69,M,26,64
+P15,70,F,27,65
+P16,71,M,28,66
+P17,72,F,29,67
+P18,73,M,30,68
+P19,74,F,31,69
+P20,65,M,32,70
+P21,66,F,33,71
+P22,67,M,34,72
+P23,68,F,35,73
+P24,69,M,12,74
+P25,70,F,13,75
+P26,71,M,14,76
+P27,72,F,15,77
+P28,73,M,16,78
+P29,74,F,17,79
+P30,65,M,18,50

visualization.py

@@ -36,10 +36,34 @@ def vector_to_matrix(vector):
         # Print diagnostic info
         print(f"Converting vector to matrix. Vector shape: {vector.shape}, length: {len(vector)}")
         
-        # Calculate matrix size from vector length
-        n = int(np.sqrt(2 * len(vector) + 0.25) + 0.5)
+        # Handle FC vectors specifically - for a 264x264 FC matrix, we expect 34716 elements
+        # This is the most common case in this application
+        if len(vector) == 34716:
+            print("Detected standard FC vector with 34716 elements (264x264 matrix)")
+            n = 264
+        else:
+            # For other sized vectors, calculate matrix size from vector length
+            # For a matrix of size n×n, the number of elements in the upper triangular part (excl. diagonal) is n(n-1)/2
+            n = int(np.sqrt(2 * len(vector) + 0.25) + 0.5)
+            
         print(f"Calculated matrix size: {n}x{n}")
         
+        # Validate calculation
+        expected_elements = int(n * (n-1) / 2)
+        if expected_elements != len(vector):
+            print(f"WARNING: Vector length {len(vector)} doesn't match expected length {expected_elements} for {n}x{n} matrix")
+            
+            # If the vector length is very close to expected, we can pad or truncate
+            if abs(expected_elements - len(vector)) < n:
+                if len(vector) < expected_elements:
+                    print(f"Padding vector with {expected_elements - len(vector)} zeros")
+                    vector = np.pad(vector, (0, expected_elements - len(vector)))
+                else:
+                    print(f"Truncating vector to {expected_elements} elements")
+                    vector = vector[:expected_elements]
+            else:
+                raise ValueError(f"Vector length {len(vector)} incompatible with calculated matrix size {n}x{n}")
+        
         # Create empty matrix
         matrix = np.zeros((n, n))
         
@@ -71,14 +95,43 @@ def vector_to_matrix(vector):
         print(f"Vector stats: min={np.min(vector)}, max={np.max(vector)}, mean={np.mean(vector)}")
         print(f"Traceback: {traceback.format_exc()}")
         
-        # Fallback - try to reshape if it's a square matrix in flat form
+        # Fallback 1 - check if it's already a matrix that was flattened
         if np.sqrt(len(vector)) == int(np.sqrt(len(vector))):
             n = int(np.sqrt(len(vector)))
             print(f"Trying fallback reshape to {n}x{n}")
             return vector.reshape(n, n)
+        
+        # Fallback 2 - try standard FC matrix size
+        elif len(vector) > 30000 and len(vector) < 40000:  # Close to 34716
+            print(f"Vector length {len(vector)} is close to 34716, trying 264x264 matrix")
+            n = 264
+            matrix = np.zeros((n, n))
+            np.fill_diagonal(matrix, 1.0)
+            
+            # Try to fill as much as possible
+            triu_indices = np.triu_indices_from(matrix, k=1)
+            max_idx = min(len(vector), len(triu_indices[0]))
+            
+            # Convert from Fisher z-transform if needed
+            if np.any(np.abs(vector[:max_idx]) > 1):
+                values = np.tanh(vector[:max_idx])
+            else:
+                values = vector[:max_idx]
+                
+            # Fill the upper triangle with as many values as we can
+            for i in range(max_idx):
+                matrix[triu_indices[0][i], triu_indices[1][i]] = values[i]
+            
+            # Make symmetric
+            matrix = matrix + matrix.T
+            np.fill_diagonal(matrix, 1.0)
+            
+            print(f"Created partial matrix with shape {matrix.shape}")
+            return matrix
+            
+        # Fallback 3 - create a dummy identity matrix as last resort
         else:
-            # If all else fails, create a dummy matrix
-            print("Creating fallback matrix")
+            print("Creating fallback identity matrix")
             n = 264  # Standard size for brain atlas
             matrix = np.zeros((n, n))
             np.fill_diagonal(matrix, 1.0)

visualize_fc.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+"""
+Standalone script to visualize FC matrices using the VAE.
+"""
+
+import os
+import sys
+import numpy as np
+import matplotlib.pyplot as plt
+from main import run_fc_analysis
+from config import PREDICTION_CONFIG
+
+def main():
+    # Configuration
+    data_dir = "SreekarB/OSFData"  # HuggingFace dataset
+    latent_dim = 16
+    nepochs = 50
+    batch_size = 4
+    use_hf_dataset = True
+    
+    # Check if using local data
+    if os.path.exists(data_dir) and os.path.isdir(data_dir):
+        print(f"Using local directory: {data_dir}")
+        use_hf_dataset = False
+    else:
+        print(f"Using HuggingFace dataset: {data_dir}")
+    
+    print(f"Running FC visualization with:")
+    print(f"- Data source: {data_dir}")
+    print(f"- Latent dimension: {latent_dim}")
+    print(f"- Training epochs: {nepochs}")
+    print(f"- Batch size: {batch_size}")
+    print(f"- Using HuggingFace API: {use_hf_dataset}")
+    
+    # Run analysis
+    try:
+        # Update config to allow synthetic data
+        PREDICTION_CONFIG['use_synthetic_nifti'] = True
+        PREDICTION_CONFIG['use_synthetic_fc'] = True
+        print("Enabled synthetic data generation")
+        
+        # Create a dummy demographic file if needed
+        demo_file = "temp_demographics.csv"
+        with open(demo_file, "w") as f:
+            f.write("ID,age_at_stroke,sex,months_post_stroke,wab_score\n")
+            # Write some dummy data
+            for i in range(1, 31):  # 30 subjects
+                f.write(f"P{i:02d},{65+i%10},{['M','F'][i%2]},{12+i%24},{50+i%30}\n")
+        
+        print(f"Created temporary demographic file: {demo_file}")
+        
+        fig, results = run_fc_analysis(
+            data_dir=data_dir,
+            demographic_file=demo_file,
+            latent_dim=latent_dim,
+            nepochs=nepochs,
+            bsize=batch_size,
+            save_model=True,
+            use_hf_dataset=use_hf_dataset,
+            return_data=True
+        )
+        
+        # Save the figure
+        output_file = "fc_visualization.png"
+        fig.savefig(output_file, dpi=300, bbox_inches='tight')
+        print(f"Saved visualization to {output_file}")
+        
+        # If results are available, calculate some metrics
+        if results:
+            X = results.get('X')
+            reconstructed_fc = results.get('reconstructed_fc')
+            
+            if X is not None and reconstructed_fc is not None:
+                # Calculate MSE between original and reconstructed
+                original = X[0]
+                recon = reconstructed_fc[0]
+                
+                # Convert to matrices if needed
+                from visualization import vector_to_matrix
+                if len(original.shape) == 1:
+                    original = vector_to_matrix(original)
+                    recon = vector_to_matrix(recon)
+                
+                # Calculate MSE
+                mse = np.mean((original - recon) ** 2)
+                print(f"Reconstruction MSE: {mse:.6f}")
+                
+                # Save the matrices
+                np.save("original_fc.npy", original)
+                np.save("reconstructed_fc.npy", recon)
+                print("Saved matrices to original_fc.npy and reconstructed_fc.npy")
+    
+    except Exception as e:
+        print(f"Error during visualization: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+    
+    print("Visualization complete!")
+
+if __name__ == "__main__":
+    main()