{ "cells": [ { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def filter_subject_data(data, subject_id):\n", " \"\"\"\n", " Filter data for a specific subject.\n", " \n", " Args:\n", " data: Dictionary containing model data\n", " subject_id: Subject ID to filter for\n", " \n", " Returns:\n", " filtered_data: Dictionary with filtered data for the specified subject\n", " \"\"\"\n", " filtered_indices = []\n", " for i, metadata in enumerate(data[\"metadata\"]):\n", " if metadata[\"subject\"] == subject_id:\n", " filtered_indices.append(i)\n", " \n", " filtered_data = {\n", " \"metadata\": [data[\"metadata\"][i] for i in filtered_indices],\n", " \"ground_truths\": [data[\"ground_truths\"][i] for i in filtered_indices],\n", " \"inputs\": [data[\"inputs\"][i] for i in filtered_indices] if \"inputs\" in data else None,\n", " \"outputs\": [data[\"outputs\"][i] for i in filtered_indices]\n", " }\n", " \n", " return filtered_data\n", "\n", "def update_metadata_with_correlations(data):\n", " \"\"\"\n", " Update metadata to include correlation scores for each branch and fusion.\n", " \n", " Args:\n", " data: Dictionary containing 'metadata', 'ground_truths', 'inputs', 'outputs'\n", " \n", " Returns:\n", " Updated data dictionary\n", " \"\"\"\n", " import numpy as np\n", " \n", " def calculate_correlation(pred, gt):\n", " \"\"\"Calculate correlation between prediction and ground truth\"\"\"\n", " return np.corrcoef(pred.reshape(-1), gt.reshape(-1))[0, 1]\n", " \n", " # Make a copy to avoid modifying the original data\n", " updated_data = data.copy()\n", " \n", " # Check if model has branches\n", " has_branches = \"envelope_branch\" in data[\"outputs\"][0]\n", " \n", " # Update each metadata entry with correlations\n", " for i in range(len(data[\"metadata\"])):\n", " gt = data[\"ground_truths\"][i]\n", " envelope = data[\"outputs\"][i][\"envelope\"]\n", " \n", " # Calculate fusion correlation\n", " fusion_corr = calculate_correlation(envelope, gt)\n", " \n", " # Update metadata dictionary with fusion correlation\n", " updated_data[\"metadata\"][i] = updated_data[\"metadata\"][i].copy()\n", " updated_data[\"metadata\"][i][\"fusion_correlation\"] = fusion_corr\n", " \n", " if has_branches:\n", " # Calculate branch correlations\n", " envelope_branch = data[\"outputs\"][i][\"envelope_branch\"]\n", " eeg_branch = data[\"outputs\"][i][\"eeg_branch\"]\n", " \n", " env_corr = calculate_correlation(envelope_branch, gt)\n", " eeg_corr = calculate_correlation(eeg_branch, gt)\n", " \n", " # Update metadata with branch correlations\n", " updated_data[\"metadata\"][i][\"envelope_branch_correlation\"] = env_corr\n", " updated_data[\"metadata\"][i][\"eeg_branch_correlation\"] = eeg_corr\n", " \n", " return updated_data" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'fusion_0p5_data' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m sub1 \u001b[38;5;241m=\u001b[39m filter_subject_data(\u001b[43mfusion_0p5_data\u001b[49m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msub-001\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2\u001b[0m sub1 \u001b[38;5;241m=\u001b[39m update_metadata_with_correlations(sub1)\n", "\u001b[0;31mNameError\u001b[0m: name 'fusion_0p5_data' is not defined" ] } ], "source": [ "sub1 = filter_subject_data(fusion_0p5_data, \"sub-001\")\n", "sub1 = update_metadata_with_correlations(sub1)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'analyze_branch_contributions' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[11], line 95\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\n\u001b[1;32m 84\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124menv_dominant_indices\u001b[39m\u001b[38;5;124m'\u001b[39m: [x[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mindex\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m top_env_dominant],\n\u001b[1;32m 85\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124meeg_dominant_indices\u001b[39m\u001b[38;5;124m'\u001b[39m: [x[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mindex\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m top_eeg_dominant],\n\u001b[1;32m 86\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mall_differences\u001b[39m\u001b[38;5;124m'\u001b[39m: differences\n\u001b[1;32m 87\u001b[0m }\n\u001b[1;32m 89\u001b[0m \u001b[38;5;66;03m# Example usage:\u001b[39;00m\n\u001b[1;32m 90\u001b[0m \u001b[38;5;66;03m# results = analyze_branch_dominance(fusion_0p5_data)\u001b[39;00m\n\u001b[1;32m 91\u001b[0m \u001b[38;5;66;03m# print(\"\\nIndices where envelope dominates:\", results['env_dominant_indices'])\u001b[39;00m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;66;03m# print(\"Indices where EEG dominates:\", results['eeg_dominant_indices'])\u001b[39;00m\n\u001b[1;32m 93\u001b[0m \n\u001b[1;32m 94\u001b[0m \u001b[38;5;66;03m# Example usage:\u001b[39;00m\n\u001b[0;32m---> 95\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43manalyze_branch_contributions\u001b[49m(sub1)\n", "\u001b[0;31mNameError\u001b[0m: name 'analyze_branch_contributions' is not defined" ] } ], "source": [ "def analyze_branch_dominance(data):\n", " \"\"\"\n", " Find and plot examples where either envelope or EEG branch dominates based on correlation differences.\n", " \"\"\"\n", " import numpy as np\n", " import matplotlib.pyplot as plt\n", " from scipy.signal import welch\n", " \n", " def normalize_data(data): \n", " return (data - np.min(data)) / (np.max(data) - np.min(data))\n", " \n", " # Calculate correlation differences for all examples\n", " differences = []\n", " for i in range(len(data[\"outputs\"])):\n", " gt = data[\"ground_truths\"][i]\n", " outputs = data[\"outputs\"][i]\n", " \n", " env_corr = np.corrcoef(outputs[\"envelope_branch\"].reshape(-1), gt.reshape(-1))[0, 1]\n", " eeg_corr = np.corrcoef(outputs[\"eeg_branch\"].reshape(-1), gt.reshape(-1))[0, 1]\n", " fusion_corr = np.corrcoef(outputs[\"envelope\"].reshape(-1), gt.reshape(-1))[0, 1]\n", " \n", " diff = env_corr - eeg_corr # positive means envelope dominates, negative means EEG dominates\n", " \n", " differences.append({\n", " 'index': i,\n", " 'difference': diff,\n", " 'env_corr': env_corr,\n", " 'eeg_corr': eeg_corr,\n", " 'fusion_corr': fusion_corr\n", " })\n", " \n", " # Sort by difference\n", " sorted_diffs = sorted(differences, key=lambda x: x['difference'])\n", " \n", " # Get top 10 EEG dominant (most negative differences)\n", " top_eeg_dominant = sorted_diffs[:10]\n", " # Get top 10 envelope dominant (most positive differences)\n", " top_env_dominant = sorted_diffs[-10:][::-1] # reverse to get highest first\n", " \n", " def plot_example(idx, info, title):\n", " \"\"\"Plot signals and PSD for a single example\"\"\"\n", " fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))\n", " \n", " # Plot signals\n", " gt = data[\"ground_truths\"][idx]\n", " outputs = data[\"outputs\"][idx]\n", " \n", " ax1.plot(normalize_data(gt), 'k', label=\"Ground Truth\", alpha=0.8)\n", " ax1.plot(normalize_data(outputs[\"envelope\"]), 'orange', label=\"Fusion\", alpha=0.8)\n", " ax1.plot(normalize_data(outputs[\"envelope_branch\"]), 'b', label=\"Envelope Branch\", alpha=0.8)\n", " ax1.plot(normalize_data(outputs[\"eeg_branch\"]), 'r', label=\"EEG Branch\", alpha=0.8)\n", " ax1.set_title(f\"{title}\\nCorr Diff={info['difference']:.3f} \"\n", " f\"(Env={info['env_corr']:.3f}, EEG={info['eeg_corr']:.3f}, Fusion={info['fusion_corr']:.3f})\")\n", " ax1.legend()\n", " ax1.grid(True)\n", " \n", " # Plot PSD\n", " f, psd = welch(gt.reshape(-1), 64, axis=0, nperseg=64)\n", " ax2.semilogy(f, psd, 'k', label='Ground Truth', alpha=0.8)\n", " f, psd = welch(outputs[\"eeg_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", " ax2.semilogy(f, psd, 'r', label='EEG Branch', alpha=0.8)\n", " f, psd = welch(outputs[\"envelope_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", " ax2.semilogy(f, psd, 'b', label='Envelope Branch', alpha=0.8)\n", " ax2.set_xlabel('Frequency [Hz]')\n", " ax2.set_ylabel('PSD')\n", " ax2.legend()\n", " ax2.grid(True)\n", " \n", " plt.tight_layout()\n", " plt.show()\n", " \n", " # Plot top 3 examples for each case\n", " print(\"\\nTop 3 Examples where Envelope Branch Dominates:\")\n", " for i in range(3):\n", " info = top_env_dominant[i]\n", " plot_example(info['index'], info, f\"Envelope Dominant Example {i+1}\")\n", " \n", " print(\"\\nTop 3 Examples where EEG Branch Dominates:\")\n", " for i in range(3):\n", " info = top_eeg_dominant[i]\n", " plot_example(info['index'], info, f\"EEG Dominant Example {i+1}\")\n", " \n", " return {\n", " 'env_dominant_indices': [x['index'] for x in top_env_dominant],\n", " 'eeg_dominant_indices': [x['index'] for x in top_eeg_dominant],\n", " 'all_differences': differences\n", " }\n", "\n", "# Example usage:\n", "# results = analyze_branch_dominance(fusion_0p5_data)\n", "# print(\"\\nIndices where envelope dominates:\", results['env_dominant_indices'])\n", "# print(\"Indices where EEG dominates:\", results['eeg_dominant_indices'])\n", "\n", "# Example usage:\n", "results = analyze_branch_contributions(sub1)\n", "# print(\"\\nIndices with strongest envelope contribution:\", results['top_envelope_indices'])\n", "# print(\"Indices with strongest EEG contribution:\", results['top_eeg_indices'])" ] }, { "cell_type": "code", "execution_count": 165, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fusion Correlation: -0.0758060760091822 Envelope Correlation: -0.1253179314285109 EEG Correlation: -0.1057595870172593\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import random\n", "import pickle\n", "import matplotlib.pyplot as plt\n", "from scipy.signal import welch\n", "\n", "with open(\"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.2SecDynamic_pearson_l1_two_branch_context_0.2sec_dynamic_20250505_193514.pkl\", 'rb') as f:\n", " fusion_0p5_data = pickle.load(f)\n", "\n", "index = random.randint(0, len(fusion_0p5_data[\"outputs\"]))\n", "\n", "def normalize_data(data): \n", " return data #(data - np.min(data)) / (np.max(data) - np.min(data))\n", "plt.figure(figsize=(10, 5))\n", "plt.plot(normalize_data(fusion_0p5_data[\"ground_truths\"][index]), label=\"ground truth\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"envelope\"]), label=\"fusion\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"]), label=\"envelope branch\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"]), label=\"eeg branch\")\n", "plt.plot(1 - normalize_data(fusion_0p5_data[\"outputs\"][index][\"fusion_weights\"]), label=\"EEG weights\", color=\"black\")\n", "#plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"fusion_weights\"]), label=\"envelope weights\", color=\"yellow\")\n", "plt.legend()\n", "\n", "import numpy as np\n", "fusion_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"envelope\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "envelope_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "eeg_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "\n", "\n", "# now lets calculate the cosine similarity using the scipy library\n", "from scipy.spatial.distance import cosine\n", "\n", "fusion_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"envelope\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "envelope_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "eeg_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "\n", "print(\"Fusion Correlation:\", fusion_correlation, \"Envelope Correlation:\", envelope_correlation, \"EEG Correlation:\", eeg_correlation)\n", "\"\"\"print(\"Fusion Cosine Similarity:\", fusion_cosine_similarity, \"Envelope Cosine Similarity:\", envelope_cosine_similarity, \"EEG Cosine Similarity:\", eeg_cosine_similarity)\n", "\n", "# make a psd of the gt signal and plot it\n", "plt.figure(figsize=(10, 5))\n", "f, psd = welch(fusion_0p5_data[\"ground_truths\"][index].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'k', label='Ground Truth', alpha=0.8)\n", "# make psd of the eeg branch\n", "f, psd = welch(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'r', label='EEG Branch', alpha=0.8)\n", "# make psd of the envelope branch\n", "f, psd = welch(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'b', label='Envelope Branch', alpha=0.8)\n", "plt.legend()\"\"\"\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import random\n", "import pickle\n", "import matplotlib.pyplot as plt\n", "from scipy.signal import welch\n", "\n", "with open(fusion_0p5_model, 'rb') as f:\n", " fusion_0p5_data = pickle.load(f)\n", "\n", "index = random.randint(0, len(fusion_0p5_data[\"outputs\"]))\n", "\n", "def normalize_data(data): \n", " return data #(data - np.min(data)) / (np.max(data) - np.min(data))\n", "\n", "plt.plot(normalize_data(fusion_0p5_data[\"ground_truths\"][index]), label=\"ground truth\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"envelope\"]), label=\"fusion\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"]), label=\"envelope branch\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"]), label=\"eeg branch\")\n", "plt.plot(normalize_data(fusion_0p5_data[\"outputs\"][index][\"fusion_weights\"]), label=\"envelope weights\", color=\"black\")\n", "plt.legend()\n", "\n", "import numpy as np\n", "fusion_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"envelope\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "envelope_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "eeg_correlation = np.corrcoef(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))[0, 1]\n", "\n", "\n", "# now lets calculate the cosine similarity using the scipy library\n", "from scipy.spatial.distance import cosine\n", "\n", "fusion_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"envelope\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "envelope_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "eeg_cosine_similarity = 1 - cosine(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), fusion_0p5_data[\"ground_truths\"][index].reshape(-1))\n", "\n", "print(\"Fusion Correlation:\", fusion_correlation, \"Envelope Correlation:\", envelope_correlation, \"EEG Correlation:\", eeg_correlation)\n", "print(\"Fusion Cosine Similarity:\", fusion_cosine_similarity, \"Envelope Cosine Similarity:\", envelope_cosine_similarity, \"EEG Cosine Similarity:\", eeg_cosine_similarity)\n", "\n", "# make a psd of the gt signal and plot it\n", "plt.figure(figsize=(10, 5))\n", "f, psd = welch(fusion_0p5_data[\"ground_truths\"][index].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'k', label='Ground Truth', alpha=0.8)\n", "# make psd of the eeg branch\n", "f, psd = welch(fusion_0p5_data[\"outputs\"][index][\"eeg_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'r', label='EEG Branch', alpha=0.8)\n", "# make psd of the envelope branch\n", "f, psd = welch(fusion_0p5_data[\"outputs\"][index][\"envelope_branch\"].reshape(-1), 64, axis=0, nperseg=64)\n", "plt.semilogy(f, psd, 'b', label='Envelope Branch', alpha=0.8)\n", "plt.legend()\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pickle\n", "\n", "def get_subject_scores(model_path):\n", " \"\"\"\n", " Calculate subject-wise correlation scores for EEG branch, envelope branch, and fusion.\n", " Handles models with and without branch outputs.\n", " \n", " Args:\n", " model_path (str): Path to the pickle file containing model data\n", " \n", " Returns:\n", " dict: Dictionary containing subject-wise scores for each branch\n", " \"\"\"\n", " # load pickle file\n", " with open(model_path, 'rb') as f:\n", " model_data = pickle.load(f)\n", "\n", " def filter_subject_data(data, subject_id):\n", " \"\"\"\n", " Filter data for a specific subject.\n", " \n", " Args:\n", " data: Dictionary containing model data\n", " subject_id: Subject ID to filter for\n", " \n", " Returns:\n", " filtered_data: Dictionary with filtered data for the specified subject\n", " \"\"\"\n", " filtered_indices = []\n", " for i, metadata in enumerate(data[\"metadata\"]):\n", " if metadata[\"subject\"] == subject_id:\n", " filtered_indices.append(i)\n", " \n", " filtered_data = {\n", " \"metadata\": [data[\"metadata\"][i] for i in filtered_indices],\n", " \"ground_truths\": [data[\"ground_truths\"][i] for i in filtered_indices],\n", " \"inputs\": [data[\"inputs\"][i] for i in filtered_indices] if \"inputs\" in data else None,\n", " \"outputs\": [data[\"outputs\"][i] for i in filtered_indices]\n", " }\n", " \n", " return filtered_data\n", "\n", " subject_scores = {\n", " \"eeg_branch\": {},\n", " \"envelope_branch\": {},\n", " \"fusion\": {}\n", " }\n", "\n", " # Check if this model has branch outputs\n", " sample_output = model_data[\"outputs\"][0]\n", " has_branches = \"envelope_branch\" in sample_output and \"eeg_branch\" in sample_output\n", "\n", " for sub_id in range(1, 86):\n", " subject_id = f\"sub-{sub_id:03}\"\n", " sub_data = filter_subject_data(model_data, subject_id)\n", "\n", " eeg_branch_average_correlation = []\n", " envelope_branch_average_correlation = []\n", " fusion_average_correlation = []\n", "\n", " for i in range(0, len(sub_data[\"outputs\"])):\n", " gt = sub_data[\"ground_truths\"][i]\n", " envelope = sub_data[\"outputs\"][i][\"envelope\"]\n", " \n", " if has_branches:\n", " # For models with branch outputs\n", " envelope_branch = sub_data[\"outputs\"][i][\"envelope_branch\"]\n", " eeg_branch = sub_data[\"outputs\"][i][\"eeg_branch\"]\n", " fusion_weights = sub_data[\"outputs\"][i][\"fusion_weights\"]\n", " \n", " eeg_corr = np.corrcoef(eeg_branch.reshape(-1), gt.reshape(-1))[0, 1]\n", " envelope_corr = np.corrcoef(envelope_branch.reshape(-1), gt.reshape(-1))[0, 1]\n", " \n", " if not np.isnan(eeg_corr) and not np.isnan(envelope_corr):\n", " eeg_branch_average_correlation.append(eeg_corr)\n", " envelope_branch_average_correlation.append(envelope_corr)\n", " \n", " # For all models, calculate fusion (or envelope) correlation\n", " fusion_corr = np.corrcoef(envelope.reshape(-1), gt.reshape(-1))[0, 1]\n", " if not np.isnan(fusion_corr):\n", " fusion_average_correlation.append(fusion_corr)\n", "\n", " # Only save branch scores if they exist\n", " if has_branches:\n", " subject_scores[\"eeg_branch\"][subject_id] = np.mean(eeg_branch_average_correlation)\n", " subject_scores[\"envelope_branch\"][subject_id] = np.mean(envelope_branch_average_correlation)\n", " \n", " subject_scores[\"fusion\"][subject_id] = np.mean(fusion_average_correlation)\n", "\n", " return subject_scores\n", "\n", "\n", "def get_subject_scores_dcorr(model_path):\n", " \"\"\"\n", " Calculate subject-wise distance correlation scores for EEG branch, envelope branch, and fusion.\n", " Handles models with and without branch outputs.\n", " \n", " Args:\n", " model_path (str): Path to the pickle file containing model data\n", " \n", " Returns:\n", " dict: Dictionary containing subject-wise distance correlation scores for each branch\n", " \"\"\"\n", " import pickle\n", " import numpy as np\n", " import torch\n", " from collections import namedtuple\n", " \n", " # Define the distance correlation function\n", " def distance_correlation(x, y):\n", " \"\"\"Calculate the distance correlation between two 1D arrays.\"\"\"\n", " # Convert numpy arrays to PyTorch tensors if they aren't already\n", " if not isinstance(x, torch.Tensor):\n", " x = torch.tensor(x, dtype=torch.float32)\n", " if not isinstance(y, torch.Tensor):\n", " y = torch.tensor(y, dtype=torch.float32)\n", " \n", " # Reshape to match expected input format (batch, seq_len, features)\n", " x = x.reshape(1, -1, 1)\n", " y = y.reshape(1, -1, 1)\n", " \n", " # Calculate pairwise distances\n", " def center(arr):\n", " return (\n", " arr\n", " - arr.mean(-2, keepdim=True)\n", " - arr.mean(-1, keepdim=True)\n", " + arr.mean((-1, -2), keepdim=True)\n", " )\n", " \n", " # Get centered pairwise distances\n", " x_centered = center(torch.cdist(x, x, 2))\n", " dvar_x = torch.sqrt((x_centered * x_centered).mean((-1, -2), keepdim=True))\n", " \n", " # For y\n", " y_centered = center(torch.cdist(y, y, 2))\n", " \n", " # Compute relevant statistics\n", " dcov = torch.sqrt((x_centered * y_centered).mean((-1, -2), keepdim=True))\n", " dvar_y = torch.sqrt((y_centered * y_centered).mean((-1, -2), keepdim=True))\n", " dcor = dcov / torch.sqrt(dvar_x * dvar_y + 1e-8)\n", " \n", " # Return scalar value\n", " return dcor.squeeze().item()\n", " \n", " # Load pickle file\n", " with open(model_path, 'rb') as f:\n", " model_data = pickle.load(f)\n", "\n", " def filter_subject_data(data, subject_id):\n", " \"\"\"\n", " Filter data for a specific subject.\n", " \n", " Args:\n", " data: Dictionary containing model data\n", " subject_id: Subject ID to filter for\n", " \n", " Returns:\n", " filtered_data: Dictionary with filtered data for the specified subject\n", " \"\"\"\n", " filtered_indices = []\n", " for i, metadata in enumerate(data[\"metadata\"]):\n", " if metadata[\"subject\"] == subject_id:\n", " filtered_indices.append(i)\n", " \n", " filtered_data = {\n", " \"metadata\": [data[\"metadata\"][i] for i in filtered_indices],\n", " \"ground_truths\": [data[\"ground_truths\"][i] for i in filtered_indices],\n", " \"inputs\": [data[\"inputs\"][i] for i in filtered_indices] if \"inputs\" in data else None,\n", " \"outputs\": [data[\"outputs\"][i] for i in filtered_indices]\n", " }\n", " \n", " return filtered_data\n", "\n", " subject_scores = {\n", " \"eeg_branch\": {},\n", " \"envelope_branch\": {},\n", " \"fusion\": {}\n", " }\n", "\n", " # Check if this model has branch outputs\n", " sample_output = model_data[\"outputs\"][0]\n", " has_branches = \"envelope_branch\" in sample_output and \"eeg_branch\" in sample_output\n", "\n", " for sub_id in range(1, 86):\n", " subject_id = f\"sub-{sub_id:03}\"\n", " sub_data = filter_subject_data(model_data, subject_id)\n", "\n", " eeg_branch_average_dcorr = []\n", " envelope_branch_average_dcorr = []\n", " fusion_average_dcorr = []\n", "\n", " for i in range(0, len(sub_data[\"outputs\"])):\n", " gt = sub_data[\"ground_truths\"][i]\n", " envelope = sub_data[\"outputs\"][i][\"envelope\"]\n", " \n", " if has_branches:\n", " # For models with branch outputs\n", " envelope_branch = sub_data[\"outputs\"][i][\"envelope_branch\"]\n", " eeg_branch = sub_data[\"outputs\"][i][\"eeg_branch\"]\n", " \n", " try:\n", " # Calculate distance correlation instead of Pearson correlation\n", " eeg_dcorr = distance_correlation(eeg_branch.reshape(-1), gt.reshape(-1))\n", " envelope_dcorr = distance_correlation(envelope_branch.reshape(-1), gt.reshape(-1))\n", " \n", " if not np.isnan(eeg_dcorr) and not np.isnan(envelope_dcorr):\n", " eeg_branch_average_dcorr.append(eeg_dcorr)\n", " envelope_branch_average_dcorr.append(envelope_dcorr)\n", " except Exception as e:\n", " print(f\"Error calculating branch dcorr for {subject_id}, sample {i}: {e}\")\n", " \n", " # For all models, calculate fusion (or envelope) distance correlation\n", " try:\n", " fusion_dcorr = distance_correlation(envelope.reshape(-1), gt.reshape(-1))\n", " if not np.isnan(fusion_dcorr):\n", " fusion_average_dcorr.append(fusion_dcorr)\n", " except Exception as e:\n", " print(f\"Error calculating fusion dcorr for {subject_id}, sample {i}: {e}\")\n", "\n", " # Only save branch scores if they exist\n", " if has_branches and eeg_branch_average_dcorr and envelope_branch_average_dcorr:\n", " subject_scores[\"eeg_branch\"][subject_id] = np.mean(eeg_branch_average_dcorr)\n", " subject_scores[\"envelope_branch\"][subject_id] = np.mean(envelope_branch_average_dcorr)\n", " \n", " if fusion_average_dcorr:\n", " subject_scores[\"fusion\"][subject_id] = np.mean(fusion_average_dcorr)\n", "\n", " return subject_scores\n", "\n", "def plot_average_psd(model_path):\n", " \"\"\"\n", " Plot average PSD for ground truth and all predictions (fusion, eeg branch, envelope branch).\n", " Includes normalization of signals before PSD calculation.\n", " \n", " Args:\n", " model_path (str): Path to the pickle file containing model data\n", " \"\"\"\n", " import numpy as np\n", " from scipy import signal\n", " import matplotlib.pyplot as plt\n", " \n", " def normalize_signal(x):\n", " \"\"\"Normalize signal to zero mean and unit variance\"\"\"\n", " return (x - np.mean(x)) / np.std(x)\n", " \n", " # Load data\n", " with open(model_path, 'rb') as f:\n", " model_data = pickle.load(f)\n", " \n", " # Check if model has branches\n", " sample_output = model_data[\"outputs\"][0]\n", " has_branches = \"envelope_branch\" in sample_output and \"eeg_branch\" in sample_output\n", " \n", " # Initialize lists to store PSDs\n", " gt_psds = []\n", " fusion_psds = []\n", " eeg_psds = []\n", " envelope_psds = []\n", " \n", " # Assuming sampling rate of 64 Hz (modify if different)\n", " fs = 64\n", " \n", " # Calculate PSD for each trial\n", " for i in range(len(model_data[\"outputs\"])):\n", " # Normalize signals before calculating PSD\n", " gt = normalize_signal(model_data[\"ground_truths\"][i].reshape(-1))\n", " envelope = normalize_signal(model_data[\"outputs\"][i][\"envelope\"].reshape(-1))\n", " \n", " # Calculate PSD for ground truth\n", " f, gt_psd = signal.welch(gt, fs=fs, nperseg=128)\n", " gt_psds.append(gt_psd)\n", " \n", " # Calculate PSD for fusion/envelope\n", " f, fusion_psd = signal.welch(envelope, fs=fs, nperseg=128)\n", " fusion_psds.append(fusion_psd)\n", " \n", " if has_branches:\n", " envelope_branch = normalize_signal(model_data[\"outputs\"][i][\"envelope_branch\"].reshape(-1))\n", " eeg_branch = normalize_signal(model_data[\"outputs\"][i][\"eeg_branch\"].reshape(-1))\n", " \n", " # Calculate PSD for branch predictions\n", " f, eeg_psd = signal.welch(eeg_branch, fs=fs, nperseg=128)\n", " f, env_psd = signal.welch(envelope_branch, fs=fs, nperseg=128)\n", " \n", " eeg_psds.append(eeg_psd)\n", " envelope_psds.append(env_psd)\n", " \n", " # Calculate means\n", " mean_gt_psd = np.mean(gt_psds, axis=0)\n", " mean_fusion_psd = np.mean(fusion_psds, axis=0)\n", " \n", " # Plot\n", " plt.figure(figsize=(10, 6))\n", " plt.semilogy(f, mean_gt_psd, 'k', label='Ground Truth', alpha=0.8)\n", " \n", " if has_branches:\n", " mean_eeg_psd = np.mean(eeg_psds, axis=0)\n", " mean_env_psd = np.mean(envelope_psds, axis=0)\n", " \n", " plt.semilogy(f, mean_eeg_psd, 'r', label='EEG Branch', alpha=0.8)\n", " plt.semilogy(f, mean_env_psd, 'b', label='Envelope Branch', alpha=0.8)\n", " plt.semilogy(f, mean_fusion_psd, 'orange', label='Fusion', alpha=0.8)\n", " else:\n", " plt.semilogy(f, mean_fusion_psd, 'gray', label='Model Output', alpha=0.8)\n", " \n", " plt.xlabel('Frequency [Hz]')\n", " plt.ylabel('PSD [V**2/Hz]')\n", " plt.title('Average Power Spectral Density (Normalized Signals)')\n", " plt.grid(True)\n", " plt.legend()\n", " plt.tight_layout()\n", " plt.show()\n", " \n", " return f, {\n", " 'ground_truth': mean_gt_psd,\n", " 'fusion': mean_fusion_psd,\n", " 'eeg_branch': np.mean(eeg_psds, axis=0) if has_branches else None,\n", " 'envelope_branch': np.mean(envelope_psds, axis=0) if has_branches else None\n", " }\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.gridspec as gridspec\n", "import pickle\n", "from scipy import signal\n", "\n", "def plot_model_comparison_grid(model_paths_dict):\n", " \"\"\"\n", " Create a publication-quality grid of PSD plots for different models.\n", " \n", " Args:\n", " model_paths_dict: Dictionary with keys as model names (e.g., '0.05s') and values as model paths\n", " \"\"\"\n", " def normalize_signal(x):\n", " \"\"\"Normalize signal to zero mean and unit variance\"\"\"\n", " return (x - np.mean(x)) / np.std(x)\n", " \n", " def calculate_psd_for_model(model_path):\n", " \"\"\"Calculate PSD for a single model\"\"\"\n", " with open(model_path, 'rb') as f:\n", " model_data = pickle.load(f)\n", " \n", " # Check if model has branches\n", " sample_output = model_data[\"outputs\"][0]\n", " has_branches = \"envelope_branch\" in sample_output and \"eeg_branch\" in sample_output\n", " \n", " # Initialize lists to store PSDs\n", " gt_psds = []\n", " fusion_psds = []\n", " eeg_psds = []\n", " envelope_psds = []\n", " \n", " # Assuming sampling rate of 64 Hz\n", " fs = 64\n", " \n", " # Calculate PSD for each trial\n", " for i in range(len(model_data[\"outputs\"])):\n", " # Normalize signals before calculating PSD\n", " gt = normalize_signal(model_data[\"ground_truths\"][i].reshape(-1))\n", " envelope = normalize_signal(model_data[\"outputs\"][i][\"envelope\"].reshape(-1))\n", " \n", " # Calculate PSD for ground truth and fusion\n", " f, gt_psd = signal.welch(gt, fs=fs, nperseg=128)\n", " gt_psds.append(gt_psd)\n", " \n", " f, fusion_psd = signal.welch(envelope, fs=fs, nperseg=128)\n", " fusion_psds.append(fusion_psd)\n", " \n", " if has_branches:\n", " envelope_branch = normalize_signal(model_data[\"outputs\"][i][\"envelope_branch\"].reshape(-1))\n", " eeg_branch = normalize_signal(model_data[\"outputs\"][i][\"eeg_branch\"].reshape(-1))\n", " \n", " f, eeg_psd = signal.welch(eeg_branch, fs=fs, nperseg=128)\n", " f, env_psd = signal.welch(envelope_branch, fs=fs, nperseg=128)\n", " \n", " eeg_psds.append(eeg_psd)\n", " envelope_psds.append(env_psd)\n", " \n", " return f, {\n", " 'gt': np.mean(gt_psds, axis=0),\n", " 'fusion': np.mean(fusion_psds, axis=0),\n", " 'eeg': np.mean(eeg_psds, axis=0) if has_branches else None,\n", " 'envelope': np.mean(envelope_psds, axis=0) if has_branches else None,\n", " 'has_branches': has_branches\n", " }\n", " \n", " # Set publication-quality style\n", " plt.style.use('seaborn-paper')\n", " \n", " # Create figure with subplots\n", " fig = plt.figure(figsize=(15, 10))\n", " gs = gridspec.GridSpec(3, 4, figure=fig)\n", " \n", " # Define consistent colors and styles\n", " colors = {\n", " 'ground_truth': 'k',\n", " 'eeg_branch': 'r',\n", " 'envelope_branch': 'b',\n", " 'fusion': 'orange',\n", " 'no_branch': 'gray'\n", " }\n", " \n", " for idx, (model_name, model_path) in enumerate(model_paths_dict.items()):\n", " ax = fig.add_subplot(gs[idx//4, idx%4])\n", " \n", " # Calculate PSD for this model\n", " f, psds = calculate_psd_for_model(model_path)\n", " \n", " # Plot with consistent styling\n", " ax.semilogy(f, psds['gt'], colors['ground_truth'], \n", " label='Ground Truth', alpha=0.8, linewidth=1.5)\n", " \n", " if psds['has_branches']:\n", " ax.semilogy(f, psds['eeg'], colors['eeg_branch'], \n", " label='EEG', alpha=0.8, linewidth=1.5)\n", " ax.semilogy(f, psds['envelope'], colors['envelope_branch'], \n", " label='Env', alpha=0.8, linewidth=1.5)\n", " ax.semilogy(f, psds['fusion'], colors['fusion'], \n", " label='Fusion', alpha=0.8, linewidth=1.5)\n", " else:\n", " ax.semilogy(f, psds['fusion'], colors['no_branch'], \n", " label='Output', alpha=0.8, linewidth=1.5)\n", " \n", " # Set title and labels\n", " ax.set_title(f'Context: {model_name}s', fontsize=10)\n", " ax.set_xlabel('Frequency [Hz]', fontsize=9)\n", " ax.set_ylabel('PSD [V²/Hz]', fontsize=9)\n", " ax.grid(True, which='both', linestyle='--', alpha=0.3)\n", " ax.tick_params(labelsize=8)\n", " \n", " if idx == len(model_paths_dict) - 1: # Changed from idx == 0\n", " ax.legend(fontsize=8, frameon=True, \n", " bbox_to_anchor=(1.05, 1), # Position legend to the right\n", " loc='upper left') # Align to upper left of bbox\n", " \n", " # Set consistent y-axis limits across all subplots\n", " ax.set_ylim(1e-5, 1e1) # Adjust these values based on your data\n", " ax.set_xlim(0, 32) # Adjust if you want to show different frequency range\n", " \n", " # Adjust layout\n", " plt.tight_layout()\n", " \n", " # Add a common title\n", " fig.suptitle('Power Spectral Density Across Different Context Lengths', \n", " fontsize=12, y=1.02)\n", " \n", " return fig\n", "\n", "def plot_frequency_band_comparison(model_paths_dict):\n", " \"\"\"\n", " Create a publication-quality grid showing average power in different frequency bands\n", " for each model using bar plots.\n", " \n", " Args:\n", " model_paths_dict: Dictionary with keys as model names and values as model paths\n", " \"\"\"\n", " import numpy as np\n", " import matplotlib.pyplot as plt\n", " import matplotlib.gridspec as gridspec\n", " from scipy import signal\n", "\n", " \n", " def normalize_signal(x):\n", " \"\"\"Normalize signal to zero mean and unit variance\"\"\"\n", " return (x - np.mean(x)) / np.std(x)\n", " \n", " def calculate_band_power(psd, freqs, band):\n", " \"\"\"Calculate average power in a frequency band\"\"\"\n", " mask = (freqs >= band[0]) & (freqs < band[1])\n", " return np.mean(psd[mask])\n", " \n", " def calculate_powers_for_model(model_path):\n", " \"\"\"Calculate average power in different bands for a model\"\"\"\n", " with open(model_path, 'rb') as f:\n", " model_data = pickle.load(f)\n", " \n", " # Check if model has branches\n", " sample_output = model_data[\"outputs\"][0]\n", " has_branches = \"envelope_branch\" in sample_output and \"eeg_branch\" in sample_output\n", " \n", " # Define frequency bands\n", " bands = [(0, 10), (10, 20), (20, 30)]\n", " \n", " # Initialize power arrays\n", " powers = {\n", " 'gt': np.zeros((len(bands),)),\n", " 'fusion': np.zeros((len(bands),)),\n", " 'eeg': np.zeros((len(bands),)) if has_branches else None,\n", " 'envelope': np.zeros((len(bands),)) if has_branches else None,\n", " 'has_branches': has_branches\n", " }\n", " \n", " # Calculate power for each trial\n", " for i in range(len(model_data[\"outputs\"])):\n", " # Normalize signals\n", " gt = normalize_signal(model_data[\"ground_truths\"][i].reshape(-1))\n", " envelope = normalize_signal(model_data[\"outputs\"][i][\"envelope\"].reshape(-1))\n", " \n", " # Calculate PSDs\n", " f, gt_psd = signal.welch(gt, fs=64, nperseg=128)\n", " _, fusion_psd = signal.welch(envelope, fs=64, nperseg=128)\n", " \n", " # Calculate band powers\n", " for j, band in enumerate(bands):\n", " powers['gt'][j] += calculate_band_power(gt_psd, f, band)\n", " powers['fusion'][j] += calculate_band_power(fusion_psd, f, band)\n", " \n", " if has_branches:\n", " envelope_branch = normalize_signal(model_data[\"outputs\"][i][\"envelope_branch\"].reshape(-1))\n", " eeg_branch = normalize_signal(model_data[\"outputs\"][i][\"eeg_branch\"].reshape(-1))\n", " \n", " _, eeg_psd = signal.welch(eeg_branch, fs=64, nperseg=128)\n", " _, env_psd = signal.welch(envelope_branch, fs=64, nperseg=128)\n", " \n", " for j, band in enumerate(bands):\n", " powers['eeg'][j] += calculate_band_power(eeg_psd, f, band)\n", " powers['envelope'][j] += calculate_band_power(env_psd, f, band)\n", " \n", " # Average powers\n", " n_trials = len(model_data[\"outputs\"])\n", " powers['gt'] /= n_trials\n", " powers['fusion'] /= n_trials\n", " if has_branches:\n", " powers['eeg'] /= n_trials\n", " powers['envelope'] /= n_trials\n", " \n", " return powers\n", " \n", " # Set publication-quality style\n", " plt.style.use('seaborn-paper')\n", " \n", " # Calculate required grid size\n", " n_models = len(model_paths_dict)\n", " n_cols = 4\n", " n_rows = (n_models + n_cols - 1) // n_cols # Ceiling division to ensure enough rows\n", " \n", " # Create figure with subplots\n", " fig = plt.figure(figsize=(15, 5*n_rows)) # Adjust figure height based on rows\n", " gs = gridspec.GridSpec(n_rows, n_cols, figure=fig)\n", " \n", " # Define colors and band labels\n", " colors = {\n", " 'ground_truth': 'k',\n", " 'eeg_branch': 'r',\n", " 'envelope_branch': 'b',\n", " 'fusion': 'orange',\n", " 'no_branch': 'gray'\n", " }\n", " bands = ['0-10 Hz', '10-20 Hz', '20-30 Hz']\n", " \n", " for idx, (model_name, model_path) in enumerate(model_paths_dict.items()):\n", " ax = fig.add_subplot(gs[idx//4, idx%4])\n", " \n", " # Calculate powers for this model\n", " powers = calculate_powers_for_model(model_path)\n", " \n", " # Set up bar positions\n", " x = np.arange(len(bands))\n", " width = 0.15\n", " \n", " # Plot bars\n", " ax.set_yscale('log') # Set log scale for y-axis\n", " \n", " # Plot bars\n", " ax.bar(x - 1.5*width, powers['gt'], width, label='Ground Truth', \n", " color=colors['ground_truth'], alpha=0.7)\n", " \n", " if powers['has_branches']:\n", " ax.bar(x - 0.5*width, powers['eeg'], width, label='EEG', \n", " color=colors['eeg_branch'], alpha=0.7)\n", " ax.bar(x + 0.5*width, powers['envelope'], width, label='Env', \n", " color=colors['envelope_branch'], alpha=0.7)\n", " ax.bar(x + 1.5*width, powers['fusion'], width, label='Fusion', \n", " color=colors['fusion'], alpha=0.7)\n", " else:\n", " ax.bar(x + 0.5*width, powers['fusion'], width, label='Output', \n", " color=colors['no_branch'], alpha=0.7)\n", " \n", " # Customize plot\n", " ax.set_title(f'Context: {model_name}s', fontsize=10)\n", " ax.set_xticks(x)\n", " ax.set_xticklabels(bands, fontsize=8)\n", " ax.tick_params(axis='y', labelsize=8)\n", " ax.set_ylabel('Average Power (log scale)', fontsize=9) # Updated ylabel\n", " ax.grid(True, axis='y', linestyle='--', alpha=0.3)\n", " \n", " # Set consistent y-axis limits for all subplots\n", " ax.set_ylim(1e-6, 1e1) # Adjust these values based on your data range\n", " \n", " # Add legend to last subplot\n", " if idx == len(model_paths_dict) - 1:\n", " ax.legend(fontsize=8, frameon=True, \n", " bbox_to_anchor=(1.05, 1), \n", " loc='upper left')\n", " \n", " # Add title and adjust layout\n", " fig.suptitle('Average Power in Frequency Bands Across Different Context Lengths', \n", " fontsize=12, y=1.02)\n", " plt.tight_layout()\n", " \n", " return fig" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/karan/anaconda3/envs/eeg_MT_s4/lib/python3.8/site-packages/numpy/lib/function_base.py:2854: RuntimeWarning: invalid value encountered in divide\n", " c /= stddev[:, None]\n", "/home/karan/anaconda3/envs/eeg_MT_s4/lib/python3.8/site-packages/numpy/lib/function_base.py:2855: RuntimeWarning: invalid value encountered in divide\n", " c /= stddev[None, :]\n" ] } ], "source": [ "linear_baseline_model = \"checkpoints_no_scaled/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_BaselineDecoder2_pearson_l1_baseline_decoder2_20250315_004035.pkl\"\n", "vlaai_model = \"checkpoints_no_scaled/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_Vlaai_pearson_l1_vlaai_20250315_045747.pkl\"\n", "#happyquoka4_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_Happyquoka4_pearson_l1_happyquoka4_20250314_230318.pkl\"\n", "happyquoka4_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_HappyquokaScaled_pearson_l1_happyquoka4_20250502_173409.pkl\"\n", "\n", "#fusion_0p05_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.05SecDynamic_pearson_l1_two_branch_context_0.05sec_dynamic_20250320_123756.pkl\"\n", "fusion_0p05_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.05SecDynamic_pearson_l1_two_branch_context_0.05sec_dynamic_20250503_033025.pkl\"\n", "\n", "#fusion_0p1_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.1SecDynamic_pearson_l1_two_branch_context_0.1sec_dynamic_20250320_164805.pkl\"\n", "fusion_0p1_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.15SecDynamic_pearson_l1_two_branch_context_0.15sec_dynamic_20250503_091231.pkl\"\n", "\n", "#fusion_0p15_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.15SecDynamic_pearson_l1_two_branch_context_0.15sec_dynamic_20250320_194734.pkl\"\n", "fusion_0p15_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.15SecDynamic_pearson_l1_two_branch_context_0.15sec_dynamic_20250503_091231.pkl\"\n", "\n", "\n", "#fusion_0p2_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.2SecDynamic_pearson_l1_two_branch_context_0.2sec_dynamic_20250320_123934.pkl\"\n", "#fusion_0p2_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.2SecDynamic_pearson_l1_two_branch_context_0.2sec_dynamic_20250320_224056.pkl\"\n", "fusion_0p2_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.2SecDynamic_pearson_l1_two_branch_context_0.2sec_dynamic_20250502_214534.pkl\"\n", "\n", "#fusion_0p25_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.25SecDynamic_pearson_l1_two_branch_context_0.25sec_dynamic_20250320_153455.pkl\"\n", "fusion_0p25_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.25SecDynamic_pearson_l1_two_branch_context_0.25sec_dynamic_20250503_014053.pkl\"\n", "\n", "#fusion_0p5_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.5SecDynamic_pearson_l1_two_branch_context_0.5sec_dynamic_20250320_181900.pkl\"\n", "fusion_0p5_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext0.5SecDynamic_pearson_l1_two_branch_context_0.5sec_dynamic_20250503_053609.pkl\"\n", "\n", "#fusion_1p0_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext1.0SecDynamic_pearson_l1_two_branch_context_1.0sec_dynamic_20250320_211305.pkl\"\n", "fusion_1p0_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext1.0SecDynamic_pearson_l1_two_branch_context_1.0sec_dynamic_20250503_093737.pkl\"\n", "\n", "#fusion_1p5_model = \"checkpoints/model_comparison_analysis/visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext1.5SecDynamic_pearson_l1_two_branch_context_1.5sec_dynamic_20250321_000620.pkl\"\n", "fusion_1p5_model = \"checkpoints/model_comparison_analysis/test_visualizations_test_cropped_ending_at_0.5sec/model_data_TwoBranchContext1.5SecDynamic_pearson_l1_two_branch_context_1.5sec_dynamic_20250503_132804.pkl\"\n", "\n", "\n", "# Example usage:\n", "model_scores = {\n", " 'linear_baseline': get_subject_scores(linear_baseline_model),\n", " 'vlaai': get_subject_scores(vlaai_model),\n", " 'happyquoka4': get_subject_scores(happyquoka4_model),\n", " '0.05sec': get_subject_scores(fusion_0p05_model),\n", " '0.1sec': get_subject_scores(fusion_0p1_model),\n", " '0.15sec': get_subject_scores(fusion_0p15_model),\n", " '0.2sec': get_subject_scores(fusion_0p2_model),\n", " '0.25sec': get_subject_scores(fusion_0p25_model),\n", " '0.5sec': get_subject_scores(fusion_0p5_model),\n", " '1.0sec': get_subject_scores(fusion_1p0_model),\n", " '1.5sec': get_subject_scores(fusion_1p5_model)\n", " }\n", "\n", "# Example usage:\n", "\"\"\"model_scores_dcorr = {\n", " 'linear_baseline': get_subject_scores_dcorr(linear_baseline_model),\n", " 'vlaai': get_subject_scores_dcorr(vlaai_model),\n", " 'happyquoka4': get_subject_scores_dcorr(happyquoka4_model),\n", " '0.05sec': get_subject_scores_dcorr(fusion_0p05_model),\n", " '0.1sec': get_subject_scores_dcorr(fusion_0p1_model),\n", " '0.15sec': get_subject_scores_dcorr(fusion_0p15_model),\n", " '0.2sec': get_subject_scores_dcorr(fusion_0p2_model),\n", " '0.25sec': get_subject_scores_dcorr(fusion_0p25_model),\n", " '0.5sec': get_subject_scores_dcorr(fusion_0p5_model),\n", " '1.0sec': get_subject_scores_dcorr(fusion_1p0_model),\n", " '1.5sec': get_subject_scores_dcorr(fusion_1p5_model)\n", " }\"\"\"\n", "\n", "model_paths = {\n", " 'linear_baseline': linear_baseline_model,\n", " 'vlaai': vlaai_model,\n", " 'happyquoka4': happyquoka4_model,\n", " '0.05sec': fusion_0p05_model,\n", " '0.1sec': fusion_0p1_model,\n", " '0.15sec': fusion_0p15_model,\n", " '0.2sec': fusion_0p2_model,\n", " '0.25sec': fusion_0p25_model,\n", " '0.5sec': fusion_0p5_model,\n", " '1.0sec': fusion_1p0_model,\n", " '1.5sec': fusion_1p5_model,\n", "}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1761133/530614111.py:390: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-