Add files using upload-large-folder tool

wandb/debug.log

@@ -0,0 +1,132 @@
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Current SDK version is 0.17.2
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Configure stats pid to 20009
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/.config/wandb/settings
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/real_time_mindEye2/wandb/settings
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Loading settings from environment variables: {}
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False}
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program': '<python with no main file>'}
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_setup.py:_flush():76] Applying login settings: {}
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_init.py:_log_setup():520] Logging user logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_153455-sdxl_turbo-MST/logs/debug.log
+2025-08-09 15:34:55,969 INFO    MainThread:20009 [wandb_init.py:_log_setup():521] Logging internal logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_153455-sdxl_turbo-MST/logs/debug-internal.log
+2025-08-09 15:34:55,970 INFO    MainThread:20009 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks <wandb.sdk.wandb_init._WandbInit object at 0x7f50b17131d0>
+2025-08-09 15:34:55,970 INFO    MainThread:20009 [wandb_init.py:init():560] calling init triggers
+2025-08-09 15:34:55,970 INFO    MainThread:20009 [wandb_init.py:init():567] wandb.init called with sweep_config: {}
+config: {'model_name': 'sdxl_turbo-MST', 'global_batch_size': 8, 'batch_size': 24, 'num_epochs': 150, 'num_sessions': 0, 'num_params': 119187688, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 1138, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 0, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+2025-08-09 15:34:55,970 INFO    MainThread:20009 [wandb_init.py:init():610] starting backend
+2025-08-09 15:34:55,970 INFO    MainThread:20009 [wandb_init.py:init():614] setting up manager
+2025-08-09 15:34:55,973 INFO    MainThread:20009 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn
+2025-08-09 15:34:55,975 INFO    MainThread:20009 [wandb_init.py:init():622] backend started and connected
+2025-08-09 15:34:55,993 INFO    MainThread:20009 [wandb_run.py:_label_probe_notebook():1334] probe notebook
+2025-08-09 15:34:55,994 INFO    MainThread:20009 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get'
+2025-08-09 15:34:55,994 INFO    MainThread:20009 [wandb_init.py:init():711] updated telemetry
+2025-08-09 15:34:56,004 INFO    MainThread:20009 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout
+2025-08-09 15:34:56,545 INFO    MainThread:20009 [wandb_run.py:_on_init():2402] communicating current version
+2025-08-09 15:34:56,705 INFO    MainThread:20009 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.21.1 is available!  To upgrade, please run:\n $ pip install wandb --upgrade"
+
+2025-08-09 15:34:56,705 INFO    MainThread:20009 [wandb_init.py:init():795] starting run threads in backend
+2025-08-09 15:34:57,218 INFO    MainThread:20009 [wandb_run.py:_console_start():2380] atexit reg
+2025-08-09 15:34:57,218 INFO    MainThread:20009 [wandb_run.py:_redirect():2235] redirect: wrap_raw
+2025-08-09 15:34:57,218 INFO    MainThread:20009 [wandb_run.py:_redirect():2300] Wrapping output streams.
+2025-08-09 15:34:57,218 INFO    MainThread:20009 [wandb_run.py:_redirect():2325] Redirects installed.
+2025-08-09 15:34:57,220 INFO    MainThread:20009 [wandb_init.py:init():838] run started, returning control to user process
+2025-08-09 15:34:57,223 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:34:57,224 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:34:57,975 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:34:57,978 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:34:57,979 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:34:58,316 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:34:58,318 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:34:58,318 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:34:58,595 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:34:58,597 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:34:58,597 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:34:58,931 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:34:59,386 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:34:59,386 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:34:59,670 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:35:13,283 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:35:13,283 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:47:19,635 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:50,915 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:50,915 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:51,344 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:51,349 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:51,350 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:51,650 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:51,652 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:51,652 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:52,007 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:52,009 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:52,009 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:52,341 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:52,349 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:52,349 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:52,646 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:52,652 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:52,652 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:52,979 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:54,012 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:54,012 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:54,354 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:54,356 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:54,356 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:54,687 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:54,689 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:54,689 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:55,044 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:55,050 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:55,050 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:55,374 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:58,719 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:58,719 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:59,022 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:59,025 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:59,025 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:59,327 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:59,330 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:59,330 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:59,652 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:59,655 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:59,655 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:08:59,957 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:08:59,959 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:08:59,959 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:00,340 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:00,343 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:00,343 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:00,657 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:00,663 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:00,664 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:00,964 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:00,972 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:00,973 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:01,959 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:01,961 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:01,961 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:02,589 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:02,679 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:02,679 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:03,880 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:03,882 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:03,882 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:05,439 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:05,441 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:05,441 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:05,730 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:05,732 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:05,732 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:06,067 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:06,069 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:06,069 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:06,366 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:06,368 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:06,369 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:06,704 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:06,707 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:06,707 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:07,026 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:07,027 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:07,028 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 16:09:07,328 INFO    MainThread:20009 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 16:09:07,330 INFO    MainThread:20009 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 16:09:07,330 INFO    MainThread:20009 [wandb_init.py:_pause_backend():431] pausing backend

wandb/run-20250809_151110-vit-h-MST/files/code/_session_history.ipynb

@@ -0,0 +1,2365 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "680cb740",
+   "metadata": {},
+   "outputs": [],
+   "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/ubuntu/mindeye_preproc/analysis/utils.py\" # \"/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": "code",
+   "execution_count": 2,
+   "id": "6213ef9f",
+   "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": "7511be2d",
+   "metadata": {},
+   "outputs": [],
+   "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": "d57d05fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if utils.is_interactive():\n",
+    "    glmsingle_path = f\"/home/ubuntu/glmsingle/glmsingle_{sub}_{session_label}_task-{task}\"\n",
+    "else:\n",
+    "    glmsingle_path = os.environ[\"glmsingle_path\"]\n",
+    "    \n",
+    "designdir = \"/home/ubuntu/real_time_mindEye2\" #\"/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": "074a6b10",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 6,
+   "id": "4af150a8",
+   "metadata": {},
+   "outputs": [],
+   "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": "4937263a",
+   "metadata": {},
+   "outputs": [],
+   "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": "108a3210",
+   "metadata": {},
+   "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": "d502b890",
+   "metadata": {},
+   "outputs": [],
+   "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": "cfc6a1f4",
+   "metadata": {},
+   "outputs": [],
+   "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": "c5fe984b",
+   "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": "f759b5d3",
+   "metadata": {},
+   "outputs": [],
+   "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": "2be1079a",
+   "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": "28bf7f64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nilearn.plotting import plot_roi\n",
+    "\n",
+    "print('loading brain mask')\n",
+    "avg_mask = nib.load(f'{orig_glmsingle_path}/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
+    "final_mask = nib.load(f'{orig_glmsingle_path}/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": "ca124946",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "glm_single_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "844c2b1f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-01-02_task-C'"
+     ]
+    }
+   ],
+   "source": [
+    "glmsingle_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fee56ca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "base_glm_single_path = os.environ[\"glmsingle_path\"]\n",
+    "base_glm_single_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "610317a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# take all paths exept last dir\n",
+    "base_glm_single_path = glmsingle_path.split('/')[:-1]\n",
+    "base_glm_single_path = '/'.join(base_glm_single_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "82cae662",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nilearn.plotting import plot_roi\n",
+    "\n",
+    "print('loading brain mask')\n",
+    "avg_mask = nib.load(f'{base_glm_single_path}/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
+    "final_mask = nib.load(f'{base_glm_single_path}/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": 20,
+   "id": "e6d4d01a",
+   "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'{base_glm_single_path}/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": "code",
+   "execution_count": 21,
+   "id": "8f372fed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_mask = []\n",
+    "\n",
+    "for s in ses_list:\n",
+    "    ses_mask_path = f'{base_glm_single_path}/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": 22,
+   "id": "36d2591a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_vox = []\n",
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:    \n",
+    "    for i, s in enumerate(ses_list):\n",
+    "        # either resampling was done in glmsingle or we aren't resampling \n",
+    "        ses_vox_path = f'{glmsingle_path}/glmsingle_sub-005_{s}_task-C'\n",
+    "        assert os.path.exists(ses_vox_path)\n",
+    "        ses_vox.append(load_preprocess_betas(ses_vox_path, *params))\n",
+    "        v = nilearn.masking.unmask(ses_vox[i], ses_mask[i])\n",
+    "        ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)\n",
+    "    vox = np.concatenate(ses_vox)\n",
+    "    print(\"applied final brain mask\")\n",
+    "    print(vox.shape)\n",
+    "    vox = vox[:, union_mask]\n",
+    "    print(\"applied union roi mask\")\n",
+    "    print(vox.shape)\n",
+    "    \n",
+    "    \n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5aca9065",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_vox = []\n",
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:    \n",
+    "    for i, s in enumerate(ses_list):\n",
+    "        # either resampling was done in glmsingle or we aren't resampling \n",
+    "        ses_vox_path = f'{base_glm_single_path}/glmsingle_sub-005_{s}_task-C'\n",
+    "        assert os.path.exists(ses_vox_path)\n",
+    "        ses_vox.append(load_preprocess_betas(ses_vox_path, *params))\n",
+    "        v = nilearn.masking.unmask(ses_vox[i], ses_mask[i])\n",
+    "        ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)\n",
+    "    vox = np.concatenate(ses_vox)\n",
+    "    print(\"applied final brain mask\")\n",
+    "    print(vox.shape)\n",
+    "    vox = vox[:, union_mask]\n",
+    "    print(\"applied union roi mask\")\n",
+    "    print(vox.shape)\n",
+    "    \n",
+    "    \n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "a8e1b076",
+   "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": 25,
+   "id": "c309fabe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs_homog = np.array([[p[0], p[1]] for p in pairs])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "04d838b7",
+   "metadata": {},
+   "outputs": [],
+   "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": 27,
+   "id": "3ddc8bdb",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 28,
+   "id": "5fd964cd",
+   "metadata": {},
+   "outputs": [],
+   "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": 29,
+   "id": "98927cca",
+   "metadata": {},
+   "outputs": [],
+   "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",
+    "print('shape of train mean from ses-01:', train_mean_s1.shape)\n",
+    "print('shape of train std from ses-01:', train_std_s1.shape)\n",
+    "print('shape of train mean from ses-02:', train_mean_s2.shape)\n",
+    "print('shape of train std from ses-02:', train_std_s2.shape)\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": 30,
+   "id": "c7a289d5",
+   "metadata": {},
+   "outputs": [],
+   "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": 31,
+   "id": "242a0f0c",
+   "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": 32,
+   "id": "1644ff68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = torch.Tensor(images)\n",
+    "vox = torch.Tensor(vox)\n",
+    "assert len(images) == len(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "f5eff44d",
+   "metadata": {},
+   "outputs": [],
+   "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": 34,
+   "id": "13696477",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 35,
+   "id": "3076e4cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h' # '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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "d8c4b5e2",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 37,
+   "id": "9f6cbde6",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 38,
+   "id": "957e3d21",
+   "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": "code",
+   "execution_count": 39,
+   "id": "7fec6e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name or True:\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": "code",
+   "execution_count": 40,
+   "id": "f9bb9d1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h-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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "d112b218",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 42,
+   "id": "4846c60d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name:\n",
+    "       if utils.is_interactive():\n",
+    "            eval_dir = os.path.join(outdir, \"eval_dir\")\n",
+    "        else:\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": "code",
+   "execution_count": 43,
+   "id": "b0d9d4bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name:\n",
+    "        if utils.is_interactive():\n",
+    "            eval_dir = os.path.join(outdir, \"eval_dir\")\n",
+    "        else:\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": "code",
+   "execution_count": 44,
+   "id": "8f59503d",
+   "metadata": {},
+   "outputs": [],
+   "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": 45,
+   "id": "5e5ffb53",
+   "metadata": {},
+   "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": 46,
+   "id": "4c12edab",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 47,
+   "id": "e0a00122",
+   "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": "code",
+   "execution_count": 48,
+   "id": "c308f889",
+   "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-H-14\",\n",
+    "        version=\"laion2b_s32b_b79k\",\n",
+    "        output_tokens=True,\n",
+    "        only_tokens=True,\n",
+    "    )\n",
+    "    clip_img_embedder.to(device)\n",
+    "clip_seq_dim = 256\n",
+    "clip_emb_dim = 1280\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": "code",
+   "execution_count": 49,
+   "id": "af081f8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h-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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None --wandb_log\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "d5b9cf29",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 51,
+   "id": "925f533f",
+   "metadata": {},
+   "outputs": [],
+   "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": 52,
+   "id": "4572d154",
+   "metadata": {},
+   "outputs": [],
+   "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": 53,
+   "id": "fed5fade",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 54,
+   "id": "ca55bf63",
+   "metadata": {},
+   "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": "code",
+   "execution_count": 55,
+   "id": "04a6fed8",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 56,
+   "id": "0d2a0961",
+   "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": "code",
+   "execution_count": 57,
+   "id": "ea0b850a",
+   "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",
+    "    try:\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",
+    "    \n",
+    "    except:\n",
+    "        print(\"Alert: wandb is not being logged locally.\")\n",
+    "else:\n",
+    "    wandb_log = False"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

wandb/run-20250809_151110-vit-h-MST/files/config.yaml

@@ -0,0 +1,112 @@
+wandb_version: 1
+
+model_name:
+  desc: null
+  value: vit-h-MST
+global_batch_size:
+  desc: null
+  value: 8
+batch_size:
+  desc: null
+  value: 24
+num_epochs:
+  desc: null
+  value: 30
+num_sessions:
+  desc: null
+  value: 0
+num_params:
+  desc: null
+  value: 358038808
+clip_scale:
+  desc: null
+  value: 1.0
+prior_scale:
+  desc: null
+  value: 30.0
+blur_scale:
+  desc: null
+  value: 0.5
+use_image_aug:
+  desc: null
+  value: false
+max_lr:
+  desc: null
+  value: 0.0003
+mixup_pct:
+  desc: null
+  value: 0.33
+num_samples_per_epoch:
+  desc: null
+  value: 1138
+ckpt_interval:
+  desc: null
+  value: 999
+ckpt_saving:
+  desc: null
+  value: true
+seed:
+  desc: null
+  value: 42
+distributed:
+  desc: null
+  value: false
+num_devices:
+  desc: null
+  value: 1
+world_size:
+  desc: null
+  value: 1
+_wandb:
+  desc: null
+  value:
+    python_version: 3.11.13
+    cli_version: 0.17.2
+    framework: huggingface
+    huggingface_version: 4.37.2
+    is_jupyter_run: true
+    is_kaggle_kernel: false
+    start_time: 1754752270
+    t:
+      1:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      2:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      3:
+      - 2
+      - 13
+      - 14
+      - 16
+      - 23
+      4: 3.11.13
+      5: 0.17.2
+      6: 4.37.2
+      8:
+      - 1
+      - 5
+      13: linux-x86_64
+    session_history: code/_session_history.ipynb

wandb/run-20250809_151110-vit-h-MST/files/requirements.txt

@@ -0,0 +1,230 @@
+CoCa-pytorch==0.1.0
+Django==5.2.5
+GitPython==3.1.45
+Jinja2==3.1.6
+MarkupSafe==3.0.2
+PyYAML==6.0.2
+Pygments==2.19.2
+Send2Trash==1.8.3
+accelerate==0.24.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+ants==0.0.7
+anyio==4.10.0
+argon2-cffi-bindings==25.1.0
+argon2-cffi==25.1.0
+arrow==1.3.0
+asgiref==3.9.1
+asttokens==3.0.0
+async-lru==2.0.5
+attrs==25.3.0
+autocommand==2.2.2
+babel==2.17.0
+backports.tarfile==1.2.0
+beartype==0.21.0
+beautifulsoup4==4.13.4
+bleach==6.2.0
+braceexpand==0.1.7
+certifi==2025.8.3
+cffi==1.17.1
+charset-normalizer==3.4.3
+click==8.2.1
+clip-anytorch==2.6.0
+clip==0.2.0
+comm==0.2.3
+contourpy==1.3.3
+cycler==0.12.1
+dalle2-pytorch==1.15.6
+debugpy==1.8.16
+decorator==5.2.1
+defusedxml==0.7.1
+diffusers==0.23.0
+docker-pycreds==0.4.0
+einops==0.7.0
+einx==0.3.0
+ema-pytorch==0.7.7
+embedding-reader==1.7.0
+executing==2.2.0
+fastjsonschema==2.21.1
+filelock==3.18.0
+fonttools==4.59.0
+fqdn==1.5.1
+frozendict==2.4.6
+frozenlist==1.7.0
+fsspec==2025.7.0
+ftfy==6.3.1
+gevent==25.5.1
+gitdb==4.0.12
+greenlet==3.2.4
+h11==0.16.0
+h5py==3.10.0
+hf-xet==1.1.7
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+importlib_metadata==8.0.0
+importlib_metadata==8.7.0
+inflect==7.3.1
+ipykernel==6.30.1
+ipython==9.4.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.7
+isoduration==20.11.0
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+jedi==0.19.2
+joblib==1.5.1
+json5==0.12.0
+jsonpointer==3.0.0
+jsonschema-specifications==2025.4.1
+jsonschema==4.25.0
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-lsp==2.2.6
+jupyter==1.1.1
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+jupyter_server==2.16.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.4.5
+jupyterlab_nvdashboard==0.13.0
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.27.3
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+kornia==0.8.1
+kornia_rs==0.1.9
+lark==1.2.2
+lazy_loader==0.4
+lightning-utilities==0.15.2
+lxml==6.0.0
+matplotlib-inline==0.1.7
+matplotlib==3.8.2
+mistune==3.1.3
+more-itertools==10.3.0
+mpmath==1.3.0
+multidict==6.6.3
+nbclient==0.10.2
+nbconvert==7.16.6
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.5
+nibabel==5.2.1
+nilearn==0.12.0
+notebook==7.4.5
+notebook_shim==0.2.4
+numpy==1.26.4
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-ml-py==12.575.51
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+omegaconf==2.3.0
+open-clip-torch==2.24.0
+overrides==7.7.0
+packaging==24.2
+packaging==25.0
+pandas==2.2.0
+pandocfilters==1.5.1
+parso==0.8.4
+pexpect==4.9.0
+pillow==10.2.0
+platformdirs==4.2.2
+platformdirs==4.3.8
+prometheus_client==0.22.1
+prompt_toolkit==3.0.51
+propcache==0.3.2
+protobuf==5.29.5
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==15.0.2
+pycparser==2.22
+pydantic==2.11.7
+pydantic_core==2.33.2
+pynvml==12.0.0
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-json-logger==3.3.0
+pytorch-lightning==2.5.2
+pytorch-warmup==0.2.0
+pytz==2025.2
+pyzmq==27.0.1
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.4
+resize-right==0.0.2
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rfc3987-syntax==1.1.0
+rotary-embedding-torch==0.8.9
+rpds-py==0.27.0
+safetensors==0.6.2
+scikit-image==0.25.2
+scikit-learn==1.4.1.post1
+scipy==1.12.0
+sentencepiece==0.2.0
+sentry-sdk==2.34.1
+setproctitle==1.3.6
+setuptools==80.9.0
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+soupsieve==2.7
+sqlparse==0.5.3
+stack-data==0.6.3
+sympy==1.13.1
+terminado==0.18.1
+threadpoolctl==3.6.0
+tifffile==2025.6.11
+timm==1.0.19
+tinycss2==1.4.0
+tokenizers==0.15.2
+tomli==2.0.1
+torch-fidelity==0.3.0
+torch==2.5.1
+torchmetrics==1.8.1
+torchvision==0.20.1
+tornado==6.5.2
+tqdm==4.66.2
+traitlets==5.14.3
+transformers==4.37.2
+triton==3.1.0
+typeguard==4.3.0
+types-python-dateutil==2.9.0.20250809
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+typing_extensions==4.14.1
+tzdata==2025.2
+uri-template==1.3.0
+urllib3==2.5.0
+vector_quantize_pytorch==1.14.7
+wandb==0.17.2
+wcwidth==0.2.13
+webcolors==24.11.1
+webdataset==0.2.73
+webencodings==0.5.1
+websocket-client==1.8.0
+wheel==0.45.1
+widgetsnbextension==4.0.14
+x-clip==0.14.4
+yarl==1.20.1
+zipp==3.19.2
+zipp==3.23.0
+zope.event==5.1.1
+zope.interface==7.2

wandb/run-20250809_151110-vit-h-MST/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_wandb": {"runtime": 0}}

wandb/run-20250809_151110-vit-h-MST/logs/debug.log

@@ -0,0 +1,61 @@
+2025-08-09 15:11:10,707 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Current SDK version is 0.17.2
+2025-08-09 15:11:10,707 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Configure stats pid to 9111
+2025-08-09 15:11:10,707 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/.config/wandb/settings
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/real_time_mindEye2/wandb/settings
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from environment variables: {}
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False}
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program': '<python with no main file>'}
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying login settings: {}
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'}
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_init.py:_log_setup():520] Logging user logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_151110-vit-h-MST/logs/debug.log
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_init.py:_log_setup():521] Logging internal logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_151110-vit-h-MST/logs/debug-internal.log
+2025-08-09 15:11:10,708 INFO    MainThread:9111 [wandb_init.py:_jupyter_setup():466] configuring jupyter hooks <wandb.sdk.wandb_init._WandbInit object at 0x7fe32c9b2a50>
+2025-08-09 15:11:10,709 INFO    MainThread:9111 [wandb_init.py:init():560] calling init triggers
+2025-08-09 15:11:10,709 INFO    MainThread:9111 [wandb_init.py:init():567] wandb.init called with sweep_config: {}
+config: {'model_name': 'vit-h-MST', 'global_batch_size': 8, 'batch_size': 24, 'num_epochs': 30, 'num_sessions': 0, 'num_params': 358038808, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 1138, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+2025-08-09 15:11:10,709 INFO    MainThread:9111 [wandb_init.py:init():610] starting backend
+2025-08-09 15:11:10,709 INFO    MainThread:9111 [wandb_init.py:init():614] setting up manager
+2025-08-09 15:11:10,711 INFO    MainThread:9111 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn
+2025-08-09 15:11:10,715 INFO    MainThread:9111 [wandb_init.py:init():622] backend started and connected
+2025-08-09 15:11:10,734 INFO    MainThread:9111 [wandb_run.py:_label_probe_notebook():1334] probe notebook
+2025-08-09 15:11:10,736 INFO    MainThread:9111 [wandb_run.py:_label_probe_notebook():1344] Unable to probe notebook: 'NoneType' object has no attribute 'get'
+2025-08-09 15:11:10,736 INFO    MainThread:9111 [wandb_init.py:init():711] updated telemetry
+2025-08-09 15:11:10,744 INFO    MainThread:9111 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout
+2025-08-09 15:11:11,170 INFO    MainThread:9111 [wandb_run.py:_on_init():2402] communicating current version
+2025-08-09 15:11:11,323 INFO    MainThread:9111 [wandb_run.py:_on_init():2411] got version response upgrade_message: "wandb version 0.21.1 is available!  To upgrade, please run:\n $ pip install wandb --upgrade"
+
+2025-08-09 15:11:11,323 INFO    MainThread:9111 [wandb_init.py:init():795] starting run threads in backend
+2025-08-09 15:11:11,823 INFO    MainThread:9111 [wandb_run.py:_console_start():2380] atexit reg
+2025-08-09 15:11:11,823 INFO    MainThread:9111 [wandb_run.py:_redirect():2235] redirect: wrap_raw
+2025-08-09 15:11:11,824 INFO    MainThread:9111 [wandb_run.py:_redirect():2300] Wrapping output streams.
+2025-08-09 15:11:11,824 INFO    MainThread:9111 [wandb_run.py:_redirect():2325] Redirects installed.
+2025-08-09 15:11:11,832 INFO    MainThread:9111 [wandb_init.py:init():838] run started, returning control to user process
+2025-08-09 15:11:11,988 INFO    MainThread:9111 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:11:11,988 INFO    MainThread:9111 [wandb_init.py:_pause_backend():431] pausing backend
+2025-08-09 15:11:47,935 INFO    MainThread:9111 [wandb_init.py:_resume_backend():436] resuming backend
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Current SDK version is 0.17.2
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Configure stats pid to 9111
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/.config/wandb/settings
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from /home/ubuntu/real_time_mindEye2/wandb/settings
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Loading settings from environment variables: {}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying setup settings: {'_disable_service': False}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program': '<python with no main file>'}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying login settings: {}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_init.py:_log_setup():520] Logging user logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_151147-vit-h-MST/logs/debug.log
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_init.py:_log_setup():521] Logging internal logs to /home/ubuntu/real_time_mindEye2/wandb/run-20250809_151147-vit-h-MST/logs/debug-internal.log
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_init.py:init():560] calling init triggers
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_init.py:init():567] wandb.init called with sweep_config: {}
+config: {'model_name': 'vit-h-MST', 'global_batch_size': 8, 'batch_size': 24, 'num_epochs': 30, 'num_sessions': 0, 'num_params': 358038808, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 1138, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+2025-08-09 15:11:47,951 INFO    MainThread:9111 [wandb_init.py:init():585] re-initializing run, found existing run on stack: vit-h-MST
+2025-08-09 15:11:47,952 INFO    MainThread:9111 [wandb_run.py:_finish():2109] finishing run ckadirt/rtmindeye/vit-h-MST
+2025-08-09 15:11:48,010 INFO    MainThread:9111 [jupyter.py:save_history():473] saving 57 cells to _session_history.ipynb
+2025-08-09 15:11:48,012 INFO    MainThread:9111 [wandb_run.py:_config_callback():1382] config_cb ('_wandb', 'session_history') code/_session_history.ipynb None
+2025-08-09 15:11:48,022 INFO    MainThread:9111 [jupyter.py:_save_ipynb():383] looking for notebook: None
+2025-08-09 15:11:48,022 INFO    MainThread:9111 [wandb_init.py:_jupyter_teardown():448] cleaning up jupyter logic
+2025-08-09 15:11:48,022 INFO    MainThread:9111 [wandb_run.py:_atexit_cleanup():2349] got exitcode: 0
+2025-08-09 15:11:48,022 INFO    MainThread:9111 [wandb_run.py:_restore():2332] restore
+2025-08-09 15:11:48,022 INFO    MainThread:9111 [wandb_run.py:_restore():2338] restore done
+2025-08-09 15:11:51,294 INFO    MainThread:9111 [wandb_run.py:_footer_history_summary_info():3988] rendering history
+2025-08-09 15:11:51,294 INFO    MainThread:9111 [wandb_run.py:_footer_history_summary_info():4020] rendering summary
+2025-08-09 15:11:51,303 INFO    MainThread:9111 [wandb_run.py:_footer_sync_info():3947] logging synced files

wandb/run-20250809_151110-vit-h-MST/tmp/code/_session_history.ipynb

@@ -0,0 +1,2365 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "680cb740",
+   "metadata": {},
+   "outputs": [],
+   "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/ubuntu/mindeye_preproc/analysis/utils.py\" # \"/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": "code",
+   "execution_count": 2,
+   "id": "6213ef9f",
+   "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": "7511be2d",
+   "metadata": {},
+   "outputs": [],
+   "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": "d57d05fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if utils.is_interactive():\n",
+    "    glmsingle_path = f\"/home/ubuntu/glmsingle/glmsingle_{sub}_{session_label}_task-{task}\"\n",
+    "else:\n",
+    "    glmsingle_path = os.environ[\"glmsingle_path\"]\n",
+    "    \n",
+    "designdir = \"/home/ubuntu/real_time_mindEye2\" #\"/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": "074a6b10",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 6,
+   "id": "4af150a8",
+   "metadata": {},
+   "outputs": [],
+   "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": "4937263a",
+   "metadata": {},
+   "outputs": [],
+   "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": "108a3210",
+   "metadata": {},
+   "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": "d502b890",
+   "metadata": {},
+   "outputs": [],
+   "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": "cfc6a1f4",
+   "metadata": {},
+   "outputs": [],
+   "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": "c5fe984b",
+   "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": "f759b5d3",
+   "metadata": {},
+   "outputs": [],
+   "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": "2be1079a",
+   "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": "28bf7f64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nilearn.plotting import plot_roi\n",
+    "\n",
+    "print('loading brain mask')\n",
+    "avg_mask = nib.load(f'{orig_glmsingle_path}/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
+    "final_mask = nib.load(f'{orig_glmsingle_path}/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": "ca124946",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "glm_single_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "844c2b1f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-01-02_task-C'"
+     ]
+    }
+   ],
+   "source": [
+    "glmsingle_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fee56ca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "base_glm_single_path = os.environ[\"glmsingle_path\"]\n",
+    "base_glm_single_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "610317a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# take all paths exept last dir\n",
+    "base_glm_single_path = glmsingle_path.split('/')[:-1]\n",
+    "base_glm_single_path = '/'.join(base_glm_single_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "82cae662",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from nilearn.plotting import plot_roi\n",
+    "\n",
+    "print('loading brain mask')\n",
+    "avg_mask = nib.load(f'{base_glm_single_path}/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')\n",
+    "final_mask = nib.load(f'{base_glm_single_path}/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": 20,
+   "id": "e6d4d01a",
+   "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'{base_glm_single_path}/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": "code",
+   "execution_count": 21,
+   "id": "8f372fed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_mask = []\n",
+    "\n",
+    "for s in ses_list:\n",
+    "    ses_mask_path = f'{base_glm_single_path}/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": 22,
+   "id": "36d2591a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_vox = []\n",
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:    \n",
+    "    for i, s in enumerate(ses_list):\n",
+    "        # either resampling was done in glmsingle or we aren't resampling \n",
+    "        ses_vox_path = f'{glmsingle_path}/glmsingle_sub-005_{s}_task-C'\n",
+    "        assert os.path.exists(ses_vox_path)\n",
+    "        ses_vox.append(load_preprocess_betas(ses_vox_path, *params))\n",
+    "        v = nilearn.masking.unmask(ses_vox[i], ses_mask[i])\n",
+    "        ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)\n",
+    "    vox = np.concatenate(ses_vox)\n",
+    "    print(\"applied final brain mask\")\n",
+    "    print(vox.shape)\n",
+    "    vox = vox[:, union_mask]\n",
+    "    print(\"applied union roi mask\")\n",
+    "    print(vox.shape)\n",
+    "    \n",
+    "    \n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5aca9065",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ses_vox = []\n",
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:    \n",
+    "    for i, s in enumerate(ses_list):\n",
+    "        # either resampling was done in glmsingle or we aren't resampling \n",
+    "        ses_vox_path = f'{base_glm_single_path}/glmsingle_sub-005_{s}_task-C'\n",
+    "        assert os.path.exists(ses_vox_path)\n",
+    "        ses_vox.append(load_preprocess_betas(ses_vox_path, *params))\n",
+    "        v = nilearn.masking.unmask(ses_vox[i], ses_mask[i])\n",
+    "        ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)\n",
+    "    vox = np.concatenate(ses_vox)\n",
+    "    print(\"applied final brain mask\")\n",
+    "    print(vox.shape)\n",
+    "    vox = vox[:, union_mask]\n",
+    "    print(\"applied union roi mask\")\n",
+    "    print(vox.shape)\n",
+    "    \n",
+    "    \n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "a8e1b076",
+   "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": 25,
+   "id": "c309fabe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs_homog = np.array([[p[0], p[1]] for p in pairs])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "04d838b7",
+   "metadata": {},
+   "outputs": [],
+   "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": 27,
+   "id": "3ddc8bdb",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 28,
+   "id": "5fd964cd",
+   "metadata": {},
+   "outputs": [],
+   "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": 29,
+   "id": "98927cca",
+   "metadata": {},
+   "outputs": [],
+   "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",
+    "print('shape of train mean from ses-01:', train_mean_s1.shape)\n",
+    "print('shape of train std from ses-01:', train_std_s1.shape)\n",
+    "print('shape of train mean from ses-02:', train_mean_s2.shape)\n",
+    "print('shape of train std from ses-02:', train_std_s2.shape)\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": 30,
+   "id": "c7a289d5",
+   "metadata": {},
+   "outputs": [],
+   "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": 31,
+   "id": "242a0f0c",
+   "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": 32,
+   "id": "1644ff68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "images = torch.Tensor(images)\n",
+    "vox = torch.Tensor(vox)\n",
+    "assert len(images) == len(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "f5eff44d",
+   "metadata": {},
+   "outputs": [],
+   "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": 34,
+   "id": "13696477",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 35,
+   "id": "3076e4cc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h' # '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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "d8c4b5e2",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 37,
+   "id": "9f6cbde6",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 38,
+   "id": "957e3d21",
+   "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": "code",
+   "execution_count": 39,
+   "id": "7fec6e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name or True:\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": "code",
+   "execution_count": 40,
+   "id": "f9bb9d1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h-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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "d112b218",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 42,
+   "id": "4846c60d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name:\n",
+    "       if utils.is_interactive():\n",
+    "            eval_dir = os.path.join(outdir, \"eval_dir\")\n",
+    "        else:\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": "code",
+   "execution_count": 43,
+   "id": "b0d9d4bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if ckpt_saving:\n",
+    "    # save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "    if 'MST' in model_name:\n",
+    "        if utils.is_interactive():\n",
+    "            eval_dir = os.path.join(outdir, \"eval_dir\")\n",
+    "        else:\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": "code",
+   "execution_count": 44,
+   "id": "8f59503d",
+   "metadata": {},
+   "outputs": [],
+   "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": 45,
+   "id": "5e5ffb53",
+   "metadata": {},
+   "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": 46,
+   "id": "4c12edab",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 47,
+   "id": "e0a00122",
+   "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": "code",
+   "execution_count": 48,
+   "id": "c308f889",
+   "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-H-14\",\n",
+    "        version=\"laion2b_s32b_b79k\",\n",
+    "        output_tokens=True,\n",
+    "        only_tokens=True,\n",
+    "    )\n",
+    "    clip_img_embedder.to(device)\n",
+    "clip_seq_dim = 256\n",
+    "clip_emb_dim = 1280\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": "code",
+   "execution_count": 49,
+   "id": "af081f8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = 'vit-h-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",
+    "    batch_size = 24\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 --ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=None --wandb_log\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "d5b9cf29",
+   "metadata": {},
+   "outputs": [],
+   "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'./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": "code",
+   "execution_count": 51,
+   "id": "925f533f",
+   "metadata": {},
+   "outputs": [],
+   "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": 52,
+   "id": "4572d154",
+   "metadata": {},
+   "outputs": [],
+   "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": 53,
+   "id": "fed5fade",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 54,
+   "id": "ca55bf63",
+   "metadata": {},
+   "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": "code",
+   "execution_count": 55,
+   "id": "04a6fed8",
+   "metadata": {},
+   "outputs": [],
+   "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": "code",
+   "execution_count": 56,
+   "id": "0d2a0961",
+   "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": "code",
+   "execution_count": 57,
+   "id": "ea0b850a",
+   "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",
+    "    try:\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",
+    "    \n",
+    "    except:\n",
+    "        print(\"Alert: wandb is not being logged locally.\")\n",
+    "else:\n",
+    "    wandb_log = False"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

wandb/run-20250809_151147-vit-h-MST/files/config.yaml

@@ -0,0 +1,112 @@
+wandb_version: 1
+
+model_name:
+  desc: null
+  value: vit-h-MST
+global_batch_size:
+  desc: null
+  value: 8
+batch_size:
+  desc: null
+  value: 24
+num_epochs:
+  desc: null
+  value: 30
+num_sessions:
+  desc: null
+  value: 0
+num_params:
+  desc: null
+  value: 358038808
+clip_scale:
+  desc: null
+  value: 1.0
+prior_scale:
+  desc: null
+  value: 30.0
+blur_scale:
+  desc: null
+  value: 0.5
+use_image_aug:
+  desc: null
+  value: false
+max_lr:
+  desc: null
+  value: 0.0003
+mixup_pct:
+  desc: null
+  value: 0.33
+num_samples_per_epoch:
+  desc: null
+  value: 1138
+ckpt_interval:
+  desc: null
+  value: 999
+ckpt_saving:
+  desc: null
+  value: true
+seed:
+  desc: null
+  value: 42
+distributed:
+  desc: null
+  value: false
+num_devices:
+  desc: null
+  value: 1
+world_size:
+  desc: null
+  value: 1
+_wandb:
+  desc: null
+  value:
+    python_version: 3.11.13
+    cli_version: 0.17.2
+    framework: huggingface
+    huggingface_version: 4.37.2
+    is_jupyter_run: true
+    is_kaggle_kernel: false
+    start_time: 1754752311
+    t:
+      1:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      2:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      3:
+      - 5
+      - 13
+      - 14
+      - 16
+      - 23
+      - 62
+      4: 3.11.13
+      5: 0.17.2
+      6: 4.37.2
+      8:
+      - 1
+      - 5
+      13: linux-x86_64

wandb/run-20250809_152227-vit-h-MST/files/config.yaml

@@ -0,0 +1,111 @@
+wandb_version: 1
+
+model_name:
+  desc: null
+  value: vit-h-MST
+global_batch_size:
+  desc: null
+  value: 8
+batch_size:
+  desc: null
+  value: 24
+num_epochs:
+  desc: null
+  value: 150
+num_sessions:
+  desc: null
+  value: 0
+num_params:
+  desc: null
+  value: 511732360
+clip_scale:
+  desc: null
+  value: 1.0
+prior_scale:
+  desc: null
+  value: 30.0
+blur_scale:
+  desc: null
+  value: 0.5
+use_image_aug:
+  desc: null
+  value: false
+max_lr:
+  desc: null
+  value: 0.0003
+mixup_pct:
+  desc: null
+  value: 0.33
+num_samples_per_epoch:
+  desc: null
+  value: 1138
+ckpt_interval:
+  desc: null
+  value: 999
+ckpt_saving:
+  desc: null
+  value: true
+seed:
+  desc: null
+  value: 0
+distributed:
+  desc: null
+  value: false
+num_devices:
+  desc: null
+  value: 1
+world_size:
+  desc: null
+  value: 1
+_wandb:
+  desc: null
+  value:
+    python_version: 3.11.13
+    cli_version: 0.17.2
+    framework: huggingface
+    huggingface_version: 4.37.2
+    is_jupyter_run: true
+    is_kaggle_kernel: false
+    start_time: 1754752947
+    t:
+      1:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      2:
+      - 1
+      - 5
+      - 9
+      - 11
+      - 41
+      - 49
+      - 53
+      - 55
+      - 63
+      - 71
+      - 79
+      - 83
+      - 103
+      3:
+      - 5
+      - 13
+      - 14
+      - 16
+      - 23
+      4: 3.11.13
+      5: 0.17.2
+      6: 4.37.2
+      8:
+      - 1
+      - 5
+      13: linux-x86_64

wandb/run-20250809_152227-vit-h-MST/files/requirements.txt

@@ -0,0 +1,230 @@
+CoCa-pytorch==0.1.0
+Django==5.2.5
+GitPython==3.1.45
+Jinja2==3.1.6
+MarkupSafe==3.0.2
+PyYAML==6.0.2
+Pygments==2.19.2
+Send2Trash==1.8.3
+accelerate==0.24.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+ants==0.0.7
+anyio==4.10.0
+argon2-cffi-bindings==25.1.0
+argon2-cffi==25.1.0
+arrow==1.3.0
+asgiref==3.9.1
+asttokens==3.0.0
+async-lru==2.0.5
+attrs==25.3.0
+autocommand==2.2.2
+babel==2.17.0
+backports.tarfile==1.2.0
+beartype==0.21.0
+beautifulsoup4==4.13.4
+bleach==6.2.0
+braceexpand==0.1.7
+certifi==2025.8.3
+cffi==1.17.1
+charset-normalizer==3.4.3
+click==8.2.1
+clip-anytorch==2.6.0
+clip==0.2.0
+comm==0.2.3
+contourpy==1.3.3
+cycler==0.12.1
+dalle2-pytorch==1.15.6
+debugpy==1.8.16
+decorator==5.2.1
+defusedxml==0.7.1
+diffusers==0.23.0
+docker-pycreds==0.4.0
+einops==0.7.0
+einx==0.3.0
+ema-pytorch==0.7.7
+embedding-reader==1.7.0
+executing==2.2.0
+fastjsonschema==2.21.1
+filelock==3.18.0
+fonttools==4.59.0
+fqdn==1.5.1
+frozendict==2.4.6
+frozenlist==1.7.0
+fsspec==2025.7.0
+ftfy==6.3.1
+gevent==25.5.1
+gitdb==4.0.12
+greenlet==3.2.4
+h11==0.16.0
+h5py==3.10.0
+hf-xet==1.1.7
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+importlib_metadata==8.0.0
+importlib_metadata==8.7.0
+inflect==7.3.1
+ipykernel==6.30.1
+ipython==9.4.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.7
+isoduration==20.11.0
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+jedi==0.19.2
+joblib==1.5.1
+json5==0.12.0
+jsonpointer==3.0.0
+jsonschema-specifications==2025.4.1
+jsonschema==4.25.0
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-lsp==2.2.6
+jupyter==1.1.1
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+jupyter_server==2.16.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.4.5
+jupyterlab_nvdashboard==0.13.0
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.27.3
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+kornia==0.8.1
+kornia_rs==0.1.9
+lark==1.2.2
+lazy_loader==0.4
+lightning-utilities==0.15.2
+lxml==6.0.0
+matplotlib-inline==0.1.7
+matplotlib==3.8.2
+mistune==3.1.3
+more-itertools==10.3.0
+mpmath==1.3.0
+multidict==6.6.3
+nbclient==0.10.2
+nbconvert==7.16.6
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.5
+nibabel==5.2.1
+nilearn==0.12.0
+notebook==7.4.5
+notebook_shim==0.2.4
+numpy==1.26.4
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-ml-py==12.575.51
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+omegaconf==2.3.0
+open-clip-torch==2.24.0
+overrides==7.7.0
+packaging==24.2
+packaging==25.0
+pandas==2.2.0
+pandocfilters==1.5.1
+parso==0.8.4
+pexpect==4.9.0
+pillow==10.2.0
+platformdirs==4.2.2
+platformdirs==4.3.8
+prometheus_client==0.22.1
+prompt_toolkit==3.0.51
+propcache==0.3.2
+protobuf==5.29.5
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==15.0.2
+pycparser==2.22
+pydantic==2.11.7
+pydantic_core==2.33.2
+pynvml==12.0.0
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-json-logger==3.3.0
+pytorch-lightning==2.5.2
+pytorch-warmup==0.2.0
+pytz==2025.2
+pyzmq==27.0.1
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.4
+resize-right==0.0.2
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rfc3987-syntax==1.1.0
+rotary-embedding-torch==0.8.9
+rpds-py==0.27.0
+safetensors==0.6.2
+scikit-image==0.25.2
+scikit-learn==1.4.1.post1
+scipy==1.12.0
+sentencepiece==0.2.0
+sentry-sdk==2.34.1
+setproctitle==1.3.6
+setuptools==80.9.0
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+soupsieve==2.7
+sqlparse==0.5.3
+stack-data==0.6.3
+sympy==1.13.1
+terminado==0.18.1
+threadpoolctl==3.6.0
+tifffile==2025.6.11
+timm==1.0.19
+tinycss2==1.4.0
+tokenizers==0.15.2
+tomli==2.0.1
+torch-fidelity==0.3.0
+torch==2.5.1
+torchmetrics==1.8.1
+torchvision==0.20.1
+tornado==6.5.2
+tqdm==4.66.2
+traitlets==5.14.3
+transformers==4.37.2
+triton==3.1.0
+typeguard==4.3.0
+types-python-dateutil==2.9.0.20250809
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+typing_extensions==4.14.1
+tzdata==2025.2
+uri-template==1.3.0
+urllib3==2.5.0
+vector_quantize_pytorch==1.14.7
+wandb==0.17.2
+wcwidth==0.2.13
+webcolors==24.11.1
+webdataset==0.2.73
+webencodings==0.5.1
+websocket-client==1.8.0
+wheel==0.45.1
+widgetsnbextension==4.0.14
+x-clip==0.14.4
+yarl==1.20.1
+zipp==3.19.2
+zipp==3.23.0
+zope.event==5.1.1
+zope.interface==7.2

wandb/run-20250809_152227-vit-h-MST/files/wandb-summary.json

@@ -0,0 +1 @@
+{"subset_0_0_test/loss": 15.603862762451172, "subset_0_0_test/loss_clip_total": 2.6600615978240967, "subset_0_0_test/loss_prior": 0.43146002292633057, "subset_0_0_test/blurry_pixcorr": 0.0, "subset_0_0_test/fwd_pct_correct": 0.30645161867141724, "subset_0_0_test/bwd_pct_correct": 0.25806450843811035, "subset_0_1_test/loss": 20.326326370239258, "subset_0_1_test/loss_clip_total": 2.8700623512268066, "subset_0_1_test/loss_prior": 0.5818755030632019, "subset_0_1_test/blurry_pixcorr": 0.0, "subset_0_1_test/fwd_pct_correct": 0.32258063554763794, "subset_0_1_test/bwd_pct_correct": 0.22580644488334656, "subset_1_0_test/loss": 18.277183532714844, "subset_1_0_test/loss_clip_total": 2.982631206512451, "subset_1_0_test/loss_prior": 0.509818434715271, "subset_1_0_test/blurry_pixcorr": 0.0, "subset_1_0_test/fwd_pct_correct": 0.24193547666072845, "subset_1_0_test/bwd_pct_correct": 0.14516128599643707, "subset_1_1_test/loss": 13.336342811584473, "subset_1_1_test/loss_clip_total": 3.0331695079803467, "subset_1_1_test/loss_prior": 0.34343910217285156, "subset_1_1_test/blurry_pixcorr": 0.0, "subset_1_1_test/fwd_pct_correct": 0.24193547666072845, "subset_1_1_test/bwd_pct_correct": 0.20967741310596466, "train/loss": 6.496718102313102, "train/lr": 1.1999999999999998e-08, "train/num_steps": 7050, "train/fwd_pct_correct": 0.9902482349821862, "train/bwd_pct_correct": 0.9902482349821862, "train/loss_clip_total": 0.014585590695942495, "train/loss_blurry_total": 0.0, "train/loss_blurry_cont_total": 0.0, "train/blurry_pixcorr": 0.0, "train/recon_cossim": 0.8349524990041205, "train/recon_mse": 0.21607108477582324, "train/loss_prior": 0.21607108477582324, "_timestamp": 1754754981.5695724, "_runtime": 2071.16503739357, "_step": 149}

wandb/run-20250809_153455-sdxl_turbo-MST/files/output.log

@@ -0,0 +1 @@
+

wandb/run-20250809_153455-sdxl_turbo-MST/files/requirements.txt

@@ -0,0 +1,230 @@
+CoCa-pytorch==0.1.0
+Django==5.2.5
+GitPython==3.1.45
+Jinja2==3.1.6
+MarkupSafe==3.0.2
+PyYAML==6.0.2
+Pygments==2.19.2
+Send2Trash==1.8.3
+accelerate==0.24.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+ants==0.0.7
+anyio==4.10.0
+argon2-cffi-bindings==25.1.0
+argon2-cffi==25.1.0
+arrow==1.3.0
+asgiref==3.9.1
+asttokens==3.0.0
+async-lru==2.0.5
+attrs==25.3.0
+autocommand==2.2.2
+babel==2.17.0
+backports.tarfile==1.2.0
+beartype==0.21.0
+beautifulsoup4==4.13.4
+bleach==6.2.0
+braceexpand==0.1.7
+certifi==2025.8.3
+cffi==1.17.1
+charset-normalizer==3.4.3
+click==8.2.1
+clip-anytorch==2.6.0
+clip==0.2.0
+comm==0.2.3
+contourpy==1.3.3
+cycler==0.12.1
+dalle2-pytorch==1.15.6
+debugpy==1.8.16
+decorator==5.2.1
+defusedxml==0.7.1
+diffusers==0.23.0
+docker-pycreds==0.4.0
+einops==0.7.0
+einx==0.3.0
+ema-pytorch==0.7.7
+embedding-reader==1.7.0
+executing==2.2.0
+fastjsonschema==2.21.1
+filelock==3.18.0
+fonttools==4.59.0
+fqdn==1.5.1
+frozendict==2.4.6
+frozenlist==1.7.0
+fsspec==2025.7.0
+ftfy==6.3.1
+gevent==25.5.1
+gitdb==4.0.12
+greenlet==3.2.4
+h11==0.16.0
+h5py==3.10.0
+hf-xet==1.1.7
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.34.4
+idna==3.10
+imageio==2.37.0
+importlib_metadata==8.0.0
+importlib_metadata==8.7.0
+inflect==7.3.1
+ipykernel==6.30.1
+ipython==9.4.0
+ipython_pygments_lexers==1.1.1
+ipywidgets==8.1.7
+isoduration==20.11.0
+jaraco.collections==5.1.0
+jaraco.context==5.3.0
+jaraco.functools==4.0.1
+jaraco.text==3.12.1
+jedi==0.19.2
+joblib==1.5.1
+json5==0.12.0
+jsonpointer==3.0.0
+jsonschema-specifications==2025.4.1
+jsonschema==4.25.0
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-lsp==2.2.6
+jupyter==1.1.1
+jupyter_client==8.6.3
+jupyter_core==5.8.1
+jupyter_server==2.16.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.4.5
+jupyterlab_nvdashboard==0.13.0
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.27.3
+jupyterlab_widgets==3.0.15
+kiwisolver==1.4.8
+kornia==0.8.1
+kornia_rs==0.1.9
+lark==1.2.2
+lazy_loader==0.4
+lightning-utilities==0.15.2
+lxml==6.0.0
+matplotlib-inline==0.1.7
+matplotlib==3.8.2
+mistune==3.1.3
+more-itertools==10.3.0
+mpmath==1.3.0
+multidict==6.6.3
+nbclient==0.10.2
+nbconvert==7.16.6
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.5
+nibabel==5.2.1
+nilearn==0.12.0
+notebook==7.4.5
+notebook_shim==0.2.4
+numpy==1.26.4
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-ml-py==12.575.51
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+omegaconf==2.3.0
+open-clip-torch==2.24.0
+overrides==7.7.0
+packaging==24.2
+packaging==25.0
+pandas==2.2.0
+pandocfilters==1.5.1
+parso==0.8.4
+pexpect==4.9.0
+pillow==10.2.0
+platformdirs==4.2.2
+platformdirs==4.3.8
+prometheus_client==0.22.1
+prompt_toolkit==3.0.51
+propcache==0.3.2
+protobuf==5.29.5
+psutil==7.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyarrow==15.0.2
+pycparser==2.22
+pydantic==2.11.7
+pydantic_core==2.33.2
+pynvml==12.0.0
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-json-logger==3.3.0
+pytorch-lightning==2.5.2
+pytorch-warmup==0.2.0
+pytz==2025.2
+pyzmq==27.0.1
+referencing==0.36.2
+regex==2025.7.34
+requests==2.32.4
+resize-right==0.0.2
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rfc3987-syntax==1.1.0
+rotary-embedding-torch==0.8.9
+rpds-py==0.27.0
+safetensors==0.6.2
+scikit-image==0.25.2
+scikit-learn==1.4.1.post1
+scipy==1.12.0
+sentencepiece==0.2.0
+sentry-sdk==2.34.1
+setproctitle==1.3.6
+setuptools==80.9.0
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+soupsieve==2.7
+sqlparse==0.5.3
+stack-data==0.6.3
+sympy==1.13.1
+terminado==0.18.1
+threadpoolctl==3.6.0
+tifffile==2025.6.11
+timm==1.0.19
+tinycss2==1.4.0
+tokenizers==0.15.2
+tomli==2.0.1
+torch-fidelity==0.3.0
+torch==2.5.1
+torchmetrics==1.8.1
+torchvision==0.20.1
+tornado==6.5.2
+tqdm==4.66.2
+traitlets==5.14.3
+transformers==4.37.2
+triton==3.1.0
+typeguard==4.3.0
+types-python-dateutil==2.9.0.20250809
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+typing_extensions==4.14.1
+tzdata==2025.2
+uri-template==1.3.0
+urllib3==2.5.0
+vector_quantize_pytorch==1.14.7
+wandb==0.17.2
+wcwidth==0.2.13
+webcolors==24.11.1
+webdataset==0.2.73
+webencodings==0.5.1
+websocket-client==1.8.0
+wheel==0.45.1
+widgetsnbextension==4.0.14
+x-clip==0.14.4
+yarl==1.20.1
+zipp==3.19.2
+zipp==3.23.0
+zope.event==5.1.1
+zope.interface==7.2

wandb/run-20250809_153455-sdxl_turbo-MST/files/wandb-metadata.json

@@ -0,0 +1,1167 @@
+{
+    "os": "Linux-5.15.0-139-generic-x86_64-with-glibc2.35",
+    "python": "3.11.13",
+    "heartbeatAt": "2025-08-09T15:34:56.942086",
+    "startedAt": "2025-08-09T15:34:55.966691",
+    "docker": null,
+    "cuda": null,
+    "args": [],
+    "state": "running",
+    "program": "<python with no main file>",
+    "codePathLocal": null,
+    "git": {
+        "remote": "https://github.com/PrincetonCompMemLab/real_time_mindEye2",
+        "commit": "a4bdfadf8f0b5e580b93a897978290a2890d5c52"
+    },
+    "email": "torrico.villanueva.cesar.kadir@gmail.com",
+    "root": "/home/ubuntu/real_time_mindEye2",
+    "host": "defiant-holly-hornet-758fccb7c4-hl6gs",
+    "username": "ubuntu",
+    "executable": "/home/ubuntu/rt_mindEye2/bin/python",
+    "cpu_count": 112,
+    "cpu_count_logical": 224,
+    "cpu_freq": {
+        "current": 824.9719598214285,
+        "min": 800.0,
+        "max": 2001.0
+    },
+    "cpu_freq_per_core": [
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1986.269,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1200.01,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1300.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1100.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1300.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1100.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1000.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 900.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 838.038,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1400.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1300.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 1400.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        },
+        {
+            "current": 800.0,
+            "min": 800.0,
+            "max": 2001.0
+        }
+    ],
+    "disk": {
+        "/": {
+            "total": 3519.2570304870605,
+            "used": 3068.076229095459
+        }
+    },
+    "gpu": "NVIDIA H100 80GB HBM3",
+    "gpu_count": 1,
+    "gpu_devices": [
+        {
+            "name": "NVIDIA H100 80GB HBM3",
+            "memory_total": 85520809984
+        }
+    ],
+    "memory": {
+        "total": 2015.504482269287
+    }
+}