diff --git "a/main-finetune-rt-preproc.ipynb" "b/main-finetune-rt-preproc.ipynb"
new file mode 100644--- /dev/null
+++ "b/main-finetune-rt-preproc.ipynb"
@@ -0,0 +1,3199 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "11aceda1-d24d-46ee-9688-c34daea6fc6e",
+   "metadata": {},
+   "source": [
+    "#### This notebook fine-tunes MindEye on training sessions using real-time compatible preprocessing to produce a checkpoint that can be used in the real-time scan"
+   ]
+  },
+  {
+   "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": 2,
+   "id": "0f2d14fc-bfe3-40dc-b14e-070812c43406",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if utils.is_interactive():\n",
+    "    sub = \"sub-005\"\n",
+    "    session = \"all\"\n",
+    "    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format\n",
+    "    func_task_name = 'C'\n",
+    "else:\n",
+    "    sub = os.environ[\"SUB\"]\n",
+    "    session = os.environ[\"SESSION\"]\n",
+    "    task = os.environ[\"TASK\"]\n",
+    "    func_task_name = 'C'\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 = False\n",
+    "resample_post_glmsingle = False  # do you want to do voxel resampling here? if resample_voxel_size = True and resample_post_glmsingle = False, assume the resampling has been done prior to GLMsingle, so just use resampled directory but otherwise proceed as normal\n",
+    "load_from_resampled_file = False  # do you want to load resampled data from file? if True, assume resampling was done in this notebook before, and that we're not using the GLMsingle resampled data\n",
+    "    \n",
+    "train_test_split = 'MST' # 'MST', 'orig', 'unique'\n",
+    "remove_close_to_MST = False\n",
+    "remove_random_n = False\n",
+    "\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",
+    "    # voxel size was unchanged in glmsingle, want to perform resampling here\n",
+    "    resampled_vox_size = 2.5\n",
+    "    resample_method = \"sinc\"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html\n",
+    "    \n",
+    "    # file name helper variables\n",
+    "    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore\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",
+    "    else:\n",
+    "        resampled_suffix += '_preglmsingle'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "67d4c658-b30e-4e82-b0d1-0731cc619751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "session label: ses-01-02\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": 4,
+   "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-01-02_task-C\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": 5,
+   "id": "34c1e0c6-0641-4239-8201-f2c676532302",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-01.csv\n",
+      "Loading: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-02.csv\n",
+      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-02.csv\n",
+      "Total number of images: 1540\n",
+      "Number of unique images: 1001\n",
+      "n_runs 22\n",
+      "['all_stimuli/special515/special_15939.jpg'\n",
+      " 'all_stimuli/special515/special_23241.jpg'\n",
+      " 'all_stimuli/special515/special_32232.jpg'\n",
+      " 'all_stimuli/special515/special_34238.jpg']\n",
+      "[190.2773371 194.2907918 198.3011098 202.3095724]\n",
+      "[0. 0. 0. 0.]\n",
+      "(1386,)\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": 6,
+   "id": "2ceb404f-b04f-42b6-afc4-283bb2b40c08",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/1386 [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%|██████████| 1386/1386 [02:13<00:00, 10.40it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "images torch.Size([1386, 3, 224, 224])\n",
+      "MST_images 1386\n",
+      "MST_images==True 248\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": 7,
+   "id": "19963e9d-9ec5-4f16-b376-2d2edbe0aedc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(31, 2) [[110  25]\n",
+      " [ 15   6]\n",
+      " [ 18  43]\n",
+      " [ 95  49]\n",
+      " [ 14  70]\n",
+      " [ 12  20]\n",
+      " [ 51  63]\n",
+      " [ 87  50]\n",
+      " [  2  58]\n",
+      " [ 45   8]\n",
+      " [ 27  39]\n",
+      " [ 92  19]\n",
+      " [ 55  33]\n",
+      " [ 78  26]\n",
+      " [  0  65]\n",
+      " [ 32  28]\n",
+      " [ 23  72]\n",
+      " [ 54  91]\n",
+      " [ 11  21]\n",
+      " [ 76  13]\n",
+      " [  5  34]\n",
+      " [ 53  52]\n",
+      " [ 66  40]\n",
+      " [ 22  69]\n",
+      " [107  24]\n",
+      " [  7 106]\n",
+      " [ 42   3]\n",
+      " [ 44  10]\n",
+      " [ 30   4]\n",
+      " [ 86  60]\n",
+      " [ 16  59]]\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": 8,
+   "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": 9,
+   "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": 10,
+   "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": 11,
+   "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": 12,
+   "id": "3d830531-2949-4646-8371-f7940a51eab1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data shape: (780, 122)\n",
+      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-01.csv\n",
+      "Total number of images: 770\n",
+      "Number of unique images: 532\n",
+      "Data shape: (780, 122)\n",
+      "Using design file: /home/ri4541/real_time_mindEye2/csv/sub-005_ses-02.csv\n",
+      "Total number of images: 770\n",
+      "Number of unique images: 532\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)\n",
+    "\n",
+    "if sub == 'sub-005' and len(ses_list) > 1:\n",
+    "    session_length = 693\n",
+    "    for image, session_indices_list in image_to_indices.items():\n",
+    "        new_indices_list = []\n",
+    "        for idx, indices in enumerate(session_indices_list):\n",
+    "            offset = idx * session_length\n",
+    "            new_indices = [i + offset for i in indices]\n",
+    "            new_indices_list.append(new_indices)\n",
+    "        image_to_indices[image] = new_indices_list\n",
+    "        \n",
+    "    import itertools\n",
+    "    assert max(itertools.chain.from_iterable(list(image_to_indices.values())))[0] == (len(ses_list)*session_length) - 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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": 14,
+   "id": "e846060a-d9c0-43d3-824b-08fa2b4b354e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loading brain mask\n",
+      "Mask dimensions: (2.0, 2.0, 2.0)\n",
+      "\n",
+      "Affine:\n",
+      "[[  2.           0.           0.         -76.29234314]\n",
+      " [  0.           2.           0.         -84.79180908]\n",
+      " [  0.           0.           2.         -62.80359268]\n",
+      " [  0.           0.           0.           1.        ]]\n",
+      "\n",
+      "There are 180585 voxels in the included brain mask\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 660x350 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from nilearn.plotting import plot_roi\n",
+    "\n",
+    "print('loading brain mask')\n",
+    "avg_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
+    "final_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')\n",
+    "\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')\n",
+    "\n",
+    "plot_roi(final_mask, bg_img=avg_mask)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "89eebb1f-bf55-44f5-b875-6d466182c03f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # create union of ses-01 and ses-02 reliability masks and plot against avg_mask \n",
+    "# rel_masks = []\n",
+    "# rel_masks.append(np.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/rel_mask_from_ses-01_to_ses-03.npy'))\n",
+    "# rel_masks.append(np.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/rel_mask_from_ses-02_to_ses-03.npy'))\n",
+    "# rel_masks = np.array(rel_masks)\n",
+    "# for r in rel_masks:\n",
+    "#     assert r.shape[0] == int(final_mask.get_fdata().sum())\n",
+    "#     assert r.dtype == bool\n",
+    "    \n",
+    "# assert len(rel_masks) == 2  # should be the case if there's 2 training sessions\n",
+    "# union_mask = np.logical_or(rel_masks[0], rel_masks[1])\n",
+    "# assert union_mask.sum() > rel_masks[0].sum()\n",
+    "# assert union_mask.sum() > rel_masks[1].sum()\n",
+    "# print(f'there are {union_mask.sum()} reliable voxels based on the union mask out of {int(final_mask.get_fdata().sum())} voxels in the nsdgeneral roi')\n",
+    "# print(f'{(union_mask.sum() / int(final_mask.get_fdata().sum())):.2%} of the voxels in the roi were selected')\n",
+    "# path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy'\n",
+    "path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy'\n",
+    "# np.save(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy', union_mask)\n",
+    "# print(f'saved union mask to {path}!')\n",
+    "union_mask = np.load(path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e89e422d-9100-463b-9d02-9b59746cf33c",
+   "metadata": {},
+   "source": [
+    "## Proceed to fine-tuning using real-time compatible betas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "5e81b967-e2d1-46f2-9bf8-bcb2812024ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77762f5d-7442-4db0-8afd-ee3062c8e968",
+   "metadata": {},
+   "source": [
+    "## load betas from ses-01 and 02 that were computed based on real-time preprocessing that is identical to that used in the real-time session"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "ecd39db6-d72e-4103-8249-53a5905c03b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1386, 8627)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ses_vox = []\n",
+    "runs_per_session = int(n_runs/len(ses_list))\n",
+    "for s in ses_list:\n",
+    "    ses_vox_path = f\"/scratch/gpfs/ri4541/MindEyeV2/src/3t/derivatives/{sub}_{s}_task-{func_task_name}_run-{runs_per_session}_recons/betas_run-{runs_per_session}.npy\"  # assumes each session list has the same number of runs\n",
+    "    ses_vox.append(np.load(ses_vox_path))\n",
+    "\n",
+    "vox = np.concatenate(ses_vox).squeeze(1)\n",
+    "print(vox.shape)\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "779861de-8628-49ad-8cec-c14d285d2ea3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_mask = []\n",
+    "\n",
+    "for s in ses_list:\n",
+    "    ses_mask_path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{s}_task-C/sub-005_{s}_task-C_brain.nii.gz'\n",
+    "    ses_mask.append(nib.load(ses_mask_path))\n",
+    "    \n",
+    "    assert np.all(ses_mask[-1].affine == final_mask.affine)\n",
+    "    assert np.all(ses_mask[-1].shape == final_mask.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "9d7d1933-b828-4312-bb36-8e6a1fc2394d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # get vox into the same shape as the union mask\n",
+    "# v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask\n",
+    "# final_mask = nilearn.masking.intersect_masks([avg_mask, roi])\n",
+    "# vox = nilearn.masking.apply_mask(vox, final_mask)  # re-flatten based on final mask so everything is in the same shape now\n",
+    "# print(vox.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "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": 21,
+   "id": "c087978f-b316-44f4-a2af-c17b5a00764b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "162 162\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": 22,
+   "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": 23,
+   "id": "8f554db1-f7cd-40d2-ab62-5d1e282c2bc8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1138 248\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": 24,
+   "id": "590f2b4b-db7c-42a1-bfd0-cc578e6af988",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "voxels have been zscored\n",
+      "ses-01: 0.015985363232110802 1.069565048194396\n",
+      "ses-02: -0.07409934511563594 0.9528142435470952\n",
+      "vox (1386, 8627)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ses_split = vox[train_image_indices].shape[0] // 2\n",
+    "\n",
+    "train_mean_s1 = np.mean(vox[train_image_indices][:ses_split], axis=0)\n",
+    "train_std_s1 = np.std(vox[train_image_indices][:ses_split], axis=0)\n",
+    "train_mean_s2 = np.mean(vox[train_image_indices][ses_split:], axis=0)\n",
+    "train_std_s2 = np.std(vox[train_image_indices][ses_split:], axis=0)\n",
+    "\n",
+    "\n",
+    "vox[:ses_split] = utils.zscore(vox[:ses_split],train_mean=train_mean_s1,train_std=train_std_s1)\n",
+    "vox[ses_split:] = utils.zscore(vox[ses_split:],train_mean=train_mean_s2,train_std=train_std_s2)\n",
+    "\n",
+    "print(\"voxels have been zscored\")\n",
+    "print(\"ses-01:\", vox[:ses_split,0].mean(), vox[:ses_split,0].std())\n",
+    "print(\"ses-02:\", vox[ses_split:,0].mean(), vox[ses_split:,0].std())\n",
+    "print(\"vox\", vox.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "ddf00e76-51ee-4e9e-8e38-c09fba22f103",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(8627,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# save the mean and std from ses-01 and 02\n",
+    "train_test_mean_s1 = np.mean(vox[:ses_split], axis=0)\n",
+    "train_test_std_s1 = np.std(vox[:ses_split], axis=0)\n",
+    "train_test_mean_s2 = np.mean(vox[ses_split:], axis=0)\n",
+    "train_test_std_s2 = np.std(vox[ses_split:], axis=0)\n",
+    "print(train_test_mean_s1.shape)\n",
+    "assert np.all(train_test_mean_s1.shape == train_test_std_s1.shape)\n",
+    "assert np.all(train_test_mean_s1.shape == train_test_mean_s2.shape)\n",
+    "assert np.all(train_test_mean_s1.shape == train_test_std_s2.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "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": 27,
+   "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": 28,
+   "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": 29,
+   "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PID of this process = 3240501\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": 30,
+   "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": 31,
+   "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": 32,
+   "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)\n",
+    "    \n",
+    "    np.save(f'{eval_dir}/train_test_mean_s1.npy', train_test_mean_s1)\n",
+    "    np.save(f'{eval_dir}/train_test_std_s1.npy', train_test_std_s1)\n",
+    "    np.save(f'{eval_dir}/train_test_mean_s2.npy', train_test_mean_s2)\n",
+    "    np.save(f'{eval_dir}/train_test_std_s2.npy', train_test_std_s2)"
+   ]
+  },
+  {
+   "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": 33,
+   "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 = 142 num_samples_per_epoch = 1138\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": 34,
+   "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": 35,
+   "id": "81084834-035f-4465-ad59-59e6b806a2f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training with 0 sessions\n",
+      "num_voxels for subj01: 8627\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": 36,
+   "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": 37,
+   "id": "22850c04-3811-4d52-ad2f-48c7be1366e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MindEyeModule()\n",
+      "param counts:\n",
+      "8,835,072 total\n",
+      "8,835,072 trainable\n",
+      "param counts:\n",
+      "8,835,072 total\n",
+      "8,835,072 trainable\n",
+      "param counts:\n",
+      "453,360,280 total\n",
+      "453,360,280 trainable\n",
+      "param counts:\n",
+      "462,195,352 total\n",
+      "462,195,352 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": 38,
+   "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([2, 1, 8627]) 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": 39,
+   "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": 40,
+   "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": 41,
+   "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total_steps 4260\n",
+      "\n",
+      "Done with model preparations!\n",
+      "param counts:\n",
+      "462,195,352 total\n",
+      "462,195,352 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": 42,
+   "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": 43,
+   "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": 44,
+   "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-08-01 13:58:15,876] [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": 45,
+   "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": 46,
+   "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": 47,
+   "id": "60be0d5f-3e94-4612-9373-61b53d836393",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "testing_MST starting with epoch 0 / 30\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0/30 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Subset (0,0) ---\n",
+      "subset_0_0_test/loss: 4.7832\n",
+      "subset_0_0_test/loss_clip_total: 4.7832\n",
+      "subset_0_0_test/loss_prior: 0.0000\n",
+      "subset_0_0_test/blurry_pixcorr: 0.0000\n",
+      "subset_0_0_test/fwd_pct_correct: 0.0000\n",
+      "subset_0_0_test/bwd_pct_correct: 0.0161\n",
+      "--- Subset (0,1) ---\n",
+      "subset_0_1_test/loss: 4.8835\n",
+      "subset_0_1_test/loss_clip_total: 4.8835\n",
+      "subset_0_1_test/loss_prior: 0.0000\n",
+      "subset_0_1_test/blurry_pixcorr: 0.0000\n",
+      "subset_0_1_test/fwd_pct_correct: 0.0323\n",
+      "subset_0_1_test/bwd_pct_correct: 0.0161\n",
+      "--- Subset (1,0) ---\n",
+      "subset_1_0_test/loss: 4.8790\n",
+      "subset_1_0_test/loss_clip_total: 4.8790\n",
+      "subset_1_0_test/loss_prior: 0.0000\n",
+      "subset_1_0_test/blurry_pixcorr: 0.0000\n",
+      "subset_1_0_test/fwd_pct_correct: 0.0000\n",
+      "subset_1_0_test/bwd_pct_correct: 0.0161\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  3%|█▊                                                      | 1/30 [00:25<12:32, 25.95s/it, subset_0_0_test/blurry_pixcorr=0, subset_0_0_test/bwd_pct_correct=0.0161, subset_0_0_test/fwd_pct_correct=0, subset_0_0_test/loss=4.78, subset_0_0_test/loss_clip_total=4.78, subset_0_0_test/loss_prior=0, subset_0_1_test/blurry_pixcorr=0, subset_0_1_test/bwd_pct_correct=0.0161, subset_0_1_test/fwd_pct_correct=0.0323, subset_0_1_test/loss=4.88, subset_0_1_test/loss_clip_total=4.88, subset_0_1_test/loss_prior=0, subset_1_0_test/blurry_pixcorr=0, subset_1_0_test/bwd_pct_correct=0.0161, subset_1_0_test/fwd_pct_correct=0, subset_1_0_test/loss=4.88, subset_1_0_test/loss_clip_total=4.88, subset_1_0_test/loss_prior=0, subset_1_1_test/blurry_pixcorr=0, subset_1_1_test/bwd_pct_correct=0.0323, subset_1_1_test/fwd_pct_correct=0, subset_1_1_test/loss=4.92, subset_1_1_test/loss_clip_total=4.92, subset_1_1_test/loss_prior=0, train/blurry_pixcorr=0, train/bwd_pct_correct=0.122, train/fwd_pct_correct=0.125, train/loss=2.52, train/loss_blurry_cont_total=0, train/loss_blurry_total=0, train/loss_clip_total=2.52, train/loss_prior=0, train/lr=0.000155, train/num_steps=142, train/recon_cossim=0, train/recon_mse=0]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--- Subset (1,1) ---\n",
+      "subset_1_1_test/loss: 4.9213\n",
+      "subset_1_1_test/loss_clip_total: 4.9213\n",
+      "subset_1_1_test/loss_prior: 0.0000\n",
+      "subset_1_1_test/blurry_pixcorr: 0.0000\n",
+      "subset_1_1_test/fwd_pct_correct: 0.0000\n",
+      "subset_1_1_test/bwd_pct_correct: 0.0323\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  3%|█▊                                                      | 1/30 [00:33<16:11, 33.51s/it, subset_0_0_test/blurry_pixcorr=0, subset_0_0_test/bwd_pct_correct=0.0161, subset_0_0_test/fwd_pct_correct=0, subset_0_0_test/loss=4.78, subset_0_0_test/loss_clip_total=4.78, subset_0_0_test/loss_prior=0, subset_0_1_test/blurry_pixcorr=0, subset_0_1_test/bwd_pct_correct=0.0161, subset_0_1_test/fwd_pct_correct=0.0323, subset_0_1_test/loss=4.88, subset_0_1_test/loss_clip_total=4.88, subset_0_1_test/loss_prior=0, subset_1_0_test/blurry_pixcorr=0, subset_1_0_test/bwd_pct_correct=0.0161, subset_1_0_test/fwd_pct_correct=0, subset_1_0_test/loss=4.88, subset_1_0_test/loss_clip_total=4.88, subset_1_0_test/loss_prior=0, subset_1_1_test/blurry_pixcorr=0, subset_1_1_test/bwd_pct_correct=0.0323, subset_1_1_test/fwd_pct_correct=0, subset_1_1_test/loss=4.92, subset_1_1_test/loss_clip_total=4.92, subset_1_1_test/loss_prior=0, train/blurry_pixcorr=0, train/bwd_pct_correct=0.122, train/fwd_pct_correct=0.125, train/loss=2.52, train/loss_blurry_cont_total=0, train/loss_blurry_total=0, train/loss_clip_total=2.52, train/loss_prior=0, train/lr=0.000155, train/num_steps=142, train/recon_cossim=0, train/recon_mse=0]\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[47], line 52\u001b[0m\n\u001b[1;32m     49\u001b[0m clip_target \u001b[38;5;241m=\u001b[39m clip_img_embedder(image)\n\u001b[1;32m     50\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch\u001b[38;5;241m.\u001b[39many(torch\u001b[38;5;241m.\u001b[39misnan(clip_target))\n\u001b[0;32m---> 52\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m epoch \u001b[38;5;241m<\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mmixup_pct\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[1;32m     53\u001b[0m     voxel, perm, betas, select \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mmixco(voxel)\n\u001b[1;32m     55\u001b[0m voxel_ridge \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mridge(voxel,\u001b[38;5;241m0\u001b[39m) \u001b[38;5;66;03m#[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\u001b[39;00m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "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(2):\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_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": null,
+   "id": "19bdef2b-02cf-40cc-8c0c-84b8b8acdd36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(test_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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": null,
+   "id": "3af2dfd7-638f-4932-b384-67d582f88c2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# MST_pairmate_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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 = []\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)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bda00d8-84b9-4e37-b4bc-aa5576e1586c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34cfada9",
+   "metadata": {},
+   "outputs": [],
+   "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(2):\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": "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": null,
+   "id": "f12f93b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pdb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3215e72f-8a91-4761-9223-5d6990ddcdb3",
+   "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": null,
+   "id": "571cf97f-5342-4005-8374-7b85385cf81e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_scores = []\n",
+    "all_failures = []\n",
+    "\n",
+    "for i in range(4):\n",
+    "    for j in range(4):\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": null,
+   "id": "6ec5ea78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_scores = np.array(all_scores)\n",
+    "print(f\"average 2-AFC corresponding: {all_scores[:,0].mean():.2f}/{all_scores[:,1].mean():.2f} ({(all_scores[:,0].sum()/all_scores[:,1].sum()):.2%})\")\n",
+    "print(f\"average 2-AFC non-corresponding: {all_scores[:,2].mean():.2f}/{all_scores[:,3].mean():.2f} ({(all_scores[:,2].sum()/all_scores[:,3].sum()):.2%})\")\n",
+    "print(f'chance = 1/{corr_total} ({(1/corr_total):.2%})')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da81a250",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "# Map from image index to failure details\n",
+    "failed_images = defaultdict(list)\n",
+    "\n",
+    "for failure_entry in all_failures:\n",
+    "    mst_pairs = failure_entry[\"mst_pairs\"]\n",
+    "    i, j = failure_entry[\"repeat_A\"], failure_entry[\"repeat_B\"]\n",
+    "\n",
+    "    # A-side failures\n",
+    "    for fail_idx in failure_entry[\"failed_A\"]:\n",
+    "        image_idx = mst_pairs[fail_idx][0]\n",
+    "        pairmate_idx = mst_pairs[fail_idx][1]\n",
+    "        failed_images[image_idx].append({\n",
+    "            \"repeat_A\": i,\n",
+    "            \"repeat_B\": j,\n",
+    "            \"pairmate\": pairmate_idx,\n",
+    "            \"type\": \"A\",\n",
+    "        })\n",
+    "\n",
+    "    # B-side failures\n",
+    "    for fail_idx in failure_entry[\"failed_B\"]:\n",
+    "        image_idx = mst_pairs[fail_idx][1]\n",
+    "        pairmate_idx = mst_pairs[fail_idx][0]\n",
+    "        failed_images[image_idx].append({\n",
+    "            \"repeat_A\": i,\n",
+    "            \"repeat_B\": j,\n",
+    "            \"pairmate\": pairmate_idx,\n",
+    "            \"type\": \"B\",\n",
+    "        })\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b55e6b64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import matplotlib.pyplot as plt\n",
+    "\n",
+    "# for img_idx, failure_list in failed_images.items():\n",
+    "#     print(f\"\\n==== Failed Image {img_idx} ====\")\n",
+    "\n",
+    "#     # Load and normalize the embeddings\n",
+    "#     image = images[img_idx].unsqueeze(0).to(device).float()\n",
+    "#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)\n",
+    "\n",
+    "#     # Get voxel→CLIP embedding\n",
+    "#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)\n",
+    "#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]\n",
+    "#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)\n",
+    "\n",
+    "#     # Display original image\n",
+    "#     print(\"Original image:\")\n",
+    "#     display(utils.torch_to_Image(images[img_idx]))\n",
+    "\n",
+    "#     # Collect unique pairmates involved in the failure\n",
+    "#     pairmate_indices = list(set(entry[\"pairmate\"] for entry in failure_list))\n",
+    "\n",
+    "#     # Plot failed pairmates with similarity annotations\n",
+    "#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))\n",
+    "#     if len(pairmate_indices) == 1:\n",
+    "#         axs = [axs]\n",
+    "\n",
+    "#     # Compute \"correct\" similarity — voxel to its own CLIP embedding\n",
+    "#     correct_clip = image_clip.float()\n",
+    "#     correct_voxel_sim = (voxel_embed.float() @ correct_clip.T).item()\n",
+    "#     print(f\"Correct voxel→CLIP similarity = {correct_voxel_sim:.4f}\")\n",
+    "\n",
+    "#     # Plot failed pairmates with similarity annotations\n",
+    "#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))\n",
+    "#     if len(pairmate_indices) == 1:\n",
+    "#         axs = [axs]\n",
+    "\n",
+    "#     for ax, mate_idx in zip(axs, pairmate_indices):\n",
+    "#         mate_image = images[mate_idx].unsqueeze(0).to(device).float()\n",
+    "#         mate_clip = nn.functional.normalize(clip_img_embedder(mate_image).flatten(1), dim=-1).float()\n",
+    "\n",
+    "#         # Similarities\n",
+    "#         clip_sim = (correct_clip @ mate_clip.T).item()\n",
+    "#         voxel_sim = (voxel_embed.float() @ mate_clip.T).item()\n",
+    "\n",
+    "#         # Check if this was the mistaken \"higher\" match\n",
+    "#         wrong_match = voxel_sim > correct_voxel_sim\n",
+    "\n",
+    "#         # Plot image and annotate\n",
+    "#         ax.imshow(utils.torch_to_Image(images[mate_idx]))\n",
+    "#         ax.axis(\"off\")\n",
+    "#         ax.set_title(f\"Pairmate {mate_idx}\\nCLIP={clip_sim:.3f}\\nVoxel={voxel_sim:.3f}\\n{'← WRONG' if wrong_match else ''}\",\n",
+    "#                      color=\"red\" if wrong_match else \"black\")\n",
+    "\n",
+    "\n",
+    "#     plt.tight_layout()\n",
+    "#     plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f053eed8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# comp[20,18] is the only False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03c0c8d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import matplotlib.pyplot as plt\n",
+    "\n",
+    "# for img_idx, failure_list in failed_images.items():\n",
+    "#     print(f\"\\n==== Failed Image {img_idx} ====\")\n",
+    "\n",
+    "#     # Load and normalize the embeddings\n",
+    "#     image = images[img_idx].unsqueeze(0).to(device).float()\n",
+    "#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)\n",
+    "\n",
+    "#     # Get voxel→CLIP embedding\n",
+    "#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)\n",
+    "#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]\n",
+    "#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)\n",
+    "\n",
+    "#     # Display original image\n",
+    "#     print(\"Original image:\")\n",
+    "#     display(utils.torch_to_Image(images[img_idx]))\n",
+    "\n",
+    "#     # Collect unique pairmates involved in the failure\n",
+    "#     pairmate_indices = list(set(entry[\"pairmate\"] for entry in failure_list))\n",
+    "\n",
+    "#     # Plot failed pairmates with similarity annotations\n",
+    "#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))\n",
+    "#     if len(pairmate_indices) == 1:\n",
+    "#         axs = [axs]\n",
+    "\n",
+    "#     for ax, mate_idx in zip(axs, pairmate_indices):\n",
+    "#         # Get all CLIP embeddings for failed image and pairmates\n",
+    "#         all_indices = [img_idx] + pairmate_indices\n",
+    "#         all_images = images[all_indices].to(device).float()\n",
+    "#         all_clip_embeds = clip_img_embedder(all_images)\n",
+    "#         all_clip_embeds = nn.functional.normalize(all_clip_embeds.flatten(1), dim=-1).float()\n",
+    "\n",
+    "#         # Compare voxel embedding for the failed image to all CLIP embeddings\n",
+    "#         sims = (voxel_embed.float() @ all_clip_embeds.T).squeeze().cpu().detach().numpy()  # shape: (1, N) → (N,)\n",
+    "#         image_ids = [\"correct\"] + [f\"pairmate {idx}\" for idx in pairmate_indices]\n",
+    "\n",
+    "#         # Sort and display\n",
+    "#         sorted_sims = sorted(zip(image_ids, all_indices, sims), key=lambda x: -x[2])\n",
+    "\n",
+    "#         print(\"\\n🧠 Voxel→CLIP similarity ranking:\")\n",
+    "#         for label, idx, sim in sorted_sims:\n",
+    "#             print(f\"{label:12} (index {idx:3}): similarity = {sim:.4f}\")\n",
+    "\n",
+    "#         # Optional assertion: did any pairmate score higher than the correct image?\n",
+    "#         correct_sim = sims[0]\n",
+    "#         higher = [(label, sim) for label, _, sim in sorted_sims[1:] if sim > correct_sim]\n",
+    "#         if higher:\n",
+    "#             print(\"\\n❌ Mismatch detected: voxel embedding matched other images more than the correct one!\")\n",
+    "#         else:\n",
+    "#             print(\"\\n✅ Model correctly ranked the correct image highest (despite failure elsewhere)\")\n",
+    "\n",
+    "#     plt.tight_layout()\n",
+    "#     plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4cf75fc6-126d-4ba7-9034-8d10b4015203",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mst_pairs[:5]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e490d576-26a0-406d-9c90-8bc1d963e02c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e6320f3c-f034-4414-ac5d-54657b5c80a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# images[image_idx[pairs[0][0]]].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84d63bf0-8ac4-406e-9562-49d784adf0bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ix = 0\n",
+    "display(utils.torch_to_Image(images[pairs[ix][0]]))\n",
+    "display(utils.torch_to_Image(images[pairs[ix][1]]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbc97bcf-5f2c-4666-b5d4-e075704b327a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# print(np.allclose(embed_A[0], embed_A[1]))  # across repeats\n",
+    "# print(np.allclose(embed_A[0], embed_B[0]))  # across pairmates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94c5db52-0bcf-4be5-9a35-5710f4738250",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# def generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=2):\n",
+    "#     n_imgs, n_pairmates, n_repeats = pairs.shape\n",
+    "#     nonmatch_pairs = []\n",
+    "\n",
+    "#     for i in range(n_imgs):\n",
+    "#         other_idxs = [j for j in range(n_imgs) if j != i]\n",
+    "#         sampled_j = np.random.choice(other_idxs, size=num_images_per_source, replace=False)\n",
+    "\n",
+    "#         for j in sampled_j:\n",
+    "#             for _ in range(num_repeats):\n",
+    "#                 a_side = np.random.randint(2)\n",
+    "#                 b_side = np.random.randint(2)\n",
+    "#                 a_repeat = np.random.randint(n_repeats)\n",
+    "#                 b_repeat = np.random.randint(n_repeats)\n",
+    "\n",
+    "#                 pair_a = pairs[i, a_side, a_repeat]\n",
+    "#                 pair_b = pairs[j, b_side, b_repeat]\n",
+    "#                 nonmatch_pairs.append([pair_a, pair_b])\n",
+    "\n",
+    "#     return np.array(nonmatch_pairs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "095b1dd8-7463-4095-bf0c-6c6ce702f711",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# nonmatch_pairs = generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=1)\n",
+    "# results = evaluate_mst_pairs(nonmatch_pairs)\n",
+    "# print(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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": null,
+   "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": null,
+   "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": null,
+   "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": null,
+   "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": []
+  }
+ ],
+ "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
+}