diff --git "a/main-multisession-3tasks.ipynb" "b/main-multisession-3tasks.ipynb"
new file mode 100644--- /dev/null
+++ "b/main-multisession-3tasks.ipynb"
@@ -0,0 +1,3321 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b0f0f4f3",
+   "metadata": {},
+   "source": [
+    "# Import packages & functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5bad764b-45c1-45ce-a716-8d055e09821a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n",
+      "SLURM seed not found, using default: 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"importing modules\")\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "import webdataset as wds\n",
+    "from PIL import Image\n",
+    "import pandas as pd\n",
+    "import nibabel as nib\n",
+    "import nilearn\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "import utils\n",
+    "from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas\n",
+    "\n",
+    "# imports utils from mindeye_preproc as \"preproc\"\n",
+    "import importlib.util\n",
+    "parent_utils_path = \"/home/ri4541/mindeye_preproc/analysis/utils.py\"\n",
+    "spec = importlib.util.spec_from_file_location(\"utils\", parent_utils_path)\n",
+    "preproc = importlib.util.module_from_spec(spec)\n",
+    "parent_dir = os.path.dirname(parent_utils_path)\n",
+    "if parent_dir not in sys.path:\n",
+    "    sys.path.append(parent_dir)\n",
+    "spec.loader.exec_module(preproc)\n",
+    "\n",
+    "if utils.is_interactive():\n",
+    "    from IPython.display import clear_output # function to clear print outputs in cell\n",
+    "    %load_ext autoreload \n",
+    "    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n",
+    "    %autoreload 2 \n",
+    "    \n",
+    "seed = utils.get_slurm_seed()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bae2b2ad-e1ef-4262-8263-6ae9a0766caa",
+   "metadata": {},
+   "source": [
+    "# Princeton data prep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6dbeabe-9e9c-4d8d-a8c3-414d79d14e63",
+   "metadata": {},
+   "source": [
+    "## Load Data & Design"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "0f2d14fc-bfe3-40dc-b14e-070812c43406",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub: sub-005\n",
+      "session: ses-04\n",
+      "task: B\n",
+      "func_task_name: B\n",
+      "ses_list: ['ses-04']\n",
+      "design_ses_list: ['ses-04']\n",
+      "task_name: _task-B\n",
+      "resample_voxel_size: True\n",
+      "resample_post_glmsingle: False\n",
+      "load_from_resampled_file: False\n",
+      "train_test_split: MST\n",
+      "remove_close_to_MST: False\n",
+      "remove_random_n: False\n",
+      "n_to_remove: 0\n",
+      "resampled_vox_size: 2.0\n",
+      "resample_method: trilinear\n",
+      "resampled_suffix: resampled_2_0mm_trilinear\n",
+      "mask_resampled_suffix: resampled_2_0mm_trilinear\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_flag(name, default, cast=int):\n",
+    "    \"\"\"Retrieve a flag from environment variables or return a default value.\"\"\"\n",
+    "    if utils.is_interactive():\n",
+    "        return default\n",
+    "    val = os.environ.get(name.upper(), str(default))\n",
+    "    print(f\"Retrieved {name.upper()} from environment: {val}\")\n",
+    "    \n",
+    "    if cast == bool:\n",
+    "        # Explicitly handle string conversion to boolean\n",
+    "        if val.lower() in ['true', '1']:\n",
+    "            return True\n",
+    "        elif val.lower() in ['false', '0']:\n",
+    "            return False\n",
+    "        else:\n",
+    "            return bool(val)  # Fallback to default casting behavior\n",
+    "    \n",
+    "    try:\n",
+    "        return cast(val)\n",
+    "    except Exception:\n",
+    "        return val\n",
+    "    \n",
+    "if not utils.is_interactive():\n",
+    "    print('running non-interactively')\n",
+    "    \n",
+    "# Define variables using get_flag\n",
+    "sub = get_flag('SUB', 'sub-005', cast=str)\n",
+    "session = get_flag('SESSION', 'ses-04', cast=str)  # 'ses-xx', 'all'\n",
+    "task = get_flag('TASK', 'B', cast=str)  # 'study', 'A', or 'B'\n",
+    "func_task_name = get_flag('FUNC_TASK_NAME', 'B', cast=str)\n",
+    "\n",
+    "if session == \"all\":\n",
+    "    ses_list = [\"ses-01\", \"ses-02\"]  # list of actual session IDs\n",
+    "    design_ses_list = [\"ses-01\", \"ses-02\"]  # list of session IDs to search for design matrix\n",
+    "else:\n",
+    "    ses_list = [session]\n",
+    "    design_ses_list = [session]\n",
+    "\n",
+    "task_name = f\"_task-{task}\" if task != 'study' else ''\n",
+    "resample_voxel_size = get_flag('RESAMPLE_VOXEL_SIZE', True, cast=bool)\n",
+    "resample_post_glmsingle = get_flag('RESAMPLE_POST_GLMSINGLE', False, cast=bool)\n",
+    "load_from_resampled_file = get_flag('LOAD_FROM_RESAMPLED_FILE', False, cast=bool)\n",
+    "\n",
+    "train_test_split = get_flag('TRAIN_TEST_SPLIT', 'MST', cast=str)\n",
+    "remove_close_to_MST = get_flag('REMOVE_CLOSE_TO_MST', False, cast=bool)\n",
+    "remove_random_n = get_flag('REMOVE_RANDOM_N', False, cast=bool)\n",
+    "if remove_close_to_MST or remove_random_n:\n",
+    "    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images\n",
+    "\n",
+    "n_to_remove = 0\n",
+    "if remove_random_n:\n",
+    "    assert train_test_split == 'MST'  # MST images are excluded from the n images removed, so only makes sense if they're not in the training set\n",
+    "    n_to_remove = 150\n",
+    "    \n",
+    "if resample_voxel_size:\n",
+    "    resampled_vox_size = get_flag('RESAMPLED_VOX_SIZE', 2.0, cast=float)\n",
+    "    resample_method = get_flag('RESAMPLE_METHOD', 'trilinear', cast=str)\n",
+    "    \n",
+    "    vox_dim_str = str(resampled_vox_size).replace('.', '_')\n",
+    "    resampled_suffix = f\"resampled_{vox_dim_str}mm_{resample_method}\"\n",
+    "    mask_resampled_suffix = resampled_suffix\n",
+    "    if resample_post_glmsingle:\n",
+    "        resampled_suffix += '_postglmsingle'      \n",
+    "        \n",
+    "    print('resample_voxel_size:', resample_voxel_size)\n",
+    "    print('resample_post_glmsingle:', resample_post_glmsingle)\n",
+    "    print('load_from_resampled_file:', load_from_resampled_file)\n",
+    "    print('resampled_vox_size:', resampled_vox_size)\n",
+    "    print('resample_method:', resample_method)\n",
+    "    print('resampled_suffix:', resampled_suffix)\n",
+    "    print('mask_resampled_suffix:', mask_resampled_suffix)\n",
+    "print('sub:', sub)\n",
+    "print('session:', session)\n",
+    "print('task:', task)\n",
+    "print('func_task_name:', func_task_name)\n",
+    "print('ses_list:', ses_list)\n",
+    "print('design_ses_list:', design_ses_list)\n",
+    "print('task_name:', task_name)\n",
+    "print('train_test_split:', train_test_split)\n",
+    "print('remove_close_to_MST:', remove_close_to_MST)\n",
+    "print('remove_random_n:', remove_random_n)\n",
+    "print('n_to_remove:', n_to_remove)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "67d4c658-b30e-4e82-b0d1-0731cc619751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "session label: ses-04\n"
+     ]
+    }
+   ],
+   "source": [
+    "session_label = preproc.get_session_label(ses_list)\n",
+    "print('session label:', session_label)\n",
+    "n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d5d98f76-1ae9-4880-93ec-cdc65e2b09a8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-04_task-B\n",
+      "glmsingle path: /scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-04_task-B_resampled_2_0mm_trilinear\n",
+      "glmsingle path exists!\n"
+     ]
+    }
+   ],
+   "source": [
+    "if utils.is_interactive():\n",
+    "    glmsingle_path = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}\"\n",
+    "else:\n",
+    "    glmsingle_path = os.environ[\"glmsingle_path\"]\n",
+    "    \n",
+    "designdir = \"/home/ri4541/real_time_mindEye2\"\n",
+    "print(glmsingle_path)\n",
+    "\n",
+    "if resample_voxel_size:\n",
+    "    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here\n",
+    "    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here\n",
+    "    if resample_post_glmsingle:\n",
+    "        # option 1\n",
+    "        orig_glmsingle_path = glmsingle_path\n",
+    "        glmsingle_path += f\"_{resampled_suffix}\"\n",
+    "        print(\"resampled glmsingle path:\", glmsingle_path)\n",
+    "        if load_from_resampled_file:\n",
+    "            # resampling is already done; load from file\n",
+    "             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here\n",
+    "        else:\n",
+    "            # don't load from file; do resampling here\n",
+    "            os.makedirs(glmsingle_path,exist_ok=True)\n",
+    "    else:\n",
+    "        # option 2\n",
+    "        glmsingle_path += f\"_{resampled_suffix}\"\n",
+    "        print(\"glmsingle path:\", glmsingle_path)\n",
+    "\n",
+    "assert os.path.exists(glmsingle_path)\n",
+    "print(\"glmsingle path exists!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "34c1e0c6-0641-4239-8201-f2c676532302",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data shape: (360, 101)\n",
+      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-06.csv\n",
+      "Total number of images: 350\n",
+      "Number of unique images: 201\n",
+      "n_runs 5\n",
+      "['all_stimuli/special515/special_13613.jpg'\n",
+      " 'all_stimuli/shared1000_notspecial/notspecial_31049.png'\n",
+      " 'all_stimuli/special515/special_28096.jpg'\n",
+      " 'all_stimuli/shared1000_notspecial/notspecial_68471.png']\n",
+      "[111.1983511 115.2323401 119.2232459 123.2833759]\n",
+      "[0. 0. 0. 0.]\n",
+      "(315,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(\n",
+    "    sub=sub,\n",
+    "    session=session,\n",
+    "    func_task_name=task,\n",
+    "    designdir=designdir,\n",
+    "    design_ses_list=design_ses_list\n",
+    ")\n",
+    "\n",
+    "if sub == 'sub-001':\n",
+    "    if session == 'ses-01':\n",
+    "        assert image_names[0] == 'images/image_686_seed_1.png'\n",
+    "    elif session in ('ses-02', 'all'):\n",
+    "        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'\n",
+    "    elif session == 'ses-03':\n",
+    "        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'\n",
+    "    elif session == 'ses-04':\n",
+    "        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'\n",
+    "elif sub == 'sub-003':\n",
+    "    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'\n",
+    "\n",
+    "unique_images = np.unique(image_names.astype(str))\n",
+    "unique_images = unique_images[(unique_images!=\"nan\")]\n",
+    "len_unique_images = len(unique_images)\n",
+    "print(\"n_runs\",n_runs)\n",
+    "\n",
+    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "    assert len(unique_images) == 851\n",
+    "\n",
+    "print(image_names[:4])\n",
+    "print(starts[:4])\n",
+    "print(is_new_run[:4])\n",
+    "\n",
+    "if remove_random_n:\n",
+    "    # want to remove 150 imgs\n",
+    "    # 100 special515 imgs are repeated 3x (300 total)\n",
+    "    # all other train imgs are only shown once (558 total)\n",
+    "    # of the 150, want to sample proportionally since we're cutting all repeats for special515\n",
+    "    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total\n",
+    "    np.random.seed(seed)\n",
+    "    options_to_remove = [x for x in set(image_names) if str(x) != 'nan' and x != 'blank.jpg' and 'MST_pairs' not in x and 'special515' not in x and list(image_names).count(x)==1]  # all the imgs that only appear once (this is O(N^2) b/c of count() within list comprehension but image_names is a relatively small list)\n",
+    "    options_to_remove_special515 = [x for x in set(image_names) if str(x) != 'nan' and x != 'blank.jpg' and 'MST_pairs' not in x and 'special515' in x and list(image_names).count(x)>1]  # all the special515 images that are repeated (count()>1 necessary because there are special515 that are not repeated)\n",
+    "    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)\n",
+    "    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))\n",
+    "\n",
+    "image_idx = np.array([])  # contains the unique index of each presented image\n",
+    "vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx\n",
+    "all_MST_images = dict()\n",
+    "for i, im in enumerate(image_names):\n",
+    "    # skip if blank, nan\n",
+    "    if im == \"blank.jpg\":\n",
+    "        i+=1\n",
+    "        continue\n",
+    "    if str(im) == \"nan\":\n",
+    "        i+=1\n",
+    "        continue\n",
+    "    vox_image_names = np.append(vox_image_names, im)\n",
+    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
+    "        if \"closest_pairs\" in im:\n",
+    "            i+=1\n",
+    "            continue\n",
+    "    elif remove_random_n:\n",
+    "        if im in imgs_to_remove:\n",
+    "            i+=1\n",
+    "            continue\n",
+    "            \n",
+    "    image_idx_ = np.where(im==unique_images)[0].item()\n",
+    "    image_idx = np.append(image_idx, image_idx_)\n",
+    "    \n",
+    "    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):  # MST images are ones that matched these image titles\n",
+    "        import re\n",
+    "        if ('w_' in im or 'paired_image_' in im or re.match(r'all_stimuli/rtmindeye_stimuli/\\d{1,2}_\\d{1,3}\\.png$', im) or re.match(r'images/\\d{1,2}_\\d{1,3}\\.png$', im)):  \n",
+    "        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it\n",
+    "            # print(im)\n",
+    "            all_MST_images[i] = im\n",
+    "            i+=1            \n",
+    "    elif 'MST' in im:\n",
+    "        all_MST_images[i] = im\n",
+    "        i+=1\n",
+    "    \n",
+    "image_idx = torch.Tensor(image_idx).long()\n",
+    "# for im in new_image_names[MST_images]:\n",
+    "#     assert 'MST_pairs' in im\n",
+    "# assert len(all_MST_images) == 300\n",
+    "\n",
+    "unique_MST_images = np.unique(list(all_MST_images.values())) \n",
+    "\n",
+    "MST_ID = np.array([], dtype=int)\n",
+    "if remove_close_to_MST:\n",
+    "    close_to_MST_idx = np.array([], dtype=int)\n",
+    "if remove_random_n:\n",
+    "    random_n_idx = np.array([], dtype=int)\n",
+    "\n",
+    "vox_idx = np.array([], dtype=int)\n",
+    "j=0  # this is a counter keeping track of the remove_random_n used later to index vox based on the removed images; unused otherwise\n",
+    "for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure\n",
+    "    # skip if blank, nan\n",
+    "    if im == \"blank.jpg\":\n",
+    "        i+=1\n",
+    "        continue\n",
+    "    if str(im) == \"nan\":\n",
+    "        i+=1\n",
+    "        continue\n",
+    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
+    "        if \"closest_pairs\" in im:\n",
+    "            close_to_MST_idx = np.append(close_to_MST_idx, i)\n",
+    "            i+=1\n",
+    "            continue\n",
+    "    if remove_random_n:\n",
+    "        if im in imgs_to_remove:\n",
+    "            vox_idx = np.append(vox_idx, j)\n",
+    "            i+=1\n",
+    "            j+=1\n",
+    "            continue\n",
+    "    j+=1\n",
+    "    curr = np.where(im == unique_MST_images)\n",
+    "    # print(curr)\n",
+    "    if curr[0].size == 0:\n",
+    "        MST_ID = np.append(MST_ID, np.array(len(unique_MST_images)))  # add a value that should be out of range based on the for loop, will index it out later\n",
+    "    else:\n",
+    "        MST_ID = np.append(MST_ID, curr)\n",
+    "        \n",
+    "assert len(MST_ID) == len(image_idx)\n",
+    "# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)\n",
+    "# MST_ID = torch.tensor(MST_ID[MST_ID != len(unique_MST_images)], dtype=torch.uint8)  # torch.tensor (lowercase) allows dtype kwarg, Tensor (uppercase) is an alias for torch.FloatTensor\n",
+    "print(MST_ID.shape)\n",
+    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "    assert len(all_MST_images) == 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e48ffe08-71ec-4a3f-9371-66fed2c21de4",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Load images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "2ceb404f-b04f-42b6-afc4-283bb2b40c08",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/315 [00:00<?, ?it/s]/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n",
+      "100%|██████████| 315/315 [00:19<00:00, 15.82it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "images torch.Size([315, 3, 224, 224])\n",
+      "MST_images 315\n",
+      "MST_images==True 100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import imageio.v2 as imageio\n",
+    "resize_transform = transforms.Resize((224, 224))\n",
+    "MST_images = []\n",
+    "images = None\n",
+    "for im_name in tqdm(image_idx):\n",
+    "    if sub == 'sub-001' and session == 'ses-01':\n",
+    "        image_file = f\"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}\"\n",
+    "    else:\n",
+    "        image_file = f\"{unique_images[im_name]}\"\n",
+    "    im = imageio.imread(image_file)\n",
+    "    im = torch.Tensor(im / 255).permute(2,0,1)\n",
+    "    im = resize_transform(im.unsqueeze(0))\n",
+    "    if images is None:\n",
+    "        images = im\n",
+    "    else:\n",
+    "        images = torch.vstack((images, im))\n",
+    "    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "        if ('w_' in image_file or 'paired_image_' in image_file or re.match(r'all_stimuli/rtmindeye_stimuli/\\d{1,2}_\\d{1,3}\\.png$', image_file) or re.match(r'all_stimuli/rtmindeye_stimuli/images/\\d{1,2}_\\d{1,3}\\.png$', image_file)):  \n",
+    "            MST_images.append(True)\n",
+    "        else:\n",
+    "            MST_images.append(False)\n",
+    "    else:   \n",
+    "        if (\"MST_pairs\" in image_file): # (\"_seed_\" not in unique_images[im_name]) and (unique_images[im_name] != \"blank.jpg\") \n",
+    "            MST_images.append(True)\n",
+    "        else:\n",
+    "            MST_images.append(False)\n",
+    "\n",
+    "print(\"images\", images.shape)\n",
+    "MST_images = np.array(MST_images)\n",
+    "print(\"MST_images\", len(MST_images))\n",
+    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "    assert len(MST_images[MST_images==True]) == 100\n",
+    "print(\"MST_images==True\", len(MST_images[MST_images==True]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "19963e9d-9ec5-4f16-b376-2d2edbe0aedc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(25, 2) [[91 47]\n",
+      " [ 3  1]\n",
+      " [ 4  8]\n",
+      " [ 9 58]\n",
+      " [12 10]\n",
+      " [22 56]\n",
+      " [19 15]\n",
+      " [43 27]\n",
+      " [ 0 32]\n",
+      " [45 42]\n",
+      " [ 5 50]\n",
+      " [24  2]\n",
+      " [34 71]\n",
+      " [54 66]\n",
+      " [29 33]\n",
+      " [25 38]\n",
+      " [70 20]\n",
+      " [41 14]\n",
+      " [28 17]\n",
+      " [44 23]\n",
+      " [18 13]\n",
+      " [36 40]\n",
+      " [35 49]\n",
+      " [67 65]\n",
+      " [46  6]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# want IDs of pairmates based on MST_images\n",
+    "# create \"MST_pairmates\" which is a 25x2 array with indices of the 25 pairs based on MST_images == True\n",
+    "\n",
+    "assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2\n",
+    "MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)\n",
+    "# print(MST_pairmate_names)\n",
+    "\n",
+    "MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)\n",
+    "for p, pair in enumerate(MST_pairmate_names):\n",
+    "    for i, im in enumerate(pair):\n",
+    "        MST_pairmate_indices[p][i] = np.where(np.isin(list(all_MST_images.values()), im))[0][0]  # just take the first repeated instance of an image\n",
+    "        \n",
+    "print(MST_pairmate_indices.shape, MST_pairmate_indices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "04a3bf7e-2388-4c7b-82cf-7e5180e7f25b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):\n",
+    "    # MST_pairs contains the indices of repeats based on all_MST_images\n",
+    "    # all_MST_images contains the indices of images from image_names\n",
+    "    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))\n",
+    "    MST_pairs = np.array(sorted(MST_pairs[:-1], key=lambda x: x[0]))  # we added a fake value as a placeholder so index out the last group of pairs\n",
+    "\n",
+    "    # assert images[MST_pairs]\n",
+    "\n",
+    "    fig, ax = plt.subplots(1, 3, figsize=(10,4))\n",
+    "    fig.suptitle('Sample MST pairs')\n",
+    "\n",
+    "    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())\n",
+    "    ax[0].set_title(f\"Trial 0\")\n",
+    "\n",
+    "    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())\n",
+    "    ax[1].set_title(f\"Trial 1\")\n",
+    "\n",
+    "    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())\n",
+    "    ax[2].set_title(f\"Trial 2\")\n",
+    "\n",
+    "    plt.setp(ax, xticks=[], yticks=[])\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "dbb17afa-579e-40ee-9cd3-3083ad31b94c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x200 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# pairs has the indices of all repeated images\n",
+    "pairs = utils.find_paired_indices(image_idx)\n",
+    "pairs = sorted(pairs, key=lambda x: x[0])\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns\n",
+    "for i, ax in enumerate(axes):\n",
+    "    ax.imshow(images[i].permute(1, 2, 0).numpy())\n",
+    "    ax.set_title(f\"Trial {i}\")\n",
+    "    ax.axis(\"off\")  # Hide axes for better visualization\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "# output_path = os.path.join(output_dir, \"trials_plot.png\")\n",
+    "# plt.savefig(output_path, dpi=300)  # Save figure\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "556ced7f-9973-42f1-8718-6121d8c8502f",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p=0\n",
+    "\n",
+    "# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(10,8))\n",
+    "\n",
+    "ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())\n",
+    "ax[0].set_title(f\"Repeat 1\")\n",
+    "\n",
+    "ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())\n",
+    "ax[1].set_title(f\"Repeat 2\")\n",
+    "\n",
+    "plt.setp(ax, xticks=[], yticks=[])\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "11fa9265-d035-4d16-848f-8d2a1ec85052",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_image_pairs(sub, session, func_task_name, designdir):\n",
+    "    \"\"\"Loads design files and processes image pairs for a given session.\"\"\"\n",
+    "    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(\n",
+    "        sub=sub,\n",
+    "        session=session,\n",
+    "        func_task_name=func_task_name,\n",
+    "        designdir=designdir,\n",
+    "        design_ses_list=[session]  # Ensure it's a list\n",
+    "    )\n",
+    "    return utils.process_images(image_names, unique_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3d830531-2949-4646-8371-f7940a51eab1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data shape: (360, 101)\n",
+      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-06.csv\n",
+      "Total number of images: 350\n",
+      "Number of unique images: 201\n"
+     ]
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "all_dicts = []\n",
+    "for s_idx, s in enumerate(ses_list):\n",
+    "    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)\n",
+    "    assert len(im) == len(vo)\n",
+    "    all_dicts.append({k:v for k,v in enumerate(vo)})\n",
+    "\n",
+    "# for the train set (ses-01-02 non-MST)\n",
+    "image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])\n",
+    "for ses_idx, idx_to_name in enumerate(all_dicts):\n",
+    "    for idx, name in idx_to_name.items():\n",
+    "        image_to_indices[name][ses_idx].append(idx)\n",
+    "        \n",
+    "image_to_indices = dict(image_to_indices)\n",
+    "\n",
+    "# for the test set (ses-03)\n",
+    "# test_image_to_indices = defaultdict(lambda: [[] for _ in range(len([ses_list[-1]]))])\n",
+    "# for ses_idx, idx_to_name in enumerate([all_dicts[-1]]):\n",
+    "#     for idx, name in idx_to_name.items():\n",
+    "#         test_image_to_indices[name][ses_idx].append(idx)\n",
+    "        \n",
+    "# test_image_to_indices = dict(test_image_to_indices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "8720ef52-4ca2-48e3-adff-fcc48ad33015",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train_pairs_list = []\n",
+    "# test_pairs_list = []\n",
+    "\n",
+    "if sub == 'sub-005' and ses_list == [\"ses-01\", \"ses-02\"]:\n",
+    "    for image, (ses0_indices, ses1_indices) in image_to_indices.items():\n",
+    "        # Offset session 1 indices by 693\n",
+    "        image_to_indices[image] = [ses0_indices, [i + 693 for i in ses1_indices]]\n",
+    "\n",
+    "#         # Combine all repeat indices (across both sessions)\n",
+    "#         all_indices = ses0_indices + ses1_indices_offset\n",
+    "\n",
+    "#         # Only include if there are at least 2 repeats\n",
+    "#         if len(all_indices) >= 2:\n",
+    "#             train_pairs_list.append(all_indices)\n",
+    "        \n",
+    "#     for i in test_image_to_indices.values():\n",
+    "#         # print(i[0])\n",
+    "#         # Only include if there are at least 2 repeats\n",
+    "#         if len(i[0]) >= 2:\n",
+    "#             test_pairs_list.append(i[0])\n",
+    "            \n",
+    "#     train_test_pairs = [train_pairs_list, test_pairs_list]\n",
+    "            \n",
+    "# elif sub == 'sub-005' and ses_list == [\"ses-01\", \"ses-03\"]:\n",
+    "#     pairs_list = []\n",
+    "\n",
+    "#     if len(ses_list) > 2:\n",
+    "#         # Case 1: Aggregate results from multiple sessions (ses_list[:-1]), concatenating into a single list\n",
+    "#         combined_pairs = sum([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list[:-1]], [])\n",
+    "#         pairs_list.append(combined_pairs)\n",
+    "\n",
+    "#         # Case 2: Process last session separately\n",
+    "#         pairs_list.append(get_image_pairs(sub, ses_list[-1], func_task_name, designdir))\n",
+    "\n",
+    "#     else:\n",
+    "#         # Case 3: Process both sessions individually if ses_list has only 2 entries\n",
+    "#         pairs_list.extend([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list])\n",
+    "\n",
+    "#     assert len(pairs_list) == 2\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "df24c635-8019-4fc9-b6c9-54c86d6eeb58",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if resample_voxel_size:\n",
+    "    from nilearn.masking import apply_mask, unmask\n",
+    "    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'\n",
+    "    omat_name = f'{glmsingle_path}/boldref_omat'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "e846060a-d9c0-43d3-824b-08fa2b4b354e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-04_task-B_resampled_2_0mm_trilinear/sub-005_ses-04_task-B_brain_resampled_2_0mm_trilinear.nii.gz\n",
+      "Mask dimensions: (2.0, 2.0, 2.0)\n",
+      "\n",
+      "Affine:\n",
+      "[[  2.           0.           0.         -73.58010864]\n",
+      " [  0.           2.           0.         -81.90008545]\n",
+      " [  0.           0.           2.         -62.2656517 ]\n",
+      " [  0.           0.           0.           1.        ]]\n",
+      "\n",
+      "There are 157949 voxels in the included brain mask\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from nilearn.plotting import plot_roi, plot_anat, plot_epi\n",
+    "\n",
+    "mask_name = f'{glmsingle_path}/{sub}_{session_label}{task_name}_brain'\n",
+    "if resample_voxel_size:\n",
+    "    if resample_post_glmsingle is True:\n",
+    "        # use original mask directory\n",
+    "        mask_in_name = f'{orig_glmsingle_path}/{sub}_{session}{task_name}_brain.nii.gz'\n",
+    "        mask_out_name = mask_name + f\"_{mask_resampled_suffix}.nii.gz\"\n",
+    "        assert os.path.exists(mask_in_name)\n",
+    "        applyxfm(mask_in_name, ref_name, omat_name, resample_method, output=mask_out_name)\n",
+    "        apply_thresh(mask_out_name, 0.5, output=mask_out_name)  # binarize the mask since resampling can result in non- 0 or 1 values\n",
+    "    mask_name += f\"_{mask_resampled_suffix}\"\n",
+    "\n",
+    "mask_name += \".nii.gz\"\n",
+    "print(mask_name)\n",
+    "avg_mask = nib.load(mask_name)\n",
+    "# mask info\n",
+    "dimsize=avg_mask.header.get_zooms()\n",
+    "affine_mat = avg_mask.affine\n",
+    "brain=avg_mask.get_fdata()\n",
+    "xyz=brain.shape #xyz dimensionality of brain mask and epi data\n",
+    "\n",
+    "print('Mask dimensions:', dimsize)\n",
+    "print('')\n",
+    "print('Affine:')\n",
+    "print(affine_mat)\n",
+    "print('')\n",
+    "print(f'There are {int(np.sum(brain))} voxels in the included brain mask\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7804edab-5dc2-4499-8a91-91d77f78bd77",
+   "metadata": {},
+   "source": [
+    "## Load GLMSingle voxel data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "9d273f33-cb38-4045-9ff0-65edc3d35060",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox (315, 1, 1, 157949)\n",
+      "vox (315, 157949)\n"
+     ]
+    }
+   ],
+   "source": [
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:\n",
+    "    # either resampling was done in glmsingle or we aren't resampling \n",
+    "    vox = load_preprocess_betas(glmsingle_path, *params)\n",
+    "\n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e98f085f-d20d-4f9e-abc5-f823c90d7f49",
+   "metadata": {},
+   "source": [
+    "### Load nsdgeneral ROI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "b3a2a6cf-5aef-4ddf-bb82-f7bb0c8caacf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if resample_voxel_size:\n",
+    "    nsdgeneral_path = f'{glmsingle_path}/{sub}_{session_label}_task-{task}_nsdgeneral_{resampled_suffix}.nii.gz'  \n",
+    "    if resample_post_glmsingle:\n",
+    "        assert os.path.exists(orig_glmsingle_path)\n",
+    "        roi_in_path = f\"{orig_glmsingle_path}/{sub}_{session_label}_task-{task}_nsdgeneral.nii.gz\"  # the input file is the original nsdgeneral mask (without resampling), from the original glmsingle directory\n",
+    "        applyxfm(roi_in_path, ref_name, omat_name, resample_method, output=nsdgeneral_path)\n",
+    "else:\n",
+    "    nsdgeneral_path = f'{glmsingle_path}/{sub}_{session_label}{task_name}_nsdgeneral.nii.gz'  \n",
+    "    \n",
+    "print(nsdgeneral_path)\n",
+    "assert os.path.exists(nsdgeneral_path)\n",
+    "print(f\"nsdgeneral path exists!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "d0bcb8dc-5ce0-4484-add6-7faa96c9490f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(75, 89, 72)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 660x350 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "roi = nib.load(nsdgeneral_path)\n",
+    "print(roi.shape)\n",
+    "plot_roi(roi, bg_img=avg_mask)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "f7f2e9dd-88af-4ca9-bd80-17cbe429b6ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total voxels (whole brain) = 157949\n",
+      "nsdgeneral voxels = 18010\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_mask = avg_mask.get_fdata().flatten()\n",
+    "print(f\"total voxels (whole brain) = {int(avg_mask.sum())}\")\n",
+    "\n",
+    "roi = roi.get_fdata()\n",
+    "roi = roi.flatten()\n",
+    "roi = roi[avg_mask.astype(bool)]\n",
+    "roi[np.isnan(roi)] = 0\n",
+    "roi = roi.astype(bool)\n",
+    "print(f\"nsdgeneral voxels = {roi.sum()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bf38b1b-1270-4f65-bc01-07f90343963d",
+   "metadata": {},
+   "source": [
+    "### ROI voxel exclusion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "de856487-6f6b-4971-8e84-8b30c9a9e943",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox before ROI exclusion: (315, 157949)\n",
+      "vox after ROI exclusion: (315, 18010)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ROI masking?\n",
+    "print(f\"vox before ROI exclusion: {vox.shape}\")\n",
+    "vox = vox[:,roi]\n",
+    "print(f\"vox after ROI exclusion: {vox.shape}\")\n",
+    "\n",
+    "if np.any(np.isnan(vox)):\n",
+    "    print(\"NaNs found! Removing voxels...\")\n",
+    "    x,y = np.where(np.isnan(vox))\n",
+    "    vox = vox[:,np.setdiff1d(np.arange(vox.shape[-1]), y)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "903c4f38-4f6e-44d7-8186-44c47c77507a",
+   "metadata": {},
+   "source": [
+    "## Reliability calculation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "288e757f-fe51-4c3b-bb3c-e78b18c755c5",
+   "metadata": {},
+   "source": [
+    "### Calculate reliability (corr between first and second presentation of same image) for every voxel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "028998bc-0a34-4820-b68c-e428d2bc4b8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs_homog = np.array([[p[0], p[1]] for p in pairs])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "765ab07f-dbb3-4bdd-8de1-57fe85231d82",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 18010/18010 [00:01<00:00, 17703.12it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rels (18010,)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# vox_pairs = []\n",
+    "# for i in pairs:\n",
+    "#     vox_pairs.append(utils.zscore(vox[i]))\n",
+    "\n",
+    "vox_pairs = utils.zscore(vox[pairs_homog])\n",
+    "rels = np.full(vox.shape[-1],np.nan)\n",
+    "for v in tqdm(range(vox.shape[-1])):\n",
+    "    rels[v] = np.corrcoef(vox_pairs[:,0,v], vox_pairs[:,1,v])[1,0]\n",
+    "# for v in tqdm(range(vox[0].shape[-1])):\n",
+    "#     rep0 = []\n",
+    "#     rep1 = []\n",
+    "\n",
+    "#     for vp in vox_pairs:\n",
+    "#         rep0.append(vp[0, v])\n",
+    "#         rep1.append(vp[1, v])\n",
+    "\n",
+    "#     rels[v] = np.corrcoef(rep0, rep1)[1, 0]\n",
+    "\n",
+    "print(\"rels\", rels.shape)\n",
+    "assert np.sum(np.all(np.isnan(rels))) == 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b646ecf4-dd03-4352-abcf-6c6ccb54d96b",
+   "metadata": {},
+   "source": [
+    "### Create representational similarity matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "81aebd28-a66b-43fd-8123-fbcd99851383",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(115, 18010, 2)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:00<00:00, 4127.30it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# creating img x vox x repetitions matrix | shape=(150, 18419, 2)\n",
+    "vox0 = np.zeros((len(pairs_homog), vox.shape[-1], 2))\n",
+    "print(vox0.shape)\n",
+    "for ipair, pair in enumerate(tqdm(pairs_homog)):\n",
+    "    pair = pair[:2] # to keep things consistent, just using the first two repeats\n",
+    "    i,j = pair\n",
+    "    vox0[ipair, :, :] = vox[pair].T\n",
+    "vox_avg = vox0.mean(-1) # average across the repetitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "30fad9fc-5399-4820-8a8a-8b63fec5d371",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "reliability threshold = 0.2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 115/115 [00:02<00:00, 38.45it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Masking RDM for each reliability threshold\n",
+    "r_thresholds = np.array([.2])\n",
+    "rdm = np.zeros((len(r_thresholds), len(pairs), len(pairs))) \n",
+    "for ir_thresh, r_thresh in enumerate(r_thresholds):\n",
+    "    print(f\"reliability threshold = {r_thresh}\")\n",
+    "    for i in tqdm(range(len(pairs))):\n",
+    "        for j in range(len(pairs)):\n",
+    "            rdm[ir_thresh,i,j] = np.corrcoef(vox_avg[i,rels>r_thresh], \n",
+    "                                             vox_avg[j,rels>r_thresh])[0,1]\n",
+    "# rdm is shape (4, 150, 150)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "feac20e6-d50f-466f-98c9-eab730db65e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "thresh = .2\n",
+    "plt.figure(figsize=(4,4))\n",
+    "plt.imshow(rdm[np.where(r_thresholds==thresh)[0].item()], clim=(-1,1))\n",
+    "plt.colorbar(shrink=0.8)\n",
+    "plt.title(f\"{sub}_{session}\\nreliability threshold={thresh}\\n\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "4a4575dc-a6b1-449b-bcb8-31b3eef348ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for thresh in range(rdm.shape[0]):\n",
+    "    for img in range(rdm.shape[1]):\n",
+    "        assert np.isclose(rdm[thresh, img, img], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "6851fd48-fe35-461a-8858-6356760cb6a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(315, 18010)"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vox.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "248ce3a0-f03b-4c97-aee1-920432664ae1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "vox before reliability thresholding: (315, 18010)\n",
+      "\n",
+      "vox after reliability thresholding: (315, 5185)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reliability thresholding?\n",
+    "print(f\"\\nvox before reliability thresholding: {vox.shape}\")\n",
+    "vox = vox[:,rels>.2]\n",
+    "print(f\"\\nvox after reliability thresholding: {vox.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "b80aeb2d-6d53-431c-90ed-658dca7ecebd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([315, 3, 224, 224])\n",
+      "(315, 5185)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(images.shape)\n",
+    "print(vox.shape)\n",
+    "assert len(images) == len(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "c087978f-b316-44f4-a2af-c17b5a00764b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "115 115\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "same_corrs = []\n",
+    "diff_corrs = []\n",
+    "for isamp, samp in enumerate(vox[pairs_homog]):\n",
+    "    avg_same_img = []\n",
+    "    for i in range(samp.shape[0]):\n",
+    "        for j in range(i, samp.shape[0]):\n",
+    "            if i != j:\n",
+    "                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))\n",
+    "    \n",
+    "    same_corrs.append(np.mean(avg_same_img))\n",
+    "                       \n",
+    "    avg_diff_img = []\n",
+    "    for isamp_j, samp_j in enumerate(vox[pairs_homog]):\n",
+    "        if isamp_j != isamp:\n",
+    "            for i in range(samp_j.shape[0]):\n",
+    "                for j in range(i, samp_j.shape[0]):\n",
+    "                    if i != j:\n",
+    "                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))\n",
+    "                                    \n",
+    "    # print(len(avg_diff_img))\n",
+    "    diff_corrs.append(np.mean(avg_diff_img))\n",
+    "\n",
+    "\n",
+    "print(len(same_corrs), len(diff_corrs))\n",
+    "same_corrs = np.array(same_corrs)\n",
+    "diff_corrs = np.array(diff_corrs)\n",
+    "\n",
+    "\n",
+    "plt.figure(figsize=(5,4))\n",
+    "plt.title(f\"{sub}_{session} same/diff Pearson corr.\")\n",
+    "plt.plot(np.sort(same_corrs),c='blue',label='same')\n",
+    "plt.plot(np.sort(diff_corrs),c='cyan',label='diff')\n",
+    "plt.axhline(0,c='k',ls='--')\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"sample\")\n",
+    "plt.ylabel(\"Pearson R\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "31646431-10ac-4820-ba5d-c35f1e104557",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "vox_pairs = utils.zscore(vox[pairs_homog])\n",
+    "plt.figure(figsize=(5,4))\n",
+    "plt.title(f\"{sub}_{session} same minus diff difference Pearson corr.\")\n",
+    "plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')\n",
+    "plt.axhline(0,c='k',ls='--')\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"sample\")\n",
+    "plt.ylabel(\"Pearson R\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8866ce2-1cf2-459e-aa81-dec26a3dcd33",
+   "metadata": {},
+   "source": [
+    "# Training MindEye"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "8f554db1-f7cd-40d2-ab62-5d1e282c2bc8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "215 100\n"
+     ]
+    }
+   ],
+   "source": [
+    "utils.seed_everything(seed)\n",
+    "\n",
+    "if train_test_split == 'orig':\n",
+    "    # train = all images except images that were repeated\n",
+    "    # test = average of the same-image presentations\n",
+    "    imageTrain = np.arange(len(images))\n",
+    "    train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])\n",
+    "    test_image_indices = pairs\n",
+    "    print(len(train_image_indices), len(test_image_indices))\n",
+    "    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)\n",
+    "elif train_test_split == 'MST':\n",
+    "    # non-MST images are the train split\n",
+    "    # MST images are the test split\n",
+    "    MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])\n",
+    "    non_MST_idx = [v for k,v in image_to_indices.items() if 'MST_pairs' not in k]\n",
+    "    non_MST_idx = np.array([z for y in non_MST_idx for x in y for z in x])  # flatten the indices\n",
+    "    train_image_indices = non_MST_idx\n",
+    "    test_image_indices = MST_idx.flatten()  # MST_idx contains the mapping for the different test sets; test_image_indices has all MST indices combined\n",
+    "    print(len(train_image_indices), len(test_image_indices))\n",
+    "    assert len(train_image_indices) + len(test_image_indices) == len(vox)\n",
+    "elif train_test_split == 'unique':\n",
+    "    imageTest = np.arange(len(images))\n",
+    "    train_image_indices = pairs.flatten()\n",
+    "    test_image_indices = np.array([item for item in imageTest if item not in pairs.flatten()])\n",
+    "    print(len(train_image_indices), len(test_image_indices))\n",
+    "    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)\n",
+    "else:\n",
+    "    raise Exception(\"invalid train_test_split\")\n",
+    "\n",
+    "# TODO add assertion that verifies file names in train and test don't overlap, guards against repeats\n",
+    "\n",
+    "for i in train_image_indices:\n",
+    "    assert i not in test_image_indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "590f2b4b-db7c-42a1-bfd0-cc578e6af988",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "voxels have been zscored\n",
+      "-0.025304822 0.9952977\n",
+      "vox (315, 5185)\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_mean = np.mean(vox[train_image_indices],axis=0)\n",
+    "train_std = np.std(vox[train_image_indices],axis=0)\n",
+    "\n",
+    "vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)\n",
+    "print(\"voxels have been zscored\")\n",
+    "print(vox[:,0].mean(), vox[:,0].std())\n",
+    "print(\"vox\", vox.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "ea7db416-e12f-4678-bd6e-74040261d0d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for idx in deleted_indices:\n",
+    "#     # check image names to be deleted match\n",
+    "#     original_name = vox_image_dict[idx]\n",
+    "#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]\n",
+    "#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \\\n",
+    "#         f\"Mismatch in image names for deleted indices {matching_indices}\"\n",
+    "\n",
+    "#     # check image data to be deleted match\n",
+    "#     base_image = images[matching_indices[0]]  # Reference image\n",
+    "#     for i in matching_indices[1:]:\n",
+    "#         assert np.array_equal(base_image, images[i]), \\\n",
+    "#             f\"Mismatch in image data for {vox_image_dict[i]} at index {i}\"\n",
+    "\n",
+    "# images = images[kept_indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "b02840f9-2836-4e64-9c86-ad255da4b2cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = torch.Tensor(images)\n",
+    "vox = torch.Tensor(vox)\n",
+    "assert len(images) == len(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LOCAL RANK  0\n"
+     ]
+    }
+   ],
+   "source": [
+    "### Multi-GPU config ###\n",
+    "from accelerate import Accelerator, DeepSpeedPlugin\n",
+    "\n",
+    "local_rank = os.getenv('RANK')\n",
+    "if local_rank is None: \n",
+    "    local_rank = 0\n",
+    "else:\n",
+    "    local_rank = int(local_rank)\n",
+    "print(\"LOCAL RANK \", local_rank)  \n",
+    "\n",
+    "data_type = torch.float32 # change depending on your mixed_precision\n",
+    "\n",
+    "accelerator = Accelerator(split_batches=False)\n",
+    "batch_size = 8 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PID of this process = 1952060\n",
+      "device: cuda\n",
+      "global_batch_size 8\n",
+      "Distributed environment: DistributedType.NO\n",
+      "Num processes: 1\n",
+      "Process index: 0\n",
+      "Local process index: 0\n",
+      "Device: cuda\n",
+      "\n",
+      "Mixed precision type: no\n",
+      "\n",
+      "distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"PID of this process =\",os.getpid())\n",
+    "device = accelerator.device\n",
+    "print(\"device:\",device)\n",
+    "world_size = accelerator.state.num_processes\n",
+    "distributed = not accelerator.state.distributed_type == 'NO'\n",
+    "num_devices = torch.cuda.device_count()\n",
+    "global_batch_size = batch_size * num_devices\n",
+    "print(\"global_batch_size\", global_batch_size)\n",
+    "if num_devices==0 or not distributed: num_devices = 1\n",
+    "num_workers = num_devices\n",
+    "print(accelerator.state)\n",
+    "\n",
+    "# set data_type to match your mixed precision (automatically set based on deepspeed config)\n",
+    "if accelerator.mixed_precision == \"bf16\":\n",
+    "    data_type = torch.bfloat16\n",
+    "elif accelerator.mixed_precision == \"fp16\":\n",
+    "    data_type = torch.float16\n",
+    "else:\n",
+    "    data_type = torch.float32\n",
+    "\n",
+    "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size, \"data_type =\", data_type)\n",
+    "print = accelerator.print # only print if local_rank=0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9018b82b-c054-4463-9527-4b0c2a75bda6",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Configurations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: testing_MST\n",
+      "--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2                     --model_name=testing_MST                     --no-multi_subject --subj=1 --batch_size=8                     --hidden_dim=1024 --clip_scale=1.                     --no-blurry_recon --blur_scale=.5                     --no-use_prior --prior_scale=30                     --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug                     --ckpt_interval=999 --no-ckpt_saving --new_test                     --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep\n"
+     ]
+    }
+   ],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'\n",
+    "    print(\"model_name:\", model_name)\n",
+    "    \n",
+    "    # global_batch_size and batch_size should already be defined in the above cells\n",
+    "    # other variables can be specified in the following string:\n",
+    "    # jupyter_args = f\"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}\"\n",
+    "\n",
+    "    jupyter_args = f\"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \\\n",
+    "                    --model_name={model_name} \\\n",
+    "                    --no-multi_subject --subj=1 --batch_size={batch_size} \\\n",
+    "                    --hidden_dim=1024 --clip_scale=1. \\\n",
+    "                    --no-blurry_recon --blur_scale=.5 \\\n",
+    "                    --no-use_prior --prior_scale=30 \\\n",
+    "                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \\\n",
+    "                    --ckpt_interval=999 --no-ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "subj_list [1] num_sessions 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n",
+    "parser.add_argument(\n",
+    "    \"--model_name\", type=str, default=\"testing\",\n",
+    "    help=\"name of model, used for ckpt saving and wandb logging (if enabled)\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--data_path\", type=str, default=\"/weka/proj-fmri/shared/natural-scenes-dataset\",\n",
+    "    help=\"Path to where NSD data is stored / where to download it to\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--subj\",type=int, default=1, choices=[1,2,3,4,5,6,7,8],\n",
+    "    help=\"Validate on which subject?\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--multisubject_ckpt\", type=str, default=None,\n",
+    "    help=\"Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--num_sessions\", type=int, default=0,\n",
+    "    help=\"Number of training sessions to include (if multi_subject, this variable doesnt matter)\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--use_prior\",action=argparse.BooleanOptionalAction,default=False,\n",
+    "    help=\"whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--batch_size\", type=int, default=32,\n",
+    "    help=\"Batch size can be increased by 10x if only training v2c and not diffusion diffuser\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--wandb_log\",action=argparse.BooleanOptionalAction,default=False,\n",
+    "    help=\"whether to log to wandb\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--resume_from_ckpt\",action=argparse.BooleanOptionalAction,default=False,\n",
+    "    help=\"if not using wandb and want to resume from a ckpt\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--wandb_project\",type=str,default=\"stability\",\n",
+    "    help=\"wandb project name\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--mixup_pct\",type=float,default=.33,\n",
+    "    help=\"proportion of way through training when to switch from BiMixCo to SoftCLIP\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--low_mem\",action=argparse.BooleanOptionalAction,default=False,\n",
+    "    help=\"whether to preload images to cpu to speed things up but consume more memory\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\n",
+    "    help=\"whether to output blurry reconstructions\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--blur_scale\",type=float,default=.5,\n",
+    "    help=\"multiply loss from blurry recons by this number\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--clip_scale\",type=float,default=1.,\n",
+    "    help=\"multiply contrastive loss by this number\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--prior_scale\",type=float,default=30,\n",
+    "    help=\"multiply diffusion prior loss by this\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--use_image_aug\",action=argparse.BooleanOptionalAction,default=True,\n",
+    "    help=\"whether to use image augmentation\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--num_epochs\",type=int,default=120,\n",
+    "    help=\"number of epochs of training\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--multi_subject\",action=argparse.BooleanOptionalAction,default=False,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--n_blocks\",type=int,default=2,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--hidden_dim\",type=int,default=1024,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seq_past\",type=int,default=0,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seq_future\",type=int,default=0,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--lr_scheduler_type\",type=str,default='cycle',choices=['cycle','linear'],\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--ckpt_saving\",action=argparse.BooleanOptionalAction,default=True,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--ckpt_interval\",type=int,default=5,\n",
+    "    help=\"save backup ckpt and reconstruct every x epochs\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seed\",type=int,default=42,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--max_lr\",type=float,default=3e-4,\n",
+    ")\n",
+    "\n",
+    "if utils.is_interactive():\n",
+    "    args = parser.parse_args(jupyter_args)\n",
+    "else:\n",
+    "    args = parser.parse_args()\n",
+    "\n",
+    "# create global variables without the args prefix\n",
+    "for attribute_name in vars(args).keys():\n",
+    "    globals()[attribute_name] = getattr(args, attribute_name)\n",
+    "    \n",
+    "outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')\n",
+    "if not os.path.exists(outdir) and ckpt_saving:\n",
+    "    os.makedirs(outdir,exist_ok=True)\n",
+    "    \n",
+    "if use_image_aug or blurry_recon:\n",
+    "    import kornia\n",
+    "    import kornia.augmentation as K\n",
+    "    from kornia.augmentation.container import AugmentationSequential\n",
+    "if use_image_aug:\n",
+    "    img_augment = AugmentationSequential(\n",
+    "        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),\n",
+    "        same_on_batch=False,\n",
+    "        data_keys=[\"input\"],\n",
+    "    )\n",
+    "    # Define the blurring augmentations\n",
+    "    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)\n",
+    "    \n",
+    "if multi_subject:\n",
+    "    subj_list = np.arange(1,9)\n",
+    "    subj_list = subj_list[subj_list != subj]\n",
+    "else:\n",
+    "    subj_list = [subj]\n",
+    "\n",
+    "print(\"subj_list\", subj_list, \"num_sessions\", num_sessions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42d13c25-1369-4c49-81d4-83d713586096",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Prep data, models, and dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "a6660667-94bc-4829-8310-227042febd4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name:\n",
+    "        eval_dir = os.environ[\"eval_dir\"]\n",
+    "        print('saving MST info in', eval_dir)\n",
+    "        # Saving ##\n",
+    "        if not os.path.exists(eval_dir):\n",
+    "            os.mkdir(eval_dir)\n",
+    "\n",
+    "        np.save(f\"{eval_dir}/MST_ID.npy\", MST_ID)\n",
+    "        np.save(f\"{eval_dir}/MST_pairmate_indices.npy\", MST_pairmate_indices)\n",
+    "\n",
+    "    if remove_random_n:\n",
+    "        np.save(f\"{eval_dir}/imgs_to_remove.npy\", imgs_to_remove)\n",
+    "\n",
+    "    np.save(f\"{eval_dir}/train_image_indices.npy\", train_image_indices)\n",
+    "    np.save(f\"{eval_dir}/test_image_indices.npy\", test_image_indices)\n",
+    "    np.save(f\"{eval_dir}/images.npy\", images)\n",
+    "    np.save(f\"{eval_dir}/vox.npy\", vox)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c023f24-5233-4a15-a2f5-78487b3a8546",
+   "metadata": {},
+   "source": [
+    "### Creating wds dataloader, preload betas and all 73k possible images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "aefe7c27-ab39-4b2c-90f4-480f4087b7ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dividing batch size by subj_list, which will then be concatenated across subj during training...\n",
+      "batch_size = 8 num_iterations_per_epoch = 26 num_samples_per_epoch = 215\n"
+     ]
+    }
+   ],
+   "source": [
+    "def my_split_by_node(urls): return urls\n",
+    "num_voxels_list = []\n",
+    "\n",
+    "if multi_subject:\n",
+    "    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])\n",
+    "    num_samples_per_epoch = (750*40) // num_devices \n",
+    "else:\n",
+    "    # num_samples_per_epoch = (750*num_sessions) // num_devices \n",
+    "    num_samples_per_epoch = len(train_image_indices)\n",
+    "\n",
+    "print(\"dividing batch size by subj_list, which will then be concatenated across subj during training...\") \n",
+    "batch_size = batch_size // len(subj_list)\n",
+    "\n",
+    "num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))\n",
+    "\n",
+    "print(\"batch_size =\", batch_size, \"num_iterations_per_epoch =\",num_iterations_per_epoch, \"num_samples_per_epoch =\",num_samples_per_epoch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "e1942b0e-1223-40e6-b543-2f7ff2e8ebcd",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "train_data = {}\n",
+    "train_dl = {}\n",
+    "\n",
+    "train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))\n",
+    "test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "81084834-035f-4465-ad59-59e6b806a2f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training with 0 sessions\n",
+      "num_voxels for subj01: 5185\n",
+      "Loaded all subj train dls and vox!\n",
+      "\n",
+      "Loaded test dl for subj1!\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_voxels = {}\n",
+    "voxels = {}\n",
+    "for s in subj_list:\n",
+    "    print(f\"Training with {num_sessions} sessions\")\n",
+    "    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True)\n",
+    "\n",
+    "    num_voxels_list.append(vox[0].shape[-1])\n",
+    "    num_voxels[f'subj0{s}'] = vox[0].shape[-1]\n",
+    "    voxels[f'subj0{s}'] = vox\n",
+    "    print(f\"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}\")\n",
+    "\n",
+    "print(\"Loaded all subj train dls and vox!\\n\")\n",
+    "\n",
+    "# Validate only on one subject\n",
+    "if multi_subject: \n",
+    "    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list\n",
+    "test_dl = torch.utils.data.DataLoader(test_data, batch_size=24, shuffle=False, drop_last=True, pin_memory=True)\n",
+    "\n",
+    "print(f\"Loaded test dl for subj{subj}!\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15",
+   "metadata": {},
+   "source": [
+    "## Load models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5",
+   "metadata": {},
+   "source": [
+    "### CLIP image embeddings  model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "b0420dc0-199e-4c1a-857d-b1747058b467",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## USING OpenCLIP ViT-bigG ###\n",
+    "sys.path.append('generative_models/')\n",
+    "import sgm\n",
+    "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder\n",
+    "# from generative_models.sgm.models.diffusion import DiffusionEngine\n",
+    "# from omegaconf import OmegaConf\n",
+    "\n",
+    "try:\n",
+    "    print(clip_img_embedder)\n",
+    "except:\n",
+    "    clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n",
+    "        arch=\"ViT-bigG-14\",\n",
+    "        version=\"laion2b_s39b_b160k\",\n",
+    "        output_tokens=True,\n",
+    "        only_tokens=True,\n",
+    "    )\n",
+    "    clip_img_embedder.to(device)\n",
+    "clip_seq_dim = 256\n",
+    "clip_emb_dim = 1664\n",
+    "\n",
+    "# ## USING OPEN AI CLIP ViT-L ###\n",
+    "# import clip\n",
+    "# try:\n",
+    "#     print(clip_model)\n",
+    "# except:\n",
+    "#     clip_model, preprocess = clip.load(\"ViT-L/14\", device=device)\n",
+    "#     preprocess = transforms.Compose([\n",
+    "#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],\n",
+    "#                              std=[0.26862954, 0.26130258, 0.27577711]),\n",
+    "#     ])\n",
+    "# def clip_img_embedder(image):\n",
+    "#     preproc_img = preprocess(image)\n",
+    "#     return clip_model.encode_image(preproc_img)\n",
+    "# clip_seq_dim = 1\n",
+    "# clip_emb_dim = 768"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0",
+   "metadata": {},
+   "source": [
+    "### MindEye modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "22850c04-3811-4d52-ad2f-48c7be1366e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MindEyeModule()\n",
+      "param counts:\n",
+      "5,310,464 total\n",
+      "5,310,464 trainable\n",
+      "param counts:\n",
+      "5,310,464 total\n",
+      "5,310,464 trainable\n",
+      "param counts:\n",
+      "453,360,280 total\n",
+      "453,360,280 trainable\n",
+      "param counts:\n",
+      "458,670,744 total\n",
+      "458,670,744 trainable\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = utils.prepare_model_and_training(\n",
+    "    num_voxels_list=num_voxels_list,\n",
+    "    n_blocks=n_blocks,\n",
+    "    hidden_dim=hidden_dim,\n",
+    "    clip_emb_dim=clip_emb_dim,\n",
+    "    clip_seq_dim=clip_seq_dim,\n",
+    "    use_prior=use_prior,\n",
+    "    clip_scale=clip_scale\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([2, 1, 5185]) torch.Size([2, 1, 1024])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# test on subject 1 with fake data\n",
+    "b = torch.randn((2,1,num_voxels_list[0]))\n",
+    "print(b.shape, model.ridge(b,0).shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "7b8de65a-6d3b-4248-bea9-9b6f4d562321",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "b.shape torch.Size([2, 1, 1024])\n",
+      "torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# test that the model works on some fake data\n",
+    "b = torch.randn((2,1,hidden_dim))\n",
+    "print(\"b.shape\",b.shape)\n",
+    "\n",
+    "backbone_, clip_, blur_ = model.backbone(b)\n",
+    "print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b397c0d7-52a3-4153-823b-c27d2eb3eeba",
+   "metadata": {},
+   "source": [
+    "### Adding diffusion prior + unCLIP if use_prior=True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "69965344-9346-4592-9cc5-e537e31d5fce",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if use_prior:\n",
+    "    from models import *\n",
+    "\n",
+    "    # setup diffusion prior network\n",
+    "    out_dim = clip_emb_dim\n",
+    "    depth = 6\n",
+    "    dim_head = 52\n",
+    "    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n",
+    "    timesteps = 100\n",
+    "\n",
+    "    prior_network = VersatileDiffusionPriorNetwork(\n",
+    "            dim=out_dim,\n",
+    "            depth=depth,\n",
+    "            dim_head=dim_head,\n",
+    "            heads=heads,\n",
+    "            causal=False,\n",
+    "            num_tokens = clip_seq_dim,\n",
+    "            learned_query_mode=\"pos_emb\"\n",
+    "        )\n",
+    "\n",
+    "    model.diffusion_prior = BrainDiffusionPrior(\n",
+    "        net=prior_network,\n",
+    "        image_embed_dim=out_dim,\n",
+    "        condition_on_text_encodings=False,\n",
+    "        timesteps=timesteps,\n",
+    "        cond_drop_prob=0.2,\n",
+    "        image_embed_scale=None,\n",
+    "    )\n",
+    "    \n",
+    "    utils.count_params(model.diffusion_prior)\n",
+    "    utils.count_params(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ec25271a-2209-400c-8026-df3b8ddc1eef",
+   "metadata": {},
+   "source": [
+    "### Setup optimizer / lr / ckpt saving"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total_steps 780\n",
+      "\n",
+      "Done with model preparations!\n",
+      "param counts:\n",
+      "458,670,744 total\n",
+      "458,670,744 trainable\n"
+     ]
+    }
+   ],
+   "source": [
+    "no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n",
+    "\n",
+    "opt_grouped_parameters = [\n",
+    "    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},\n",
+    "    {'params': [p for n, p in model.backbone.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n",
+    "    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},\n",
+    "]\n",
+    "# model.backbone.requires_grad_(False)\n",
+    "\n",
+    "if use_prior:\n",
+    "    opt_grouped_parameters.extend([\n",
+    "        {'params': [p for n, p in model.diffusion_prior.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 1e-2},\n",
+    "        {'params': [p for n, p in model.diffusion_prior.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n",
+    "    ])\n",
+    "\n",
+    "optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)\n",
+    "\n",
+    "if lr_scheduler_type == 'linear':\n",
+    "    lr_scheduler = torch.optim.lr_scheduler.LinearLR(\n",
+    "        optimizer,\n",
+    "        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),\n",
+    "        last_epoch=-1\n",
+    "    )\n",
+    "elif lr_scheduler_type == 'cycle':\n",
+    "    if num_iterations_per_epoch==0:\n",
+    "        num_iterations_per_epoch=1\n",
+    "    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))\n",
+    "    print(\"total_steps\", total_steps)\n",
+    "    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n",
+    "        optimizer, \n",
+    "        max_lr=max_lr,\n",
+    "        total_steps=total_steps,\n",
+    "        final_div_factor=1000,\n",
+    "        last_epoch=-1, pct_start=2/num_epochs\n",
+    "    )\n",
+    "    \n",
+    "def save_ckpt(tag):\n",
+    "    ckpt_path = outdir+f'/{tag}.pth'\n",
+    "    if accelerator.is_main_process:\n",
+    "        unwrapped_model = accelerator.unwrap_model(model)\n",
+    "        torch.save({\n",
+    "            'epoch': epoch,\n",
+    "            'model_state_dict': unwrapped_model.state_dict(),\n",
+    "            'optimizer_state_dict': optimizer.state_dict(),\n",
+    "            'lr_scheduler': lr_scheduler.state_dict(),\n",
+    "            'train_losses': losses,\n",
+    "            'test_losses': test_losses,\n",
+    "            'lrs': lrs,\n",
+    "            }, ckpt_path)\n",
+    "    print(f\"\\n---saved {outdir}/{tag} ckpt!---\\n\")\n",
+    "\n",
+    "def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): \n",
+    "    print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n",
+    "    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')\n",
+    "    state_dict = checkpoint['model_state_dict']\n",
+    "    if multisubj_loading: # remove incompatible ridge layer that will otherwise error\n",
+    "        state_dict.pop('ridge.linears.0.weight',None)\n",
+    "    model.load_state_dict(state_dict, strict=strict)\n",
+    "    if load_epoch:\n",
+    "        globals()[\"epoch\"] = checkpoint['epoch']\n",
+    "        print(\"Epoch\",epoch)\n",
+    "    if load_optimizer:\n",
+    "        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
+    "    if load_lr:\n",
+    "        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])\n",
+    "    del checkpoint\n",
+    "\n",
+    "print(\"\\nDone with model preparations!\")\n",
+    "num_params = utils.count_params(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1e8dcc4-5ce2-4206-88dc-a68d1dd701cd",
+   "metadata": {},
+   "source": [
+    "# Wandb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "990cce8c-df83-473a-93c8-c47ba355eccd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if local_rank==0 and wandb_log: # only use main process for wandb logging\n",
+    "    import wandb\n",
+    "    import time\n",
+    "    \n",
+    "    wandb_project = 'rtmindeye'\n",
+    "    print(f\"wandb {wandb_project} run {model_name}\")\n",
+    "\n",
+    "    # Need to configure wandb beforehand in terminal with \"wandb init\"!\n",
+    "    wandb_config = {\n",
+    "        \"model_name\": model_name,\n",
+    "        \"global_batch_size\": global_batch_size,\n",
+    "        \"batch_size\": batch_size,\n",
+    "        \"num_epochs\": num_epochs,\n",
+    "        \"num_sessions\": num_sessions,\n",
+    "        \"num_params\": num_params,\n",
+    "        \"clip_scale\": clip_scale,\n",
+    "        \"prior_scale\": prior_scale,\n",
+    "        \"blur_scale\": blur_scale,\n",
+    "        \"use_image_aug\": use_image_aug,\n",
+    "        \"max_lr\": max_lr,\n",
+    "        \"mixup_pct\": mixup_pct,\n",
+    "        \"num_samples_per_epoch\": num_samples_per_epoch,\n",
+    "        \"ckpt_interval\": ckpt_interval,\n",
+    "        \"ckpt_saving\": ckpt_saving,\n",
+    "        \"seed\": seed,  # SLURM array task ID\n",
+    "        \"distributed\": distributed,\n",
+    "        \"num_devices\": num_devices,\n",
+    "        \"world_size\": world_size,\n",
+    "    }\n",
+    "    print(\"wandb_config:\\n\", wandb_config)\n",
+    "    print(\"wandb_id:\", model_name)\n",
+    "\n",
+    "    # Initialize wandb\n",
+    "    wandb.init(\n",
+    "        id=model_name,\n",
+    "        project=wandb_project,\n",
+    "        name=model_name,\n",
+    "        config=wandb_config,\n",
+    "        resume=\"allow\",\n",
+    "        save_code=True,\n",
+    "    )\n",
+    "\n",
+    "    # Get SLURM job & array ID\n",
+    "    slurm_job_id = utils.get_slurm_job()\n",
+    "    slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID\n",
+    "\n",
+    "    # Define SLURM log paths\n",
+    "    log_dir = \"slurms\"\n",
+    "    log_files = [\n",
+    "        f\"{log_dir}/{slurm_job_id}_{slurm_array_id}.out\",\n",
+    "        f\"{log_dir}/{slurm_job_id}_{slurm_array_id}.err\",\n",
+    "    ]\n",
+    "\n",
+    "    # Ensure logs exist before logging them\n",
+    "    for log_file in log_files:\n",
+    "        wait_time = 0\n",
+    "        while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s\n",
+    "            time.sleep(5)\n",
+    "            wait_time += 5\n",
+    "\n",
+    "    # Log SLURM logs as artifacts\n",
+    "    artifact = wandb.Artifact(f\"slurm_logs_{slurm_job_id}_{slurm_array_id}\", type=\"logs\")\n",
+    "    for log_file in log_files:\n",
+    "        if os.path.exists(log_file):\n",
+    "            artifact.add_file(log_file)\n",
+    "\n",
+    "    wandb.log_artifact(artifact)\n",
+    "else:\n",
+    "    wandb_log = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5690151-2131-4918-b750-e869cbd1a8a8",
+   "metadata": {},
+   "source": [
+    "# Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "12de6387-6e18-4e4b-b5ce-a847d625330a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epoch = 0\n",
+    "losses, test_losses, lrs = [], [], []\n",
+    "best_test_loss = 1e9\n",
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "607a7c7b-fe5e-41a4-80bf-d2814b3a57cc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "---loading /scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep/last.pth ckpt---\n",
+      "\n",
+      "[2025-07-09 20:03:08,630] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# load multisubject stage1 ckpt if set\n",
+    "if multisubject_ckpt is not None and not resume_from_ckpt:\n",
+    "    load_ckpt(\"last\",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "00ea5ae0-5c92-4276-af5b-25a17ba4dc17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')\n",
+    "# state_dict = checkpoint['model_state_dict']\n",
+    "# model.load_state_dict(state_dict, strict=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]\n",
+    "\n",
+    "model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)\n",
+    "# leaving out test_dl since we will only have local_rank 0 device do evals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60be0d5f-3e94-4612-9373-61b53d836393",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n",
+    "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n",
+    "test_image, test_voxel = None, None\n",
+    "mse = nn.MSELoss()\n",
+    "l1 = nn.L1Loss()\n",
+    "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n",
+    "skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model\n",
+    "\n",
+    "for epoch in progress_bar:\n",
+    "    model.train()\n",
+    "\n",
+    "    fwd_percent_correct = 0.\n",
+    "    bwd_percent_correct = 0.\n",
+    "    test_fwd_percent_correct = 0.\n",
+    "    test_bwd_percent_correct = 0.\n",
+    "    \n",
+    "    recon_cossim = 0.\n",
+    "    test_recon_cossim = 0.\n",
+    "    recon_mse = 0.\n",
+    "    test_recon_mse = 0.\n",
+    "\n",
+    "    loss_clip_total = 0.\n",
+    "    loss_blurry_total = 0.\n",
+    "    loss_blurry_cont_total = 0.\n",
+    "    test_loss_clip_total = 0.\n",
+    "    \n",
+    "    loss_prior_total = 0.\n",
+    "    test_loss_prior_total = 0.\n",
+    "\n",
+    "    blurry_pixcorr = 0.\n",
+    "    test_blurry_pixcorr = 0. \n",
+    "\n",
+    "    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each\n",
+    "    for train_i, behav in enumerate(train_dl):  \n",
+    "        with torch.cuda.amp.autocast(dtype=data_type):\n",
+    "            optimizer.zero_grad()\n",
+    "            loss = 0.\n",
+    "            \n",
+    "            behav = behav[0]\n",
+    "\n",
+    "            image = images[behav.long().cpu()].to(device)\n",
+    "            voxel = vox[behav.long().cpu()]\n",
+    "            # voxel = (voxel - train_mean) / train_std\n",
+    "            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "\n",
+    "            if use_image_aug: \n",
+    "                image = img_augment(image)\n",
+    "\n",
+    "            clip_target = clip_img_embedder(image)\n",
+    "            assert not torch.any(torch.isnan(clip_target))\n",
+    "\n",
+    "            if epoch < int(mixup_pct * num_epochs):\n",
+    "                voxel, perm, betas, select = utils.mixco(voxel)\n",
+    "\n",
+    "            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\n",
+    "            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)\n",
+    "\n",
+    "            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n",
+    "\n",
+    "            if use_prior:\n",
+    "                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)\n",
+    "                loss_prior_total += loss_prior.item()\n",
+    "                loss_prior *= prior_scale\n",
+    "                loss += loss_prior\n",
+    "\n",
+    "                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()\n",
+    "                recon_mse += mse(prior_out, clip_target).item()\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                if epoch < int(mixup_pct * num_epochs):                \n",
+    "                    loss_clip = utils.mixco_nce(\n",
+    "                        clip_voxels_norm,\n",
+    "                        clip_target_norm,\n",
+    "                        temp=.006,\n",
+    "                        perm=perm, betas=betas, select=select)\n",
+    "                else:\n",
+    "                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n",
+    "                    loss_clip = utils.soft_clip_loss(\n",
+    "                        clip_voxels_norm,\n",
+    "                        clip_target_norm,\n",
+    "                        temp=epoch_temp)\n",
+    "\n",
+    "                loss_clip_total += loss_clip.item()\n",
+    "                loss_clip *= clip_scale\n",
+    "                loss += loss_clip\n",
+    "\n",
+    "            if blurry_recon:     \n",
+    "                image_enc_pred, transformer_feats = blurry_image_enc_\n",
+    "\n",
+    "                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215\n",
+    "                loss_blurry = l1(image_enc_pred, image_enc)\n",
+    "                loss_blurry_total += loss_blurry.item()\n",
+    "\n",
+    "                if epoch < int(mixup_pct * num_epochs):\n",
+    "                    image_enc_shuf = image_enc[perm]\n",
+    "                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)\n",
+    "                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \\\n",
+    "                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)\n",
+    "\n",
+    "                image_norm = (image - mean)/std\n",
+    "                image_aug = (blur_augs(image) - mean)/std\n",
+    "                _, cnx_embeds = cnx(image_norm)\n",
+    "                _, cnx_aug_embeds = cnx(image_aug)\n",
+    "\n",
+    "                cont_loss = utils.soft_cont_loss(\n",
+    "                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),\n",
+    "                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n",
+    "                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n",
+    "                    temp=0.2)\n",
+    "                loss_blurry_cont_total += cont_loss.item()\n",
+    "\n",
+    "                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                # forward and backward top 1 accuracy        \n",
+    "                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n",
+    "                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n",
+    "                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n",
+    "\n",
+    "            if blurry_recon:\n",
+    "                with torch.no_grad():\n",
+    "                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n",
+    "                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n",
+    "                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n",
+    "                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n",
+    "                    blurry_pixcorr += pixcorr.item()\n",
+    "            \n",
+    "            utils.check_loss(loss)\n",
+    "            accelerator.backward(loss)\n",
+    "            optimizer.step()\n",
+    "\n",
+    "            losses.append(loss.item())\n",
+    "            lrs.append(optimizer.param_groups[0]['lr'])\n",
+    "\n",
+    "            if lr_scheduler_type is not None:\n",
+    "                lr_scheduler.step()\n",
+    "                \n",
+    "            if train_i >= num_iterations_per_epoch-1:\n",
+    "                break\n",
+    "                \n",
+    "    model.eval()\n",
+    "    logs = {}\n",
+    "\n",
+    "    if local_rank == 0:\n",
+    "        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):\n",
+    "            for i in range(1):\n",
+    "                for j in range(2):\n",
+    "                    subset_indices = MST_idx[:, i, j].reshape(-1)\n",
+    "                    subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))\n",
+    "                    subset_dl = torch.utils.data.DataLoader(\n",
+    "                        subset_dataset, batch_size=len(MST_idx), shuffle=False,\n",
+    "                        drop_last=False, pin_memory=True\n",
+    "                    )\n",
+    "\n",
+    "                    # Reset metrics for this subset\n",
+    "                    test_losses = []\n",
+    "                    test_loss_clip_total = 0\n",
+    "                    test_loss_prior_total = 0\n",
+    "                    test_blurry_pixcorr = 0\n",
+    "                    test_fwd_percent_correct = 0\n",
+    "                    test_bwd_percent_correct = 0\n",
+    "                    test_recon_cossim = 0\n",
+    "                    test_recon_mse = 0\n",
+    "\n",
+    "                    for test_i, behav in enumerate(subset_dl):\n",
+    "                        behav = behav[0]\n",
+    "                        loss = 0.\n",
+    "\n",
+    "                        if behav.ndim > 1:\n",
+    "                            image = images[behav[:, 0].long().cpu()].to(device)\n",
+    "                            voxel = vox[behav.long().cpu()].mean(1)\n",
+    "                        else:\n",
+    "                            image = images[behav.long().cpu()].to(device)\n",
+    "                            voxel = vox[behav.long().cpu()]\n",
+    "\n",
+    "                        voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "\n",
+    "                        clip_img_embedder = clip_img_embedder.to(device)\n",
+    "                        clip_target = clip_img_embedder(image.float())\n",
+    "\n",
+    "                        voxel_ridge = model.ridge(voxel, 0)\n",
+    "                        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "                        if clip_scale > 0:\n",
+    "                            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "                            clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n",
+    "\n",
+    "                        random_samps = np.random.choice(np.arange(len(image)), size=len(image) // 5, replace=False)\n",
+    "\n",
+    "                        if use_prior:\n",
+    "                            loss_prior, contaminated_prior_out = model.diffusion_prior(\n",
+    "                                text_embed=backbone[random_samps], image_embed=clip_target[random_samps])\n",
+    "                            test_loss_prior_total += loss_prior.item()\n",
+    "                            loss_prior *= prior_scale\n",
+    "                            loss += loss_prior\n",
+    "\n",
+    "                        if clip_scale > 0:\n",
+    "                            loss_clip = utils.soft_clip_loss(\n",
+    "                                clip_voxels_norm,\n",
+    "                                clip_target_norm,\n",
+    "                                temp=0.006\n",
+    "                            )\n",
+    "                            test_loss_clip_total += loss_clip.item()\n",
+    "                            loss_clip *= clip_scale\n",
+    "                            loss += loss_clip\n",
+    "\n",
+    "                        if blurry_recon:\n",
+    "                            image_enc_pred, _ = blurry_image_enc_\n",
+    "                            blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps] / 0.18215).sample / 2 + 0.5).clamp(0, 1)\n",
+    "                            pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n",
+    "                            test_blurry_pixcorr += pixcorr.item()\n",
+    "\n",
+    "                        if clip_scale > 0:\n",
+    "                            labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)\n",
+    "                            test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n",
+    "                            test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n",
+    "\n",
+    "                        utils.check_loss(loss)\n",
+    "                        test_losses.append(loss.item())\n",
+    "\n",
+    "                    logs.update({\n",
+    "                        f\"subset_{i}_{j}_test/loss\": np.mean(test_losses),\n",
+    "                        f\"subset_{i}_{j}_test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n",
+    "                        f\"subset_{i}_{j}_test/loss_prior\": test_loss_prior_total / (test_i + 1),\n",
+    "                        f\"subset_{i}_{j}_test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n",
+    "                        f\"subset_{i}_{j}_test/fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n",
+    "                        f\"subset_{i}_{j}_test/bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n",
+    "                    })\n",
+    "                    print(f\"--- Subset ({i},{j}) ---\")\n",
+    "                    for k, v in logs.items():\n",
+    "                        if f\"subset_{i}_{j}\" in k:\n",
+    "                            print(f\"{k}: {v:.4f}\")\n",
+    "\n",
+    "            # After subset loop: add train (and global test, if you want) metrics\n",
+    "            logs.update({\n",
+    "                \"train/loss\": np.mean(losses[-(train_i+1):]),\n",
+    "                \"train/lr\": lrs[-1],\n",
+    "                \"train/num_steps\": len(losses),\n",
+    "                \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n",
+    "                \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n",
+    "                \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n",
+    "                \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n",
+    "                \"train/loss_blurry_cont_total\": loss_blurry_cont_total / (train_i + 1),\n",
+    "                \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n",
+    "                \"train/recon_cossim\": recon_cossim / (train_i + 1),\n",
+    "                \"train/recon_mse\": recon_mse / (train_i + 1),\n",
+    "                \"train/loss_prior\": loss_prior_total / (train_i + 1),\n",
+    "            })\n",
+    "\n",
+    "\n",
+    "            # if finished training, save jpg recons if they exist\n",
+    "            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):\n",
+    "                if blurry_recon:    \n",
+    "                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215\n",
+    "                    # transform blurry recon latents to images and plot it\n",
+    "                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n",
+    "                    jj=-1\n",
+    "                    for j in [0,1,2,3]:\n",
+    "                        jj+=1\n",
+    "                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n",
+    "                        axes[jj].axis('off')\n",
+    "                        jj+=1\n",
+    "                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n",
+    "                        axes[jj].axis('off')\n",
+    "                    plt.show()\n",
+    "\n",
+    "            progress_bar.set_postfix(**logs)\n",
+    "\n",
+    "            if wandb_log: wandb.log(logs)\n",
+    "            \n",
+    "    # Save model checkpoint and reconstruct\n",
+    "    if (ckpt_saving) and (epoch % ckpt_interval == 0):\n",
+    "        save_ckpt(f'last')\n",
+    "\n",
+    "    # wait for other GPUs to catch up if needed\n",
+    "    accelerator.wait_for_everyone()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "print(\"\\n===Finished!===\\n\")\n",
+    "if ckpt_saving:\n",
+    "    save_ckpt(f'last')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "19bdef2b-02cf-40cc-8c0c-84b8b8acdd36",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "100"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(test_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "5702acf6-45fe-44f5-8842-c0e2d4d8e8ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Track metrics here:\n",
+    "# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23a54acc-1dce-4de4-9d5f-d0582f5097c5",
+   "metadata": {},
+   "source": [
+    "**To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "3af2dfd7-638f-4932-b384-67d582f88c2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# MST_pairmate_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "b5a7e752-6665-41fb-b3cc-022d36893de7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]\n",
+    "assert len(image_idx) == len(x)\n",
+    "pairs = np.empty(shape=MST_pairmate_names.shape, dtype=int)\n",
+    "for i, p in enumerate(MST_pairmate_names):\n",
+    "    assert p[0] != p[1]  # no duplicate images\n",
+    "    pairs[i,0] = x.index(p[0])\n",
+    "    pairs[i,1] = x.index(p[1])\n",
+    "    \n",
+    "# print(pairs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "3d1501cd-0473-4faa-8bfc-b2e2472559ae",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# if sub==\"sub-002\":\n",
+    "#     unique_images_pairs = [\n",
+    "#         (2,3),(4,5),(7,8),(15,16),\n",
+    "#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),\n",
+    "#         (503, 504), (512, 513), \n",
+    "#     ]\n",
+    "# elif sub != 'sub-001' and session != 'ses-05':\n",
+    "#     unique_images_pairs = [\n",
+    "#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),\n",
+    "#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),\n",
+    "#         (31,32),(33,34),(35,36),\n",
+    "#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),\n",
+    "#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),\n",
+    "#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),\n",
+    "#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),\n",
+    "#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),\n",
+    "#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),\n",
+    "#         (847, 848), (849, 850)\n",
+    "#     ]\n",
+    "# else:\n",
+    "#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]\n",
+    "#     unique_images_pairs = find_mst_pairs(x)\n",
+    "# # unique_images[unique_images_pairs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "3215e72f-8a91-4761-9223-5d6990ddcdb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "def evaluate_mst_pairs(mst_pairs):\n",
+    "    score = 0\n",
+    "    total = 0\n",
+    "    \n",
+    "    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):\n",
+    "        for pair in mst_pairs:\n",
+    "            voxel = vox[image_idx[pair[0]]].to(device)[None]\n",
+    "            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "            \n",
+    "            imageA = images[image_idx[pair[0]]].to(device)[None]\n",
+    "            imageB = images[image_idx[pair[1]]].to(device)[None]\n",
+    "            \n",
+    "            clip_targetA = clip_img_embedder(imageA.float())\n",
+    "            clip_targetB = clip_img_embedder(imageB.float())\n",
+    "            \n",
+    "            voxel_ridge = model.ridge(voxel,0)\n",
+    "            backbone, clip_voxels, _ = model.backbone(voxel_ridge)\n",
+    "            \n",
+    "            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "            clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)\n",
+    "            clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)\n",
+    "            \n",
+    "            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm):\n",
+    "                score += 1\n",
+    "            total += 1\n",
+    "            \n",
+    "            voxel = vox[image_idx[pair[1]]].to(device)[None]\n",
+    "            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "            \n",
+    "            voxel_ridge = model.ridge(voxel,0)\n",
+    "            backbone, clip_voxels, _ = model.backbone(voxel_ridge)\n",
+    "            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "            \n",
+    "            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm):\n",
+    "                score += 1\n",
+    "            total += 1\n",
+    "            \n",
+    "    return score/total\n",
+    "\n",
+    "print(evaluate_mst_pairs(pairs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "d7bcfb28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.25999999046325684\n",
+      "0.2800000011920929\n",
+      "0.35999998450279236\n",
+      "0.35999998450279236\n",
+      "--- Full Dataset Evaluation ---\n",
+      "subset_0_0_test/fwd_pct_correct: 0.2600\n",
+      "subset_0_0_test/bwd_pct_correct: 0.2800\n",
+      "subset_0_1_test/fwd_pct_correct: 0.3600\n",
+      "subset_0_1_test/bwd_pct_correct: 0.3600\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.eval()\n",
+    "logs = {}\n",
+    "if local_rank == 0:\n",
+    "    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):\n",
+    "        for i in range(1):\n",
+    "            for j in range(2):\n",
+    "                subset_indices = MST_idx[:, i, j].reshape(-1)\n",
+    "                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))\n",
+    "                subset_dl = torch.utils.data.DataLoader(\n",
+    "                    subset_dataset, batch_size=len(MST_idx), shuffle=False,\n",
+    "                    drop_last=True, pin_memory=True\n",
+    "                )\n",
+    "\n",
+    "                # Reset metrics for this subset\n",
+    "                test_fwd_percent_correct = 0\n",
+    "                test_bwd_percent_correct = 0\n",
+    "\n",
+    "                for test_i, behav in enumerate(subset_dl):\n",
+    "                    behav = behav[0]\n",
+    "                    loss = 0.\n",
+    "                    image = images[behav.long().cpu()].to(device)\n",
+    "                    voxel = vox[behav.long().cpu()]\n",
+    "                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "                    clip_img_embedder = clip_img_embedder.to(device)\n",
+    "                    clip_target = clip_img_embedder(image.float())\n",
+    "\n",
+    "                    voxel_ridge = model.ridge(voxel, 0)\n",
+    "                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)\n",
+    "                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)\n",
+    "\n",
+    "                    if clip_scale > 0:\n",
+    "                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)\n",
+    "                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n",
+    "                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n",
+    "                    print(test_fwd_percent_correct)\n",
+    "                    print(test_bwd_percent_correct)\n",
+    "                    logs.update({\n",
+    "                        f\"subset_{i}_{j}_test/fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n",
+    "                        f\"subset_{i}_{j}_test/bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n",
+    "                    })\n",
+    "\n",
+    "    print(\"--- Full Dataset Evaluation ---\")\n",
+    "    for k, v in logs.items():\n",
+    "        print(f\"{k}: {v:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5be6369b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "top_k = 5\n",
+    "\n",
+    "for x in range(len(MST_idx)):\n",
+    "    # Get top-k indices\n",
+    "    y = torch.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)[x], k=top_k).indices.to('cpu').tolist()\n",
+    "\n",
+    "    # Set up the plot with original + top_k images in one row\n",
+    "    fig, axs = plt.subplots(1, top_k + 1, figsize=(3 * (top_k + 1), 3))\n",
+    "    \n",
+    "    # Plot the original image\n",
+    "    orig_img = utils.torch_to_Image(images[MST_idx[x]])\n",
+    "    axs[0].imshow(orig_img)\n",
+    "    axs[0].set_title(\"Original\")\n",
+    "    axs[0].axis(\"off\")\n",
+    "\n",
+    "    # Plot the top-k retrieved images\n",
+    "    for idx, i in enumerate(y):\n",
+    "        pred_img = utils.torch_to_Image(images[MST_idx[i]])\n",
+    "        axs[idx + 1].imshow(pred_img)\n",
+    "        axs[idx + 1].set_title(f\"Top {idx+1}\")\n",
+    "        axs[idx + 1].axis(\"off\")\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "7267c884",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate_mst_pairs(mst_pairs):\n",
+    "    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):\n",
+    "        failed_A = []\n",
+    "        failed_B = []\n",
+    "        failed_non_corr = []\n",
+    "\n",
+    "        # Get all unique image indices\n",
+    "        all_indices = np.unique(mst_pairs.flatten())\n",
+    "        \n",
+    "        # Pre-load all images and betas to device\n",
+    "        all_images = images[image_idx[all_indices]].to(device)\n",
+    "        all_voxels = torch.Tensor(vox[image_idx[all_indices]]).unsqueeze(1).to(device)\n",
+    "        \n",
+    "        # Get CLIP embeddings for all images\n",
+    "        all_clip_targets = clip_img_embedder(all_images.float())\n",
+    "        all_clip_targets_norm = nn.functional.normalize(all_clip_targets.flatten(1), dim=-1)\n",
+    "        \n",
+    "        # Pass all betas through model to get MindEye embeddings\n",
+    "        all_voxel_ridge = model.ridge(all_voxels, 0)\n",
+    "        _, all_clip_voxels, _ = model.backbone(all_voxel_ridge)\n",
+    "        all_clip_voxels_norm = nn.functional.normalize(all_clip_voxels.flatten(1), dim=-1)\n",
+    "        \n",
+    "        # Dict mapping idx (which indexes the \"vox\" and \"images\" tensors) to pos (their position in the flattened array \"all_indices\")\n",
+    "        idx_to_pos = {idx: pos for pos, idx in enumerate(all_indices)}\n",
+    "        \n",
+    "        # Initialize scores\n",
+    "        corr_score = 0\n",
+    "        non_corr_score = 0\n",
+    "        corr_total = len(mst_pairs) * 2\n",
+    "        non_corr_total = len(mst_pairs) * (len(mst_pairs)-1) * 4  # number of elements in the matrix excluding the diagonal is n*(n-1)*4 since we're doing this twice each for pairmate A and B\n",
+    "\n",
+    "        \n",
+    "        # Pre-load voxelwise beta-based embeddings from MindEye and CLIP image embeddings\n",
+    "        idxA = np.array([pair[0] for pair in mst_pairs])\n",
+    "        idxB = np.array([pair[1] for pair in mst_pairs])\n",
+    "        \n",
+    "        posA = np.array([idx_to_pos[idx] for idx in idxA])\n",
+    "        posB = np.array([idx_to_pos[idx] for idx in idxB])\n",
+    "        \n",
+    "        voxA_embeddings = all_clip_voxels_norm[posA]\n",
+    "        voxB_embeddings = all_clip_voxels_norm[posB]\n",
+    "        imgA_embeddings = all_clip_targets_norm[posA]\n",
+    "        imgB_embeddings = all_clip_targets_norm[posB]\n",
+    "        \n",
+    "        simA_A = utils.batchwise_cosine_similarity(voxA_embeddings, imgA_embeddings)\n",
+    "        simA_B = utils.batchwise_cosine_similarity(voxA_embeddings, imgB_embeddings)\n",
+    "        simB_B = utils.batchwise_cosine_similarity(voxB_embeddings, imgB_embeddings)\n",
+    "        simB_A = utils.batchwise_cosine_similarity(voxB_embeddings, imgA_embeddings)\n",
+    "\n",
+    "        \n",
+    "        # corresponding 2-AFC\n",
+    "        # is the voxel embedding for image 1 pairmate A more similar to the CLIP embedding for image 1 pairmate A or the CLIP embedding for image 1 pairmate B?\n",
+    "        correct_A = torch.diag(simA_A) > torch.diag(simA_B)\n",
+    "        # is the voxel embedding for image 1 pairmate B more similar to the CLIP embedding for image 1 pairmate B or the CLIP embedding for image 1 pairmate A?\n",
+    "        correct_B = torch.diag(simB_B) > torch.diag(simB_A)\n",
+    "\n",
+    "        corr_score += correct_A.sum().item()\n",
+    "        corr_score += correct_B.sum().item()\n",
+    "\n",
+    "        # Store indices where AFC fails\n",
+    "        failed_A = [i for i, correct in enumerate(correct_A.cpu()) if not correct]\n",
+    "        failed_B = [i for i, correct in enumerate(correct_B.cpu()) if not correct]\n",
+    "        \n",
+    "        # non-corresponding 2-AFC\n",
+    "        N = len(mst_pairs)        \n",
+    "        # Create a mask that is True for all off-diagonal elements\n",
+    "        row_idx = torch.arange(N).unsqueeze(1)  # (N, 1)\n",
+    "        col_idx = torch.arange(N).unsqueeze(0)  # (1, N)\n",
+    "        off_diag_mask = row_idx != col_idx  # shape (N, N)\n",
+    "        \n",
+    "        diagA_A = simA_A.diag().unsqueeze(1).expand(-1, N)  # Get diagonal values and expand to (N, N) by duplicating the diagonal element along the rows (since each row is the cosine similarity between a single voxel embedding and all CLIP embeddings)\n",
+    "        diagB_B = simB_B.diag().unsqueeze(1).expand(-1, N)\n",
+    "        \n",
+    "        # pdb.set_trace()\n",
+    "\n",
+    "        # Compare each element in the row to the diagonal element\n",
+    "        off_diag_mask_device = off_diag_mask.to(device)\n",
+    "\n",
+    "        fail_AA = (simA_A < diagA_A) & off_diag_mask_device\n",
+    "        fail_AB = (simA_B < diagA_A) & off_diag_mask_device\n",
+    "        fail_BB = (simB_B < diagB_B) & off_diag_mask_device\n",
+    "        fail_BA = (simB_A < diagB_B) & off_diag_mask_device\n",
+    "\n",
+    "        non_corr_score += fail_AA.sum().item()\n",
+    "        non_corr_score += fail_AB.sum().item()\n",
+    "        non_corr_score += fail_BB.sum().item()\n",
+    "        non_corr_score += fail_BA.sum().item()\n",
+    "\n",
+    "        # Log failed indices\n",
+    "        fail_sources = [fail_AA, fail_AB, fail_BB, fail_BA]\n",
+    "        for fail_matrix, label in zip(fail_sources, [\"AA\", \"AB\", \"BB\", \"BA\"]):\n",
+    "            fail_coords = torch.nonzero(fail_matrix, as_tuple=False).cpu().numpy()\n",
+    "            for i, j in fail_coords:\n",
+    "                failed_non_corr.append({\"type\": label, \"i\": i, \"j\": j, \"pair_i\": mst_pairs[i], \"pair_j\": mst_pairs[j]})\n",
+    "\n",
+    "    return corr_score, corr_total, int(non_corr_score), non_corr_total, failed_A, failed_B, failed_non_corr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "76009d48",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(25, 2, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]\n",
+    "assert len(image_idx) == len(x)\n",
+    "pairs = []\n",
+    "for i, p in enumerate(MST_pairmate_names):\n",
+    "    assert p[0] != p[1]  # no duplicate images\n",
+    "    pairs.append([utils.find_all_indices(x,p[0]), utils.find_all_indices(x,p[1])])\n",
+    "\n",
+    "pairs = np.array(pairs)\n",
+    "print(pairs.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "id": "23a23cdf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pairmate A repeat 0 vs pairmate B repeat 0:\n",
+      "2-AFC corresponding = 45/50 (90.00%)\n",
+      "2-AFC non-corresponding = 2298/2400 (95.75%)\n",
+      "\n",
+      "pairmate A repeat 0 vs pairmate B repeat 1:\n",
+      "2-AFC corresponding = 45/50 (90.00%)\n",
+      "2-AFC non-corresponding = 2298/2400 (95.75%)\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "all_scores = []\n",
+    "all_failures = []\n",
+    "\n",
+    "for i in range(1):\n",
+    "    for j in range(2):\n",
+    "        mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)\n",
+    "        corr_score, corr_total, non_corr_score, non_corr_total, failed_A, failed_B, failed_non_corr = evaluate_mst_pairs(mst_pairs)\n",
+    "\n",
+    "        # Store scores and failure info together\n",
+    "        all_scores.append((corr_score, corr_total, non_corr_score, non_corr_total))\n",
+    "        all_failures.append({\n",
+    "            \"repeat_A\": i,\n",
+    "            \"repeat_B\": j,\n",
+    "            \"failed_A\": failed_A,\n",
+    "            \"failed_B\": failed_B,\n",
+    "            \"failed_non_corr\": failed_non_corr,\n",
+    "            \"mst_pairs\": mst_pairs,\n",
+    "        })\n",
+    "\n",
+    "        # Print summary\n",
+    "        print(f\"pairmate A repeat {i} vs pairmate B repeat {j}:\")\n",
+    "        print(f\"2-AFC corresponding = {corr_score}/{corr_total} ({corr_score/corr_total:.2%})\")\n",
+    "        print(f\"2-AFC non-corresponding = {non_corr_score}/{non_corr_total} ({non_corr_score/non_corr_total:.2%})\")\n",
+    "        print(\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "id": "35f91159-eab1-4f9d-ba75-a380e3a4111b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Compare first few pairs\n",
+    "# for pair in pairs:  # Checking first 2 pairs\n",
+    "#     print(\"Indices in mst_pairs:\", pair)\n",
+    "#     print(\"Corresponding filenames:\")\n",
+    "#     print(f\"Image 1: {x[pair[0]]}\")\n",
+    "#     print(f\"Image 2: {x[pair[1]]}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "id": "922145d0-9e71-4c05-a76d-36009f193926",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for i in range(len(pairs)):\n",
+    "#     fig, ax = plt.subplots(1, 2, figsize=(10,8))\n",
+    "\n",
+    "#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())\n",
+    "#     ax[0].set_title(f\"Repeat 1\")\n",
+    "\n",
+    "#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())\n",
+    "#     ax[1].set_title(f\"Repeat 2\")\n",
+    "\n",
+    "#     plt.setp(ax, xticks=[], yticks=[])\n",
+    "#     plt.tight_layout()\n",
+    "#     plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "id": "e97de7b2-2a32-4ce7-9533-aa8e06946cfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# score = 0\n",
+    "# total = 0\n",
+    "# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n",
+    "#     for pair in unique_images_pairs:\n",
+    "#         imageA_idx, imageB_idx = pair\n",
+    "#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()\n",
+    "#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()\n",
+    "        \n",
+    "#         voxel = vox[imageA_idx].to(device)[None]\n",
+    "#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "        \n",
+    "#         imageA = images[imageA_idx].to(device)[None]\n",
+    "#         imageB = images[imageB_idx].to(device)[None]\n",
+    "\n",
+    "#         clip_targetA = clip_img_embedder(imageA.float())\n",
+    "#         clip_targetB = clip_img_embedder(imageB.float())\n",
+    "        \n",
+    "#         voxel_ridge = model.ridge(voxel,0)\n",
+    "#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)\n",
+    "#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)\n",
+    "\n",
+    "#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)\n",
+    "#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)\n",
+    "        \n",
+    "#         if cossimA > cossimB:\n",
+    "#             score += 1\n",
+    "#         total += 1\n",
+    "        \n",
+    "#     for pair in unique_images_pairs:\n",
+    "#         imageA_idx, imageB_idx = pair\n",
+    "#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()\n",
+    "#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()\n",
+    "        \n",
+    "#         voxel = vox[imageB_idx].to(device)[None]\n",
+    "#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "        \n",
+    "#         imageA = images[imageA_idx].to(device)[None]\n",
+    "#         imageB = images[imageB_idx].to(device)[None]\n",
+    "\n",
+    "#         clip_targetA = clip_img_embedder(imageA.float())\n",
+    "#         clip_targetB = clip_img_embedder(imageB.float())\n",
+    "        \n",
+    "#         voxel_ridge = model.ridge(voxel,0)\n",
+    "#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)\n",
+    "#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)\n",
+    "\n",
+    "#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)\n",
+    "#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)\n",
+    "        \n",
+    "#         if cossimB > cossimA:\n",
+    "#             score += 1\n",
+    "#         total += 1\n",
+    "\n",
+    "# print(score/total)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "id": "ee4bd720-864a-480a-818e-e7e61c8ad429",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#display(utils.torch_to_Image(imageA))\n",
+    "#display(utils.torch_to_Image(imageB))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "id": "b0b54c3d-7544-4249-a0da-c4ae90b5172a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from scipy.stats import binomtest\n",
+    "\n",
+    "# total_samples = len(np.array(unique_images_pairs).flatten())\n",
+    "# assert total_samples == 100\n",
+    "\n",
+    "# correct_predictions = int((score/total) * total_samples)  # calculate the number of correct predictions\n",
+    "# expected_accuracy = 0.5  # expected accuracy under the null hypothesis\n",
+    "\n",
+    "# # Perform the binomial test\n",
+    "# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')\n",
+    "# p_value = binom_stats.pvalue\n",
+    "\n",
+    "# # Output the result\n",
+    "# print(f\"P-value: {p_value}\")\n",
+    "# if p_value < 0.05:\n",
+    "#     print(\"The decoder's accuracy is significantly better than chance.\")\n",
+    "# else:\n",
+    "#     print(\"The decoder's accuracy is not significantly better than chance.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68473420-d978-4d4d-ba51-90e02e62741b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "47e0dfca-651b-4fb9-92be-97e5c00ac244",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "165px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  },
+  "toc-autonumbering": true,
+  "vscode": {
+   "interpreter": {
+    "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}