Add files using upload-large-folder tool

.gitattributes

@@ -1,59 +1,13 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.png,[[:space:]]*.jpg filter=lfs diff=lfs merge=lfs -text
+main*.ipynb filter=lfs diff=lfs merge=lfs -text
+all_stimuli/MST_pairs1/pair_10_14_33.png filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024_scalf_best/testing_MST_ViT-H_1024_scalf_MST_pairmate_indices.npy filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024_MST_ID.npy filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024_scalf/testing_MST_ViT-H_1024_scalf_MST_pairmate_indices.npy filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024/testing_MST_ViT-H_1024_MST_ID.npy filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024_scalf_best/testing_MST_ViT-H_1024_scalf_MST_ID.npy filter=lfs diff=lfs merge=lfs -text
+all_stimuli/MST_pairs1/pair_44_w_log_cabin1.jpg filter=lfs diff=lfs merge=lfs -text
+all_stimuli/MST_pairs1/pair_48_w_runway1.jpg filter=lfs diff=lfs merge=lfs -text
+all_stimuli/MST_pairs1/pair_40_w_escalator1.jpg filter=lfs diff=lfs merge=lfs -text
+all_stimuli/MST_pairs1/pair_48_w_runway2.jpg filter=lfs diff=lfs merge=lfs -text
+evals/testing_MST_ViT-H_1024/testing_MST_ViT-H_1024_MST_pairmate_indices.npy filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,66 @@
+src/clip_img_embedder
+src/processor
+src/clip_text_model
+src/diffusion_engine
+raw/
+src/eval_downloads/
+src/evals/
+rt_python/masks
+rt_python/generative_models
+rt_python/fine_tuned_model
+rt_python/data
+*DS_Store
+__pycache__/
+*.py[cod]
+*$py.class
+Untitled*.ipynb
+.ipynb_checkpoints/
+Train (2).ipynb
+Train (2).py
+Train.ipynb
+accel-more-train.slurm
+accel-multi-3subj.slurm
+accel-multi-batch.slurm
+accel-ses-03.slurm
+debug/
+enhanced_recon_inference-ses-03.ipynb
+enhanced_recon_inference.py
+enhanced_recon_inference_orig.ipynb
+enhanced_recon_inference_orig.py
+evals/
+figures/
+final_batch_evals.ipynb
+final_evaluations-ses-03.ipynb
+final_evaluations.py
+final_evaluations_orig.ipynb
+final_evaluations_orig.py
+main-more-train.ipynb
+main-more-train.py
+main-multisession-3subj.ipynb
+main-multisession.py
+main-multisession_old.ipynb
+main-multisession_old.py
+main-ses-03.ipynb
+main-ses-03.py
+main.py
+masks/
+orig_main.ipynb
+orig_main.py
+recon_inference-multisession-simple-copy.ipynb
+recon_inference-multisession-simple-copy.py
+recon_inference-multisession-simple.ipynb
+recon_inference-multisession-simple.py
+recon_inference-multisession.py
+recon_inference-ses-03.ipynb
+recon_inference.py
+recon_inference_orig.ipynb
+recon_inference_orig.py
+run_final_evals.slurm
+run_recon_final.slurm
+run_recon_final_batch.slurm
+run_recon_multi.slurm
+slurms/
+wandb/
+wandb_test.ipynb
+wandb_test.py
+.run_all_batch.slurm.swp

MindEye2.py

@@ -0,0 +1,102 @@
+import torch
+import torch.nn as nn
+
+class MindEyeModule(nn.Module):
+    def __init__(self):
+        super(MindEyeModule, self).__init__()
+    def forward(self, x):
+        return x
+
+
+class RidgeRegression(torch.nn.Module):
+    # make sure to add weight_decay when initializing optimizer
+    def __init__(self, input_sizes, out_features, seq_len=1): 
+        super(RidgeRegression, self).__init__()
+        self.seq_len = seq_len
+        self.out_features = out_features
+        self.linears = torch.nn.ModuleList([
+                torch.nn.Linear(input_size, out_features) for input_size in input_sizes
+            ])
+    def forward(self, x, subj_idx=0):
+        out = torch.cat([self.linears[subj_idx](x[:,seq]).unsqueeze(1) for seq in range(self.seq_len)], dim=1)
+        return out
+
+    
+from functools import partial
+
+class BrainNetwork(nn.Module):
+    def __init__(self, h=4096, in_dim=15724, out_dim=768, seq_len=1, n_blocks=4, drop=.15, 
+                 clip_size=768, clip_scale=1):
+        super().__init__()
+        self.seq_len = seq_len
+        self.h = h
+        self.clip_size = clip_size
+        self.clip_scale = clip_scale
+        
+        self.mixer_blocks1 = nn.ModuleList([
+            self.mixer_block1(h, drop) for _ in range(n_blocks)
+        ])
+        self.mixer_blocks2 = nn.ModuleList([
+            self.mixer_block2(seq_len, drop) for _ in range(n_blocks)
+        ])
+        
+        # Output linear layer
+        self.backbone_linear = nn.Linear(h * seq_len, out_dim, bias=True) 
+        if self.clip_scale>0:
+            self.clip_proj = self.projector(clip_size, clip_size, h=clip_size)
+            
+    def projector(self, in_dim, out_dim, h=2048):
+        return nn.Sequential(
+            nn.LayerNorm(in_dim),
+            nn.GELU(),
+            nn.Linear(in_dim, h),
+            nn.LayerNorm(h),
+            nn.GELU(),
+            nn.Linear(h, h),
+            nn.LayerNorm(h),
+            nn.GELU(),
+            nn.Linear(h, out_dim)
+        )
+    
+    def mlp(self, in_dim, out_dim, drop):
+        return nn.Sequential(
+            nn.Linear(in_dim, out_dim),
+            nn.GELU(),
+            nn.Dropout(drop),
+            nn.Linear(out_dim, out_dim),
+        )
+    
+    def mixer_block1(self, h, drop):
+        return nn.Sequential(
+            nn.LayerNorm(h),
+            self.mlp(h, h, drop),  # Token mixing
+        )
+
+    def mixer_block2(self, seq_len, drop):
+        return nn.Sequential(
+            nn.LayerNorm(seq_len),
+            self.mlp(seq_len, seq_len, drop)  # Channel mixing
+        )
+        
+    def forward(self, x):
+        # make empty tensors
+        c,b = torch.Tensor([0.]), torch.Tensor([[0.],[0.]])
+        
+        # Mixer blocks
+        residual1 = x
+        residual2 = x.permute(0,2,1)
+        for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2):
+            x = block1(x) + residual1
+            residual1 = x
+            x = x.permute(0,2,1)
+            
+            x = block2(x) + residual2
+            residual2 = x
+            x = x.permute(0,2,1)
+            
+        x = x.reshape(x.size(0), -1)
+        backbone = self.backbone_linear(x).reshape(len(x), -1, self.clip_size)
+        if self.clip_scale>0:
+            c = self.clip_proj(backbone)
+        
+        return backbone, c, b

accel-multi.slurm

@@ -0,0 +1,41 @@
+#!/bin/bash
+#SBATCH --job-name=ses-01
+#SBATCH --ntasks-per-node=1
+#SBATCH --nodes=1              
+#SBATCH --gres=gpu:1
+#SBATCH --constraint=gpu80
+#SBATCH --gpus-per-task=1       # Set to equal gres=gpu:#!
+#SBATCH --cpus-per-task=40      # 40 / 80 / 176 distributed across node
+#SBATCH --time=01:20:00         # total run time limit (HH:MM:SS)
+#SBATCH -e slurms/%j.err        # first create a "slurms" folder in current directory to store logs
+#SBATCH -o slurms/%j.out
+#SBATCH --no-requeue
+#SBATCH --array=0-19
+#SBATCH --mail-type=END
+#SBATCH [email protected]
+
+module purge
+module load anaconda3/2023.3
+# conda activate rt_mindEye2
+source /scratch/gpfs/ri4541/MindEyeV2/src/fmri/bin/activate
+
+# The following line converts your jupyter notebook into a python script runnable with Slurm
+jupyter nbconvert main-multisession.ipynb --to python
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+# Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) 
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+# singlesubject finetuning
+model_name="sub-001_ses-01_bs24_MST_rishab_MSTsplit_orig"
+echo model_name=${model_name}
+accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT orig_main.py --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-5 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep

accel.slurm

@@ -0,0 +1,41 @@
+#!/bin/bash
+#SBATCH --job-name=ses-01_orig
+#SBATCH --ntasks-per-node=1
+#SBATCH --nodes=1              
+#SBATCH --gres=gpu:1
+#SBATCH --constraint=gpu80
+#SBATCH --gpus-per-task=1       # Set to equal gres=gpu:#!
+#SBATCH --cpus-per-task=40      # 40 / 80 / 176 distributed across node
+#SBATCH --time=01:20:00         # total run time limit (HH:MM:SS)
+#SBATCH -e slurms/%j.err        # first create a "slurms" folder in current directory to store logs
+#SBATCH -o slurms/%j.out
+#SBATCH --no-requeue
+#SBATCH --array=0
+#SBATCH --mail-type=END
+#SBATCH [email protected]
+
+module load anaconda3/2023.3
+conda activate rt_mindEye2
+
+# The following line converts your jupyter notebook into a python script runnable with Slurm
+jupyter nbconvert orig_main.ipynb --to python
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+# Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) 
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+# singlesubject finetuning
+model_name="sub-001_ses-01_bs24_MST_original"
+echo model_name=${model_name}
+accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT orig_main.py --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep
+
+#accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT Train.py --data_path=/weka/proj-fmri/shared/mindeyev2_dataset --cache_dir=/weka/proj-fmri/shared/cache --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=../train_logs/multisubject_excludingsubj01_40sess

compare_protocols.ipynb

@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a42c36bb-6436-4225-aef0-e0396d3fb323",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"importing modules\")\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "import webdataset as wds\n",
+    "from PIL import Image\n",
+    "import pandas as pd\n",
+    "import nibabel as nib\n",
+    "import nilearn\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "import utils\n",
+    "from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas\n",
+    "\n",
+    "# imports utils from mindeye_preproc as \"preproc\"\n",
+    "import importlib.util\n",
+    "parent_utils_path = \"/home/ri4541/mindeye_preproc/analysis/utils.py\"\n",
+    "spec = importlib.util.spec_from_file_location(\"utils\", parent_utils_path)\n",
+    "preproc = importlib.util.module_from_spec(spec)\n",
+    "parent_dir = os.path.dirname(parent_utils_path)\n",
+    "if parent_dir not in sys.path:\n",
+    "    sys.path.append(parent_dir)\n",
+    "spec.loader.exec_module(preproc)\n",
+    "\n",
+    "if utils.is_interactive():\n",
+    "    from IPython.display import clear_output # function to clear print outputs in cell\n",
+    "    %load_ext autoreload \n",
+    "    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n",
+    "    %autoreload 2 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a697e85-f2fe-473a-9ce0-fb4f2ffc3622",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sub = 'sub-001'\n",
+    "session = 'ses-05'\n",
+    "tasks = ['A', 'B', 'C']\n",
+    "split = 'MST'  # train/test split should be MST for multi-protocol experiments\n",
+    "n_seeds = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f00cab3e-0d92-4205-8273-f8961f08f4fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ast  # safe evaluation of limited python data types\n",
+    "\n",
+    "all_evals = []\n",
+    "for i in range(10):\n",
+    "    evals = []\n",
+    "    model_name=f\"{sub}_{session}_task-{task}_bs24_MST_rishab_{split}split_{i}\"\n",
+    "    eval_dir = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/{model_name}\"\n",
+    "    with open(f\"{eval_dir}/final_evals\", 'r') as f:\n",
+    "        # skip the first two lines - no useful info\n",
+    "        f.readline(); f.readline()\n",
+    "        for line in f:  # pixcorr, ssim, alexnet2, alexnet5, inception, clip_, effnet, swav, fwd_acc, bwd_acc, mst_score\n",
+    "            # print(line.strip())\n",
+    "            evals.append(ast.literal_eval(line.strip()))  # strip() gets rid of leading and trailing spaces/newlines; literal_eval() returns the values as the \"intended\" type instead of strings\n",
+    "            # evals.append(line.strip())\n",
+    "    all_evals.append(evals)\n",
+    "\n",
+    "all_evals[0]"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

enhanced_recon_inference.ipynb

@@ -0,0 +1,460 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6b18f6a3-cc4f-437e-9756-c99fc6a5fad4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LOCAL RANK  0\n",
+      "device: cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('importing modules')\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import math\n",
+    "from einops import rearrange\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "from accelerate import Accelerator, DeepSpeedPlugin\n",
+    "\n",
+    "# SDXL unCLIP requires code from https://github.com/Stability-AI/generative-models/tree/main\n",
+    "sys.path.append('generative_models/')\n",
+    "import sgm\n",
+    "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder, FrozenCLIPEmbedder, FrozenOpenCLIPEmbedder2\n",
+    "from generative_models.sgm.models.diffusion import DiffusionEngine\n",
+    "from generative_models.sgm.util import append_dims\n",
+    "from omegaconf import OmegaConf\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "# custom functions #\n",
+    "import utils\n",
+    "from models import *\n",
+    "\n",
+    "### Multi-GPU config ###\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",
+    "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n",
+    "device = accelerator.device\n",
+    "print(\"device:\",device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "20cdb696-1d6e-4b73-951b-b0cd1dda219a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0\n",
+      "--model_name=sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0 --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0/all_recons.pt\n",
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = f\"sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0\" #\"sub-001_bs24_MST\"\n",
+    "    print(\"model_name:\", model_name)\n",
+    "    if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "        all_recons_path = f\"{eval_dir}/all_recons.pt\"\n",
+    "    elif \"paul\" in model_name:\n",
+    "        all_recons_path = f\"evals/{model_name}/{model_name}_all_recons.pt\"\n",
+    "    else:\n",
+    "        all_recons_path = f\"{eval_dir}/{model_name}_all_recons.pt\" \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\"--model_name={model_name} --all_recons_path={all_recons_path}\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()\n",
+    "    \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 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4b31d7c0-f5bd-4a19-a8be-7a3a165d79b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0\n",
+      "torch.Size([300, 3, 768, 768]) torch.Size([300, 256, 1664])\n"
+     ]
+    }
+   ],
+   "source": [
+    "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n",
+    "parser.add_argument(\n",
+    "    \"--model_name\", type=str, default=\"testing\",\n",
+    "    help=\"will load ckpt for model found in ../train_logs/model_name\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--all_recons_path\", type=str,\n",
+    "    help=\"Path to where all_recons.pt is stored\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seed\",type=int,default=42,\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",
+    "# seed all random functions\n",
+    "utils.seed_everything(seed)\n",
+    "\n",
+    "# make output directory\n",
+    "eval_dir = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/{model_name}\"\n",
+    "if not exists(f\"eval_dir\"):\n",
+    "    os.mkdir(\"eval_dir\")\n",
+    "\n",
+    "# all_images = torch.load(f\"{eval_dir}/all_images.pt\")\n",
+    "# all_recons = torch.load(f\"{eval_dir}/all_recons.pt\")\n",
+    "# all_clipvoxels = torch.load(f\"{eval_dir}/all_clipvoxels.pt\")\n",
+    "# all_predcaptions = torch.load(f\"{eval_dir}/all_predcaptions.pt\")\n",
+    "if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "    all_images = torch.load(f\"{eval_dir}/all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/all_clipvoxels.pt\")\n",
+    "    all_predcaptions = torch.load(f\"{eval_dir}/all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/all_recons.pt\")\n",
+    "elif \"ses-01\" in model_name and \"paul\" in model_name:\n",
+    "    all_images = torch.load(f\"evals/{model_name}/{model_name}_all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"evals/{model_name}/{model_name}_all_clipvoxels.pt\")\n",
+    "    all_predcaptions = torch.load(f\"evals/{model_name}/{model_name}_all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"evals/{model_name}/{model_name}_all_recons.pt\")\n",
+    "else:\n",
+    "    all_images = torch.load(f\"{eval_dir}/{model_name}_all_images.pt\") \n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/{model_name}_all_clipvoxels.pt\") \n",
+    "    all_predcaptions = torch.load(f\"{eval_dir}/{model_name}_all_predcaptions.pt\") \n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/{model_name}_all_recons.pt\") \n",
+    "\n",
+    "all_recons = torch.load(all_recons_path)\n",
+    "all_recons = transforms.Resize((768,768))(all_recons).float()\n",
+    "\n",
+    "print(model_name)\n",
+    "print(all_recons.shape, all_clipvoxels.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "24bdd667-0862-4561-b432-9fa7543df863",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n",
+      "SpatialTransformer: Found context dims [2048] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [2048, 2048] now.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initialized embedder #0: FrozenCLIPEmbedder with 123060480 params. Trainable: False\n",
+      "Initialized embedder #1: FrozenOpenCLIPEmbedder2 with 694659841 params. Trainable: False\n",
+      "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n",
+      "Initialized embedder #3: ConcatTimestepEmbedderND with 0 params. Trainable: False\n",
+      "Initialized embedder #4: ConcatTimestepEmbedderND with 0 params. Trainable: False\n",
+      "Restored from /scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/zavychromaxl_v30.safetensors with 1 missing and 1 unexpected keys\n",
+      "Missing Keys: ['denoiser.sigmas']\n",
+      "Unexpected Keys: ['conditioner.embedders.0.transformer.text_model.embeddings.position_ids']\n",
+      "crossattn torch.Size([1, 77, 2048])\n",
+      "vector_suffix torch.Size([1, 1536])\n",
+      "---\n",
+      "crossattn_uc torch.Size([1, 77, 2048])\n",
+      "vector_uc torch.Size([1, 2816])\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = OmegaConf.load(\"generative_models/configs/unclip6.yaml\")\n",
+    "config = OmegaConf.to_container(config, resolve=True)\n",
+    "unclip_params = config[\"model\"][\"params\"]\n",
+    "sampler_config = unclip_params[\"sampler_config\"]\n",
+    "sampler_config['params']['num_steps'] = 38\n",
+    "config = OmegaConf.load(\"generative_models/configs/inference/sd_xl_base.yaml\")\n",
+    "config = OmegaConf.to_container(config, resolve=True)\n",
+    "refiner_params = config[\"model\"][\"params\"]\n",
+    "\n",
+    "network_config = refiner_params[\"network_config\"]\n",
+    "denoiser_config = refiner_params[\"denoiser_config\"]\n",
+    "first_stage_config = refiner_params[\"first_stage_config\"]\n",
+    "conditioner_config = refiner_params[\"conditioner_config\"]\n",
+    "scale_factor = refiner_params[\"scale_factor\"]\n",
+    "disable_first_stage_autocast = refiner_params[\"disable_first_stage_autocast\"]\n",
+    "\n",
+    "# base_ckpt_path = '/weka/robin/projects/stable-research/checkpoints/sd_xl_base_1.0.safetensors'\n",
+    "# base_ckpt_path = '/weka/proj-fmri/paulscotti/stable-research/zavychromaxl_v30.safetensors'\n",
+    "\n",
+    "# if running on Della compute node, won't be able to find openai/clip-vit-large-patch14 (or any other internet-accessed file like from huggingface) so always download \"locally\" (onto Della)\n",
+    "base_ckpt_path = '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/zavychromaxl_v30.safetensors'\n",
+    "base_engine = DiffusionEngine(network_config=network_config,\n",
+    "                       denoiser_config=denoiser_config,\n",
+    "                       first_stage_config=first_stage_config,\n",
+    "                       conditioner_config=conditioner_config,\n",
+    "                       sampler_config=sampler_config, # using the one defined by the unclip\n",
+    "                       scale_factor=scale_factor,\n",
+    "                       disable_first_stage_autocast=disable_first_stage_autocast,\n",
+    "                       ckpt_path=base_ckpt_path)\n",
+    "base_engine.eval().requires_grad_(False)\n",
+    "base_engine.to(device)\n",
+    "\n",
+    "base_text_embedder1 = FrozenCLIPEmbedder(\n",
+    "    layer=conditioner_config['params']['emb_models'][0]['params']['layer'],\n",
+    "    layer_idx=conditioner_config['params']['emb_models'][0]['params']['layer_idx'],\n",
+    ")\n",
+    "base_text_embedder1.to(device)\n",
+    "\n",
+    "base_text_embedder2 = FrozenOpenCLIPEmbedder2(\n",
+    "    arch=conditioner_config['params']['emb_models'][1]['params']['arch'],\n",
+    "    version=conditioner_config['params']['emb_models'][1]['params']['version'],\n",
+    "    freeze=conditioner_config['params']['emb_models'][1]['params']['freeze'],\n",
+    "    layer=conditioner_config['params']['emb_models'][1]['params']['layer'],\n",
+    "    always_return_pooled=conditioner_config['params']['emb_models'][1]['params']['always_return_pooled'],\n",
+    "    legacy=conditioner_config['params']['emb_models'][1]['params']['legacy'],\n",
+    ")\n",
+    "base_text_embedder2.to(device)\n",
+    "\n",
+    "batch={\"txt\": \"\",\n",
+    "      \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n",
+    "      \"crop_coords_top_left\": torch.zeros(1, 2).to(device),\n",
+    "      \"target_size_as_tuple\": torch.ones(1, 2).to(device) * 1024}\n",
+    "out = base_engine.conditioner(batch)\n",
+    "crossattn = out[\"crossattn\"].to(device)\n",
+    "vector_suffix = out[\"vector\"][:,-1536:].to(device)\n",
+    "print(\"crossattn\", crossattn.shape)\n",
+    "print(\"vector_suffix\", vector_suffix.shape)\n",
+    "print(\"---\")\n",
+    "\n",
+    "batch_uc={\"txt\": \"painting, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, deformed, ugly, blurry, bad anatomy, bad proportions, extra limbs, cloned face, skinny, glitchy, double torso, extra arms, extra hands, mangled fingers, missing lips, ugly face, distorted face, extra legs, anime\",\n",
+    "      \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n",
+    "      \"crop_coords_top_left\": torch.zeros(1, 2).to(device),\n",
+    "      \"target_size_as_tuple\": torch.ones(1, 2).to(device) * 1024}\n",
+    "out = base_engine.conditioner(batch_uc)\n",
+    "crossattn_uc = out[\"crossattn\"].to(device)\n",
+    "vector_uc = out[\"vector\"].to(device)\n",
+    "print(\"crossattn_uc\", crossattn_uc.shape)\n",
+    "print(\"vector_uc\", vector_uc.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "07f437d1-9b8e-4b13-85ad-d45062a5ce09",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "num_samples = 1 # PS: I tried increasing this to 16 and picking highest cosine similarity, it didnt seem to increase eval performance!\n",
+    "img2img_timepoint = 15 # 13 # higher number means more reliance on prompt, less reliance on matching the conditioning image\n",
+    "base_engine.sampler.guider.scale = 5 # cfg\n",
+    "def denoiser(x, sigma, c): return base_engine.denoiser(base_engine.model, x, sigma, c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "939e1cbb-5836-48c2-87d8-3e493e950011",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/300 [00:00<?, ?it/s]/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/utils/checkpoint.py:429: UserWarning: torch.utils.checkpoint: please pass in use_reentrant=True or use_reentrant=False explicitly. The default value of use_reentrant will be updated to be False in the future. To maintain current behavior, pass use_reentrant=True. It is recommended that you use use_reentrant=False. Refer to docs for more details on the differences between the two variants.\n",
+      "  warnings.warn(\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/utils/checkpoint.py:61: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+      "  warnings.warn(\n",
+      "100%|██████████| 300/300 [09:15<00:00,  1.85s/it]\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "all_enhancedrecons torch.Size([300, 3, 512, 512])\n",
+      "saved /scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0/sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0_all_enhancedrecons.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "all_enhancedrecons = None\n",
+    "for img_idx in tqdm(range(len(all_recons))):\n",
+    "    with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16), base_engine.ema_scope():\n",
+    "        base_engine.sampler.num_steps = 25\n",
+    "        \n",
+    "        image = all_recons[[img_idx]]\n",
+    "        image = image.to(device)\n",
+    "        prompt = all_predcaptions[[img_idx]][0]\n",
+    "        # prompt = \"\"\n",
+    "\n",
+    "        # z = torch.randn(num_samples,4,96,96).to(device)\n",
+    "        assert image.shape[-1]==768\n",
+    "        z = base_engine.encode_first_stage(image*2-1).repeat(num_samples,1,1,1)\n",
+    "\n",
+    "        openai_clip_text = base_text_embedder1(prompt)\n",
+    "        clip_text_tokenized, clip_text_emb  = base_text_embedder2(prompt)\n",
+    "        clip_text_emb = torch.hstack((clip_text_emb, vector_suffix))\n",
+    "        clip_text_tokenized = torch.cat((openai_clip_text, clip_text_tokenized),dim=-1)\n",
+    "        c = {\"crossattn\": clip_text_tokenized.repeat(num_samples,1,1), \"vector\": clip_text_emb.repeat(num_samples,1)}\n",
+    "        uc = {\"crossattn\": crossattn_uc.repeat(num_samples,1,1), \"vector\": vector_uc.repeat(num_samples,1)}\n",
+    "\n",
+    "        noise = torch.randn_like(z)\n",
+    "        sigmas = base_engine.sampler.discretization(base_engine.sampler.num_steps).to(device)\n",
+    "        init_z = (z + noise * append_dims(sigmas[-img2img_timepoint], z.ndim)) / torch.sqrt(1.0 + sigmas[0] ** 2.0)\n",
+    "        sigmas = sigmas[-img2img_timepoint:].repeat(num_samples,1)\n",
+    "\n",
+    "        base_engine.sampler.num_steps = sigmas.shape[-1] - 1\n",
+    "        noised_z, _, _, _, c, uc = base_engine.sampler.prepare_sampling_loop(init_z, cond=c, uc=uc, \n",
+    "                                                            num_steps=base_engine.sampler.num_steps)\n",
+    "        for timestep in range(base_engine.sampler.num_steps):\n",
+    "            noised_z = base_engine.sampler.sampler_step(sigmas[:,timestep],\n",
+    "                                                        sigmas[:,timestep+1],\n",
+    "                                                        denoiser, noised_z, cond=c, uc=uc, gamma=0)\n",
+    "        samples_z_base = noised_z\n",
+    "        samples_x = base_engine.decode_first_stage(samples_z_base)\n",
+    "        samples = torch.clamp((samples_x + 1.0) / 2.0, min=0.0, max=1.0)[0].cpu()[None]\n",
+    "\n",
+    "        if all_enhancedrecons is None:\n",
+    "            all_enhancedrecons = samples\n",
+    "        else:\n",
+    "            all_enhancedrecons = torch.vstack((all_enhancedrecons, samples))\n",
+    "\n",
+    "all_enhancedrecons = transforms.Resize((512,512))(all_enhancedrecons).float()\n",
+    "print(\"all_enhancedrecons\", all_enhancedrecons.shape)\n",
+    "\n",
+    "torch.save(all_enhancedrecons,f\"{eval_dir}/all_enhancedrecons.pt\")\n",
+    "print(f\"saved {eval_dir}/all_enhancedrecons.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1da11b84-9bf7-4057-872e-20cba36f6921",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# x = torch.permute(all_images, (0,2,3,1))\n",
+    "# y = torch.permute(all_enhancedrecons, (0,2,3,1))\n",
+    "# fig, ax = plt.subplots(102, 2, figsize=(15, 500))\n",
+    "# for row, _ in enumerate(ax):\n",
+    "#     ax[row][0].imshow(x.cpu()[row])\n",
+    "#     ax[row][1].imshow(y.cpu()[row])\n",
+    "# plt.tight_layout()\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cc52f485-1e51-44d8-ad69-04388fc4e8c7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

environment.yml

@@ -0,0 +1,322 @@
+name: rt_mindEye2
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - asttokens=2.4.1=pyhd8ed1ab_0
+  - bcrypt=3.2.0=py311h5eee18b_1
+  - blas=1.0=mkl
+  - boto3=1.34.117=pyhd8ed1ab_0
+  - botocore=1.34.117=pyge310_1234567_0
+  - brotli=1.0.9=h9c3ff4c_4
+  - brotli-python=1.0.9=py311h6a678d5_8
+  - bzip2=1.0.8=h5eee18b_5
+  - ca-certificates=2024.8.30=hbcca054_0
+  - cffi=1.16.0=py311h5eee18b_1
+  - cryptography=42.0.5=py311hdda0065_1
+  - cycler=0.12.1=pyhd8ed1ab_0
+  - decorator=5.1.1=pyhd8ed1ab_0
+  - exceptiongroup=1.2.2=pyhd8ed1ab_0
+  - freetype=2.10.4=h0708190_1
+  - icu=73.1=h6a678d5_0
+  - inotify-tools=3.20.2=h516909a_0
+  - inotify_simple=1.3.5=pyha770c72_3
+  - intel-openmp=2021.4.0=h06a4308_3561
+  - ipympl=0.9.4=pyhd8ed1ab_0
+  - ipython_genutils=0.2.0=pyhd8ed1ab_1
+  - jedi=0.19.1=pyhd8ed1ab_0
+  - jmespath=1.0.1=py311h06a4308_0
+  - jpeg=9e=h166bdaf_1
+  - jupyterlab_pygments=0.3.0=pyhd8ed1ab_1
+  - jupyterlab_widgets=3.0.13=pyhd8ed1ab_0
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - lerc=3.0=h295c915_0
+  - libdeflate=1.17=h5eee18b_1
+  - libffi=3.4.4=h6a678d5_0
+  - libgcc=7.2.0=h69d50b8_2
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libpng=1.6.39=h5eee18b_0
+  - libsodium=1.0.18=h7b6447c_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtiff=4.5.1=h6a678d5_0
+  - libuuid=1.41.5=h5eee18b_0
+  - libuv=1.48.0=h5eee18b_0
+  - libwebp-base=1.3.2=h5eee18b_1
+  - lz4-c=1.9.4=h6a678d5_1
+  - matplotlib-base=3.9.2=py311h6fb44e5_0
+  - mkl=2021.4.0=h06a4308_640
+  - mkl-service=2.4.0=py311h5eee18b_0
+  - mkl_fft=1.3.1=py311h30b3d60_0
+  - mkl_random=1.2.2=py311hba01205_0
+  - munkres=1.1.4=pyh9f0ad1d_0
+  - ncurses=6.4=h6a678d5_0
+  - nodejs=20.17.0=hb8e3597_0
+  - openjpeg=2.5.2=he7f1fd0_0
+  - openssl=3.0.15=h5eee18b_0
+  - paramiko=2.8.1=pyhd3eb1b0_0
+  - pexpect=4.9.0=pyhd8ed1ab_0
+  - pickleshare=0.7.5=py_1003
+  - plumbum=1.8.3=pyhd8ed1ab_0
+  - ptyprocess=0.7.0=pyhd3deb0d_0
+  - pure_eval=0.2.3=pyhd8ed1ab_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pynacl=1.5.0=py311h5eee18b_0
+  - pyparsing=3.2.0=pyhd8ed1ab_1
+  - pysocks=1.7.1=py311h06a4308_0
+  - python=3.11.7=h955ad1f_0
+  - python-dateutil=2.9.0post0=py311h06a4308_2
+  - python_abi=3.11=2_cp311
+  - pywin32-on-windows=0.1.0=pyh1179c8e_3
+  - readline=8.2=h5eee18b_0
+  - rpyc=5.3.0=pyhd8ed1ab_0
+  - s3transfer=0.10.1=py311h06a4308_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.41.2=h5eee18b_0
+  - stack_data=0.6.2=pyhd8ed1ab_0
+  - tk=8.6.12=h1ccaba5_0
+  - toml=0.10.2=pyhd3eb1b0_0
+  - typing_extensions=4.12.2=pyha770c72_0
+  - watchdog=4.0.1=py311h38be061_0
+  - wcwidth=0.2.13=pyhd8ed1ab_0
+  - wheel=0.41.2=py311h06a4308_0
+  - xz=5.4.6=h5eee18b_0
+  - yaml=0.2.5=h7b6447c_0
+  - zlib=1.2.13=h5eee18b_0
+  - zstd=1.5.6=hc292b87_0
+  - pip:
+      - accelerate==0.24.1
+      - aiofiles==22.1.0
+      - aiohttp==3.9.3
+      - aiosignal==1.3.1
+      - aiosqlite==0.20.0
+      - annotated-types==0.6.0
+      - antlr4-python3-runtime==4.9.3
+      - anyio==4.3.0
+      - appdirs==1.4.4
+      - argon2-cffi==23.1.0
+      - argon2-cffi-bindings==21.2.0
+      - arrow==1.3.0
+      - astor==0.8.1
+      - astroid==3.3.5
+      - async-lru==2.0.4
+      - attrs==23.2.0
+      - babel==2.14.0
+      - beartype==0.17.2
+      - beautifulsoup4==4.12.3
+      - bids-validator==1.14.6
+      - bleach==6.1.0
+      - bokeh==3.3.4
+      - braceexpand==0.1.7
+      - certifi==2024.8.30
+      - charset-normalizer==3.4.0
+      - click==8.1.7
+      - clip==1.0
+      - clip-anytorch==2.6.0
+      - coca-pytorch==0.1.0
+      - comm==0.2.1
+      - contourpy==1.3.1
+      - dalle2-pytorch==1.15.6
+      - datasets==2.18.0
+      - debugpy==1.8.1
+      - deepspeed==0.13.1
+      - defusedxml==0.7.1
+      - diffusers==0.23.0
+      - dill==0.3.8
+      - docker-pycreds==0.4.0
+      - docopt==0.6.2
+      - einops==0.7.0
+      - einx==0.1.3
+      - ema-pytorch==0.4.2
+      - embedding-reader==1.7.0
+      - entrypoints==0.4
+      - evaluate==0.4.1
+      - executing==2.0.1
+      - fastjsonschema==2.19.1
+      - filelock==3.13.1
+      - fonttools==4.55.1
+      - formulaic==0.3.4
+      - fqdn==1.5.1
+      - frozendict==2.4.0
+      - frozenlist==1.4.1
+      - fsspec==2024.2.0
+      - ftfy==6.1.3
+      - gitdb==4.0.11
+      - gitpython==3.1.43
+      - greenlet==3.0.3
+      - h11==0.14.0
+      - h5py==3.10.0
+      - hf-transfer==0.1.8
+      - hjson==3.1.0
+      - httpcore==1.0.6
+      - httpx==0.27.2
+      - huggingface-hub==0.20.3
+      - idna==3.10
+      - imageio==2.34.0
+      - importlib-metadata==7.0.1
+      - inotify==0.2.10
+      - interface-meta==1.3.0
+      - ipykernel==6.29.2
+      - ipython==8.22.1
+      - ipywidgets==8.1.2
+      - isoduration==20.11.0
+      - isort==5.13.2
+      - jinja2==3.1.3
+      - joblib==1.3.2
+      - json5==0.9.17
+      - jsonpointer==2.4
+      - jsonschema==4.21.1
+      - jsonschema-specifications==2023.12.1
+      - jupyter==1.1.1
+      - jupyter-client==7.4.9
+      - jupyter-console==6.6.3
+      - jupyter-core==5.7.1
+      - jupyter-events==0.9.0
+      - jupyter-lsp==2.2.5
+      - jupyter-server==2.12.5
+      - jupyter-server-fileid==0.9.1
+      - jupyter-server-proxy==4.1.0
+      - jupyter-server-terminals==0.5.2
+      - jupyter-server-ydoc==0.8.0
+      - jupyter-ydoc==0.2.5
+      - jupyterlab==3.6.7
+      - jupyterlab-nvdashboard==0.9.0
+      - jupyterlab-server==2.27.3
+      - kiwisolver==1.4.7
+      - kornia==0.7.1
+      - lazy-loader==0.3
+      - lightning-utilities==0.10.1
+      - lxml==5.1.0
+      - markupsafe==2.1.5
+      - matplotlib==3.8.2
+      - matplotlib-inline==0.1.6
+      - mccabe==0.7.0
+      - mistune==3.0.2
+      - mpmath==1.3.0
+      - multidict==6.0.5
+      - multiprocess==0.70.16
+      - nbclassic==1.0.0
+      - nbclient==0.9.0
+      - nbconvert==7.16.1
+      - nbformat==5.9.2
+      - nest-asyncio==1.6.0
+      - networkx==3.2.1
+      - nibabel==5.2.1
+      - nilearn==0.10.3
+      - ninja==1.11.1.1
+      - nose==1.3.7
+      - notebook==6.5.6
+      - notebook-shim==0.2.4
+      - num2words==0.5.13
+      - numpy==1.26.4
+      - nvidia-cublas-cu12==12.1.3.1
+      - nvidia-cuda-cupti-cu12==12.1.105
+      - nvidia-cuda-nvrtc-cu12==12.1.105
+      - nvidia-cuda-runtime-cu12==12.1.105
+      - nvidia-cudnn-cu12==8.9.2.26
+      - nvidia-cufft-cu12==11.0.2.54
+      - nvidia-curand-cu12==10.3.2.106
+      - nvidia-cusolver-cu12==11.4.5.107
+      - nvidia-cusparse-cu12==12.1.0.106
+      - nvidia-nccl-cu12==2.18.1
+      - nvidia-nvjitlink-cu12==12.3.101
+      - nvidia-nvtx-cu12==12.1.105
+      - omegaconf==2.3.0
+      - open-clip-torch==2.24.0
+      - overrides==7.7.0
+      - packaging==24.2
+      - pandas==2.2.0
+      - pandocfilters==1.5.1
+      - parso==0.8.3
+      - pillow==10.2.0
+      - pip==24.3.1
+      - platformdirs==4.3.6
+      - prometheus-client==0.20.0
+      - prompt-toolkit==3.0.43
+      - protobuf==5.28.3
+      - psutil==6.1.0
+      - pure-eval==0.2.2
+      - py-cpuinfo==9.0.0
+      - pyarrow==15.0.0
+      - pyarrow-hotfix==0.6
+      - pybids==0.15.3
+      - pydantic==2.6.2
+      - pydantic-core==2.16.3
+      - pydicom==2.4.4
+      - pygments==2.17.2
+      - pylint==3.3.1
+      - pynvml==11.5.0
+      - python-json-logger==2.0.7
+      - pytorch-lightning==2.0.1
+      - pytorch-warmup==0.1.1
+      - pytz==2024.1
+      - pyyaml==6.0.2
+      - pyzmq==24.0.1
+      - qtconsole==5.5.1
+      - qtpy==2.4.1
+      - referencing==0.33.0
+      - regex==2023.12.25
+      - requests==2.32.3
+      - resize-right==0.0.2
+      - responses==0.18.0
+      - rfc3339-validator==0.1.4
+      - rfc3986-validator==0.1.1
+      - rotary-embedding-torch==0.5.3
+      - rpds-py==0.18.0
+      - safetensors==0.4.2
+      - scikit-image==0.22.0
+      - scikit-learn==1.4.1.post1
+      - scipy==1.12.0
+      - send2trash==1.8.2
+      - sentence-transformers==2.5.1
+      - sentencepiece==0.2.0
+      - sentry-sdk==2.18.0
+      - setproctitle==1.3.4
+      - setuptools==75.5.0
+      - simpervisor==1.0.0
+      - smmap==5.0.1
+      - sniffio==1.3.0
+      - soupsieve==2.5
+      - sqlalchemy==1.3.24
+      - stack-data==0.6.3
+      - sympy==1.12
+      - terminado==0.18.0
+      - threadpoolctl==3.3.0
+      - tifffile==2024.2.12
+      - timm==0.9.16
+      - tinycss2==1.2.1
+      - tokenizers==0.15.2
+      - tomlkit==0.13.2
+      - torch==2.1.0
+      - torch-fidelity==0.3.0
+      - torchmetrics==1.3.0.post0
+      - torchvision==0.16.0
+      - tornado==6.4
+      - tqdm==4.66.2
+      - traitlets==5.14.1
+      - transformers==4.37.2
+      - triton==2.1.0
+      - types-python-dateutil==2.8.19.20240106
+      - typing-extensions==4.9.0
+      - tzdata==2024.1
+      - uri-template==1.3.0
+      - urllib3==2.2.3
+      - vector-quantize-pytorch==1.14.1
+      - wandb==0.17.2
+      - webcolors==1.13
+      - webdataset==0.2.73
+      - webencodings==0.5.1
+      - websocket-client==1.7.0
+      - widgetsnbextension==4.0.10
+      - wrapt==1.16.0
+      - x-clip==0.14.4
+      - xformers==0.0.22.post7
+      - xxhash==3.4.1
+      - xyzservices==2023.10.1
+      - y-py==0.6.2
+      - yarl==1.9.4
+      - ypy-websocket==0.8.4
+      - zipp==3.17.0

evals/testing_MST_ViT-H_1024/final_evals

@@ -0,0 +1,12 @@
+Metric,Value
+alexnet2,0.5318009664359409
+alexnet5,0.5370902442209743
+inception,0.5256954420791432
+clip_,0.5321927647903878
+effnet,0.9561490287097593
+swav,0.6627069928859551
+pixcorr,0.06609624355941902
+ssim,0.4277698868332266
+percent_correct_fwd,0.016129031777381897
+percent_correct_bwd,0.016129031777381897
+mst_score,[]

evals/testing_MST_ViT-H_1024/testing_MST_ViT-H_1024_MST_ID.npy

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

evals/testing_MST_ViT-H_1024/testing_MST_ViT-H_1024_MST_pairmate_indices.npy

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

evals/testing_MST_ViT-H_1024_MST_ID.npy

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

evals/testing_MST_ViT-H_1024_scalf/final_evals

@@ -0,0 +1,12 @@
+Metric,Value
+alexnet2,0.5106438552958077
+alexnet5,0.49751861042183626
+inception,0.5076890427060207
+clip_,0.519328718819381
+effnet,0.9543885725097773
+swav,0.6520650061534471
+pixcorr,0.05185274977219404
+ssim,0.4141594942526016
+percent_correct_fwd,0.04838709533214569
+percent_correct_bwd,0.016129031777381897
+mst_score,[]

evals/testing_MST_ViT-H_1024_scalf/testing_MST_ViT-H_1024_scalf_MST_pairmate_indices.npy

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

evals/testing_MST_ViT-H_1024_scalf_best/final_evals

@@ -0,0 +1,12 @@
+Metric,Value
+alexnet2,0.5031343868355753
+alexnet5,0.5026772887553872
+inception,0.5045220060075747
+clip_,0.49902050411388277
+effnet,0.9661921941512774
+swav,0.6689534720263354
+pixcorr,0.029649783436161304
+ssim,0.410797652241365
+percent_correct_fwd,0.06451612710952759
+percent_correct_bwd,0.016129031777381897
+mst_score,[]

evals/testing_MST_ViT-H_1024_scalf_best/testing_MST_ViT-H_1024_scalf_MST_ID.npy

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

evals/testing_MST_ViT-H_1024_scalf_best/testing_MST_ViT-H_1024_scalf_MST_pairmate_indices.npy

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

final_evaluations.ipynb

@@ -0,0 +1,1778 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7d5f265e-407a-40bd-92fb-a652091fd7ea",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LOCAL RANK  0\n",
+      "PID of this process = 1915809\n",
+      "device: cuda\n",
+      "Distributed environment: DistributedType.NO\n",
+      "Num processes: 1\n",
+      "Process index: 0\n",
+      "Local process index: 0\n",
+      "Device: cuda\n",
+      "\n",
+      "Mixed precision type: fp16\n",
+      "\n",
+      "distributed = False num_devices = 1 local rank = 0 world size = 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('importing modules')\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import math\n",
+    "from einops import rearrange\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "import webdataset as wds\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "from accelerate import Accelerator, DeepSpeedPlugin\n",
+    "\n",
+    "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder\n",
+    "from models import GNet8_Encoder\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "# custom functions #\n",
+    "import utils\n",
+    "\n",
+    "### Multi-GPU config ###\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",
+    "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\") # ['no', 'fp8', 'fp16', 'bf16']\n",
+    "\n",
+    "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",
+    "if num_devices==0 or not distributed: num_devices = 1\n",
+    "num_workers = num_devices\n",
+    "print(accelerator.state)\n",
+    "\n",
+    "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n",
+    "print = accelerator.print # only print if local_rank=0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1b8e8d9e-2931-4546-a2ce-a7417bbe21f4",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Load embedding model (last hidden layer)\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",
+    "## Load embedding model (last layer)\n",
+    "#     clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n",
+    "#         arch=\"ViT-bigG-14\",\n",
+    "#         version=\"laion2b_s39b_b160k\",\n",
+    "#         output_tokens=False,\n",
+    "#         only_tokens=False,\n",
+    "#     )\n",
+    "#     clip_img_embedder.to(device)\n",
+    "# clip_seq_dim = 1\n",
+    "# clip_emb_dim = 1280"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1ffb659a-8154-4536-ab27-2d976da1bf4e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0\n",
+      "--model_name=sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0 --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --all_recons_path=evals/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0_all_recons.pt --eval_dir=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_all = False\n",
+    "compute_circular = False  # for the circular tests looking at image similarity in clip space (without any brain data involved)\n",
+    "saving = True\n",
+    "\n",
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = f\"sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0\"\n",
+    "    eval_dir = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/{model_name}\"\n",
+    "    if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "        all_recons_path = f\"{eval_dir}/all_recons.pt\"\n",
+    "    elif \"paul\" in model_name:\n",
+    "        all_recons_path = f\"evals/{model_name}/{model_name}_all_recons.pt\"\n",
+    "    else:\n",
+    "        all_recons_path = f\"{eval_dir}/{model_name}_all_recons.pt\" \n",
+    "\n",
+    "    data_path = \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2\"\n",
+    "    print(\"model_name:\", model_name)\n",
+    "\n",
+    "    jupyter_args = f\"--model_name={model_name} --data_path={data_path} --all_recons_path={all_recons_path} --eval_dir={eval_dir}\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()\n",
+    "    \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 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "fb8120cd-f226-4e2c-a6c5-3cd8ef6e9bc8",
+   "metadata": {
+    "tags": []
+   },
+   "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/mindeyev2_dataset\",\n",
+    "    help=\"Path to where NSD data is stored / where to download it to\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--all_recons_path\", type=str,\n",
+    "    help=\"Path to where all_recons.pt is stored\",\n",
+    ")\n",
+    "\n",
+    "parser.add_argument(\n",
+    "    \"--eval_dir\", type=str,\n",
+    "    help=\"Path to where evaluations should be stored\",\n",
+    ")\n",
+    "\n",
+    "parser.add_argument(\n",
+    "    \"--seed\",type=int,default=42,\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",
+    "# seed all random functions\n",
+    "utils.seed_everything(seed)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95d66b33-b327-4895-a861-ecc6ccc51296",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Evals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "be66f9c9-f25a-48d9-9e9a-272ab33d20ed",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([100, 3, 256, 256])\n",
+      "all_recons_path: evals/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0_all_recons.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "    all_images = torch.load(f\"{eval_dir}/all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/all_clipvoxels.pt\")\n",
+    "    all_predcaptions = torch.load(f\"{eval_dir}/all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/all_recons.pt\")\n",
+    "elif \"ses-01\" in model_name and \"paul\" in model_name:\n",
+    "    all_images = torch.load(f\"evals/{model_name}/{model_name}_all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"evals/{model_name}/{model_name}_all_clipvoxels.pt\")\n",
+    "    all_predcaptions = torch.load(f\"evals/{model_name}/{model_name}_all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"evals/{model_name}/{model_name}_all_recons.pt\")\n",
+    "else:\n",
+    "    all_images = torch.load(f\"{eval_dir}/{model_name}_all_images.pt\") \n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/{model_name}_all_clipvoxels.pt\") \n",
+    "    all_predcaptions = torch.load(f\"{eval_dir}/{model_name}_all_predcaptions.pt\") \n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/{model_name}_all_recons.pt\") \n",
+    "\n",
+    "print(all_images.shape)\n",
+    "print(\"all_recons_path:\", all_recons_path)\n",
+    "all_recons = torch.load(all_recons_path)\n",
+    "\n",
+    "# all_blurryrecons = torch.load(f\"{eval_dir}/all_blurryrecons.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4b6c44f9-95ac-4bac-9fbf-d0b31f4f127f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if \"ses-01\" in model_name:\n",
+    "#     paul_all_images = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_images.pt\").to('cpu')\n",
+    "#     paul_all_clipvoxels = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_clipvoxels.pt\").to('cpu')\n",
+    "#     paul_all_recons = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_recons.pt\").to('cpu')\n",
+    "#     # paul_all_prior_out = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_prior_out.pt\").to('cpu')\n",
+    "#     # all_images = torch.load(f\"{eval_dir}/all_images.pt\") \n",
+    "#     print(paul_all_images.shape, all_images.shape)\n",
+    "#     print(paul_all_clipvoxels.shape, all_clipvoxels.shape)\n",
+    "#     print(torch.eq(paul_all_clipvoxels, all_clipvoxels))\n",
+    "#     # assert torch.allclose(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e8f29ac6-6561-4770-8837-8877488dce05",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# for i in range(100):\n",
+    "#     # print(torch.allclose(paul_all_images[i], all_images[i]))\n",
+    "#     pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a1382548-4b43-4101-a15b-e67b1225059c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# num_images = paul_all_images.size(0)\n",
+    "# rows = 10  # Number of rows for the grid\n",
+    "# cols = 10  # Number of columns for the grid\n",
+    "\n",
+    "# fig, axes = plt.subplots(rows, cols * 2, figsize=(80, 40))\n",
+    "\n",
+    "# for i in range(num_images):\n",
+    "#     row = i // cols\n",
+    "#     col = (i % cols) * 2  # Adjust for side-by-side\n",
+    "    \n",
+    "#     # Plot correct image\n",
+    "#     ax_correct = axes[row, col]\n",
+    "#     ax_correct.imshow(paul_all_recons[i].permute(1, 2, 0).cpu().numpy())\n",
+    "#     ax_correct.axis('off')\n",
+    "#     ax_correct.set_title(f\"Correct {i}\")\n",
+    "    \n",
+    "#     # Plot modified image\n",
+    "#     ax_modified = axes[row, col + 1]\n",
+    "#     ax_modified.imshow(all_recons[i].permute(1, 2, 0).cpu().numpy())\n",
+    "#     ax_modified.axis('off')\n",
+    "#     ax_modified.set_title(f\"Modified {i}\")\n",
+    "\n",
+    "# plt.tight_layout()\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4cc551db-85c3-4696-a6fd-52b0092669eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0_all_recons.pt\n",
+      "torch.Size([100, 3, 256, 256]) torch.Size([100, 3, 256, 256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_name_plus_suffix = all_recons_path.split('/')[-1]\n",
+    "print(model_name_plus_suffix)\n",
+    "print(all_images.shape, all_recons.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "22e933c4-1eed-48a7-a22f-84a4606ac253",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0 (50, 2) torch.Size([100, 3, 256, 256]) torch.Size([100, 256, 1664])\n"
+     ]
+    }
+   ],
+   "source": [
+    "if \"MST\" in model_name:\n",
+    "    if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name or \"rishab\" in model_name:\n",
+    "        MST_ID = np.load(f\"{eval_dir}/MST_ID.npy\")\n",
+    "        MST_pairmate_indices = np.load(f\"{eval_dir}/MST_pairmate_indices.npy\")\n",
+    "    elif \"paul\" in model_name:\n",
+    "        MST_ID = np.load(f\"evals/{model_name}/{model_name}_MST_ID.npy\")\n",
+    "        MST_pairmate_indices = np.array(utils.find_paired_indices(torch.Tensor(MST_ID)))\n",
+    "        # print(MST_pairmate_indices)\n",
+    "    else:\n",
+    "        MST_ID = np.load(f\"{eval_dir}/{model_name}_MST_ID.npy\") \n",
+    "        MST_pairmate_indices = np.load(f\"{eval_dir}/{model_name}_MST_pairmate_indices.npy\") \n",
+    "\n",
+    "    # pairs = utils.find_paired_indices(torch.Tensor(MST_ID))\n",
+    "    # if \"close_to_MST\" in model_name or (\"remove\" in model_name and \"random\" in model_name) or \"ses-0\" in model_name:\n",
+    "    #     pairs = np.array(pairs[:-1])  # index out the placeholder\n",
+    "    # pairs = np.array(pairs)\n",
+    "    # if \"ses-0\" in model_name:\n",
+    "    #     if \"ses-01\" in model_name or \"ses-04\" in model_name:\n",
+    "    #         print(pairs.shape)\n",
+    "    #         assert pairs.shape == (49,2)\n",
+    "    #     else:\n",
+    "    #         assert pairs.shape == (50,3)\n",
+    "    # else:\n",
+    "    #     assert pairs.shape == (100,3)\n",
+    "    # print(pairs)\n",
+    "    # repeats_in_test = torch.load(f\"{eval_dir}/repeats_in_test.pt\")\n",
+    "    # test_image_indices = torch.load(f\"{eval_dir}/test_image_indices.pt\")\n",
+    "    all_unique_images = all_images[MST_pairmate_indices.flatten()]\n",
+    "    all_unique_clipvoxels = all_clipvoxels[MST_pairmate_indices.flatten()]\n",
+    "\n",
+    "    print(model_name, MST_pairmate_indices.shape, all_unique_images.shape, all_unique_clipvoxels.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "880081e4-7567-4b1e-acb0-4af863018228",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# visualize all unique images\n",
+    "if plot_all:\n",
+    "    # Plot all the MST images and pairmates\n",
+    "    import textwrap\n",
+    "    def wrap_title(title, wrap_width):\n",
+    "        return \"\\n\".join(textwrap.wrap(title, wrap_width))\n",
+    "\n",
+    "    size = int(np.ceil(MST_pairmate_indices.shape[0]/2))  # helps determine size of plot\n",
+    "    fig, axes = plt.subplots(size, 4, figsize=(15, size*4))\n",
+    "    jj=-1; kk=0;\n",
+    "    for i, j in enumerate(all_unique_images):\n",
+    "        jj+=1\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(j))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        if jj==3: \n",
+    "            kk+=1; jj=-1\n",
+    "\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/MST_2_pairmates_10-01')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "48c8772b-871a-4031-b013-d7159bf8b74a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# if plot_all:\n",
+    "#     # create full grid of recon comparisons\n",
+    "#     from PIL import Image\n",
+    "\n",
+    "#     imsize = 150\n",
+    "#     if all_images.shape[-1] != imsize:\n",
+    "#         all_images = transforms.Resize((imsize,imsize))(all_images).float()\n",
+    "#     if all_recons.shape[-1] != imsize:\n",
+    "#         all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n",
+    "\n",
+    "#     num_images = all_recons.shape[0]\n",
+    "#     num_rows = (2 * num_images + 9) // 10\n",
+    "\n",
+    "#     # Interleave tensors\n",
+    "#     merged = torch.stack([val for pair in zip(all_images, all_recons) for val in pair], dim=0)\n",
+    "\n",
+    "#     # Calculate grid size\n",
+    "#     grid = torch.zeros((num_rows * 10, 3, all_recons.shape[-1], all_recons.shape[-1]))\n",
+    "\n",
+    "#     # Populate the grid\n",
+    "#     grid[:2*num_images] = merged\n",
+    "#     grid_images = [transforms.functional.to_pil_image(grid[i]) for i in range(num_rows * 10)]\n",
+    "\n",
+    "#     # Create the grid image\n",
+    "#     grid_image = Image.new('RGB', (all_recons.shape[-1]*10, all_recons.shape[-1] * num_rows))  # 10 images wide\n",
+    "\n",
+    "#     # Paste images into the grid\n",
+    "#     for i, img in enumerate(grid_images):\n",
+    "#         grid_image.paste(img, (all_recons.shape[-1] * (i % 10), all_recons.shape[-1] * (i // 10)))\n",
+    "#     grid_image\n",
+    "#     # grid_image.save(f\"{model_name_plus_suffix[:-3]}_1000recons.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f42009e9-f910-4f02-8db6-d46778aa6595",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imsize = 256\n",
+    "if all_images.shape[-1] != imsize:\n",
+    "    all_images = transforms.Resize((imsize,imsize))(all_images).float()\n",
+    "if all_recons.shape[-1] != imsize:\n",
+    "    all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n",
+    "try:\n",
+    "    if all_blurryrecons.shape[-1] != imsize:\n",
+    "        all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float()\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "if \"enhanced\" in model_name_plus_suffix:\n",
+    "    try:\n",
+    "        all_recons = all_recons*.75 + all_blurryrecons*.25\n",
+    "        print(\"weighted averaging to improve low-level evals\")\n",
+    "    except:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "06e23174-a777-4dd1-8b73-6783587d8f9c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# visualize some images with recons and captions\n",
+    "if plot_all:\n",
+    "    assert np.all(all_images.shape == all_recons.shape)\n",
+    "    import textwrap\n",
+    "    def wrap_title(title, wrap_width):\n",
+    "        return \"\\n\".join(textwrap.wrap(title, wrap_width))\n",
+    "\n",
+    "    fig, axes = plt.subplots(3, 4, figsize=(10, 8))\n",
+    "    jj=-1; kk=0;\n",
+    "    for j in np.array([0,1,2,3,4,5]):\n",
+    "        jj+=1\n",
+    "        # print(kk,jj)\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(all_images[j]))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        jj+=1\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(all_recons[j]))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        axes[kk][jj].set_title(wrap_title(str(all_predcaptions[[j]]),wrap_width=30), fontsize=8)\n",
+    "        if jj==3: \n",
+    "            kk+=1; jj=-1\n",
+    "\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/recon_09-26')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b4deb53-4d85-4292-92c5-bb59077523cf",
+   "metadata": {},
+   "source": [
+    "# Retrieval eval (chance =  1/100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2e49d57a-9b65-490c-a1e0-61bd05682171",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "overall fwd percent_correct: 0.7100\n",
+      "overall bwd percent_correct: 0.7000\n"
+     ]
+    }
+   ],
+   "source": [
+    "from scipy import stats\n",
+    "\n",
+    "all_fwd_acc = []\n",
+    "all_bwd_acc = []\n",
+    "\n",
+    "assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "all_percent_correct_fwds, all_percent_correct_bwds = [], []\n",
+    "\n",
+    "with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "    all_emb = clip_img_embedder(all_unique_images.to(device)).float() # CLIP-Image\n",
+    "    all_emb_ = all_unique_clipvoxels # CLIP-Brain\n",
+    "\n",
+    "    # flatten if necessary\n",
+    "    all_emb = all_emb.reshape(len(all_emb),-1).to(device)\n",
+    "    all_emb_ = all_emb_.reshape(len(all_emb_),-1).to(device)\n",
+    "\n",
+    "    # l2norm \n",
+    "    all_emb = nn.functional.normalize(all_emb,dim=-1)\n",
+    "    all_emb_ = nn.functional.normalize(all_emb_,dim=-1)\n",
+    "\n",
+    "    all_labels = torch.arange(len(all_emb)).to(device)\n",
+    "    all_bwd_sim = utils.batchwise_cosine_similarity(all_emb,all_emb_)  # clip, brain\n",
+    "    all_fwd_sim = utils.batchwise_cosine_similarity(all_emb_,all_emb)  # brain, clip\n",
+    "\n",
+    "    if \"ses-0\" not in model_name or \"ses-01\" in model_name or \"ses-04\" in model_name:\n",
+    "        assert len(all_fwd_sim) == 100\n",
+    "        assert len(all_bwd_sim) == 100\n",
+    "    else:\n",
+    "        assert len(all_fwd_sim) == 50\n",
+    "        assert len(all_bwd_sim) == 50\n",
+    "    \n",
+    "    all_percent_correct_fwds = utils.topk(all_fwd_sim, all_labels, k=1).item()\n",
+    "    all_percent_correct_bwds = utils.topk(all_bwd_sim, all_labels, k=1).item()\n",
+    "\n",
+    "all_fwd_acc.append(all_percent_correct_fwds)\n",
+    "all_bwd_acc.append(all_percent_correct_bwds)\n",
+    "\n",
+    "all_fwd_sim = np.array(all_fwd_sim.cpu())\n",
+    "all_bwd_sim = np.array(all_bwd_sim.cpu())\n",
+    "\n",
+    "print(f\"overall fwd percent_correct: {all_fwd_acc[0]:.4f}\")\n",
+    "print(f\"overall bwd percent_correct: {all_bwd_acc[0]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1a4cda50-ef4a-43d0-9c2e-53ee8509482d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if \"ses-0\" not in model_name:\n",
+    "    from scipy import stats\n",
+    "\n",
+    "    fwd_acc = []\n",
+    "    bwd_acc = []\n",
+    "    fwd_sim_halves = []\n",
+    "    bwd_sim_halves = []\n",
+    "\n",
+    "    assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "    for i in range(2):  # since this is a 2-session model, we evaluate on the test set corresponding to each session and report both separately for better comparison to single-session models\n",
+    "        percent_correct_fwds, percent_correct_bwds = [], []\n",
+    "        # percent_correct_fwd, percent_correct_bwd = None, None\n",
+    "\n",
+    "        if i==0:  \n",
+    "            all_unique_images_half = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "            all_unique_clipvoxels_half = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "        elif i==1:\n",
+    "            all_unique_images_half = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "            all_unique_clipvoxels_half = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "\n",
+    "\n",
+    "        with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "            emb = clip_img_embedder(all_unique_images_half.to(device)).float() # CLIP-Image\n",
+    "            emb_ = all_unique_clipvoxels_half # CLIP-Brain\n",
+    "\n",
+    "            # flatten if necessary\n",
+    "            emb = emb.reshape(len(emb),-1).to(device)\n",
+    "            emb_ = emb_.reshape(len(emb_),-1).to(device)\n",
+    "\n",
+    "            # l2norm \n",
+    "            emb = nn.functional.normalize(emb,dim=-1)\n",
+    "            emb_ = nn.functional.normalize(emb_,dim=-1)\n",
+    "\n",
+    "            labels = torch.arange(len(emb)).to(device)\n",
+    "            bwd_sim = utils.batchwise_cosine_similarity(emb,emb_)  # clip, brain\n",
+    "            fwd_sim = utils.batchwise_cosine_similarity(emb_,emb)  # brain, clip\n",
+    "\n",
+    "            assert len(fwd_sim) == 50\n",
+    "            assert len(bwd_sim) == 50\n",
+    "\n",
+    "            # percent_correct_fwds = np.append(percent_correct_fwds, utils.topk(fwd_sim, labels, k=1).item())\n",
+    "            # percent_correct_bwds = np.append(percent_correct_bwds, utils.topk(bwd_sim, labels, k=1).item())\n",
+    "            percent_correct_fwds = utils.topk(fwd_sim, labels, k=1).item()\n",
+    "            percent_correct_bwds = utils.topk(bwd_sim, labels, k=1).item()\n",
+    "\n",
+    "        # percent_correct_fwd = np.mean(percent_correct_fwds)\n",
+    "        # fwd_sd = np.std(percent_correct_fwds) / np.sqrt(len(percent_correct_fwds))\n",
+    "        # fwd_ci = stats.norm.interval(0.95, loc=percent_correct_fwd, scale=fwd_sd)\n",
+    "\n",
+    "        # percent_correct_bwd = np.mean(percent_correct_bwds)\n",
+    "        # bwd_sd = np.std(percent_correct_bwds) / np.sqrt(len(percent_correct_bwds))\n",
+    "        # bwd_ci = stats.norm.interval(0.95, loc=percent_correct_bwd, scale=bwd_sd)\n",
+    "\n",
+    "        fwd_acc.append(percent_correct_fwds)\n",
+    "        bwd_acc.append(percent_correct_bwds)\n",
+    "\n",
+    "        fwd_sim = np.array(fwd_sim.cpu())\n",
+    "        bwd_sim = np.array(bwd_sim.cpu())\n",
+    "        fwd_sim_halves.append(fwd_sim)\n",
+    "        bwd_sim_halves.append(bwd_sim)\n",
+    "\n",
+    "    print(f\"ses-02 fwd percent_correct: {fwd_acc[0]:.4f}; ses-03 fwd percent_correct: {fwd_acc[1]:.4f}\")\n",
+    "    print(f\"ses-02 bwd percent_correct: {bwd_acc[0]:.4f}; ses-03 bwd percent_correct: {bwd_acc[1]:.4f} \")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "40d43a70-e1db-43e5-ae84-40eb1577cf01",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    if \"ses-0\" not in model_name:  # we're in a multisession model, assumed ses-02 and ses-03 for now\n",
+    "        fwd_acc_circular = []\n",
+    "        fwd_sim_halves_circular = []\n",
+    "\n",
+    "        assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "        for i in range(2):  # since this is a 2-session model, we evaluate on the test set corresponding to each session and report both separately for better comparison to single-session models\n",
+    "            percent_correct_fwds_circular = []\n",
+    "            # percent_correct_fwd_circular = None\n",
+    "\n",
+    "            if i==0:  \n",
+    "                all_unique_images_half_circular = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                all_unique_clipvoxels_half_circular = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "            elif i==1:\n",
+    "                all_unique_images_half_circular = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                all_unique_clipvoxels_half_circular = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "\n",
+    "            with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "                emb_circular = clip_img_embedder(all_unique_images_half_circular.to(device)).float() # CLIP-Image\n",
+    "\n",
+    "                # flatten if necessary\n",
+    "                emb_circular = emb_circular.reshape(len(emb_circular),-1).to(device)\n",
+    "\n",
+    "                # l2norm \n",
+    "                emb_circular = nn.functional.normalize(emb_circular,dim=-1)\n",
+    "\n",
+    "                labels_circular = torch.arange(len(emb_circular)).to(device)\n",
+    "                fwd_sim_circular = utils.batchwise_cosine_similarity(emb_circular,emb_circular)  # clip, clip\n",
+    "\n",
+    "\n",
+    "                if \"ses-0\" in model_name:\n",
+    "                    assert len(fwd_sim_circular) == 25\n",
+    "                else:\n",
+    "                    assert len(fwd_sim_circular) == 50\n",
+    "\n",
+    "                # percent_correct_fwds_circular = np.append(percent_correct_fwds_circular, utils.topk(fwd_sim_circular, labels_circular, k=1).item())\n",
+    "                percent_correct_fwds_circular = utils.topk(fwd_sim_circular, labels_circular, k=1).item()\n",
+    "\n",
+    "\n",
+    "            # percent_correct_fwd_circular = np.mean(percent_correct_fwds_circular)\n",
+    "            # fwd_sd_circular = np.std(percent_correct_fwds_circular) / np.sqrt(len(percent_correct_fwds_circular))\n",
+    "            # fwd_ci_circular = stats.norm.interval(0.95, loc=percent_correct_fwd_circular, scale=fwd_sd_circular)\n",
+    "\n",
+    "            fwd_acc_circular.append(percent_correct_fwds_circular)\n",
+    "\n",
+    "            fwd_sim_circular = np.array(fwd_sim_circular.cpu())\n",
+    "            fwd_sim_halves_circular.append(fwd_sim_circular)\n",
+    "\n",
+    "        print(f\"ses-02 fwd percent_correct: {fwd_acc_circular[0]:.4f}; ses-03 fwd percent_correct: {fwd_acc_circular[1]:.4f}\")\n",
+    "    \n",
+    "    else:  # single session model\n",
+    "        fwd_acc_circular = []\n",
+    "\n",
+    "        assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "        percent_correct_fwds_circular = []\n",
+    "        # percent_correct_fwd_circular = None\n",
+    "\n",
+    "        with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "            emb_circular = clip_img_embedder(all_unique_images.to(device)).float() # CLIP-Image\n",
+    "\n",
+    "            # flatten if necessary\n",
+    "            emb_circular = emb_circular.reshape(len(emb_circular),-1).to(device)\n",
+    "\n",
+    "            # l2norm \n",
+    "            emb_circular = nn.functional.normalize(emb_circular,dim=-1)\n",
+    "\n",
+    "            labels_circular = torch.arange(len(emb_circular)).to(device)\n",
+    "            fwd_sim_circular = utils.batchwise_cosine_similarity(emb_circular,emb_circular)  # clip, clip\n",
+    "\n",
+    "\n",
+    "            if \"ses-01\" in model_name:\n",
+    "                assert len(fwd_sim_circular) == 100\n",
+    "            else:\n",
+    "                assert len(fwd_sim_circular) == 50\n",
+    "\n",
+    "            # percent_correct_fwds_circular = np.append(percent_correct_fwds_circular, utils.topk(fwd_sim_circular, labels_circular, k=1).item())\n",
+    "            percent_correct_fwds_circular = utils.topk(fwd_sim_circular, labels_circular, k=1).item()\n",
+    "\n",
+    "\n",
+    "        # percent_correct_fwd_circular = np.mean(percent_correct_fwds_circular)\n",
+    "        # fwd_sd_circular = np.std(percent_correct_fwds_circular) / np.sqrt(len(percent_correct_fwds_circular))\n",
+    "        # fwd_ci_circular = stats.norm.interval(0.95, loc=percent_correct_fwd_circular, scale=fwd_sd_circular)\n",
+    "\n",
+    "        fwd_acc_circular.append(percent_correct_fwds_circular)\n",
+    "\n",
+    "        fwd_sim_circular = np.array(fwd_sim_circular.cpu())\n",
+    "\n",
+    "        print(f\"session fwd percent_correct (circular): {fwd_acc_circular[0]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "d086c99a-c712-4ac7-b625-a0656c9ee886",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    # print(utils.topk(torch.Tensor(fwd_sim_halves[1]).to(device), labels, k=1).item())\n",
+    "    # ses02_top1 = torch.argsort(torch.Tensor(fwd_sim_halves[0]).to(device),axis=1)[:,-1] == labels  # from utils.topk()\n",
+    "    # ses03_top1 = torch.argsort(torch.Tensor(fwd_sim_halves[1]).to(device),axis=1)[:,-1] == labels\n",
+    "    # top1_results = torch.cat((ses02_top1, ses03_top1))\n",
+    "    # incorrect_idx = torch.argwhere(top1_results == False)[:,0]\n",
+    "    # print(incorrect_idx)\n",
+    "\n",
+    "    # confirm that the lure is behind the target 80% of the time in CLIP last hidden layer embeddings\n",
+    "\n",
+    "    use_fwd_sim = False\n",
+    "    use_first_half = False\n",
+    "\n",
+    "    all_top_sims = []  # len(fwd_sim_halves[0]); for each image, contains the similarity to the top-n choices until it gets the correct answer. If len 1, top-1 is correct\n",
+    "    all_pairmate_sims = []  # len(fwd_sim_halves[0]); the similarity of each image to its pairmate \n",
+    "    all_chose_lures = []  # len(fwd_sim_halves[0]); True for each top-n choice if the lure was predicted to be more similar to the target \n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        sim_halves = fwd_sim_halves if use_fwd_sim else bwd_sim_halves\n",
+    "        sim_halves = sim_halves[0] if use_first_half else sim_halves[1]\n",
+    "    else:\n",
+    "        sim_halves = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "    for i, img in enumerate(sim_halves):\n",
+    "        if i%2==0:\n",
+    "            idx_to_pairmate = 1\n",
+    "        elif i%2==1:\n",
+    "            idx_to_pairmate = -1\n",
+    "\n",
+    "        order = img.argsort()[::-1]\n",
+    "        # print(order)\n",
+    "        top_sim = []\n",
+    "        chose_lure = []\n",
+    "        for idx in order:\n",
+    "            sim = img[idx]\n",
+    "            pairmate_sim = img[i+idx_to_pairmate]\n",
+    "            top_sim.append(sim) \n",
+    "            chose_lure.append((idx, sim <= pairmate_sim))\n",
+    "            # print(i, idx, img[idx], img[i+idx_to_pairmate])\n",
+    "            if idx == i:\n",
+    "                break\n",
+    "\n",
+    "        all_top_sims.append(top_sim)\n",
+    "        all_pairmate_sims.append(pairmate_sim)\n",
+    "        all_chose_lures.append(chose_lure)\n",
+    "\n",
+    "    # print(all_top_sims)\n",
+    "    # print()\n",
+    "    # print(all_pairmate_sims)\n",
+    "    # print()\n",
+    "    # print(all_chose_lures)\n",
+    "\n",
+    "    where_chose_pairmate = []\n",
+    "    for idx, i in enumerate(all_chose_lures):\n",
+    "        for value in i:\n",
+    "            # print(value[1])\n",
+    "            if value[1] == True:\n",
+    "                # print(idx, i, end='\\n')\n",
+    "                where_chose_pairmate.append(idx)\n",
+    "                break\n",
+    "\n",
+    "    # where_chose_pairmate  # trials where the pairmate was chosen ahead of the target"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "a5c4405c-b3b7-42fe-b622-f4cb81500464",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# top-n predictions using CLIP brain embeddings\n",
+    "\n",
+    "if plot_all:\n",
+    "    use_fwd_sim = True\n",
+    "    top_n = 10  # how many of the top n images to display\n",
+    "    print(\"Given Brain embedding, find correct Image embedding\")\n",
+    "    fig, ax = plt.subplots(nrows=len(all_unique_images), ncols=top_n+1, figsize=(top_n*2,len(all_unique_images)*2))\n",
+    "    for trial in range(len(all_unique_images)):\n",
+    "        ax[trial, 0].imshow(utils.torch_to_Image(all_unique_images[trial]))\n",
+    "        ax[trial, 0].set_title(\"original\\nimage\")\n",
+    "        ax[trial, 0].axis(\"off\")\n",
+    "        for attempt in range(top_n):\n",
+    "            if trial < 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_half = fwd_sim_halves[0] if use_fwd_sim else bwd_sim_halves[0]\n",
+    "                    unique_imgs_to_plot = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "                else:\n",
+    "                    sim_half = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "                    unique_imgs_to_plot = all_unique_images\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels\n",
+    "                which = np.flip(np.argsort(sim_half[trial]))[attempt]\n",
+    "\n",
+    "            elif trial >= 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_halves = fwd_sim_halves[1] if use_fwd_sim else bwd_sim_halves[1]\n",
+    "                    unique_imgs_to_plot = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "                else:\n",
+    "                    sim_halves = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "                    unique_imgs_to_plot = all_unique_images\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels\n",
+    "                which = np.flip(np.argsort(sim_half[trial-50]))[attempt]\n",
+    "\n",
+    "            ax[trial, attempt+1].imshow(utils.torch_to_Image(unique_imgs_to_plot[which]))\n",
+    "            ax[trial, attempt+1].set_title(f\"Top {attempt+1}\")\n",
+    "            ax[trial, attempt+1].axis(\"off\")\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/retrieval_top10')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "05df72ce-3cdb-4ad2-a790-0835a41fb0f6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# similarity of each unique MST image to all others using CLIP image embeddings only (top-1 is guaranteed to be correct)\n",
+    "# uses last hidden layer (which may not match as well as the last layer to human semantic judgments)\n",
+    "if plot_all and compute_circular:\n",
+    "    print(\"Given Brain embedding, find correct Image embedding\")\n",
+    "    top_n = 10  # how many of the top n images to display\n",
+    "    fig, ax = plt.subplots(nrows=len(all_unique_images), ncols=top_n+1, figsize=(top_n*2,len(all_unique_images)*2))\n",
+    "    for trial in range(len(all_unique_images)):\n",
+    "        ax[trial, 0].imshow(utils.torch_to_Image(all_unique_images[trial]))\n",
+    "        ax[trial, 0].set_title(\"original\\nimage\")\n",
+    "        ax[trial, 0].axis(\"off\")\n",
+    "        for attempt in range(10):\n",
+    "            if trial < 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_half_circular = fwd_sim_halves_circular[0]\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                else:\n",
+    "                    sim_half_circular = fwd_sim_circular\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images\n",
+    "                which_circular = np.flip(np.argsort(sim_half_circular[trial]))[attempt]\n",
+    "\n",
+    "            elif trial >= 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_halves_circular = fwd_sim_halves_circular[1]\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                else:\n",
+    "                    sim_halves_circular = all_fwd_sim_circular\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images\n",
+    "                which_circular = np.flip(np.argsort(sim_half_circular[trial-50]))[attempt]\n",
+    "\n",
+    "            ax[trial, attempt+1].imshow(utils.torch_to_Image(unique_imgs_to_plot_circular[which_circular]))\n",
+    "            ax[trial, attempt+1].set_title(f\"Top {attempt+1}\")\n",
+    "            ax[trial, attempt+1].axis(\"off\")\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/circular_top10')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d404dec-5336-45cf-8932-833e895a9ebe",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## MST Paired Retrieval (chance = 50%)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "06667f7d-a356-4c30-8e1b-06ebd7ff1752",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    all_top_sims_circular = []  # len(fwd_sim_halves[0]); for each image, contains the similarity to the top-n choices until it gets the correct answer. If len 1, top-1 is correct\n",
+    "    all_pairmate_sims_circular = []  # len(fwd_sim_halves[0]); the similarity of each image to its pairmate \n",
+    "    all_chose_lures_circular = []  # len(fwd_sim_halves[0]); True for each top-n choice if the lure was predicted to be more similar to the target \n",
+    "\n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        first_half = True\n",
+    "        sim_halves_circular = fwd_sim_halves_circular\n",
+    "        sim_halves_circular = sim_halves_circular[0] if use_first_half else sim_halves_circular[1]\n",
+    "    else:\n",
+    "        sim_halves_circular = all_fwd_sim_circular\n",
+    "    for i, img in enumerate(sim_halves_circular):\n",
+    "        if i%2==0:\n",
+    "            idx_to_pairmate = 1\n",
+    "        elif i%2==1:\n",
+    "            idx_to_pairmate = -1\n",
+    "\n",
+    "        order_circular = img.argsort()[::-1]\n",
+    "        # print(order)\n",
+    "        top_sim_circular = []\n",
+    "        chose_lure_circular = []\n",
+    "        for idx in order_circular:\n",
+    "            sim_circular = img[idx]\n",
+    "            pairmate_sim_circular = img[i+idx_to_pairmate]\n",
+    "            top_sim_circular.append(sim_circular) \n",
+    "            chose_lure_circular.append((idx, sim_circular <= pairmate_sim_circular))\n",
+    "            # print(i, idx, img[idx], img[i+idx_to_pairmate])\n",
+    "            if idx == i:\n",
+    "                break\n",
+    "\n",
+    "        all_top_sims_circular.append(top_sim_circular)\n",
+    "        all_pairmate_sims_circular.append(pairmate_sim_circular)\n",
+    "        all_chose_lures_circular.append(chose_lure_circular)\n",
+    "\n",
+    "    bot_half = (all_pairmate_sims_circular < np.median(all_pairmate_sims_circular))[::2]  # every other one since the sims are symmetric\n",
+    "    top_half = (all_pairmate_sims_circular > np.median(all_pairmate_sims_circular))[::2]\n",
+    "\n",
+    "    binary_acc = []\n",
+    "    for i,(a,b) in enumerate(tqdm(MST_pairmate_indices,total=len(MST_pairmate_indices))):\n",
+    "        # print(i,a,b)\n",
+    "        with torch.no_grad():\n",
+    "            with torch.cuda.amp.autocast():\n",
+    "                emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "        with torch.no_grad():\n",
+    "            with torch.cuda.amp.autocast():\n",
+    "                emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                binary_acc.append(a_sim < b_sim)\n",
+    "\n",
+    "    assert len(binary_acc) == 50\n",
+    "    mst_score = np.mean(binary_acc)\n",
+    "    print(f\"session score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "3468021c-660d-4205-8e5d-d75f6f3c2881",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test = np.sort(MST_pairmate_indices, axis=1)\n",
+    "# test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "a032c4cc-4cf9-4b33-ac02-0e569f7757be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model_name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "130bb4d9-b7f1-40a4-a3e2-7e3699c69c49",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# paul_all_images = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_images.pt\").to('cpu')\n",
+    "# paul_all_clipvoxels = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_clipvoxels.pt\").to('cpu')\n",
+    "# paul_all_recons = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_recons.pt\").to('cpu')\n",
+    "# paul_all_prior_out = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_prior_out.pt\").to('cpu')\n",
+    "# print(paul_all_images.shape, all_images.shape)\n",
+    "# # assert torch.eq(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "698ffc2c-5653-49d3-9d16-38a32f9e7f6b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# print(paul_all_images.shape, all_images.shape)\n",
+    "# torch.eq(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "23f26846-3170-4c91-a8e3-f98322e90dc0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "assuming single session\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 50/50 [00:04<00:00, 10.23it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "session score: 0.8900 ± 0.3129\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "if \"MST\" in model_name:\n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        print('assuming ses-02+ses-03 multisession model')\n",
+    "        mst_score = []\n",
+    "        for half in range(2):\n",
+    "            binary_acc = []\n",
+    "            if half==0:\n",
+    "                MST_pairmate_indices_half = MST_pairmate_indices[:int(len(MST_pairmate_indices)/2)]\n",
+    "            elif half==1:\n",
+    "                MST_pairmate_indices_half = MST_pairmate_indices[int(len(MST_pairmate_indices)/2):]\n",
+    "            for i,(a,b) in enumerate(tqdm(MST_pairmate_indices_half,total=len(MST_pairmate_indices_half))):\n",
+    "                # print(i,a,b)\n",
+    "                with torch.no_grad():\n",
+    "                    with torch.cuda.amp.autocast():\n",
+    "                        emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                        a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                        b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                        binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "                with torch.no_grad():\n",
+    "                    with torch.cuda.amp.autocast():\n",
+    "                        emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                        a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                        b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                        binary_acc.append(a_sim < b_sim)\n",
+    "\n",
+    "            assert len(binary_acc) == 50  # don't want to average across both sessions; make sure it resets\n",
+    "            print(f\"ses-0{half+2} score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n",
+    "            mst_score.append((np.mean(binary_acc),np.std(binary_acc)))\n",
+    "\n",
+    "        # print(mst_score)\n",
+    "    else:\n",
+    "        print('assuming single session')\n",
+    "        binary_acc = []\n",
+    "        for i,(a,b) in enumerate(tqdm(MST_pairmate_indices,total=len(MST_pairmate_indices))):\n",
+    "            # print(i,a,b)\n",
+    "            with torch.no_grad():\n",
+    "                with torch.cuda.amp.autocast():\n",
+    "                    emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                    a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                    b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                    binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "            with torch.no_grad():\n",
+    "                with torch.cuda.amp.autocast():\n",
+    "                    emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                    a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                    b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                    binary_acc.append(a_sim < b_sim)\n",
+    "                    \n",
+    "        # assert len(binary_acc) == 50\n",
+    "        mst_score = np.mean(binary_acc)\n",
+    "        print(f\"session score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a26e124-2444-434d-a399-d03c2c90cc08",
+   "metadata": {},
+   "source": [
+    "## 2-way identification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "3e1778ff-5d6a-4087-b59f-0f44b9e0eada",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torchvision.models.feature_extraction import create_feature_extractor, get_graph_node_names\n",
+    "\n",
+    "@torch.no_grad()\n",
+    "def two_way_identification(all_recons, all_images, model, preprocess, feature_layer=None, return_avg=True):\n",
+    "    preds = model(torch.stack([preprocess(recon) for recon in all_recons], dim=0).to(device))\n",
+    "    reals = model(torch.stack([preprocess(indiv) for indiv in all_images], dim=0).to(device))\n",
+    "    if feature_layer is None:\n",
+    "        preds = preds.float().flatten(1).cpu().numpy()\n",
+    "        reals = reals.float().flatten(1).cpu().numpy()\n",
+    "    else:\n",
+    "        preds = preds[feature_layer].float().flatten(1).cpu().numpy()\n",
+    "        reals = reals[feature_layer].float().flatten(1).cpu().numpy()\n",
+    "\n",
+    "    r = np.corrcoef(reals, preds)\n",
+    "    r = r[:len(all_images), len(all_images):]\n",
+    "    congruents = np.diag(r)\n",
+    "\n",
+    "    success = r < congruents\n",
+    "    success_cnt = np.sum(success, 0)\n",
+    "\n",
+    "    if return_avg:\n",
+    "        perf = np.mean(success_cnt) / (len(all_images)-1)\n",
+    "        return perf\n",
+    "    else:\n",
+    "        return success_cnt, len(all_images)-1\n",
+    "    \n",
+    "all_recons=all_recons.to(device)\n",
+    "all_images=all_images.to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df6be966-52ef-4cf6-8078-8d2d9617564b",
+   "metadata": {},
+   "source": [
+    "## PixCorr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "2e17ea38-a254-4e90-a910-711734fdd8eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([100, 541875])\n",
+      "torch.Size([100, 541875])\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [00:00<00:00, 775.96it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.19027211547192407\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "])\n",
+    "\n",
+    "# Flatten images while keeping the batch dimension\n",
+    "all_images_flattened = preprocess(all_images).reshape(len(all_images), -1).cpu()\n",
+    "all_recons_flattened = preprocess(all_recons).view(len(all_recons), -1).cpu()\n",
+    "\n",
+    "print(all_images_flattened.shape)\n",
+    "print(all_recons_flattened.shape)\n",
+    "\n",
+    "corr_stack = []\n",
+    "\n",
+    "corrsum = 0\n",
+    "for i in tqdm(range(len(all_images))):\n",
+    "    corrcoef = np.corrcoef(all_images_flattened[i], all_recons_flattened[i])[0][1]\n",
+    "    if np.isnan(corrcoef):\n",
+    "        print(\"WARNING: CORRCOEF WAS NAN\")\n",
+    "        corrcoef = 0\n",
+    "    corrsum += corrcoef\n",
+    "    corr_stack.append(corrcoef)\n",
+    "corrmean = corrsum / len(all_images)\n",
+    "\n",
+    "pixcorr = corrmean\n",
+    "print(pixcorr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "7e2cd891-db44-475d-a8c6-ab345eaa58f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# print(all_images.shape)\n",
+    "# print(all_images_flattened.shape)\n",
+    "# print(all_recons.shape)\n",
+    "# print(all_recons_flattened.shape)\n",
+    "# len(all_images)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a556d5b-33a2-44aa-b48d-4b168316bbdd",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## SSIM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "2326fc4c-1248-4d0f-9176-218c6460f285",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "converted, now calculating ssim...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [00:00<00:00, 120.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.3447461015516486\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# see https://github.com/zijin-gu/meshconv-decoding/issues/3\n",
+    "from skimage.color import rgb2gray\n",
+    "from skimage.metrics import structural_similarity as ssim\n",
+    "\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), \n",
+    "])\n",
+    "\n",
+    "# convert image to grayscale with rgb2grey\n",
+    "img_gray = rgb2gray(preprocess(all_images).permute((0,2,3,1)).cpu())\n",
+    "recon_gray = rgb2gray(preprocess(all_recons).permute((0,2,3,1)).cpu())\n",
+    "print(\"converted, now calculating ssim...\")\n",
+    "\n",
+    "ssim_score=[]\n",
+    "for im,rec in tqdm(zip(img_gray,recon_gray),total=len(all_images)):\n",
+    "    ssim_score.append(ssim(rec, im, multichannel=True, gaussian_weights=True, sigma=1.5, use_sample_covariance=False, data_range=1.0))\n",
+    "\n",
+    "ssim = np.mean(ssim_score)\n",
+    "print(ssim)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35138520-ec00-48a6-90dc-249a32a783d2",
+   "metadata": {},
+   "source": [
+    "## AlexNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "3b45cc6c-ab80-43e2-b446-c8fcb4fc54e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/overrides.py:110: UserWarning: 'has_cuda' is deprecated, please use 'torch.backends.cuda.is_built()'\n",
+      "  torch.has_cuda,\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/overrides.py:111: UserWarning: 'has_cudnn' is deprecated, please use 'torch.backends.cudnn.is_available()'\n",
+      "  torch.has_cudnn,\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/overrides.py:117: UserWarning: 'has_mps' is deprecated, please use 'torch.backends.mps.is_built()'\n",
+      "  torch.has_mps,\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/overrides.py:118: UserWarning: 'has_mkldnn' is deprecated, please use 'torch.backends.mkldnn.is_available()'\n",
+      "  torch.has_mkldnn,\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "---early, AlexNet(2)---\n",
+      "2-way Percent Correct: 0.8010\n",
+      "\n",
+      "---mid, AlexNet(5)---\n",
+      "2-way Percent Correct: 0.8542\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchvision.models import alexnet, AlexNet_Weights\n",
+    "alex_weights = AlexNet_Weights.IMAGENET1K_V1\n",
+    "\n",
+    "alex_model = create_feature_extractor(alexnet(weights=alex_weights), return_nodes=['features.4','features.11']).to(device)\n",
+    "alex_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see alex_weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(256, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "layer = 'early, AlexNet(2)'\n",
+    "print(f\"\\n---{layer}---\")\n",
+    "all_per_correct = two_way_identification(all_recons, all_images, \n",
+    "                                                          alex_model, preprocess, 'features.4')\n",
+    "alexnet2 = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {alexnet2:.4f}\")\n",
+    "\n",
+    "layer = 'mid, AlexNet(5)'\n",
+    "print(f\"\\n---{layer}---\")\n",
+    "all_per_correct = two_way_identification(all_recons, all_images, \n",
+    "                                                          alex_model, preprocess, 'features.11')\n",
+    "alexnet5 = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {alexnet5:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c296bab2-d106-469e-b997-b32d21a2cf01",
+   "metadata": {},
+   "source": [
+    "## InceptionV3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "5a9c1b2b-af2a-476d-a1ac-32ee915ac2ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/feature_extraction.py:174: UserWarning: NOTE: The nodes obtained by tracing the model in eval mode are a subsequence of those obtained in train mode. When choosing nodes for feature extraction, you may need to specify output nodes for train and eval mode separately.\n",
+      "  warnings.warn(msg + suggestion_msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2-way Percent Correct: 0.7205\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchvision.models import inception_v3, Inception_V3_Weights\n",
+    "weights = Inception_V3_Weights.DEFAULT\n",
+    "inception_model = create_feature_extractor(inception_v3(weights=weights), \n",
+    "                                           return_nodes=['avgpool']).to(device)\n",
+    "inception_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(342, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "all_per_correct = two_way_identification(all_recons, all_images,\n",
+    "                                        inception_model, preprocess, 'avgpool')\n",
+    "        \n",
+    "inception = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {inception:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7a25f7f-8298-4413-b512-8a1173413e07",
+   "metadata": {},
+   "source": [
+    "## CLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "6afbf7ce-8793-4988-a328-a632acd88aa9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2-way Percent Correct: 0.7387\n"
+     ]
+    }
+   ],
+   "source": [
+    "import clip\n",
+    "clip_model, preprocess = clip.load(\"ViT-L/14\", device=device)\n",
+    "\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",
+    "\n",
+    "all_per_correct = two_way_identification(all_recons, all_images,\n",
+    "                                        clip_model.encode_image, preprocess, None) # final layer\n",
+    "clip_ = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {clip_:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4fed9f8-ef1a-4c6d-a83f-2a934b6e87fd",
+   "metadata": {},
+   "source": [
+    "## Efficient Net"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "14143c0f-1b32-43ef-98d8-8ed458df4551",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Distance: 0.8597363629795817\n"
+     ]
+    }
+   ],
+   "source": [
+    "import scipy as sp\n",
+    "from torchvision.models import efficientnet_b1, EfficientNet_B1_Weights\n",
+    "weights = EfficientNet_B1_Weights.DEFAULT\n",
+    "eff_model = create_feature_extractor(efficientnet_b1(weights=weights), \n",
+    "                                    return_nodes=['avgpool'])\n",
+    "eff_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(255, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "gt = eff_model(preprocess(all_images))['avgpool']\n",
+    "gt = gt.reshape(len(gt),-1).cpu().numpy()\n",
+    "fake = eff_model(preprocess(all_recons))['avgpool']\n",
+    "fake = fake.reshape(len(fake),-1).cpu().numpy()\n",
+    "\n",
+    "effnet_nomean = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))])\n",
+    "effnet = effnet_nomean.mean()\n",
+    "print(\"Distance:\",effnet)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "405f669d-cab7-4c75-90cd-651283f65a9e",
+   "metadata": {},
+   "source": [
+    "## SwAV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "4c60b0c4-79fe-4cff-95e9-99733c821e67",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in /home/ri4541/.cache/torch/hub/facebookresearch_swav_main\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Distance: 0.5120611452768613\n"
+     ]
+    }
+   ],
+   "source": [
+    "swav_model = torch.hub.load('facebookresearch/swav:main', 'resnet50')\n",
+    "swav_model = create_feature_extractor(swav_model, \n",
+    "                                    return_nodes=['avgpool'])\n",
+    "swav_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "gt = swav_model(preprocess(all_images))['avgpool']\n",
+    "gt = gt.reshape(len(gt),-1).cpu().numpy()\n",
+    "fake = swav_model(preprocess(all_recons))['avgpool']\n",
+    "fake = fake.reshape(len(fake),-1).cpu().numpy()\n",
+    "\n",
+    "swav_nomean = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))])\n",
+    "swav = swav_nomean.mean()\n",
+    "print(\"Distance:\",swav)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "8ebeeff0-49ab-4bf5-9e12-dd45eb7ff71f",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "        0\n",
+      "  metrics\n",
+      "  0.80101\n",
+      " 0.854242\n",
+      " 0.720505\n",
+      " 0.738687\n",
+      " 0.859736\n",
+      " 0.512061\n",
+      "     0.71\n",
+      "      0.7\n",
+      "     0.89\n"
+     ]
+    },
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0/final_evals'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[36], line 13\u001b[0m\n\u001b[1;32m     11\u001b[0m final_evals_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00meval_dir\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/final_evals\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m saving:\n\u001b[0;32m---> 13\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mfinal_evals_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mw\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m     14\u001b[0m         f\u001b[38;5;241m.\u001b[39mwrite(df)\n\u001b[1;32m     15\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msaved final evals!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+      "File \u001b[0;32m~/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/IPython/core/interactiveshell.py:324\u001b[0m, in \u001b[0;36m_modified_open\u001b[0;34m(file, *args, **kwargs)\u001b[0m\n\u001b[1;32m    317\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[1;32m    318\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    319\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    320\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    321\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    322\u001b[0m     )\n\u001b[0;32m--> 324\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_ses-01_bs24_MST_paul_MSTsplit_random_seed_0/final_evals'"
+     ]
+    }
+   ],
+   "source": [
+    "#[pixcorr, ssim, alexnet2, alexnet5, inception, clip_, effnet, swav, percent_correct_fwd, percent_correct_bwd]\n",
+    "import pandas as pd\n",
+    "# pd.options.display.float_format = '{:.2%}'.format\n",
+    "# pd.reset_option('all')\n",
+    "if \"ses-0\" not in model_name:\n",
+    "    df = pd.DataFrame([\"metrics\", alexnet2, alexnet5, inception, clip_, effnet, swav, fwd_acc, bwd_acc, mst_score]).to_string(index=False)\n",
+    "else:\n",
+    "    df = pd.DataFrame([\"metrics\", alexnet2, alexnet5, inception, clip_, effnet, swav, all_fwd_acc[0], all_bwd_acc[0], mst_score]).to_string(index=False)\n",
+    "print(df)\n",
+    "# print(model_name_plus_suffix)\n",
+    "final_evals_path = f\"{eval_dir}/final_evals\"\n",
+    "if saving:\n",
+    "    with open(final_evals_path, 'w') as f:\n",
+    "        f.write(df)\n",
+    "    print('saved final evals!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0446fb2a-fd3f-451f-b9b2-38aa95a2be8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(final_evals_path, 'r') as f:\n",
+    "    for line in f:\n",
+    "        print(line, end='')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd74e27c-6d79-4d49-bcc9-f6b85fadc752",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

final_evaluations_sdxl_turbo.ipynb

@@ -0,0 +1,1837 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "7d5f265e-407a-40bd-92fb-a652091fd7ea",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n",
+      "LOCAL RANK  0\n",
+      "PID of this process = 73671\n",
+      "device: cuda\n",
+      "Distributed environment: DistributedType.NO\n",
+      "Num processes: 1\n",
+      "Process index: 0\n",
+      "Local process index: 0\n",
+      "Device: cuda\n",
+      "\n",
+      "Mixed precision type: fp16\n",
+      "\n",
+      "distributed = False num_devices = 1 local rank = 0 world size = 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('importing modules')\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import math\n",
+    "from einops import rearrange\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "import webdataset as wds\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "from accelerate import Accelerator, DeepSpeedPlugin\n",
+    "\n",
+    "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder\n",
+    "from models import GNet8_Encoder\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "# custom functions #\n",
+    "import utils\n",
+    "\n",
+    "### Multi-GPU config ###\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",
+    "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\") # ['no', 'fp8', 'fp16', 'bf16']\n",
+    "\n",
+    "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",
+    "if num_devices==0 or not distributed: num_devices = 1\n",
+    "num_workers = num_devices\n",
+    "print(accelerator.state)\n",
+    "\n",
+    "print(\"distributed =\",distributed, \"num_devices =\", num_devices, \"local rank =\", local_rank, \"world size =\", world_size)\n",
+    "print = accelerator.print # only print if local_rank=0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "1b8e8d9e-2931-4546-a2ce-a7417bbe21f4",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<utils.CLIPEncoder object at 0x7f56edac0710>\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load embedding model (last hidden layer)\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",
+    "from utils import CLIPEncoder\n",
+    "\n",
+    "try:\n",
+    "    print(clip_img_embedder)\n",
+    "except:\n",
+    "    clip_img_embedder = CLIPEncoder(\n",
+    "            model_name=\"ViT-H-14\",\n",
+    "            pretrained=\"laion2b_s32b_b79k\",\n",
+    "            precision=\"fp32\",\n",
+    "            batch_size=20,\n",
+    "            device=\"cuda\"\n",
+    "    )\n",
+    "\n",
+    "clip_seq_dim = 1\n",
+    "clip_emb_dim = 1024\n",
+    "\n",
+    "\n",
+    "## Load embedding model (last layer)\n",
+    "#     clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n",
+    "#         arch=\"ViT-bigG-14\",\n",
+    "#         version=\"laion2b_s39b_b160k\",\n",
+    "#         output_tokens=False,\n",
+    "#         only_tokens=False,\n",
+    "#     )\n",
+    "#     clip_img_embedder.to(device)\n",
+    "# clip_seq_dim = 1\n",
+    "# clip_emb_dim = 1280"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "1ffb659a-8154-4536-ab27-2d976da1bf4e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: testing_MST_ViT-H_1024_scalf\n",
+      "--model_name=testing_MST_ViT-H_1024_scalf --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --all_recons_path=/home/ubuntu/real_time_mindEye2/evals/testing_MST_ViT-H_1024_scalf/testing_MST_ViT-H_1024_scalf_all_recons.pt --eval_dir=/home/ubuntu/real_time_mindEye2/evals/testing_MST_ViT-H_1024_scalf\n",
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "plot_all = False\n",
+    "compute_circular = False  # for the circular tests looking at image similarity in clip space (without any brain data involved)\n",
+    "saving = True\n",
+    "\n",
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = f\"testing_MST_ViT-H_1024_scalf\"\n",
+    "    eval_dir = f\"/home/ubuntu/real_time_mindEye2/evals/{model_name}\" # f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/{model_name}\"\n",
+    "    if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "        all_recons_path = f\"{eval_dir}/all_recons.pt\"\n",
+    "    elif \"paul\" in model_name:\n",
+    "        all_recons_path = f\"evals/{model_name}/{model_name}_all_recons.pt\"\n",
+    "    else:\n",
+    "        all_recons_path = f\"{eval_dir}/{model_name}_all_recons.pt\" \n",
+    "\n",
+    "    data_path = \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2\"\n",
+    "    print(\"model_name:\", model_name)\n",
+    "\n",
+    "    jupyter_args = f\"--model_name={model_name} --data_path={data_path} --all_recons_path={all_recons_path} --eval_dir={eval_dir}\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()\n",
+    "    \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 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "fb8120cd-f226-4e2c-a6c5-3cd8ef6e9bc8",
+   "metadata": {
+    "tags": []
+   },
+   "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/mindeyev2_dataset\",\n",
+    "    help=\"Path to where NSD data is stored / where to download it to\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--all_recons_path\", type=str,\n",
+    "    help=\"Path to where all_recons.pt is stored\",\n",
+    ")\n",
+    "\n",
+    "parser.add_argument(\n",
+    "    \"--eval_dir\", type=str,\n",
+    "    help=\"Path to where evaluations should be stored\",\n",
+    ")\n",
+    "\n",
+    "parser.add_argument(\n",
+    "    \"--seed\",type=int,default=42,\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",
+    "# seed all random functions\n",
+    "utils.seed_everything(seed)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95d66b33-b327-4895-a861-ecc6ccc51296",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Evals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "be66f9c9-f25a-48d9-9e9a-272ab33d20ed",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([248, 3, 256, 256])\n",
+      "all_recons_path: /home/ubuntu/real_time_mindEye2/evals/testing_MST_ViT-H_1024_scalf/testing_MST_ViT-H_1024_scalf_all_recons.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "eval_captions = False\n",
+    "if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name:\n",
+    "    all_images = torch.load(f\"{eval_dir}/all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/all_clipvoxels.pt\")\n",
+    "    if eval_captions:\n",
+    "        all_predcaptions = torch.load(f\"{eval_dir}/all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/all_recons.pt\")\n",
+    "elif \"ses-01\" in model_name and \"paul\" in model_name:\n",
+    "    all_images = torch.load(f\"evals/{model_name}/{model_name}_all_images.pt\")\n",
+    "    all_clipvoxels = torch.load(f\"evals/{model_name}/{model_name}_all_clipvoxels.pt\")\n",
+    "    if eval_captions:\n",
+    "        all_predcaptions = torch.load(f\"evals/{model_name}/{model_name}_all_predcaptions.pt\")\n",
+    "    all_unrefinedrecons = torch.load(f\"evals/{model_name}/{model_name}_all_recons.pt\")\n",
+    "else:\n",
+    "    all_images = torch.load(f\"{eval_dir}/{model_name}_all_images.pt\") \n",
+    "    all_clipvoxels = torch.load(f\"{eval_dir}/{model_name}_all_clipvoxels.pt\") \n",
+    "    if eval_captions:\n",
+    "        all_predcaptions = torch.load(f\"{eval_dir}/{model_name}_all_predcaptions.pt\") \n",
+    "    all_unrefinedrecons = torch.load(f\"{eval_dir}/{model_name}_all_recons.pt\") \n",
+    "\n",
+    "print(all_images.shape)\n",
+    "print(\"all_recons_path:\", all_recons_path)\n",
+    "all_recons = torch.load(all_recons_path)\n",
+    "\n",
+    "# all_blurryrecons = torch.load(f\"{eval_dir}/all_blurryrecons.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "4b6c44f9-95ac-4bac-9fbf-d0b31f4f127f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if \"ses-01\" in model_name:\n",
+    "#     paul_all_images = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_images.pt\").to('cpu')\n",
+    "#     paul_all_clipvoxels = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_clipvoxels.pt\").to('cpu')\n",
+    "#     paul_all_recons = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_recons.pt\").to('cpu')\n",
+    "#     # paul_all_prior_out = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_prior_out.pt\").to('cpu')\n",
+    "#     # all_images = torch.load(f\"{eval_dir}/all_images.pt\") \n",
+    "#     print(paul_all_images.shape, all_images.shape)\n",
+    "#     print(paul_all_clipvoxels.shape, all_clipvoxels.shape)\n",
+    "#     print(torch.eq(paul_all_clipvoxels, all_clipvoxels))\n",
+    "#     # assert torch.allclose(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "e8f29ac6-6561-4770-8837-8877488dce05",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# for i in range(100):\n",
+    "#     # print(torch.allclose(paul_all_images[i], all_images[i]))\n",
+    "#     pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "a1382548-4b43-4101-a15b-e67b1225059c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# num_images = paul_all_images.size(0)\n",
+    "# rows = 10  # Number of rows for the grid\n",
+    "# cols = 10  # Number of columns for the grid\n",
+    "\n",
+    "# fig, axes = plt.subplots(rows, cols * 2, figsize=(80, 40))\n",
+    "\n",
+    "# for i in range(num_images):\n",
+    "#     row = i // cols\n",
+    "#     col = (i % cols) * 2  # Adjust for side-by-side\n",
+    "    \n",
+    "#     # Plot correct image\n",
+    "#     ax_correct = axes[row, col]\n",
+    "#     ax_correct.imshow(paul_all_recons[i].permute(1, 2, 0).cpu().numpy())\n",
+    "#     ax_correct.axis('off')\n",
+    "#     ax_correct.set_title(f\"Correct {i}\")\n",
+    "    \n",
+    "#     # Plot modified image\n",
+    "#     ax_modified = axes[row, col + 1]\n",
+    "#     ax_modified.imshow(all_recons[i].permute(1, 2, 0).cpu().numpy())\n",
+    "#     ax_modified.axis('off')\n",
+    "#     ax_modified.set_title(f\"Modified {i}\")\n",
+    "\n",
+    "# plt.tight_layout()\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "4cc551db-85c3-4696-a6fd-52b0092669eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "testing_MST_ViT-H_1024_scalf_all_recons.pt\n",
+      "torch.Size([248, 3, 256, 256]) torch.Size([248, 3, 256, 256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_name_plus_suffix = all_recons_path.split('/')[-1]\n",
+    "print(model_name_plus_suffix)\n",
+    "print(all_images.shape, all_recons.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "22e933c4-1eed-48a7-a22f-84a4606ac253",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "testing_MST_ViT-H_1024_scalf (31, 2) torch.Size([62, 3, 256, 256]) torch.Size([62, 1, 1024])\n"
+     ]
+    }
+   ],
+   "source": [
+    "if \"MST\" in model_name:\n",
+    "    if (\"remove\" in model_name and \"random\" in model_name) or \"ses-04\" in model_name or \"rishab\" in model_name:\n",
+    "        MST_ID = np.load(f\"{eval_dir}/MST_ID.npy\")\n",
+    "        MST_pairmate_indices = np.load(f\"{eval_dir}/MST_pairmate_indices.npy\")\n",
+    "    elif \"paul\" in model_name:\n",
+    "        MST_ID = np.load(f\"evals/{model_name}/{model_name}_MST_ID.npy\")\n",
+    "        MST_pairmate_indices = np.array(utils.find_paired_indices(torch.Tensor(MST_ID)))\n",
+    "        # print(MST_pairmate_indices)\n",
+    "    else:\n",
+    "        MST_ID = np.load(f\"{eval_dir}/{model_name}_MST_ID.npy\") \n",
+    "        MST_pairmate_indices = np.load(f\"{eval_dir}/{model_name}_MST_pairmate_indices.npy\") \n",
+    "\n",
+    "    # pairs = utils.find_paired_indices(torch.Tensor(MST_ID))\n",
+    "    # if \"close_to_MST\" in model_name or (\"remove\" in model_name and \"random\" in model_name) or \"ses-0\" in model_name:\n",
+    "    #     pairs = np.array(pairs[:-1])  # index out the placeholder\n",
+    "    # pairs = np.array(pairs)\n",
+    "    # if \"ses-0\" in model_name:\n",
+    "    #     if \"ses-01\" in model_name or \"ses-04\" in model_name:\n",
+    "    #         print(pairs.shape)\n",
+    "    #         assert pairs.shape == (49,2)\n",
+    "    #     else:\n",
+    "    #         assert pairs.shape == (50,3)\n",
+    "    # else:\n",
+    "    #     assert pairs.shape == (100,3)\n",
+    "    # print(pairs)\n",
+    "    # repeats_in_test = torch.load(f\"{eval_dir}/repeats_in_test.pt\")\n",
+    "    # test_image_indices = torch.load(f\"{eval_dir}/test_image_indices.pt\")\n",
+    "    all_unique_images = all_images[MST_pairmate_indices.flatten()]\n",
+    "    all_unique_clipvoxels = all_clipvoxels[MST_pairmate_indices.flatten()]\n",
+    "\n",
+    "    print(model_name, MST_pairmate_indices.shape, all_unique_images.shape, all_unique_clipvoxels.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "880081e4-7567-4b1e-acb0-4af863018228",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# visualize all unique images\n",
+    "if plot_all:\n",
+    "    # Plot all the MST images and pairmates\n",
+    "    import textwrap\n",
+    "    def wrap_title(title, wrap_width):\n",
+    "        return \"\\n\".join(textwrap.wrap(title, wrap_width))\n",
+    "\n",
+    "    size = int(np.ceil(MST_pairmate_indices.shape[0]/2))  # helps determine size of plot\n",
+    "    fig, axes = plt.subplots(size, 4, figsize=(15, size*4))\n",
+    "    jj=-1; kk=0;\n",
+    "    for i, j in enumerate(all_unique_images):\n",
+    "        jj+=1\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(j))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        if jj==3: \n",
+    "            kk+=1; jj=-1\n",
+    "\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/MST_2_pairmates_10-01')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "48c8772b-871a-4031-b013-d7159bf8b74a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# if plot_all:\n",
+    "#     # create full grid of recon comparisons\n",
+    "#     from PIL import Image\n",
+    "\n",
+    "#     imsize = 150\n",
+    "#     if all_images.shape[-1] != imsize:\n",
+    "#         all_images = transforms.Resize((imsize,imsize))(all_images).float()\n",
+    "#     if all_recons.shape[-1] != imsize:\n",
+    "#         all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n",
+    "\n",
+    "#     num_images = all_recons.shape[0]\n",
+    "#     num_rows = (2 * num_images + 9) // 10\n",
+    "\n",
+    "#     # Interleave tensors\n",
+    "#     merged = torch.stack([val for pair in zip(all_images, all_recons) for val in pair], dim=0)\n",
+    "\n",
+    "#     # Calculate grid size\n",
+    "#     grid = torch.zeros((num_rows * 10, 3, all_recons.shape[-1], all_recons.shape[-1]))\n",
+    "\n",
+    "#     # Populate the grid\n",
+    "#     grid[:2*num_images] = merged\n",
+    "#     grid_images = [transforms.functional.to_pil_image(grid[i]) for i in range(num_rows * 10)]\n",
+    "\n",
+    "#     # Create the grid image\n",
+    "#     grid_image = Image.new('RGB', (all_recons.shape[-1]*10, all_recons.shape[-1] * num_rows))  # 10 images wide\n",
+    "\n",
+    "#     # Paste images into the grid\n",
+    "#     for i, img in enumerate(grid_images):\n",
+    "#         grid_image.paste(img, (all_recons.shape[-1] * (i % 10), all_recons.shape[-1] * (i // 10)))\n",
+    "#     grid_image\n",
+    "#     # grid_image.save(f\"{model_name_plus_suffix[:-3]}_1000recons.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "f42009e9-f910-4f02-8db6-d46778aa6595",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "imsize = 256\n",
+    "if all_images.shape[-1] != imsize:\n",
+    "    all_images = transforms.Resize((imsize,imsize))(all_images).float()\n",
+    "if all_recons.shape[-1] != imsize:\n",
+    "    all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n",
+    "try:\n",
+    "    if all_blurryrecons.shape[-1] != imsize:\n",
+    "        all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float()\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "if \"enhanced\" in model_name_plus_suffix:\n",
+    "    try:\n",
+    "        all_recons = all_recons*.75 + all_blurryrecons*.25\n",
+    "        print(\"weighted averaging to improve low-level evals\")\n",
+    "    except:\n",
+    "        pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "06e23174-a777-4dd1-8b73-6783587d8f9c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# visualize some images with recons and captions\n",
+    "if plot_all:\n",
+    "    assert np.all(all_images.shape == all_recons.shape)\n",
+    "    import textwrap\n",
+    "    def wrap_title(title, wrap_width):\n",
+    "        return \"\\n\".join(textwrap.wrap(title, wrap_width))\n",
+    "\n",
+    "    fig, axes = plt.subplots(3, 4, figsize=(10, 8))\n",
+    "    jj=-1; kk=0;\n",
+    "    for j in np.array([0,1,2,3,4,5]):\n",
+    "        jj+=1\n",
+    "        # print(kk,jj)\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(all_images[j]))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        jj+=1\n",
+    "        axes[kk][jj].imshow(utils.torch_to_Image(all_recons[j]))\n",
+    "        axes[kk][jj].axis('off')\n",
+    "        axes[kk][jj].set_title(wrap_title(str(all_predcaptions[[j]]),wrap_width=30), fontsize=8)\n",
+    "        if jj==3: \n",
+    "            kk+=1; jj=-1\n",
+    "\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/recon_09-26')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b4deb53-4d85-4292-92c5-bb59077523cf",
+   "metadata": {},
+   "source": [
+    "# Retrieval eval (chance =  1/100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "2e49d57a-9b65-490c-a1e0-61bd05682171",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "overall fwd percent_correct: 0.0484\n",
+      "overall bwd percent_correct: 0.0161\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from scipy import stats\n",
+    "\n",
+    "all_fwd_acc = []\n",
+    "all_bwd_acc = []\n",
+    "\n",
+    "assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "all_percent_correct_fwds, all_percent_correct_bwds = [], []\n",
+    "\n",
+    "with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "    all_unique_images_resized = transforms.Resize((224,224))(all_unique_images).float() # embedder requires this shape\n",
+    "    all_emb = clip_img_embedder(all_unique_images_resized.to(device)).float() # CLIP-Image\n",
+    "    all_emb_ = all_unique_clipvoxels # CLIP-Brain\n",
+    "\n",
+    "    # flatten if necessary\n",
+    "    all_emb = all_emb.reshape(len(all_emb),-1).to(device)\n",
+    "    all_emb_ = all_emb_.reshape(len(all_emb_),-1).to(device)\n",
+    "\n",
+    "    # l2norm \n",
+    "    all_emb = nn.functional.normalize(all_emb,dim=-1)\n",
+    "    all_emb_ = nn.functional.normalize(all_emb_,dim=-1)\n",
+    "\n",
+    "    all_labels = torch.arange(len(all_emb)).to(device)\n",
+    "    all_bwd_sim = utils.batchwise_cosine_similarity(all_emb,all_emb_)  # clip, brain\n",
+    "    all_fwd_sim = utils.batchwise_cosine_similarity(all_emb_,all_emb)  # brain, clip\n",
+    "\n",
+    "    # if \"ses-0\" not in model_name or \"ses-01\" in model_name or \"ses-04\" in model_name:\n",
+    "    #     assert len(all_fwd_sim) == 100\n",
+    "    #     assert len(all_bwd_sim) == 100\n",
+    "    # else:\n",
+    "    #     assert len(all_fwd_sim) == 50\n",
+    "    #     assert len(all_bwd_sim) == 50\n",
+    "    \n",
+    "    all_percent_correct_fwds = utils.topk(all_fwd_sim, all_labels, k=1).item()\n",
+    "    all_percent_correct_bwds = utils.topk(all_bwd_sim, all_labels, k=1).item()\n",
+    "\n",
+    "all_fwd_acc.append(all_percent_correct_fwds)\n",
+    "all_bwd_acc.append(all_percent_correct_bwds)\n",
+    "\n",
+    "all_fwd_sim = np.array(all_fwd_sim.cpu())\n",
+    "all_bwd_sim = np.array(all_bwd_sim.cpu())\n",
+    "\n",
+    "print(f\"overall fwd percent_correct: {all_fwd_acc[0]:.4f}\")\n",
+    "print(f\"overall bwd percent_correct: {all_bwd_acc[0]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "1a4cda50-ef4a-43d0-9c2e-53ee8509482d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "The size of tensor a (325) must match the size of tensor b (257) at non-singleton dimension 1",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mRuntimeError\u001b[39m                              Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[55]\u001b[39m\u001b[32m, line 24\u001b[39m\n\u001b[32m     20\u001b[39m     all_unique_clipvoxels_half = all_unique_clipvoxels[\u001b[38;5;28mint\u001b[39m(\u001b[38;5;28mlen\u001b[39m(all_unique_clipvoxels)/\u001b[32m2\u001b[39m):]\n\u001b[32m     23\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m torch.cuda.amp.autocast(dtype=torch.float16):\n\u001b[32m---> \u001b[39m\u001b[32m24\u001b[39m     emb = \u001b[43mclip_img_embedder\u001b[49m\u001b[43m(\u001b[49m\u001b[43mall_unique_images_half\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m.float() \u001b[38;5;66;03m# CLIP-Image\u001b[39;00m\n\u001b[32m     25\u001b[39m     emb_ = all_unique_clipvoxels_half \u001b[38;5;66;03m# CLIP-Brain\u001b[39;00m\n\u001b[32m     27\u001b[39m     \u001b[38;5;66;03m# flatten if necessary\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/real_time_mindEye2/utils.py:1151\u001b[39m, in \u001b[36mCLIPEncoder.__call__\u001b[39m\u001b[34m(self, image)\u001b[39m\n\u001b[32m   1150\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, image):\n\u001b[32m-> \u001b[39m\u001b[32m1151\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mencode_image\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m.unsqueeze(\u001b[32m1\u001b[39m)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/real_time_mindEye2/utils.py:1142\u001b[39m, in \u001b[36mCLIPEncoder.encode_image\u001b[39m\u001b[34m(self, image, verbose)\u001b[39m\n\u001b[32m   1140\u001b[39m         batch_images = torch.stack(batch_images)\n\u001b[32m   1141\u001b[39m     \u001b[38;5;28;01mwith\u001b[39;00m torch.no_grad():\n\u001b[32m-> \u001b[39m\u001b[32m1142\u001b[39m         batch_features = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mencode_image\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m   1143\u001b[39m \u001b[43m            \u001b[49m\u001b[43mbatch_images\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1144\u001b[39m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1145\u001b[39m     features.append(batch_features)\n\u001b[32m   1147\u001b[39m features = torch.cat(features, dim=\u001b[32m0\u001b[39m)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/rt_mindEye2/lib/python3.11/site-packages/open_clip/model.py:266\u001b[39m, in \u001b[36mCLIP.encode_image\u001b[39m\u001b[34m(self, image, normalize)\u001b[39m\n\u001b[32m    265\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mencode_image\u001b[39m(\u001b[38;5;28mself\u001b[39m, image, normalize: \u001b[38;5;28mbool\u001b[39m = \u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[32m--> \u001b[39m\u001b[32m266\u001b[39m     features = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisual\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    267\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m F.normalize(features, dim=-\u001b[32m1\u001b[39m) \u001b[38;5;28;01mif\u001b[39;00m normalize \u001b[38;5;28;01melse\u001b[39;00m features\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/rt_mindEye2/lib/python3.11/site-packages/torch/nn/modules/module.py:1518\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1516\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m   1517\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1518\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/rt_mindEye2/lib/python3.11/site-packages/torch/nn/modules/module.py:1527\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1522\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m   1523\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m   1524\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m   1525\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m   1526\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1527\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1529\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m   1530\u001b[39m     result = \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/rt_mindEye2/lib/python3.11/site-packages/open_clip/transformer.py:616\u001b[39m, in \u001b[36mVisionTransformer.forward\u001b[39m\u001b[34m(self, x)\u001b[39m\n\u001b[32m    614\u001b[39m x = torch.cat([_expand_token(\u001b[38;5;28mself\u001b[39m.class_embedding, x.shape[\u001b[32m0\u001b[39m]).to(x.dtype), x], dim=\u001b[32m1\u001b[39m)\n\u001b[32m    615\u001b[39m \u001b[38;5;66;03m# shape = [*, grid ** 2 + 1, width]\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m616\u001b[39m x = \u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpositional_embedding\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    618\u001b[39m x = \u001b[38;5;28mself\u001b[39m.patch_dropout(x)\n\u001b[32m    619\u001b[39m x = \u001b[38;5;28mself\u001b[39m.ln_pre(x)\n",
+      "\u001b[31mRuntimeError\u001b[39m: The size of tensor a (325) must match the size of tensor b (257) at non-singleton dimension 1"
+     ]
+    }
+   ],
+   "source": [
+    "if \"ses-0\" not in model_name:\n",
+    "    from scipy import stats\n",
+    "\n",
+    "    fwd_acc = []\n",
+    "    bwd_acc = []\n",
+    "    fwd_sim_halves = []\n",
+    "    bwd_sim_halves = []\n",
+    "\n",
+    "    assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "    for i in range(2):  # since this is a 2-session model, we evaluate on the test set corresponding to each session and report both separately for better comparison to single-session models\n",
+    "        percent_correct_fwds, percent_correct_bwds = [], []\n",
+    "        # percent_correct_fwd, percent_correct_bwd = None, None\n",
+    "\n",
+    "        if i==0:  \n",
+    "            all_unique_images_half = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "            all_unique_clipvoxels_half = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "        elif i==1:\n",
+    "            all_unique_images_half = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "            all_unique_clipvoxels_half = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "\n",
+    "\n",
+    "        with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "            emb = clip_img_embedder(all_unique_images_half.to(device)).float() # CLIP-Image\n",
+    "            emb_ = all_unique_clipvoxels_half # CLIP-Brain\n",
+    "\n",
+    "            # flatten if necessary\n",
+    "            emb = emb.reshape(len(emb),-1).to(device)\n",
+    "            emb_ = emb_.reshape(len(emb_),-1).to(device)\n",
+    "\n",
+    "            # l2norm \n",
+    "            emb = nn.functional.normalize(emb,dim=-1)\n",
+    "            emb_ = nn.functional.normalize(emb_,dim=-1)\n",
+    "\n",
+    "            labels = torch.arange(len(emb)).to(device)\n",
+    "            bwd_sim = utils.batchwise_cosine_similarity(emb,emb_)  # clip, brain\n",
+    "            fwd_sim = utils.batchwise_cosine_similarity(emb_,emb)  # brain, clip\n",
+    "\n",
+    "            assert len(fwd_sim) == 50\n",
+    "            assert len(bwd_sim) == 50\n",
+    "\n",
+    "            # percent_correct_fwds = np.append(percent_correct_fwds, utils.topk(fwd_sim, labels, k=1).item())\n",
+    "            # percent_correct_bwds = np.append(percent_correct_bwds, utils.topk(bwd_sim, labels, k=1).item())\n",
+    "            percent_correct_fwds = utils.topk(fwd_sim, labels, k=1).item()\n",
+    "            percent_correct_bwds = utils.topk(bwd_sim, labels, k=1).item()\n",
+    "\n",
+    "        # percent_correct_fwd = np.mean(percent_correct_fwds)\n",
+    "        # fwd_sd = np.std(percent_correct_fwds) / np.sqrt(len(percent_correct_fwds))\n",
+    "        # fwd_ci = stats.norm.interval(0.95, loc=percent_correct_fwd, scale=fwd_sd)\n",
+    "\n",
+    "        # percent_correct_bwd = np.mean(percent_correct_bwds)\n",
+    "        # bwd_sd = np.std(percent_correct_bwds) / np.sqrt(len(percent_correct_bwds))\n",
+    "        # bwd_ci = stats.norm.interval(0.95, loc=percent_correct_bwd, scale=bwd_sd)\n",
+    "\n",
+    "        fwd_acc.append(percent_correct_fwds)\n",
+    "        bwd_acc.append(percent_correct_bwds)\n",
+    "\n",
+    "        fwd_sim = np.array(fwd_sim.cpu())\n",
+    "        bwd_sim = np.array(bwd_sim.cpu())\n",
+    "        fwd_sim_halves.append(fwd_sim)\n",
+    "        bwd_sim_halves.append(bwd_sim)\n",
+    "\n",
+    "    print(f\"ses-02 fwd percent_correct: {fwd_acc[0]:.4f}; ses-03 fwd percent_correct: {fwd_acc[1]:.4f}\")\n",
+    "    print(f\"ses-02 bwd percent_correct: {bwd_acc[0]:.4f}; ses-03 bwd percent_correct: {bwd_acc[1]:.4f} \")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "40d43a70-e1db-43e5-ae84-40eb1577cf01",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    if \"ses-0\" not in model_name:  # we're in a multisession model, assumed ses-02 and ses-03 for now\n",
+    "        fwd_acc_circular = []\n",
+    "        fwd_sim_halves_circular = []\n",
+    "\n",
+    "        assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "        for i in range(2):  # since this is a 2-session model, we evaluate on the test set corresponding to each session and report both separately for better comparison to single-session models\n",
+    "            percent_correct_fwds_circular = []\n",
+    "            # percent_correct_fwd_circular = None\n",
+    "\n",
+    "            if i==0:  \n",
+    "                all_unique_images_half_circular = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                all_unique_clipvoxels_half_circular = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "            elif i==1:\n",
+    "                all_unique_images_half_circular = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                all_unique_clipvoxels_half_circular = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "\n",
+    "            with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "                emb_circular = clip_img_embedder(all_unique_images_half_circular.to(device)).float() # CLIP-Image\n",
+    "\n",
+    "                # flatten if necessary\n",
+    "                emb_circular = emb_circular.reshape(len(emb_circular),-1).to(device)\n",
+    "\n",
+    "                # l2norm \n",
+    "                emb_circular = nn.functional.normalize(emb_circular,dim=-1)\n",
+    "\n",
+    "                labels_circular = torch.arange(len(emb_circular)).to(device)\n",
+    "                fwd_sim_circular = utils.batchwise_cosine_similarity(emb_circular,emb_circular)  # clip, clip\n",
+    "\n",
+    "\n",
+    "                if \"ses-0\" in model_name:\n",
+    "                    assert len(fwd_sim_circular) == 25\n",
+    "                else:\n",
+    "                    assert len(fwd_sim_circular) == 50\n",
+    "\n",
+    "                # percent_correct_fwds_circular = np.append(percent_correct_fwds_circular, utils.topk(fwd_sim_circular, labels_circular, k=1).item())\n",
+    "                percent_correct_fwds_circular = utils.topk(fwd_sim_circular, labels_circular, k=1).item()\n",
+    "\n",
+    "\n",
+    "            # percent_correct_fwd_circular = np.mean(percent_correct_fwds_circular)\n",
+    "            # fwd_sd_circular = np.std(percent_correct_fwds_circular) / np.sqrt(len(percent_correct_fwds_circular))\n",
+    "            # fwd_ci_circular = stats.norm.interval(0.95, loc=percent_correct_fwd_circular, scale=fwd_sd_circular)\n",
+    "\n",
+    "            fwd_acc_circular.append(percent_correct_fwds_circular)\n",
+    "\n",
+    "            fwd_sim_circular = np.array(fwd_sim_circular.cpu())\n",
+    "            fwd_sim_halves_circular.append(fwd_sim_circular)\n",
+    "\n",
+    "        print(f\"ses-02 fwd percent_correct: {fwd_acc_circular[0]:.4f}; ses-03 fwd percent_correct: {fwd_acc_circular[1]:.4f}\")\n",
+    "    \n",
+    "    else:  # single session model\n",
+    "        fwd_acc_circular = []\n",
+    "\n",
+    "        assert len(all_unique_images) == len(all_unique_clipvoxels)  \n",
+    "\n",
+    "        percent_correct_fwds_circular = []\n",
+    "        # percent_correct_fwd_circular = None\n",
+    "\n",
+    "        with torch.cuda.amp.autocast(dtype=torch.float16):\n",
+    "            emb_circular = clip_img_embedder(all_unique_images.to(device)).float() # CLIP-Image\n",
+    "\n",
+    "            # flatten if necessary\n",
+    "            emb_circular = emb_circular.reshape(len(emb_circular),-1).to(device)\n",
+    "\n",
+    "            # l2norm \n",
+    "            emb_circular = nn.functional.normalize(emb_circular,dim=-1)\n",
+    "\n",
+    "            labels_circular = torch.arange(len(emb_circular)).to(device)\n",
+    "            fwd_sim_circular = utils.batchwise_cosine_similarity(emb_circular,emb_circular)  # clip, clip\n",
+    "\n",
+    "\n",
+    "            if \"ses-01\" in model_name:\n",
+    "                assert len(fwd_sim_circular) == 100\n",
+    "            else:\n",
+    "                assert len(fwd_sim_circular) == 50\n",
+    "\n",
+    "            # percent_correct_fwds_circular = np.append(percent_correct_fwds_circular, utils.topk(fwd_sim_circular, labels_circular, k=1).item())\n",
+    "            percent_correct_fwds_circular = utils.topk(fwd_sim_circular, labels_circular, k=1).item()\n",
+    "\n",
+    "\n",
+    "        # percent_correct_fwd_circular = np.mean(percent_correct_fwds_circular)\n",
+    "        # fwd_sd_circular = np.std(percent_correct_fwds_circular) / np.sqrt(len(percent_correct_fwds_circular))\n",
+    "        # fwd_ci_circular = stats.norm.interval(0.95, loc=percent_correct_fwd_circular, scale=fwd_sd_circular)\n",
+    "\n",
+    "        fwd_acc_circular.append(percent_correct_fwds_circular)\n",
+    "\n",
+    "        fwd_sim_circular = np.array(fwd_sim_circular.cpu())\n",
+    "\n",
+    "        print(f\"session fwd percent_correct (circular): {fwd_acc_circular[0]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "d086c99a-c712-4ac7-b625-a0656c9ee886",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    # print(utils.topk(torch.Tensor(fwd_sim_halves[1]).to(device), labels, k=1).item())\n",
+    "    # ses02_top1 = torch.argsort(torch.Tensor(fwd_sim_halves[0]).to(device),axis=1)[:,-1] == labels  # from utils.topk()\n",
+    "    # ses03_top1 = torch.argsort(torch.Tensor(fwd_sim_halves[1]).to(device),axis=1)[:,-1] == labels\n",
+    "    # top1_results = torch.cat((ses02_top1, ses03_top1))\n",
+    "    # incorrect_idx = torch.argwhere(top1_results == False)[:,0]\n",
+    "    # print(incorrect_idx)\n",
+    "\n",
+    "    # confirm that the lure is behind the target 80% of the time in CLIP last hidden layer embeddings\n",
+    "\n",
+    "    use_fwd_sim = False\n",
+    "    use_first_half = False\n",
+    "\n",
+    "    all_top_sims = []  # len(fwd_sim_halves[0]); for each image, contains the similarity to the top-n choices until it gets the correct answer. If len 1, top-1 is correct\n",
+    "    all_pairmate_sims = []  # len(fwd_sim_halves[0]); the similarity of each image to its pairmate \n",
+    "    all_chose_lures = []  # len(fwd_sim_halves[0]); True for each top-n choice if the lure was predicted to be more similar to the target \n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        sim_halves = fwd_sim_halves if use_fwd_sim else bwd_sim_halves\n",
+    "        sim_halves = sim_halves[0] if use_first_half else sim_halves[1]\n",
+    "    else:\n",
+    "        sim_halves = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "    for i, img in enumerate(sim_halves):\n",
+    "        if i%2==0:\n",
+    "            idx_to_pairmate = 1\n",
+    "        elif i%2==1:\n",
+    "            idx_to_pairmate = -1\n",
+    "\n",
+    "        order = img.argsort()[::-1]\n",
+    "        # print(order)\n",
+    "        top_sim = []\n",
+    "        chose_lure = []\n",
+    "        for idx in order:\n",
+    "            sim = img[idx]\n",
+    "            pairmate_sim = img[i+idx_to_pairmate]\n",
+    "            top_sim.append(sim) \n",
+    "            chose_lure.append((idx, sim <= pairmate_sim))\n",
+    "            # print(i, idx, img[idx], img[i+idx_to_pairmate])\n",
+    "            if idx == i:\n",
+    "                break\n",
+    "\n",
+    "        all_top_sims.append(top_sim)\n",
+    "        all_pairmate_sims.append(pairmate_sim)\n",
+    "        all_chose_lures.append(chose_lure)\n",
+    "\n",
+    "    # print(all_top_sims)\n",
+    "    # print()\n",
+    "    # print(all_pairmate_sims)\n",
+    "    # print()\n",
+    "    # print(all_chose_lures)\n",
+    "\n",
+    "    where_chose_pairmate = []\n",
+    "    for idx, i in enumerate(all_chose_lures):\n",
+    "        for value in i:\n",
+    "            # print(value[1])\n",
+    "            if value[1] == True:\n",
+    "                # print(idx, i, end='\\n')\n",
+    "                where_chose_pairmate.append(idx)\n",
+    "                break\n",
+    "\n",
+    "    # where_chose_pairmate  # trials where the pairmate was chosen ahead of the target"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "a5c4405c-b3b7-42fe-b622-f4cb81500464",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# top-n predictions using CLIP brain embeddings\n",
+    "\n",
+    "if plot_all:\n",
+    "    use_fwd_sim = True\n",
+    "    top_n = 10  # how many of the top n images to display\n",
+    "    print(\"Given Brain embedding, find correct Image embedding\")\n",
+    "    fig, ax = plt.subplots(nrows=len(all_unique_images), ncols=top_n+1, figsize=(top_n*2,len(all_unique_images)*2))\n",
+    "    for trial in range(len(all_unique_images)):\n",
+    "        ax[trial, 0].imshow(utils.torch_to_Image(all_unique_images[trial]))\n",
+    "        ax[trial, 0].set_title(\"original\\nimage\")\n",
+    "        ax[trial, 0].axis(\"off\")\n",
+    "        for attempt in range(top_n):\n",
+    "            if trial < 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_half = fwd_sim_halves[0] if use_fwd_sim else bwd_sim_halves[0]\n",
+    "                    unique_imgs_to_plot = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels[:int(len(all_unique_clipvoxels)/2)]\n",
+    "                else:\n",
+    "                    sim_half = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "                    unique_imgs_to_plot = all_unique_images\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels\n",
+    "                which = np.flip(np.argsort(sim_half[trial]))[attempt]\n",
+    "\n",
+    "            elif trial >= 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_halves = fwd_sim_halves[1] if use_fwd_sim else bwd_sim_halves[1]\n",
+    "                    unique_imgs_to_plot = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels[int(len(all_unique_clipvoxels)/2):]\n",
+    "                else:\n",
+    "                    sim_halves = all_fwd_sim if use_fwd_sim else all_bwd_sim\n",
+    "                    unique_imgs_to_plot = all_unique_images\n",
+    "                    # unique_clipvoxels_to_plot = all_unique_clipvoxels\n",
+    "                which = np.flip(np.argsort(sim_half[trial-50]))[attempt]\n",
+    "\n",
+    "            ax[trial, attempt+1].imshow(utils.torch_to_Image(unique_imgs_to_plot[which]))\n",
+    "            ax[trial, attempt+1].set_title(f\"Top {attempt+1}\")\n",
+    "            ax[trial, attempt+1].axis(\"off\")\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/retrieval_top10')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "05df72ce-3cdb-4ad2-a790-0835a41fb0f6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# similarity of each unique MST image to all others using CLIP image embeddings only (top-1 is guaranteed to be correct)\n",
+    "# uses last hidden layer (which may not match as well as the last layer to human semantic judgments)\n",
+    "if plot_all and compute_circular:\n",
+    "    print(\"Given Brain embedding, find correct Image embedding\")\n",
+    "    top_n = 10  # how many of the top n images to display\n",
+    "    fig, ax = plt.subplots(nrows=len(all_unique_images), ncols=top_n+1, figsize=(top_n*2,len(all_unique_images)*2))\n",
+    "    for trial in range(len(all_unique_images)):\n",
+    "        ax[trial, 0].imshow(utils.torch_to_Image(all_unique_images[trial]))\n",
+    "        ax[trial, 0].set_title(\"original\\nimage\")\n",
+    "        ax[trial, 0].axis(\"off\")\n",
+    "        for attempt in range(10):\n",
+    "            if trial < 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_half_circular = fwd_sim_halves_circular[0]\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images[:int(len(all_unique_images)/2)]\n",
+    "                else:\n",
+    "                    sim_half_circular = fwd_sim_circular\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images\n",
+    "                which_circular = np.flip(np.argsort(sim_half_circular[trial]))[attempt]\n",
+    "\n",
+    "            elif trial >= 50:\n",
+    "                if \"ses-0\" not in model_name:\n",
+    "                    sim_halves_circular = fwd_sim_halves_circular[1]\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images[int(len(all_unique_images)/2):]\n",
+    "                else:\n",
+    "                    sim_halves_circular = all_fwd_sim_circular\n",
+    "                    unique_imgs_to_plot_circular = all_unique_images\n",
+    "                which_circular = np.flip(np.argsort(sim_half_circular[trial-50]))[attempt]\n",
+    "\n",
+    "            ax[trial, attempt+1].imshow(utils.torch_to_Image(unique_imgs_to_plot_circular[which_circular]))\n",
+    "            ax[trial, attempt+1].set_title(f\"Top {attempt+1}\")\n",
+    "            ax[trial, attempt+1].axis(\"off\")\n",
+    "    fig.tight_layout()\n",
+    "    # plt.savefig('figures/circular_top10')\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d404dec-5336-45cf-8932-833e895a9ebe",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## MST Paired Retrieval (chance = 50%)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "06667f7d-a356-4c30-8e1b-06ebd7ff1752",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if compute_circular:\n",
+    "    all_top_sims_circular = []  # len(fwd_sim_halves[0]); for each image, contains the similarity to the top-n choices until it gets the correct answer. If len 1, top-1 is correct\n",
+    "    all_pairmate_sims_circular = []  # len(fwd_sim_halves[0]); the similarity of each image to its pairmate \n",
+    "    all_chose_lures_circular = []  # len(fwd_sim_halves[0]); True for each top-n choice if the lure was predicted to be more similar to the target \n",
+    "\n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        first_half = True\n",
+    "        sim_halves_circular = fwd_sim_halves_circular\n",
+    "        sim_halves_circular = sim_halves_circular[0] if use_first_half else sim_halves_circular[1]\n",
+    "    else:\n",
+    "        sim_halves_circular = all_fwd_sim_circular\n",
+    "    for i, img in enumerate(sim_halves_circular):\n",
+    "        if i%2==0:\n",
+    "            idx_to_pairmate = 1\n",
+    "        elif i%2==1:\n",
+    "            idx_to_pairmate = -1\n",
+    "\n",
+    "        order_circular = img.argsort()[::-1]\n",
+    "        # print(order)\n",
+    "        top_sim_circular = []\n",
+    "        chose_lure_circular = []\n",
+    "        for idx in order_circular:\n",
+    "            sim_circular = img[idx]\n",
+    "            pairmate_sim_circular = img[i+idx_to_pairmate]\n",
+    "            top_sim_circular.append(sim_circular) \n",
+    "            chose_lure_circular.append((idx, sim_circular <= pairmate_sim_circular))\n",
+    "            # print(i, idx, img[idx], img[i+idx_to_pairmate])\n",
+    "            if idx == i:\n",
+    "                break\n",
+    "\n",
+    "        all_top_sims_circular.append(top_sim_circular)\n",
+    "        all_pairmate_sims_circular.append(pairmate_sim_circular)\n",
+    "        all_chose_lures_circular.append(chose_lure_circular)\n",
+    "\n",
+    "    bot_half = (all_pairmate_sims_circular < np.median(all_pairmate_sims_circular))[::2]  # every other one since the sims are symmetric\n",
+    "    top_half = (all_pairmate_sims_circular > np.median(all_pairmate_sims_circular))[::2]\n",
+    "\n",
+    "    binary_acc = []\n",
+    "    for i,(a,b) in enumerate(tqdm(MST_pairmate_indices,total=len(MST_pairmate_indices))):\n",
+    "        # print(i,a,b)\n",
+    "        with torch.no_grad():\n",
+    "            with torch.cuda.amp.autocast():\n",
+    "                emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "        with torch.no_grad():\n",
+    "            with torch.cuda.amp.autocast():\n",
+    "                emb_a = nn.functional.normalize(clip_img_embedder(all_images[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_b = nn.functional.normalize(clip_img_embedder(all_images[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                binary_acc.append(a_sim < b_sim)\n",
+    "\n",
+    "    assert len(binary_acc) == 50\n",
+    "    mst_score = np.mean(binary_acc)\n",
+    "    print(f\"session score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "3468021c-660d-4205-8e5d-d75f6f3c2881",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test = np.sort(MST_pairmate_indices, axis=1)\n",
+    "# test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "a032c4cc-4cf9-4b33-ac02-0e569f7757be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model_name"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "130bb4d9-b7f1-40a4-a3e2-7e3699c69c49",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# paul_all_images = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_images.pt\").to('cpu')\n",
+    "# paul_all_clipvoxels = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_clipvoxels.pt\").to('cpu')\n",
+    "# paul_all_recons = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_recons.pt\").to('cpu')\n",
+    "# paul_all_prior_out = torch.load(f\"evals/sub-001_ses-01_bs24_MST_paul_MSTsplit/sub-001_ses-01_bs24_MST_paul_MSTsplit_all_prior_out.pt\").to('cpu')\n",
+    "# print(paul_all_images.shape, all_images.shape)\n",
+    "# # assert torch.eq(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "698ffc2c-5653-49d3-9d16-38a32f9e7f6b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# print(paul_all_images.shape, all_images.shape)\n",
+    "# torch.eq(paul_all_images, all_images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "23f26846-3170-4c91-a8e3-f98322e90dc0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "assuming ses-02+ses-03 multisession model\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 15/15 [00:03<00:00,  4.28it/s]\n"
+     ]
+    },
+    {
+     "ename": "AssertionError",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mAssertionError\u001b[39m                            Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[65]\u001b[39m\u001b[32m, line 36\u001b[39m\n\u001b[32m     32\u001b[39m             b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n\u001b[32m     34\u001b[39m             binary_acc.append(a_sim < b_sim)\n\u001b[32m---> \u001b[39m\u001b[32m36\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(binary_acc) == \u001b[32m50\u001b[39m  \u001b[38;5;66;03m# don't want to average across both sessions; make sure it resets\u001b[39;00m\n\u001b[32m     37\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mses-0\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mhalf+\u001b[32m2\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m score: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp.mean(binary_acc)\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp.std(binary_acc)\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m     38\u001b[39m mst_score.append((np.mean(binary_acc),np.std(binary_acc)))\n",
+      "\u001b[31mAssertionError\u001b[39m: "
+     ]
+    }
+   ],
+   "source": [
+    "all_images_resized = transforms.Resize((224,224))(all_images).float()\n",
+    "if \"MST\" in model_name:\n",
+    "    if \"ses-0\" not in model_name:\n",
+    "        print('assuming ses-02+ses-03 multisession model')\n",
+    "        mst_score = []\n",
+    "        for half in range(2):\n",
+    "            binary_acc = []\n",
+    "            if half==0:\n",
+    "                MST_pairmate_indices_half = MST_pairmate_indices[:int(len(MST_pairmate_indices)/2)]\n",
+    "            elif half==1:\n",
+    "                MST_pairmate_indices_half = MST_pairmate_indices[int(len(MST_pairmate_indices)/2):]\n",
+    "            for i,(a,b) in enumerate(tqdm(MST_pairmate_indices_half,total=len(MST_pairmate_indices_half))):\n",
+    "                # print(i,a,b)\n",
+    "                with torch.no_grad():\n",
+    "                    with torch.cuda.amp.autocast():\n",
+    "                        emb_a = nn.functional.normalize(clip_img_embedder(all_images_resized[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_b = nn.functional.normalize(clip_img_embedder(all_images_resized[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                        a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                        b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                        binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "                with torch.no_grad():\n",
+    "                    with torch.cuda.amp.autocast():\n",
+    "                        emb_a = nn.functional.normalize(clip_img_embedder(all_images_resized[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_b = nn.functional.normalize(clip_img_embedder(all_images_resized[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                        emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                        a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                        b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                        binary_acc.append(a_sim < b_sim)\n",
+    "\n",
+    "            assert len(binary_acc) == 50  # don't want to average across both sessions; make sure it resets\n",
+    "            print(f\"ses-0{half+2} score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n",
+    "            mst_score.append((np.mean(binary_acc),np.std(binary_acc)))\n",
+    "\n",
+    "        # print(mst_score)\n",
+    "    else:\n",
+    "        print('assuming single session')\n",
+    "        binary_acc = []\n",
+    "        for i,(a,b) in enumerate(tqdm(MST_pairmate_indices,total=len(MST_pairmate_indices))):\n",
+    "            # print(i,a,b)\n",
+    "            with torch.no_grad():\n",
+    "                with torch.cuda.amp.autocast():\n",
+    "                    emb_a = nn.functional.normalize(clip_img_embedder(all_images_resized[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_b = nn.functional.normalize(clip_img_embedder(all_images_resized[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_v = nn.functional.normalize(all_clipvoxels[[a]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                    a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                    b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                    binary_acc.append(a_sim > b_sim)\n",
+    "\n",
+    "            with torch.no_grad():\n",
+    "                with torch.cuda.amp.autocast():\n",
+    "                    emb_a = nn.functional.normalize(clip_img_embedder(all_images_resized[[a]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_b = nn.functional.normalize(clip_img_embedder(all_images_resized[[b]].to(device)).float().flatten(1),dim=-1)\n",
+    "                    emb_v = nn.functional.normalize(all_clipvoxels[[b]].flatten(1),dim=-1).to(device)\n",
+    "\n",
+    "                    a_sim = utils.pairwise_cosine_similarity(emb_v, emb_a).item()\n",
+    "                    b_sim = utils.pairwise_cosine_similarity(emb_v, emb_b).item()\n",
+    "\n",
+    "                    binary_acc.append(a_sim < b_sim)\n",
+    "                    \n",
+    "        # assert len(binary_acc) == 50\n",
+    "        mst_score = np.mean(binary_acc)\n",
+    "        print(f\"session score: {np.mean(binary_acc):.4f} ± {np.std(binary_acc):.4f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a26e124-2444-434d-a399-d03c2c90cc08",
+   "metadata": {},
+   "source": [
+    "## 2-way identification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "3e1778ff-5d6a-4087-b59f-0f44b9e0eada",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from torchvision.models.feature_extraction import create_feature_extractor, get_graph_node_names\n",
+    "\n",
+    "@torch.no_grad()\n",
+    "def two_way_identification(all_recons, all_images, model, preprocess, feature_layer=None, return_avg=True):\n",
+    "    preds = model(torch.stack([preprocess(recon) for recon in all_recons], dim=0).to(device))\n",
+    "    reals = model(torch.stack([preprocess(indiv) for indiv in all_images], dim=0).to(device))\n",
+    "    if feature_layer is None:\n",
+    "        preds = preds.float().flatten(1).cpu().numpy()\n",
+    "        reals = reals.float().flatten(1).cpu().numpy()\n",
+    "    else:\n",
+    "        preds = preds[feature_layer].float().flatten(1).cpu().numpy()\n",
+    "        reals = reals[feature_layer].float().flatten(1).cpu().numpy()\n",
+    "\n",
+    "    r = np.corrcoef(reals, preds)\n",
+    "    r = r[:len(all_images), len(all_images):]\n",
+    "    congruents = np.diag(r)\n",
+    "\n",
+    "    success = r < congruents\n",
+    "    success_cnt = np.sum(success, 0)\n",
+    "\n",
+    "    if return_avg:\n",
+    "        perf = np.mean(success_cnt) / (len(all_images)-1)\n",
+    "        return perf\n",
+    "    else:\n",
+    "        return success_cnt, len(all_images)-1\n",
+    "    \n",
+    "all_recons=all_recons.to(device)\n",
+    "all_images=all_images.to(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df6be966-52ef-4cf6-8078-8d2d9617564b",
+   "metadata": {},
+   "source": [
+    "## PixCorr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "2e17ea38-a254-4e90-a910-711734fdd8eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([248, 541875])\n",
+      "torch.Size([248, 541875])\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 248/248 [00:01<00:00, 133.19it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.05185274977219404\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "])\n",
+    "\n",
+    "# Flatten images while keeping the batch dimension\n",
+    "all_images_flattened = preprocess(all_images).reshape(len(all_images), -1).cpu()\n",
+    "all_recons_flattened = preprocess(all_recons).view(len(all_recons), -1).cpu()\n",
+    "\n",
+    "print(all_images_flattened.shape)\n",
+    "print(all_recons_flattened.shape)\n",
+    "\n",
+    "corr_stack = []\n",
+    "\n",
+    "corrsum = 0\n",
+    "for i in tqdm(range(len(all_images))):\n",
+    "    corrcoef = np.corrcoef(all_images_flattened[i], all_recons_flattened[i])[0][1]\n",
+    "    if np.isnan(corrcoef):\n",
+    "        print(\"WARNING: CORRCOEF WAS NAN\")\n",
+    "        corrcoef = 0\n",
+    "    corrsum += corrcoef\n",
+    "    corr_stack.append(corrcoef)\n",
+    "corrmean = corrsum / len(all_images)\n",
+    "\n",
+    "pixcorr = corrmean\n",
+    "print(pixcorr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "id": "7e2cd891-db44-475d-a8c6-ab345eaa58f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# print(all_images.shape)\n",
+    "# print(all_images_flattened.shape)\n",
+    "# print(all_recons.shape)\n",
+    "# print(all_recons_flattened.shape)\n",
+    "# len(all_images)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a556d5b-33a2-44aa-b48d-4b168316bbdd",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## SSIM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "id": "2326fc4c-1248-4d0f-9176-218c6460f285",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "converted, now calculating ssim...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 248/248 [00:03<00:00, 69.48it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.4141594942526016\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# see https://github.com/zijin-gu/meshconv-decoding/issues/3\n",
+    "from skimage.color import rgb2gray\n",
+    "from skimage.metrics import structural_similarity as ssim\n",
+    "\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR), \n",
+    "])\n",
+    "\n",
+    "# convert image to grayscale with rgb2grey\n",
+    "img_gray = rgb2gray(preprocess(all_images).permute((0,2,3,1)).cpu())\n",
+    "recon_gray = rgb2gray(preprocess(all_recons).permute((0,2,3,1)).cpu())\n",
+    "print(\"converted, now calculating ssim...\")\n",
+    "\n",
+    "ssim_score=[]\n",
+    "for im,rec in tqdm(zip(img_gray,recon_gray),total=len(all_images)):\n",
+    "    ssim_score.append(ssim(rec, im, multichannel=True, gaussian_weights=True, sigma=1.5, use_sample_covariance=False, data_range=1.0))\n",
+    "\n",
+    "ssim = np.mean(ssim_score)\n",
+    "print(ssim)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35138520-ec00-48a6-90dc-249a32a783d2",
+   "metadata": {},
+   "source": [
+    "## AlexNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "id": "3b45cc6c-ab80-43e2-b446-c8fcb4fc54e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "---early, AlexNet(2)---\n",
+      "2-way Percent Correct: 0.5106\n",
+      "\n",
+      "---mid, AlexNet(5)---\n",
+      "2-way Percent Correct: 0.4975\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchvision.models import alexnet, AlexNet_Weights\n",
+    "alex_weights = AlexNet_Weights.IMAGENET1K_V1\n",
+    "\n",
+    "alex_model = create_feature_extractor(alexnet(weights=alex_weights), return_nodes=['features.4','features.11']).to(device)\n",
+    "alex_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see alex_weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(256, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "layer = 'early, AlexNet(2)'\n",
+    "print(f\"\\n---{layer}---\")\n",
+    "all_per_correct = two_way_identification(all_recons, all_images, \n",
+    "                                                          alex_model, preprocess, 'features.4')\n",
+    "alexnet2 = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {alexnet2:.4f}\")\n",
+    "\n",
+    "layer = 'mid, AlexNet(5)'\n",
+    "print(f\"\\n---{layer}---\")\n",
+    "all_per_correct = two_way_identification(all_recons, all_images, \n",
+    "                                                          alex_model, preprocess, 'features.11')\n",
+    "alexnet5 = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {alexnet5:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c296bab2-d106-469e-b997-b32d21a2cf01",
+   "metadata": {},
+   "source": [
+    "## InceptionV3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "id": "5a9c1b2b-af2a-476d-a1ac-32ee915ac2ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/feature_extraction.py:174: UserWarning: NOTE: The nodes obtained by tracing the model in eval mode are a subsequence of those obtained in train mode. When choosing nodes for feature extraction, you may need to specify output nodes for train and eval mode separately.\n",
+      "  warnings.warn(msg + suggestion_msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2-way Percent Correct: 0.5077\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchvision.models import inception_v3, Inception_V3_Weights\n",
+    "weights = Inception_V3_Weights.DEFAULT\n",
+    "inception_model = create_feature_extractor(inception_v3(weights=weights), \n",
+    "                                           return_nodes=['avgpool']).to(device)\n",
+    "inception_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(342, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "all_per_correct = two_way_identification(all_recons, all_images,\n",
+    "                                        inception_model, preprocess, 'avgpool')\n",
+    "        \n",
+    "inception = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {inception:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7a25f7f-8298-4413-b512-8a1173413e07",
+   "metadata": {},
+   "source": [
+    "## CLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "id": "6afbf7ce-8793-4988-a328-a632acd88aa9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2-way Percent Correct: 0.5193\n"
+     ]
+    }
+   ],
+   "source": [
+    "import clip\n",
+    "clip_model, preprocess = clip.load(\"ViT-L/14\", device=device)\n",
+    "\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",
+    "\n",
+    "all_per_correct = two_way_identification(all_recons, all_images,\n",
+    "                                        clip_model.encode_image, preprocess, None) # final layer\n",
+    "clip_ = np.mean(all_per_correct)\n",
+    "print(f\"2-way Percent Correct: {clip_:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4fed9f8-ef1a-4c6d-a83f-2a934b6e87fd",
+   "metadata": {},
+   "source": [
+    "## Efficient Net"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "14143c0f-1b32-43ef-98d8-8ed458df4551",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Distance: 0.9543885725097773\n"
+     ]
+    }
+   ],
+   "source": [
+    "import scipy as sp\n",
+    "from torchvision.models import efficientnet_b1, EfficientNet_B1_Weights\n",
+    "weights = EfficientNet_B1_Weights.DEFAULT\n",
+    "eff_model = create_feature_extractor(efficientnet_b1(weights=weights), \n",
+    "                                    return_nodes=['avgpool'])\n",
+    "eff_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "# see weights.transforms()\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(255, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "gt = eff_model(preprocess(all_images))['avgpool']\n",
+    "gt = gt.reshape(len(gt),-1).cpu().numpy()\n",
+    "fake = eff_model(preprocess(all_recons))['avgpool']\n",
+    "fake = fake.reshape(len(fake),-1).cpu().numpy()\n",
+    "\n",
+    "effnet_nomean = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))])\n",
+    "effnet = effnet_nomean.mean()\n",
+    "print(\"Distance:\",effnet)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "405f669d-cab7-4c75-90cd-651283f65a9e",
+   "metadata": {},
+   "source": [
+    "## SwAV"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "4c60b0c4-79fe-4cff-95e9-99733c821e67",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in /home/ubuntu/.cache/torch/hub/facebookresearch_swav_main\n",
+      "/home/ubuntu/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/home/ubuntu/rt_mindEye2/lib/python3.11/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Distance: 0.6520650061534471\n"
+     ]
+    }
+   ],
+   "source": [
+    "swav_model = torch.hub.load('facebookresearch/swav:main', 'resnet50')\n",
+    "swav_model = create_feature_extractor(swav_model, \n",
+    "                                    return_nodes=['avgpool'])\n",
+    "swav_model.eval().requires_grad_(False).to(device)\n",
+    "\n",
+    "preprocess = transforms.Compose([\n",
+    "    transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
+    "                         std=[0.229, 0.224, 0.225]),\n",
+    "])\n",
+    "\n",
+    "gt = swav_model(preprocess(all_images))['avgpool']\n",
+    "gt = gt.reshape(len(gt),-1).cpu().numpy()\n",
+    "fake = swav_model(preprocess(all_recons))['avgpool']\n",
+    "fake = fake.reshape(len(fake),-1).cpu().numpy()\n",
+    "\n",
+    "swav_nomean = np.array([sp.spatial.distance.correlation(gt[i],fake[i]) for i in range(len(gt))])\n",
+    "swav = swav_nomean.mean()\n",
+    "print(\"Distance:\",swav)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "id": "8ebeeff0-49ab-4bf5-9e12-dd45eb7ff71f",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "             Metric     Value\n",
+      "           alexnet2  0.510644\n",
+      "           alexnet5  0.497519\n",
+      "          inception  0.507689\n",
+      "              clip_  0.519329\n",
+      "             effnet  0.954389\n",
+      "               swav  0.652065\n",
+      "            pixcorr  0.051853\n",
+      "               ssim  0.414159\n",
+      "percent_correct_fwd  0.048387\n",
+      "percent_correct_bwd  0.016129\n",
+      "          mst_score        []\n",
+      "Saved final evals!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Define metric names\n",
+    "metric_names = [\n",
+    "    \"alexnet2\", \"alexnet5\", \"inception\", \"clip_\", \"effnet\", \"swav\", \"pixcorr\", \"ssim\",\n",
+    "    \"percent_correct_fwd\", \"percent_correct_bwd\", \"mst_score\"\n",
+    "]\n",
+    "\n",
+    "# Define values depending on session\n",
+    "if \"ses-0\" not in model_name and False:\n",
+    "    values = [alexnet2, alexnet5, inception, clip_, effnet, swav, pixcorr, ssim, fwd_acc, bwd_acc, mst_score]\n",
+    "else:\n",
+    "    values = [alexnet2, alexnet5, inception, clip_, effnet, swav, pixcorr, ssim, all_fwd_acc[0], all_bwd_acc[0], mst_score]\n",
+    "\n",
+    "# Create the DataFrame\n",
+    "df = pd.DataFrame({\n",
+    "    \"Metric\": metric_names,\n",
+    "    \"Value\": values\n",
+    "})\n",
+    "\n",
+    "# Optional formatting\n",
+    "# pd.options.display.float_format = '{:.2%}'.format\n",
+    "\n",
+    "# Print the DataFrame nicely\n",
+    "print(df.to_string(index=False))\n",
+    "\n",
+    "# Save to file if needed\n",
+    "final_evals_path = f\"{eval_dir}/final_evals\"\n",
+    "if saving:\n",
+    "    df.to_csv(final_evals_path, index=False)\n",
+    "    print('Saved final evals!')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "8dd57b7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([62, 1, 1024])"
+      ]
+     },
+     "execution_count": 76,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all_unique_clipvoxels.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "0446fb2a-fd3f-451f-b9b2-38aa95a2be8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Metric,Value\n",
+      "alexnet2,0.5106438552958077\n",
+      "alexnet5,0.49751861042183626\n",
+      "inception,0.5076890427060207\n",
+      "clip_,0.519328718819381\n",
+      "effnet,0.9543885725097773\n",
+      "swav,0.6520650061534471\n",
+      "pixcorr,0.05185274977219404\n",
+      "ssim,0.4141594942526016\n",
+      "percent_correct_fwd,0.04838709533214569\n",
+      "percent_correct_bwd,0.016129031777381897\n",
+      "mst_score,[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open(final_evals_path, 'r') as f:\n",
+    "    for line in f:\n",
+    "        print(line, end='')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd74e27c-6d79-4d49-bcc9-f6b85fadc752",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2",
+   "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
+}

main-finetune-rt-preproc.py

@@ -0,0 +1,2260 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# #### This notebook fine-tunes MindEye on training sessions using real-time compatible preprocessing to produce a checkpoint that can be used in the real-time scan
+
+# # Import packages & functions
+
+# In[1]:
+
+
+print("importing modules")
+import os
+import sys
+import json
+import argparse
+import numpy as np
+import time
+import random
+import string
+import h5py
+from tqdm import tqdm
+import webdataset as wds
+from PIL import Image
+import pandas as pd
+import nibabel as nib
+import nilearn
+
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+# tf32 data type is faster than standard float32
+torch.backends.cuda.matmul.allow_tf32 = True
+
+import utils
+from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas
+
+# imports utils from mindeye_preproc as "preproc"
+import importlib.util
+parent_utils_path = "/home/ri4541/mindeye_preproc/analysis/utils.py"
+spec = importlib.util.spec_from_file_location("utils", parent_utils_path)
+preproc = importlib.util.module_from_spec(spec)
+parent_dir = os.path.dirname(parent_utils_path)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+spec.loader.exec_module(preproc)
+
+if utils.is_interactive():
+    from IPython.display import clear_output # function to clear print outputs in cell
+    get_ipython().run_line_magic('load_ext', 'autoreload')
+    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions
+    get_ipython().run_line_magic('autoreload', '2')
+    
+seed = utils.get_slurm_seed()
+
+
+# # Princeton data prep
+
+# ## Load Data & Design
+
+# In[2]:
+
+
+if utils.is_interactive():
+    sub = "sub-005"
+    session = "all"
+    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format
+    func_task_name = 'C'
+else:
+    sub = os.environ["SUB"]
+    session = os.environ["SESSION"]
+    task = os.environ["TASK"]
+    func_task_name = 'C'
+
+if session == "all":
+    ses_list = ["ses-01", "ses-02"]  # list of actual session IDs
+    design_ses_list = ["ses-01", "ses-02"]  # list of session IDs to search for design matrix
+else:
+    ses_list = [session]
+    design_ses_list = [session]
+    
+task_name = f"_task-{task}" if task != 'study' else ''
+resample_voxel_size = False
+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
+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
+    
+train_test_split = 'MST' # 'MST', 'orig', 'unique'
+remove_close_to_MST = False
+remove_random_n = False
+
+if remove_close_to_MST or remove_random_n:
+    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images
+
+n_to_remove = 0
+if remove_random_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_to_remove = 150
+    
+if resample_voxel_size:
+    # voxel size was unchanged in glmsingle, want to perform resampling here
+    resampled_vox_size = 2.5
+    resample_method = "sinc"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html
+    
+    # file name helper variables
+    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore
+    resampled_suffix = f"resampled_{vox_dim_str}mm_{resample_method}"
+    mask_resampled_suffix = resampled_suffix
+    if resample_post_glmsingle:
+        resampled_suffix += '_postglmsingle'
+    else:
+        resampled_suffix += '_preglmsingle'
+
+
+# In[3]:
+
+
+session_label = preproc.get_session_label(ses_list)
+print('session label:', session_label)
+n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)
+
+
+# In[4]:
+
+
+if utils.is_interactive():
+    glmsingle_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}"
+else:
+    glmsingle_path = os.environ["glmsingle_path"]
+    
+designdir = "/home/ri4541/real_time_mindEye2"
+print(glmsingle_path)
+
+if resample_voxel_size:
+    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here
+    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here
+    if resample_post_glmsingle:
+        # option 1
+        orig_glmsingle_path = glmsingle_path
+        glmsingle_path += f"_{resampled_suffix}"
+        print("resampled glmsingle path:", glmsingle_path)
+        if load_from_resampled_file:
+            # resampling is already done; load from file
+             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here
+        else:
+            # don't load from file; do resampling here
+            os.makedirs(glmsingle_path,exist_ok=True)
+    else:
+        # option 2
+        glmsingle_path += f"_{resampled_suffix}"
+        print("glmsingle path:", glmsingle_path)
+
+assert os.path.exists(glmsingle_path)
+print("glmsingle path exists!")
+
+
+# In[5]:
+
+
+data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(
+    sub=sub,
+    session=session,
+    func_task_name=task,
+    designdir=designdir,
+    design_ses_list=design_ses_list
+)
+
+if sub == 'sub-001':
+    if session == 'ses-01':
+        assert image_names[0] == 'images/image_686_seed_1.png'
+    elif session in ('ses-02', 'all'):
+        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'
+    elif session == 'ses-03':
+        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'
+    elif session == 'ses-04':
+        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+elif sub == 'sub-003':
+    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+
+unique_images = np.unique(image_names.astype(str))
+unique_images = unique_images[(unique_images!="nan")]
+len_unique_images = len(unique_images)
+print("n_runs",n_runs)
+
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(unique_images) == 851
+
+print(image_names[:4])
+print(starts[:4])
+print(is_new_run[:4])
+
+if remove_random_n:
+    # want to remove 150 imgs
+    # 100 special515 imgs are repeated 3x (300 total)
+    # all other train imgs are only shown once (558 total)
+    # of the 150, want to sample proportionally since we're cutting all repeats for special515
+    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total
+    np.random.seed(seed)
+    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)
+    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)
+    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)
+    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))
+
+image_idx = np.array([])  # contains the unique index of each presented image
+vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx
+all_MST_images = dict()
+for i, im in enumerate(image_names):
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    vox_image_names = np.append(vox_image_names, im)
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            i+=1
+            continue
+    elif remove_random_n:
+        if im in imgs_to_remove:
+            i+=1
+            continue
+            
+    image_idx_ = np.where(im==unique_images)[0].item()
+    image_idx = np.append(image_idx, image_idx_)
+    
+    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
+        import re
+        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)):  
+        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it
+            # print(im)
+            all_MST_images[i] = im
+            i+=1            
+    elif 'MST' in im:
+        all_MST_images[i] = im
+        i+=1
+    
+image_idx = torch.Tensor(image_idx).long()
+# for im in new_image_names[MST_images]:
+#     assert 'MST_pairs' in im
+# assert len(all_MST_images) == 300
+
+unique_MST_images = np.unique(list(all_MST_images.values())) 
+
+MST_ID = np.array([], dtype=int)
+if remove_close_to_MST:
+    close_to_MST_idx = np.array([], dtype=int)
+if remove_random_n:
+    random_n_idx = np.array([], dtype=int)
+
+vox_idx = np.array([], dtype=int)
+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
+for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            i+=1
+            continue
+    if remove_random_n:
+        if im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            i+=1
+            j+=1
+            continue
+    j+=1
+    curr = np.where(im == unique_MST_images)
+    # print(curr)
+    if curr[0].size == 0:
+        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
+    else:
+        MST_ID = np.append(MST_ID, curr)
+        
+assert len(MST_ID) == len(image_idx)
+# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)
+# 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
+print(MST_ID.shape)
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(all_MST_images) == 100
+
+
+# ## Load images
+
+# In[6]:
+
+
+import imageio.v2 as imageio
+resize_transform = transforms.Resize((224, 224))
+MST_images = []
+images = None
+for im_name in tqdm(image_idx):
+    if sub == 'sub-001' and session == 'ses-01':
+        image_file = f"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}"
+    else:
+        image_file = f"{unique_images[im_name]}"
+    im = imageio.imread(image_file)
+    im = torch.Tensor(im / 255).permute(2,0,1)
+    im = resize_transform(im.unsqueeze(0))
+    if images is None:
+        images = im
+    else:
+        images = torch.vstack((images, im))
+    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+        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)):  
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+    else:   
+        if ("MST_pairs" in image_file): # ("_seed_" not in unique_images[im_name]) and (unique_images[im_name] != "blank.jpg") 
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+
+print("images", images.shape)
+MST_images = np.array(MST_images)
+print("MST_images", len(MST_images))
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(MST_images[MST_images==True]) == 100
+print("MST_images==True", len(MST_images[MST_images==True]))
+
+
+# In[7]:
+
+
+# want IDs of pairmates based on MST_images
+# create "MST_pairmates" which is a 25x2 array with indices of the 25 pairs based on MST_images == True
+
+assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2
+MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)
+# print(MST_pairmate_names)
+
+MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for p, pair in enumerate(MST_pairmate_names):
+    for i, im in enumerate(pair):
+        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
+        
+print(MST_pairmate_indices.shape, MST_pairmate_indices)
+
+
+# In[8]:
+
+
+if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):
+    # MST_pairs contains the indices of repeats based on all_MST_images
+    # all_MST_images contains the indices of images from image_names
+    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))
+    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
+
+    # assert images[MST_pairs]
+
+    fig, ax = plt.subplots(1, 3, figsize=(10,4))
+    fig.suptitle('Sample MST pairs')
+
+    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())
+    ax[0].set_title(f"Trial 0")
+
+    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())
+    ax[1].set_title(f"Trial 1")
+
+    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())
+    ax[2].set_title(f"Trial 2")
+
+    plt.setp(ax, xticks=[], yticks=[])
+    plt.tight_layout()
+    plt.show()
+
+
+# In[9]:
+
+
+# pairs has the indices of all repeated images
+pairs = utils.find_paired_indices(image_idx)
+pairs = sorted(pairs, key=lambda x: x[0])
+
+fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns
+for i, ax in enumerate(axes):
+    ax.imshow(images[i].permute(1, 2, 0).numpy())
+    ax.set_title(f"Trial {i}")
+    ax.axis("off")  # Hide axes for better visualization
+
+plt.tight_layout()
+# output_path = os.path.join(output_dir, "trials_plot.png")
+# plt.savefig(output_path, dpi=300)  # Save figure
+plt.show()
+
+
+# In[10]:
+
+
+p=0
+
+# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)
+fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())
+ax[0].set_title(f"Repeat 1")
+
+ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())
+ax[1].set_title(f"Repeat 2")
+
+plt.setp(ax, xticks=[], yticks=[])
+plt.tight_layout()
+plt.show()
+
+
+# In[11]:
+
+
+def get_image_pairs(sub, session, func_task_name, designdir):
+    """Loads design files and processes image pairs for a given session."""
+    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(
+        sub=sub,
+        session=session,
+        func_task_name=func_task_name,
+        designdir=designdir,
+        design_ses_list=[session]  # Ensure it's a list
+    )
+    return utils.process_images(image_names, unique_images)
+
+
+# In[12]:
+
+
+from collections import defaultdict
+
+all_dicts = []
+for s_idx, s in enumerate(ses_list):
+    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)
+    assert len(im) == len(vo)
+    all_dicts.append({k:v for k,v in enumerate(vo)})
+
+# for the train set (ses-01-02 non-MST)
+image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])
+for ses_idx, idx_to_name in enumerate(all_dicts):
+    for idx, name in idx_to_name.items():
+        image_to_indices[name][ses_idx].append(idx)
+        
+image_to_indices = dict(image_to_indices)
+
+# for the test set (ses-03)
+# test_image_to_indices = defaultdict(lambda: [[] for _ in range(len([ses_list[-1]]))])
+# for ses_idx, idx_to_name in enumerate([all_dicts[-1]]):
+#     for idx, name in idx_to_name.items():
+#         test_image_to_indices[name][ses_idx].append(idx)
+        
+# test_image_to_indices = dict(test_image_to_indices)
+
+if sub == 'sub-005' and len(ses_list) > 1:
+    session_length = 693
+    for image, session_indices_list in image_to_indices.items():
+        new_indices_list = []
+        for idx, indices in enumerate(session_indices_list):
+            offset = idx * session_length
+            new_indices = [i + offset for i in indices]
+            new_indices_list.append(new_indices)
+        image_to_indices[image] = new_indices_list
+        
+    import itertools
+    assert max(itertools.chain.from_iterable(list(image_to_indices.values())))[0] == (len(ses_list)*session_length) - 1
+
+
+# In[13]:
+
+
+if resample_voxel_size:
+    from nilearn.masking import apply_mask, unmask
+    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'
+    omat_name = f'{glmsingle_path}/boldref_omat'
+
+
+# In[14]:
+
+
+from nilearn.plotting import plot_roi
+
+print('loading brain mask')
+avg_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')
+final_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')
+
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+plot_roi(final_mask, bg_img=avg_mask)
+plt.show()
+
+
+# In[15]:
+
+
+# # create union of ses-01 and ses-02 reliability masks and plot against avg_mask 
+# rel_masks = []
+# 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'))
+# 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'))
+# rel_masks = np.array(rel_masks)
+# for r in rel_masks:
+#     assert r.shape[0] == int(final_mask.get_fdata().sum())
+#     assert r.dtype == bool
+    
+# assert len(rel_masks) == 2  # should be the case if there's 2 training sessions
+# union_mask = np.logical_or(rel_masks[0], rel_masks[1])
+# assert union_mask.sum() > rel_masks[0].sum()
+# assert union_mask.sum() > rel_masks[1].sum()
+# 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')
+# print(f'{(union_mask.sum() / int(final_mask.get_fdata().sum())):.2%} of the voxels in the roi were selected')
+# path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy'
+path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy'
+# np.save(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy', union_mask)
+# print(f'saved union mask to {path}!')
+union_mask = np.load(path)
+
+
+# ## Proceed to fine-tuning using real-time compatible betas
+
+# In[16]:
+
+
+## 
+
+
+# ## load betas from ses-01 and 02 that were computed based on real-time preprocessing that is identical to that used in the real-time session
+
+# In[17]:
+
+
+ses_vox = []
+runs_per_session = int(n_runs/len(ses_list))
+for s in ses_list:
+    ses_vox_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/3t/derivatives/{sub}_{s}_task-{func_task_name}_run-{runs_per_session}_recons/betas_run-{runs_per_session}.npy"  # assumes each session list has the same number of runs
+    ses_vox.append(np.load(ses_vox_path))
+
+vox = np.concatenate(ses_vox).squeeze(1)
+print(vox.shape)
+assert len(vox) == len(image_idx)
+
+
+# In[18]:
+
+
+ses_mask = []
+
+for s in ses_list:
+    ses_mask_path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{s}_task-C/sub-005_{s}_task-C_brain.nii.gz'
+    ses_mask.append(nib.load(ses_mask_path))
+    
+    assert np.all(ses_mask[-1].affine == final_mask.affine)
+    assert np.all(ses_mask[-1].shape == final_mask.shape)
+
+
+# In[19]:
+
+
+# # get vox into the same shape as the union mask
+# v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask
+# final_mask = nilearn.masking.intersect_masks([avg_mask, roi])
+# vox = nilearn.masking.apply_mask(vox, final_mask)  # re-flatten based on final mask so everything is in the same shape now
+# print(vox.shape)
+
+
+# In[20]:
+
+
+pairs_homog = np.array([[p[0], p[1]] for p in pairs])
+
+
+# In[21]:
+
+
+same_corrs = []
+diff_corrs = []
+for isamp, samp in enumerate(vox[pairs_homog]):
+    avg_same_img = []
+    for i in range(samp.shape[0]):
+        for j in range(i, samp.shape[0]):
+            if i != j:
+                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))
+    
+    same_corrs.append(np.mean(avg_same_img))
+                       
+    avg_diff_img = []
+    for isamp_j, samp_j in enumerate(vox[pairs_homog]):
+        if isamp_j != isamp:
+            for i in range(samp_j.shape[0]):
+                for j in range(i, samp_j.shape[0]):
+                    if i != j:
+                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))
+                                    
+    # print(len(avg_diff_img))
+    diff_corrs.append(np.mean(avg_diff_img))
+
+
+print(len(same_corrs), len(diff_corrs))
+same_corrs = np.array(same_corrs)
+diff_corrs = np.array(diff_corrs)
+
+
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same/diff Pearson corr.")
+plt.plot(np.sort(same_corrs),c='blue',label='same')
+plt.plot(np.sort(diff_corrs),c='cyan',label='diff')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# In[22]:
+
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same minus diff difference Pearson corr.")
+plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# # Training MindEye
+
+# In[23]:
+
+
+utils.seed_everything(seed)
+
+if train_test_split == 'orig':
+    # train = all images except images that were repeated
+    # test = average of the same-image presentations
+    imageTrain = np.arange(len(images))
+    train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])
+    test_image_indices = pairs
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+elif train_test_split == 'MST':
+    # non-MST images are the train split
+    # MST images are the test split
+    MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])
+    non_MST_idx = [v for k,v in image_to_indices.items() if 'MST_pairs' not in k]
+    non_MST_idx = np.array([z for y in non_MST_idx for x in y for z in x])  # flatten the indices
+    train_image_indices = non_MST_idx
+    test_image_indices = MST_idx.flatten()  # MST_idx contains the mapping for the different test sets; test_image_indices has all MST indices combined
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(vox)
+elif train_test_split == 'unique':
+    imageTest = np.arange(len(images))
+    train_image_indices = pairs.flatten()
+    test_image_indices = np.array([item for item in imageTest if item not in pairs.flatten()])
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+else:
+    raise Exception("invalid train_test_split")
+
+# TODO add assertion that verifies file names in train and test don't overlap, guards against repeats
+
+for i in train_image_indices:
+    assert i not in test_image_indices
+
+
+# In[24]:
+
+
+ses_split = vox[train_image_indices].shape[0] // 2
+
+train_mean_s1 = np.mean(vox[train_image_indices][:ses_split], axis=0)
+train_std_s1 = np.std(vox[train_image_indices][:ses_split], axis=0)
+train_mean_s2 = np.mean(vox[train_image_indices][ses_split:], axis=0)
+train_std_s2 = np.std(vox[train_image_indices][ses_split:], axis=0)
+
+
+vox[:ses_split] = utils.zscore(vox[:ses_split],train_mean=train_mean_s1,train_std=train_std_s1)
+vox[ses_split:] = utils.zscore(vox[ses_split:],train_mean=train_mean_s2,train_std=train_std_s2)
+
+print("voxels have been zscored")
+print("ses-01:", vox[:ses_split,0].mean(), vox[:ses_split,0].std())
+print("ses-02:", vox[ses_split:,0].mean(), vox[ses_split:,0].std())
+print("vox", vox.shape)
+
+
+# In[25]:
+
+
+# save the mean and std from ses-01 and 02
+train_test_mean_s1 = np.mean(vox[:ses_split], axis=0)
+train_test_std_s1 = np.std(vox[:ses_split], axis=0)
+train_test_mean_s2 = np.mean(vox[ses_split:], axis=0)
+train_test_std_s2 = np.std(vox[ses_split:], axis=0)
+print(train_test_mean_s1.shape)
+assert np.all(train_test_mean_s1.shape == train_test_std_s1.shape)
+assert np.all(train_test_mean_s1.shape == train_test_mean_s2.shape)
+assert np.all(train_test_mean_s1.shape == train_test_std_s2.shape)
+
+
+# In[26]:
+
+
+# for idx in deleted_indices:
+#     # check image names to be deleted match
+#     original_name = vox_image_dict[idx]
+#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]
+#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \
+#         f"Mismatch in image names for deleted indices {matching_indices}"
+
+#     # check image data to be deleted match
+#     base_image = images[matching_indices[0]]  # Reference image
+#     for i in matching_indices[1:]:
+#         assert np.array_equal(base_image, images[i]), \
+#             f"Mismatch in image data for {vox_image_dict[i]} at index {i}"
+
+# images = images[kept_indices]
+
+
+# In[27]:
+
+
+images = torch.Tensor(images)
+vox = torch.Tensor(vox)
+assert len(images) == len(vox)
+
+
+# In[28]:
+
+
+### Multi-GPU config ###
+from accelerate import Accelerator, DeepSpeedPlugin
+
+local_rank = os.getenv('RANK')
+if local_rank is None: 
+    local_rank = 0
+else:
+    local_rank = int(local_rank)
+print("LOCAL RANK ", local_rank)  
+
+data_type = torch.float32 # change depending on your mixed_precision
+
+accelerator = Accelerator(split_batches=False)
+batch_size = 8 
+
+
+# In[29]:
+
+
+print("PID of this process =",os.getpid())
+device = accelerator.device
+print("device:",device)
+world_size = accelerator.state.num_processes
+distributed = not accelerator.state.distributed_type == 'NO'
+num_devices = torch.cuda.device_count()
+global_batch_size = batch_size * num_devices
+print("global_batch_size", global_batch_size)
+if num_devices==0 or not distributed: num_devices = 1
+num_workers = num_devices
+print(accelerator.state)
+
+# set data_type to match your mixed precision (automatically set based on deepspeed config)
+if accelerator.mixed_precision == "bf16":
+    data_type = torch.bfloat16
+elif accelerator.mixed_precision == "fp16":
+    data_type = torch.float16
+else:
+    data_type = torch.float32
+
+print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type)
+print = accelerator.print # only print if local_rank=0
+
+
+# ## Configurations
+
+# In[30]:
+
+
+# if running this interactively, can specify jupyter_args here for argparser to use
+if utils.is_interactive():
+    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'
+    print("model_name:", model_name)
+    
+    # global_batch_size and batch_size should already be defined in the above cells
+    # other variables can be specified in the following string:
+    # jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}"
+
+    jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \
+                    --model_name={model_name} \
+                    --no-multi_subject --subj=1 --batch_size={batch_size} \
+                    --hidden_dim=1024 --clip_scale=1. \
+                    --no-blurry_recon --blur_scale=.5 \
+                    --no-use_prior --prior_scale=30 \
+                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \
+                    --ckpt_interval=999 --no-ckpt_saving --new_test \
+                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep"
+    print(jupyter_args)
+    jupyter_args = jupyter_args.split()
+
+
+# In[31]:
+
+
+parser = argparse.ArgumentParser(description="Model Training Configuration")
+parser.add_argument(
+    "--model_name", type=str, default="testing",
+    help="name of model, used for ckpt saving and wandb logging (if enabled)",
+)
+parser.add_argument(
+    "--data_path", type=str, default="/weka/proj-fmri/shared/natural-scenes-dataset",
+    help="Path to where NSD data is stored / where to download it to",
+)
+parser.add_argument(
+    "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8],
+    help="Validate on which subject?",
+)
+parser.add_argument(
+    "--multisubject_ckpt", type=str, default=None,
+    help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.",
+)
+parser.add_argument(
+    "--num_sessions", type=int, default=0,
+    help="Number of training sessions to include (if multi_subject, this variable doesnt matter)",
+)
+parser.add_argument(
+    "--use_prior",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)",
+)
+parser.add_argument(
+    "--batch_size", type=int, default=32,
+    help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser",
+)
+parser.add_argument(
+    "--wandb_log",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to log to wandb",
+)
+parser.add_argument(
+    "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False,
+    help="if not using wandb and want to resume from a ckpt",
+)
+parser.add_argument(
+    "--wandb_project",type=str,default="stability",
+    help="wandb project name",
+)
+parser.add_argument(
+    "--mixup_pct",type=float,default=.33,
+    help="proportion of way through training when to switch from BiMixCo to SoftCLIP",
+)
+parser.add_argument(
+    "--low_mem",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to preload images to cpu to speed things up but consume more memory",
+)
+parser.add_argument(
+    "--blurry_recon",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to output blurry reconstructions",
+)
+parser.add_argument(
+    "--blur_scale",type=float,default=.5,
+    help="multiply loss from blurry recons by this number",
+)
+parser.add_argument(
+    "--clip_scale",type=float,default=1.,
+    help="multiply contrastive loss by this number",
+)
+parser.add_argument(
+    "--prior_scale",type=float,default=30,
+    help="multiply diffusion prior loss by this",
+)
+parser.add_argument(
+    "--use_image_aug",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to use image augmentation",
+)
+parser.add_argument(
+    "--num_epochs",type=int,default=120,
+    help="number of epochs of training",
+)
+parser.add_argument(
+    "--multi_subject",action=argparse.BooleanOptionalAction,default=False,
+)
+parser.add_argument(
+    "--new_test",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--n_blocks",type=int,default=2,
+)
+parser.add_argument(
+    "--hidden_dim",type=int,default=1024,
+)
+parser.add_argument(
+    "--seq_past",type=int,default=0,
+)
+parser.add_argument(
+    "--seq_future",type=int,default=0,
+)
+parser.add_argument(
+    "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'],
+)
+parser.add_argument(
+    "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--ckpt_interval",type=int,default=5,
+    help="save backup ckpt and reconstruct every x epochs",
+)
+parser.add_argument(
+    "--seed",type=int,default=42,
+)
+parser.add_argument(
+    "--max_lr",type=float,default=3e-4,
+)
+
+if utils.is_interactive():
+    args = parser.parse_args(jupyter_args)
+else:
+    args = parser.parse_args()
+
+# create global variables without the args prefix
+for attribute_name in vars(args).keys():
+    globals()[attribute_name] = getattr(args, attribute_name)
+    
+outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+if not os.path.exists(outdir) and ckpt_saving:
+    os.makedirs(outdir,exist_ok=True)
+    
+if use_image_aug or blurry_recon:
+    import kornia
+    import kornia.augmentation as K
+    from kornia.augmentation.container import AugmentationSequential
+if use_image_aug:
+    img_augment = AugmentationSequential(
+        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),
+        same_on_batch=False,
+        data_keys=["input"],
+    )
+    # Define the blurring augmentations
+    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)
+    
+if multi_subject:
+    subj_list = np.arange(1,9)
+    subj_list = subj_list[subj_list != subj]
+else:
+    subj_list = [subj]
+
+print("subj_list", subj_list, "num_sessions", num_sessions)
+
+
+# ## Prep data, models, and dataloaders
+
+# In[32]:
+
+
+if ckpt_saving:
+    # save MST_ID for 2-alternative forced-choice retrieval evaluation 
+    if 'MST' in model_name:
+        eval_dir = os.environ["eval_dir"]
+        print('saving MST info in', eval_dir)
+        # Saving ##
+        if not os.path.exists(eval_dir):
+            os.mkdir(eval_dir)
+
+        np.save(f"{eval_dir}/MST_ID.npy", MST_ID)
+        np.save(f"{eval_dir}/MST_pairmate_indices.npy", MST_pairmate_indices)
+
+    if remove_random_n:
+        np.save(f"{eval_dir}/imgs_to_remove.npy", imgs_to_remove)
+
+    np.save(f"{eval_dir}/train_image_indices.npy", train_image_indices)
+    np.save(f"{eval_dir}/test_image_indices.npy", test_image_indices)
+    np.save(f"{eval_dir}/images.npy", images)
+    np.save(f"{eval_dir}/vox.npy", vox)
+    
+    np.save(f'{eval_dir}/train_test_mean_s1.npy', train_test_mean_s1)
+    np.save(f'{eval_dir}/train_test_std_s1.npy', train_test_std_s1)
+    np.save(f'{eval_dir}/train_test_mean_s2.npy', train_test_mean_s2)
+    np.save(f'{eval_dir}/train_test_std_s2.npy', train_test_std_s2)
+
+
+# ### Creating wds dataloader, preload betas and all 73k possible images
+
+# In[33]:
+
+
+def my_split_by_node(urls): return urls
+num_voxels_list = []
+
+if multi_subject:
+    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])
+    num_samples_per_epoch = (750*40) // num_devices 
+else:
+    # num_samples_per_epoch = (750*num_sessions) // num_devices 
+    num_samples_per_epoch = len(train_image_indices)
+
+print("dividing batch size by subj_list, which will then be concatenated across subj during training...") 
+batch_size = batch_size // len(subj_list)
+
+num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))
+
+print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch)
+
+
+# In[34]:
+
+
+train_data = {}
+train_dl = {}
+
+train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))
+test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))
+
+
+# In[35]:
+
+
+num_voxels = {}
+voxels = {}
+for s in subj_list:
+    print(f"Training with {num_sessions} sessions")
+    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True)
+
+    num_voxels_list.append(vox[0].shape[-1])
+    num_voxels[f'subj0{s}'] = vox[0].shape[-1]
+    voxels[f'subj0{s}'] = vox
+    print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}")
+
+print("Loaded all subj train dls and vox!\n")
+
+# Validate only on one subject
+if multi_subject: 
+    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list
+test_dl = torch.utils.data.DataLoader(test_data, batch_size=24, shuffle=False, drop_last=True, pin_memory=True)
+
+print(f"Loaded test dl for subj{subj}!\n")
+
+
+# ## Load models
+
+# ### CLIP image embeddings  model
+
+# In[36]:
+
+
+## USING OpenCLIP ViT-bigG ###
+sys.path.append('generative_models/')
+import sgm
+from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder
+# from generative_models.sgm.models.diffusion import DiffusionEngine
+# from omegaconf import OmegaConf
+
+try:
+    print(clip_img_embedder)
+except:
+    clip_img_embedder = FrozenOpenCLIPImageEmbedder(
+        arch="ViT-bigG-14",
+        version="laion2b_s39b_b160k",
+        output_tokens=True,
+        only_tokens=True,
+    )
+    clip_img_embedder.to(device)
+clip_seq_dim = 256
+clip_emb_dim = 1664
+
+# ## USING OPEN AI CLIP ViT-L ###
+# import clip
+# try:
+#     print(clip_model)
+# except:
+#     clip_model, preprocess = clip.load("ViT-L/14", device=device)
+#     preprocess = transforms.Compose([
+#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),
+#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+#                              std=[0.26862954, 0.26130258, 0.27577711]),
+#     ])
+# def clip_img_embedder(image):
+#     preproc_img = preprocess(image)
+#     return clip_model.encode_image(preproc_img)
+# clip_seq_dim = 1
+# clip_emb_dim = 768
+
+
+# ### MindEye modules
+
+# In[37]:
+
+
+model = utils.prepare_model_and_training(
+    num_voxels_list=num_voxels_list,
+    n_blocks=n_blocks,
+    hidden_dim=hidden_dim,
+    clip_emb_dim=clip_emb_dim,
+    clip_seq_dim=clip_seq_dim,
+    use_prior=use_prior,
+    clip_scale=clip_scale
+)
+
+
+# In[38]:
+
+
+# test on subject 1 with fake data
+b = torch.randn((2,1,num_voxels_list[0]))
+print(b.shape, model.ridge(b,0).shape)
+
+
+# In[39]:
+
+
+# test that the model works on some fake data
+b = torch.randn((2,1,hidden_dim))
+print("b.shape",b.shape)
+
+backbone_, clip_, blur_ = model.backbone(b)
+print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)
+
+
+# ### Adding diffusion prior + unCLIP if use_prior=True
+
+# In[40]:
+
+
+if use_prior:
+    from models import *
+
+    # setup diffusion prior network
+    out_dim = clip_emb_dim
+    depth = 6
+    dim_head = 52
+    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+    timesteps = 100
+
+    prior_network = VersatileDiffusionPriorNetwork(
+            dim=out_dim,
+            depth=depth,
+            dim_head=dim_head,
+            heads=heads,
+            causal=False,
+            num_tokens = clip_seq_dim,
+            learned_query_mode="pos_emb"
+        )
+
+    model.diffusion_prior = BrainDiffusionPrior(
+        net=prior_network,
+        image_embed_dim=out_dim,
+        condition_on_text_encodings=False,
+        timesteps=timesteps,
+        cond_drop_prob=0.2,
+        image_embed_scale=None,
+    )
+    
+    utils.count_params(model.diffusion_prior)
+    utils.count_params(model)
+
+
+# ### Setup optimizer / lr / ckpt saving
+
+# In[41]:
+
+
+no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+opt_grouped_parameters = [
+    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},
+    {'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},
+    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
+]
+# model.backbone.requires_grad_(False)
+
+if use_prior:
+    opt_grouped_parameters.extend([
+        {'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},
+        {'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}
+    ])
+
+optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)
+
+if lr_scheduler_type == 'linear':
+    lr_scheduler = torch.optim.lr_scheduler.LinearLR(
+        optimizer,
+        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),
+        last_epoch=-1
+    )
+elif lr_scheduler_type == 'cycle':
+    if num_iterations_per_epoch==0:
+        num_iterations_per_epoch=1
+    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))
+    print("total_steps", total_steps)
+    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, 
+        max_lr=max_lr,
+        total_steps=total_steps,
+        final_div_factor=1000,
+        last_epoch=-1, pct_start=2/num_epochs
+    )
+    
+def save_ckpt(tag):
+    ckpt_path = outdir+f'/{tag}.pth'
+    if accelerator.is_main_process:
+        unwrapped_model = accelerator.unwrap_model(model)
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': unwrapped_model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'lr_scheduler': lr_scheduler.state_dict(),
+            'train_losses': losses,
+            'test_losses': test_losses,
+            'lrs': lrs,
+            }, ckpt_path)
+    print(f"\n---saved {outdir}/{tag} ckpt!---\n")
+
+def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): 
+    print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')
+    state_dict = checkpoint['model_state_dict']
+    if multisubj_loading: # remove incompatible ridge layer that will otherwise error
+        state_dict.pop('ridge.linears.0.weight',None)
+    model.load_state_dict(state_dict, strict=strict)
+    if load_epoch:
+        globals()["epoch"] = checkpoint['epoch']
+        print("Epoch",epoch)
+    if load_optimizer:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    if load_lr:
+        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+    del checkpoint
+
+print("\nDone with model preparations!")
+num_params = utils.count_params(model)
+
+
+# # Wandb
+
+# In[42]:
+
+
+if local_rank==0 and wandb_log: # only use main process for wandb logging
+    import wandb
+    import time
+    
+    wandb_project = 'rtmindeye'
+    print(f"wandb {wandb_project} run {model_name}")
+
+    # Need to configure wandb beforehand in terminal with "wandb init"!
+    wandb_config = {
+        "model_name": model_name,
+        "global_batch_size": global_batch_size,
+        "batch_size": batch_size,
+        "num_epochs": num_epochs,
+        "num_sessions": num_sessions,
+        "num_params": num_params,
+        "clip_scale": clip_scale,
+        "prior_scale": prior_scale,
+        "blur_scale": blur_scale,
+        "use_image_aug": use_image_aug,
+        "max_lr": max_lr,
+        "mixup_pct": mixup_pct,
+        "num_samples_per_epoch": num_samples_per_epoch,
+        "ckpt_interval": ckpt_interval,
+        "ckpt_saving": ckpt_saving,
+        "seed": seed,  # SLURM array task ID
+        "distributed": distributed,
+        "num_devices": num_devices,
+        "world_size": world_size,
+    }
+    print("wandb_config:\n", wandb_config)
+    print("wandb_id:", model_name)
+
+    # Initialize wandb
+    wandb.init(
+        id=model_name,
+        project=wandb_project,
+        name=model_name,
+        config=wandb_config,
+        resume="allow",
+        save_code=True,
+    )
+
+    # Get SLURM job & array ID
+    slurm_job_id = utils.get_slurm_job()
+    slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID
+
+    # Define SLURM log paths
+    log_dir = "slurms"
+    log_files = [
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.out",
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.err",
+    ]
+
+    # Ensure logs exist before logging them
+    for log_file in log_files:
+        wait_time = 0
+        while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s
+            time.sleep(5)
+            wait_time += 5
+
+    # Log SLURM logs as artifacts
+    artifact = wandb.Artifact(f"slurm_logs_{slurm_job_id}_{slurm_array_id}", type="logs")
+    for log_file in log_files:
+        if os.path.exists(log_file):
+            artifact.add_file(log_file)
+
+    wandb.log_artifact(artifact)
+else:
+    wandb_log = False
+
+
+# # Train the model
+
+# In[43]:
+
+
+epoch = 0
+losses, test_losses, lrs = [], [], []
+best_test_loss = 1e9
+torch.cuda.empty_cache()
+
+
+# In[44]:
+
+
+# load multisubject stage1 ckpt if set
+if multisubject_ckpt is not None and not resume_from_ckpt:
+    load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)
+
+
+# In[45]:
+
+
+# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')
+# state_dict = checkpoint['model_state_dict']
+# model.load_state_dict(state_dict, strict=False)
+
+
+# In[46]:
+
+
+# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]
+
+model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)
+# leaving out test_dl since we will only have local_rank 0 device do evals
+
+
+# In[47]:
+
+
+print(f"{model_name} starting with epoch {epoch} / {num_epochs}")
+progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))
+test_image, test_voxel = None, None
+mse = nn.MSELoss()
+l1 = nn.L1Loss()
+soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))
+skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model
+
+for epoch in progress_bar:
+    model.train()
+
+    fwd_percent_correct = 0.
+    bwd_percent_correct = 0.
+    test_fwd_percent_correct = 0.
+    test_bwd_percent_correct = 0.
+    
+    recon_cossim = 0.
+    test_recon_cossim = 0.
+    recon_mse = 0.
+    test_recon_mse = 0.
+
+    loss_clip_total = 0.
+    loss_blurry_total = 0.
+    loss_blurry_cont_total = 0.
+    test_loss_clip_total = 0.
+    
+    loss_prior_total = 0.
+    test_loss_prior_total = 0.
+
+    blurry_pixcorr = 0.
+    test_blurry_pixcorr = 0. 
+
+    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each
+    for train_i, behav in enumerate(train_dl):  
+        with torch.cuda.amp.autocast(dtype=data_type):
+            optimizer.zero_grad()
+            loss = 0.
+            
+            behav = behav[0]
+
+            image = images[behav.long().cpu()].to(device)
+            voxel = vox[behav.long().cpu()]
+            # voxel = (voxel - train_mean) / train_std
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+            if use_image_aug: 
+                image = img_augment(image)
+
+            clip_target = clip_img_embedder(image)
+            assert not torch.any(torch.isnan(clip_target))
+
+            if epoch < int(mixup_pct * num_epochs):
+                voxel, perm, betas, select = utils.mixco(voxel)
+
+            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]
+            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)
+
+            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+            if clip_scale>0:
+                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+            if use_prior:
+                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)
+                loss_prior_total += loss_prior.item()
+                loss_prior *= prior_scale
+                loss += loss_prior
+
+                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()
+                recon_mse += mse(prior_out, clip_target).item()
+
+            if clip_scale>0:
+                if epoch < int(mixup_pct * num_epochs):                
+                    loss_clip = utils.mixco_nce(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=.006,
+                        perm=perm, betas=betas, select=select)
+                else:
+                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]
+                    loss_clip = utils.soft_clip_loss(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=epoch_temp)
+
+                loss_clip_total += loss_clip.item()
+                loss_clip *= clip_scale
+                loss += loss_clip
+
+            if blurry_recon:     
+                image_enc_pred, transformer_feats = blurry_image_enc_
+
+                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215
+                loss_blurry = l1(image_enc_pred, image_enc)
+                loss_blurry_total += loss_blurry.item()
+
+                if epoch < int(mixup_pct * num_epochs):
+                    image_enc_shuf = image_enc[perm]
+                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)
+                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \
+                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)
+
+                image_norm = (image - mean)/std
+                image_aug = (blur_augs(image) - mean)/std
+                _, cnx_embeds = cnx(image_norm)
+                _, cnx_aug_embeds = cnx(image_aug)
+
+                cont_loss = utils.soft_cont_loss(
+                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    temp=0.2)
+                loss_blurry_cont_total += cont_loss.item()
+
+                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215
+
+            if clip_scale>0:
+                # forward and backward top 1 accuracy        
+                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) 
+                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+            if blurry_recon:
+                with torch.no_grad():
+                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()
+                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)
+                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)
+                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                    blurry_pixcorr += pixcorr.item()
+            
+            utils.check_loss(loss)
+            accelerator.backward(loss)
+            optimizer.step()
+
+            losses.append(loss.item())
+            lrs.append(optimizer.param_groups[0]['lr'])
+
+            if lr_scheduler_type is not None:
+                lr_scheduler.step()
+                
+            if train_i >= num_iterations_per_epoch-1:
+                break
+                
+    model.eval()
+    logs = {}
+
+    if local_rank == 0:
+        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+            for i in range(2):
+                for j in range(2):
+                    subset_indices = MST_idx[:, i, j].reshape(-1)
+                    subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                    subset_dl = torch.utils.data.DataLoader(
+                        subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                        drop_last=True, pin_memory=True
+                    )
+
+                    # Reset metrics for this subset
+                    test_losses = []
+                    test_loss_clip_total = 0
+                    test_loss_prior_total = 0
+                    test_blurry_pixcorr = 0
+                    test_fwd_percent_correct = 0
+                    test_bwd_percent_correct = 0
+                    test_recon_cossim = 0
+                    test_recon_mse = 0
+
+                    for test_i, behav in enumerate(subset_dl):
+                        behav = behav[0]
+                        loss = 0.
+
+                        if behav.ndim > 1:
+                            image = images[behav[:, 0].long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()].mean(1)
+                        else:
+                            image = images[behav.long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()]
+
+                        voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+                        clip_img_embedder = clip_img_embedder.to(device)
+                        clip_target = clip_img_embedder(image.float())
+
+                        voxel_ridge = model.ridge(voxel, 0)
+                        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                        if clip_scale > 0:
+                            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                            clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+                        random_samps = np.random.choice(np.arange(len(image)), size=len(image) // 5, replace=False)
+
+                        if use_prior:
+                            loss_prior, contaminated_prior_out = model.diffusion_prior(
+                                text_embed=backbone[random_samps], image_embed=clip_target[random_samps])
+                            test_loss_prior_total += loss_prior.item()
+                            loss_prior *= prior_scale
+                            loss += loss_prior
+
+                        if clip_scale > 0:
+                            loss_clip = utils.soft_clip_loss(
+                                clip_voxels_norm,
+                                clip_target_norm,
+                                temp=0.006
+                            )
+                            test_loss_clip_total += loss_clip.item()
+                            loss_clip *= clip_scale
+                            loss += loss_clip
+
+                        if blurry_recon:
+                            image_enc_pred, _ = blurry_image_enc_
+                            blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps] / 0.18215).sample / 2 + 0.5).clamp(0, 1)
+                            pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                            test_blurry_pixcorr += pixcorr.item()
+
+                        if clip_scale > 0:
+                            labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                            test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                            test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+                        utils.check_loss(loss)
+                        test_losses.append(loss.item())
+
+                    logs.update({
+                        f"subset_{i}_{j}_test/loss": np.mean(test_losses),
+                        f"subset_{i}_{j}_test/loss_clip_total": test_loss_clip_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/loss_prior": test_loss_prior_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1),
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+                    print(f"--- Subset ({i},{j}) ---")
+                    for k, v in logs.items():
+                        if f"subset_{i}_{j}" in k:
+                            print(f"{k}: {v:.4f}")
+
+            # After subset loop: add train (and global test, if you want) metrics
+            logs.update({
+                "train/loss": np.mean(losses[-(train_i+1):]),
+                "train/lr": lrs[-1],
+                "train/num_steps": len(losses),
+                "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1),
+                "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1),
+                "train/loss_clip_total": loss_clip_total / (train_i + 1),
+                "train/loss_blurry_total": loss_blurry_total / (train_i + 1),
+                "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1),
+                "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1),
+                "train/recon_cossim": recon_cossim / (train_i + 1),
+                "train/recon_mse": recon_mse / (train_i + 1),
+                "train/loss_prior": loss_prior_total / (train_i + 1),
+            })
+
+
+            # if finished training, save jpg recons if they exist
+            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):
+                if blurry_recon:    
+                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215
+                    # transform blurry recon latents to images and plot it
+                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))
+                    jj=-1
+                    for j in [0,1,2,3]:
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                    plt.show()
+
+            progress_bar.set_postfix(**logs)
+
+            if wandb_log: wandb.log(logs)
+            
+    # Save model checkpoint and reconstruct
+    if (ckpt_saving) and (epoch % ckpt_interval == 0):
+        save_ckpt(f'last')
+
+    # wait for other GPUs to catch up if needed
+    accelerator.wait_for_everyone()
+    torch.cuda.empty_cache()
+
+print("\n===Finished!===\n")
+if ckpt_saving:
+    save_ckpt(f'last')
+
+
+# In[ ]:
+
+
+len(test_data)
+
+
+# In[ ]:
+
+
+# # Track metrics here:
+# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999
+
+
+# **To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**
+
+# In[ ]:
+
+
+# MST_pairmate_names
+
+
+# In[ ]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = []
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs.append([utils.find_all_indices(x,p[0]), utils.find_all_indices(x,p[1])])
+    
+pairs = np.array(pairs)
+
+
+# In[ ]:
+
+
+pairs.shape
+
+
+# In[ ]:
+
+
+model.eval()
+logs = {}
+if local_rank == 0:
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for i in range(2):
+            for j in range(2):
+                subset_indices = MST_idx[:, i, j].reshape(-1)
+                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                subset_dl = torch.utils.data.DataLoader(
+                    subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                    drop_last=True, pin_memory=True
+                )
+
+                # Reset metrics for this subset
+                test_fwd_percent_correct = 0
+                test_bwd_percent_correct = 0
+
+                for test_i, behav in enumerate(subset_dl):
+                    behav = behav[0]
+                    loss = 0.
+                    image = images[behav.long().cpu()].to(device)
+                    voxel = vox[behav.long().cpu()]
+                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+                    clip_img_embedder = clip_img_embedder.to(device)
+                    clip_target = clip_img_embedder(image.float())
+
+                    voxel_ridge = model.ridge(voxel, 0)
+                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)
+                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)
+
+                    if clip_scale > 0:
+                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+                    print(test_fwd_percent_correct)
+                    print(test_bwd_percent_correct)
+                    logs.update({
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+
+    print("--- Full Dataset Evaluation ---")
+    for k, v in logs.items():
+        print(f"{k}: {v:.4f}")
+
+
+# In[ ]:
+
+
+# if sub=="sub-002":
+#     unique_images_pairs = [
+#         (2,3),(4,5),(7,8),(15,16),
+#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),
+#         (503, 504), (512, 513), 
+#     ]
+# elif sub != 'sub-001' and session != 'ses-05':
+#     unique_images_pairs = [
+#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),
+#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),
+#         (31,32),(33,34),(35,36),
+#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),
+#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),
+#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),
+#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),
+#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),
+#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),
+#         (847, 848), (849, 850)
+#     ]
+# else:
+#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]
+#     unique_images_pairs = find_mst_pairs(x)
+# # unique_images[unique_images_pairs]
+
+
+# In[ ]:
+
+
+import pdb
+
+
+# In[ ]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        failed_A = []
+        failed_B = []
+        failed_non_corr = []
+
+        # Get all unique image indices
+        all_indices = np.unique(mst_pairs.flatten())
+        
+        # Pre-load all images and betas to device
+        all_images = images[image_idx[all_indices]].to(device)
+        all_voxels = torch.Tensor(vox[image_idx[all_indices]]).unsqueeze(1).to(device)
+        
+        # Get CLIP embeddings for all images
+        all_clip_targets = clip_img_embedder(all_images.float())
+        all_clip_targets_norm = nn.functional.normalize(all_clip_targets.flatten(1), dim=-1)
+        
+        # Pass all betas through model to get MindEye embeddings
+        all_voxel_ridge = model.ridge(all_voxels, 0)
+        _, all_clip_voxels, _ = model.backbone(all_voxel_ridge)
+        all_clip_voxels_norm = nn.functional.normalize(all_clip_voxels.flatten(1), dim=-1)
+        
+        # Dict mapping idx (which indexes the "vox" and "images" tensors) to pos (their position in the flattened array "all_indices")
+        idx_to_pos = {idx: pos for pos, idx in enumerate(all_indices)}
+        
+        # Initialize scores
+        corr_score = 0
+        non_corr_score = 0
+        corr_total = len(mst_pairs) * 2
+        non_corr_total = len(mst_pairs) * (len(mst_pairs)-1) * 4  # number of elements in the matrix excluding the diagonal is n*(n-1)*4 since we're doing this twice each for pairmate A and B
+
+        
+        # Pre-load voxelwise beta-based embeddings from MindEye and CLIP image embeddings
+        idxA = np.array([pair[0] for pair in mst_pairs])
+        idxB = np.array([pair[1] for pair in mst_pairs])
+        
+        posA = np.array([idx_to_pos[idx] for idx in idxA])
+        posB = np.array([idx_to_pos[idx] for idx in idxB])
+        
+        voxA_embeddings = all_clip_voxels_norm[posA]
+        voxB_embeddings = all_clip_voxels_norm[posB]
+        imgA_embeddings = all_clip_targets_norm[posA]
+        imgB_embeddings = all_clip_targets_norm[posB]
+        
+        simA_A = utils.batchwise_cosine_similarity(voxA_embeddings, imgA_embeddings)
+        simA_B = utils.batchwise_cosine_similarity(voxA_embeddings, imgB_embeddings)
+        simB_B = utils.batchwise_cosine_similarity(voxB_embeddings, imgB_embeddings)
+        simB_A = utils.batchwise_cosine_similarity(voxB_embeddings, imgA_embeddings)
+
+        
+        # corresponding 2-AFC
+        # is the voxel embedding for image 1 pairmate A more similar to the CLIP embedding for image 1 pairmate A or the CLIP embedding for image 1 pairmate B?
+        correct_A = torch.diag(simA_A) > torch.diag(simA_B)
+        # is the voxel embedding for image 1 pairmate B more similar to the CLIP embedding for image 1 pairmate B or the CLIP embedding for image 1 pairmate A?
+        correct_B = torch.diag(simB_B) > torch.diag(simB_A)
+
+        corr_score += correct_A.sum().item()
+        corr_score += correct_B.sum().item()
+
+        # Store indices where AFC fails
+        failed_A = [i for i, correct in enumerate(correct_A.cpu()) if not correct]
+        failed_B = [i for i, correct in enumerate(correct_B.cpu()) if not correct]
+        
+        # non-corresponding 2-AFC
+        N = len(mst_pairs)        
+        # Create a mask that is True for all off-diagonal elements
+        row_idx = torch.arange(N).unsqueeze(1)  # (N, 1)
+        col_idx = torch.arange(N).unsqueeze(0)  # (1, N)
+        off_diag_mask = row_idx != col_idx  # shape (N, N)
+        
+        diagA_A = simA_A.diag().unsqueeze(1).expand(-1, N)  # Get diagonal values and expand to (N, N) by duplicating the diagonal element along the rows (since each row is the cosine similarity between a single voxel embedding and all CLIP embeddings)
+        diagB_B = simB_B.diag().unsqueeze(1).expand(-1, N)
+        
+        # pdb.set_trace()
+
+        # Compare each element in the row to the diagonal element
+        off_diag_mask_device = off_diag_mask.to(device)
+
+        fail_AA = (simA_A < diagA_A) & off_diag_mask_device
+        fail_AB = (simA_B < diagA_A) & off_diag_mask_device
+        fail_BB = (simB_B < diagB_B) & off_diag_mask_device
+        fail_BA = (simB_A < diagB_B) & off_diag_mask_device
+
+        non_corr_score += fail_AA.sum().item()
+        non_corr_score += fail_AB.sum().item()
+        non_corr_score += fail_BB.sum().item()
+        non_corr_score += fail_BA.sum().item()
+
+        # Log failed indices
+        fail_sources = [fail_AA, fail_AB, fail_BB, fail_BA]
+        for fail_matrix, label in zip(fail_sources, ["AA", "AB", "BB", "BA"]):
+            fail_coords = torch.nonzero(fail_matrix, as_tuple=False).cpu().numpy()
+            for i, j in fail_coords:
+                failed_non_corr.append({"type": label, "i": i, "j": j, "pair_i": mst_pairs[i], "pair_j": mst_pairs[j]})
+
+    return corr_score, corr_total, int(non_corr_score), non_corr_total, failed_A, failed_B, failed_non_corr
+
+
+# In[ ]:
+
+
+all_scores = []
+all_failures = []
+
+for i in range(4):
+    for j in range(4):
+        mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)
+        corr_score, corr_total, non_corr_score, non_corr_total, failed_A, failed_B, failed_non_corr = evaluate_mst_pairs(mst_pairs)
+
+        # Store scores and failure info together
+        all_scores.append((corr_score, corr_total, non_corr_score, non_corr_total))
+        all_failures.append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "failed_A": failed_A,
+            "failed_B": failed_B,
+            "failed_non_corr": failed_non_corr,
+            "mst_pairs": mst_pairs,
+        })
+
+        # Print summary
+        print(f"pairmate A repeat {i} vs pairmate B repeat {j}:")
+        print(f"2-AFC corresponding = {corr_score}/{corr_total} ({corr_score/corr_total:.2%})")
+        print(f"2-AFC non-corresponding = {non_corr_score}/{non_corr_total} ({non_corr_score/non_corr_total:.2%})")
+        print("")
+
+
+# In[ ]:
+
+
+all_scores = np.array(all_scores)
+print(f"average 2-AFC corresponding: {all_scores[:,0].mean():.2f}/{all_scores[:,1].mean():.2f} ({(all_scores[:,0].sum()/all_scores[:,1].sum()):.2%})")
+print(f"average 2-AFC non-corresponding: {all_scores[:,2].mean():.2f}/{all_scores[:,3].mean():.2f} ({(all_scores[:,2].sum()/all_scores[:,3].sum()):.2%})")
+print(f'chance = 1/{corr_total} ({(1/corr_total):.2%})')
+
+
+# In[ ]:
+
+
+from collections import defaultdict
+
+# Map from image index to failure details
+failed_images = defaultdict(list)
+
+for failure_entry in all_failures:
+    mst_pairs = failure_entry["mst_pairs"]
+    i, j = failure_entry["repeat_A"], failure_entry["repeat_B"]
+
+    # A-side failures
+    for fail_idx in failure_entry["failed_A"]:
+        image_idx = mst_pairs[fail_idx][0]
+        pairmate_idx = mst_pairs[fail_idx][1]
+        failed_images[image_idx].append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "pairmate": pairmate_idx,
+            "type": "A",
+        })
+
+    # B-side failures
+    for fail_idx in failure_entry["failed_B"]:
+        image_idx = mst_pairs[fail_idx][1]
+        pairmate_idx = mst_pairs[fail_idx][0]
+        failed_images[image_idx].append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "pairmate": pairmate_idx,
+            "type": "B",
+        })
+
+
+# In[ ]:
+
+
+# import matplotlib.pyplot as plt
+
+# for img_idx, failure_list in failed_images.items():
+#     print(f"\n==== Failed Image {img_idx} ====")
+
+#     # Load and normalize the embeddings
+#     image = images[img_idx].unsqueeze(0).to(device).float()
+#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)
+
+#     # Get voxel→CLIP embedding
+#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)
+#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]
+#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)
+
+#     # Display original image
+#     print("Original image:")
+#     display(utils.torch_to_Image(images[img_idx]))
+
+#     # Collect unique pairmates involved in the failure
+#     pairmate_indices = list(set(entry["pairmate"] for entry in failure_list))
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     # Compute "correct" similarity — voxel to its own CLIP embedding
+#     correct_clip = image_clip.float()
+#     correct_voxel_sim = (voxel_embed.float() @ correct_clip.T).item()
+#     print(f"Correct voxel→CLIP similarity = {correct_voxel_sim:.4f}")
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     for ax, mate_idx in zip(axs, pairmate_indices):
+#         mate_image = images[mate_idx].unsqueeze(0).to(device).float()
+#         mate_clip = nn.functional.normalize(clip_img_embedder(mate_image).flatten(1), dim=-1).float()
+
+#         # Similarities
+#         clip_sim = (correct_clip @ mate_clip.T).item()
+#         voxel_sim = (voxel_embed.float() @ mate_clip.T).item()
+
+#         # Check if this was the mistaken "higher" match
+#         wrong_match = voxel_sim > correct_voxel_sim
+
+#         # Plot image and annotate
+#         ax.imshow(utils.torch_to_Image(images[mate_idx]))
+#         ax.axis("off")
+#         ax.set_title(f"Pairmate {mate_idx}\nCLIP={clip_sim:.3f}\nVoxel={voxel_sim:.3f}\n{'← WRONG' if wrong_match else ''}",
+#                      color="red" if wrong_match else "black")
+
+
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# comp[20,18] is the only False
+
+
+# In[ ]:
+
+
+# import matplotlib.pyplot as plt
+
+# for img_idx, failure_list in failed_images.items():
+#     print(f"\n==== Failed Image {img_idx} ====")
+
+#     # Load and normalize the embeddings
+#     image = images[img_idx].unsqueeze(0).to(device).float()
+#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)
+
+#     # Get voxel→CLIP embedding
+#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)
+#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]
+#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)
+
+#     # Display original image
+#     print("Original image:")
+#     display(utils.torch_to_Image(images[img_idx]))
+
+#     # Collect unique pairmates involved in the failure
+#     pairmate_indices = list(set(entry["pairmate"] for entry in failure_list))
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     for ax, mate_idx in zip(axs, pairmate_indices):
+#         # Get all CLIP embeddings for failed image and pairmates
+#         all_indices = [img_idx] + pairmate_indices
+#         all_images = images[all_indices].to(device).float()
+#         all_clip_embeds = clip_img_embedder(all_images)
+#         all_clip_embeds = nn.functional.normalize(all_clip_embeds.flatten(1), dim=-1).float()
+
+#         # Compare voxel embedding for the failed image to all CLIP embeddings
+#         sims = (voxel_embed.float() @ all_clip_embeds.T).squeeze().cpu().detach().numpy()  # shape: (1, N) → (N,)
+#         image_ids = ["correct"] + [f"pairmate {idx}" for idx in pairmate_indices]
+
+#         # Sort and display
+#         sorted_sims = sorted(zip(image_ids, all_indices, sims), key=lambda x: -x[2])
+
+#         print("\n🧠 Voxel→CLIP similarity ranking:")
+#         for label, idx, sim in sorted_sims:
+#             print(f"{label:12} (index {idx:3}): similarity = {sim:.4f}")
+
+#         # Optional assertion: did any pairmate score higher than the correct image?
+#         correct_sim = sims[0]
+#         higher = [(label, sim) for label, _, sim in sorted_sims[1:] if sim > correct_sim]
+#         if higher:
+#             print("\n❌ Mismatch detected: voxel embedding matched other images more than the correct one!")
+#         else:
+#             print("\n✅ Model correctly ranked the correct image highest (despite failure elsewhere)")
+
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+mst_pairs[:5]
+
+
+# In[ ]:
+
+
+pairs[0]
+
+
+# In[ ]:
+
+
+# images[image_idx[pairs[0][0]]].shape
+
+
+# In[ ]:
+
+
+ix = 0
+display(utils.torch_to_Image(images[pairs[ix][0]]))
+display(utils.torch_to_Image(images[pairs[ix][1]]))
+
+
+# In[ ]:
+
+
+# print(np.allclose(embed_A[0], embed_A[1]))  # across repeats
+# print(np.allclose(embed_A[0], embed_B[0]))  # across pairmates
+
+
+# In[ ]:
+
+
+# def generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=2):
+#     n_imgs, n_pairmates, n_repeats = pairs.shape
+#     nonmatch_pairs = []
+
+#     for i in range(n_imgs):
+#         other_idxs = [j for j in range(n_imgs) if j != i]
+#         sampled_j = np.random.choice(other_idxs, size=num_images_per_source, replace=False)
+
+#         for j in sampled_j:
+#             for _ in range(num_repeats):
+#                 a_side = np.random.randint(2)
+#                 b_side = np.random.randint(2)
+#                 a_repeat = np.random.randint(n_repeats)
+#                 b_repeat = np.random.randint(n_repeats)
+
+#                 pair_a = pairs[i, a_side, a_repeat]
+#                 pair_b = pairs[j, b_side, b_repeat]
+#                 nonmatch_pairs.append([pair_a, pair_b])
+
+#     return np.array(nonmatch_pairs)
+
+
+# In[ ]:
+
+
+# nonmatch_pairs = generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=1)
+# results = evaluate_mst_pairs(nonmatch_pairs)
+# print(results)
+
+
+# In[ ]:
+
+
+# # Compare first few pairs
+# for pair in pairs:  # Checking first 2 pairs
+#     print("Indices in mst_pairs:", pair)
+#     print("Corresponding filenames:")
+#     print(f"Image 1: {x[pair[0]]}")
+#     print(f"Image 2: {x[pair[1]]}\n")
+
+
+# In[ ]:
+
+
+# for i in range(len(pairs)):
+#     fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())
+#     ax[0].set_title(f"Repeat 1")
+
+#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())
+#     ax[1].set_title(f"Repeat 2")
+
+#     plt.setp(ax, xticks=[], yticks=[])
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# score = 0
+# total = 0
+# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): 
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageA_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimA > cossimB:
+#             score += 1
+#         total += 1
+        
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageB_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimB > cossimA:
+#             score += 1
+#         total += 1
+
+# print(score/total)
+
+
+# In[ ]:
+
+
+#display(utils.torch_to_Image(imageA))
+#display(utils.torch_to_Image(imageB))
+
+
+# In[ ]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(np.array(unique_images_pairs).flatten())
+# assert total_samples == 100
+
+# correct_predictions = int((score/total) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+
+

main-finetune.py

@@ -0,0 +1,2280 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Import packages & functions
+
+# In[1]:
+
+
+print("importing modules")
+import os
+import sys
+import json
+import argparse
+import numpy as np
+import time
+import random
+import string
+import h5py
+from tqdm import tqdm
+import webdataset as wds
+from PIL import Image
+import pandas as pd
+import nibabel as nib
+import nilearn
+
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+# tf32 data type is faster than standard float32
+torch.backends.cuda.matmul.allow_tf32 = True
+
+import utils
+from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas
+
+# imports utils from mindeye_preproc as "preproc"
+import importlib.util
+parent_utils_path = "/home/ri4541/mindeye_preproc/analysis/utils.py"
+spec = importlib.util.spec_from_file_location("utils", parent_utils_path)
+preproc = importlib.util.module_from_spec(spec)
+parent_dir = os.path.dirname(parent_utils_path)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+spec.loader.exec_module(preproc)
+
+if utils.is_interactive():
+    from IPython.display import clear_output # function to clear print outputs in cell
+    get_ipython().run_line_magic('load_ext', 'autoreload')
+    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions
+    get_ipython().run_line_magic('autoreload', '2')
+    
+seed = utils.get_slurm_seed()
+
+
+# # Princeton data prep
+
+# ## Load Data & Design
+
+# In[2]:
+
+
+if utils.is_interactive():
+    sub = "sub-005"
+    session = "all"
+    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format
+    func_task_name = 'C'
+else:
+    sub = os.environ["sub"]
+    session = os.environ["session"]
+    task = os.environ["task"]
+    func_task_name = 'C'
+
+if session == "all":
+    ses_list = ["ses-01", "ses-02", "ses-03"]  # list of actual session IDs
+    design_ses_list = ["ses-01", "ses-02", "ses-03"]  # list of session IDs to search for design matrix
+else:
+    ses_list = [session]
+    design_ses_list = [session]
+    
+task_name = f"_task-{task}" if task != 'study' else ''
+resample_voxel_size = False
+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
+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
+    
+train_test_split = 'MST' # 'MST', 'orig', 'unique'
+remove_close_to_MST = False
+remove_random_n = False
+
+if remove_close_to_MST or remove_random_n:
+    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images
+
+n_to_remove = 0
+if remove_random_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_to_remove = 150
+    
+if resample_voxel_size:
+    # voxel size was unchanged in glmsingle, want to perform resampling here
+    resampled_vox_size = 2.5
+    resample_method = "sinc"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html
+    
+    # file name helper variables
+    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore
+    resampled_suffix = f"resampled_{vox_dim_str}mm_{resample_method}"
+    mask_resampled_suffix = resampled_suffix
+    if resample_post_glmsingle:
+        resampled_suffix += '_postglmsingle'
+    else:
+        resampled_suffix += '_preglmsingle'
+
+
+# In[3]:
+
+
+session_label = preproc.get_session_label(ses_list)
+print('session label:', session_label)
+n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)
+
+
+# In[4]:
+
+
+if utils.is_interactive():
+    glmsingle_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}"
+else:
+    glmsingle_path = os.environ["glmsingle_path"]
+    
+designdir = "/home/ri4541/real_time_mindEye2"
+print(glmsingle_path)
+
+if resample_voxel_size:
+    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here
+    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here
+    if resample_post_glmsingle:
+        # option 1
+        orig_glmsingle_path = glmsingle_path
+        glmsingle_path += f"_{resampled_suffix}"
+        print("resampled glmsingle path:", glmsingle_path)
+        if load_from_resampled_file:
+            # resampling is already done; load from file
+             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here
+        else:
+            # don't load from file; do resampling here
+            os.makedirs(glmsingle_path,exist_ok=True)
+    else:
+        # option 2
+        glmsingle_path += f"_{resampled_suffix}"
+        print("glmsingle path:", glmsingle_path)
+
+assert os.path.exists(glmsingle_path)
+print("glmsingle path exists!")
+
+
+# In[5]:
+
+
+data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(
+    sub=sub,
+    session=session,
+    func_task_name=task,
+    designdir=designdir,
+    design_ses_list=design_ses_list
+)
+
+if sub == 'sub-001':
+    if session == 'ses-01':
+        assert image_names[0] == 'images/image_686_seed_1.png'
+    elif session in ('ses-02', 'all'):
+        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'
+    elif session == 'ses-03':
+        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'
+    elif session == 'ses-04':
+        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+elif sub == 'sub-003':
+    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+
+unique_images = np.unique(image_names.astype(str))
+unique_images = unique_images[(unique_images!="nan")]
+len_unique_images = len(unique_images)
+print("n_runs",n_runs)
+
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(unique_images) == 851
+
+print(image_names[:4])
+print(starts[:4])
+print(is_new_run[:4])
+
+if remove_random_n:
+    # want to remove 150 imgs
+    # 100 special515 imgs are repeated 3x (300 total)
+    # all other train imgs are only shown once (558 total)
+    # of the 150, want to sample proportionally since we're cutting all repeats for special515
+    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total
+    np.random.seed(seed)
+    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)
+    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)
+    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)
+    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))
+
+image_idx = np.array([])  # contains the unique index of each presented image
+vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx
+all_MST_images = dict()
+for i, im in enumerate(image_names):
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    vox_image_names = np.append(vox_image_names, im)
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            i+=1
+            continue
+    elif remove_random_n:
+        if im in imgs_to_remove:
+            i+=1
+            continue
+            
+    image_idx_ = np.where(im==unique_images)[0].item()
+    image_idx = np.append(image_idx, image_idx_)
+    
+    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
+        import re
+        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)):  
+        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it
+            # print(im)
+            all_MST_images[i] = im
+            i+=1            
+    elif 'MST' in im:
+        all_MST_images[i] = im
+        i+=1
+    
+image_idx = torch.Tensor(image_idx).long()
+# for im in new_image_names[MST_images]:
+#     assert 'MST_pairs' in im
+# assert len(all_MST_images) == 300
+
+unique_MST_images = np.unique(list(all_MST_images.values())) 
+
+MST_ID = np.array([], dtype=int)
+if remove_close_to_MST:
+    close_to_MST_idx = np.array([], dtype=int)
+if remove_random_n:
+    random_n_idx = np.array([], dtype=int)
+
+vox_idx = np.array([], dtype=int)
+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
+for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            i+=1
+            continue
+    if remove_random_n:
+        if im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            i+=1
+            j+=1
+            continue
+    j+=1
+    curr = np.where(im == unique_MST_images)
+    # print(curr)
+    if curr[0].size == 0:
+        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
+    else:
+        MST_ID = np.append(MST_ID, curr)
+        
+assert len(MST_ID) == len(image_idx)
+# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)
+# 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
+print(MST_ID.shape)
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(all_MST_images) == 100
+
+
+# ## Load images
+
+# In[ ]:
+
+
+import imageio.v2 as imageio
+resize_transform = transforms.Resize((224, 224))
+MST_images = []
+images = None
+for im_name in tqdm(image_idx):
+    if sub == 'sub-001' and session == 'ses-01':
+        image_file = f"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}"
+    else:
+        image_file = f"{unique_images[im_name]}"
+    im = imageio.imread(image_file)
+    im = torch.Tensor(im / 255).permute(2,0,1)
+    im = resize_transform(im.unsqueeze(0))
+    if images is None:
+        images = im
+    else:
+        images = torch.vstack((images, im))
+    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+        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)):  
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+    else:   
+        if ("MST_pairs" in image_file): # ("_seed_" not in unique_images[im_name]) and (unique_images[im_name] != "blank.jpg") 
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+
+print("images", images.shape)
+MST_images = np.array(MST_images)
+print("MST_images", len(MST_images))
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(MST_images[MST_images==True]) == 100
+print("MST_images==True", len(MST_images[MST_images==True]))
+
+
+# In[ ]:
+
+
+# want IDs of pairmates based on MST_images
+# create "MST_pairmates" which is a 25x2 array with indices of the 25 pairs based on MST_images == True
+
+assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2
+MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)
+# print(MST_pairmate_names)
+
+MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for p, pair in enumerate(MST_pairmate_names):
+    for i, im in enumerate(pair):
+        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
+        
+print(MST_pairmate_indices.shape, MST_pairmate_indices)
+
+
+# In[ ]:
+
+
+if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):
+    # MST_pairs contains the indices of repeats based on all_MST_images
+    # all_MST_images contains the indices of images from image_names
+    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))
+    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
+
+    # assert images[MST_pairs]
+
+    fig, ax = plt.subplots(1, 3, figsize=(10,4))
+    fig.suptitle('Sample MST pairs')
+
+    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())
+    ax[0].set_title(f"Trial 0")
+
+    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())
+    ax[1].set_title(f"Trial 1")
+
+    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())
+    ax[2].set_title(f"Trial 2")
+
+    plt.setp(ax, xticks=[], yticks=[])
+    plt.tight_layout()
+    plt.show()
+
+
+# In[ ]:
+
+
+# pairs has the indices of all repeated images
+pairs = utils.find_paired_indices(image_idx)
+pairs = sorted(pairs, key=lambda x: x[0])
+
+fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns
+for i, ax in enumerate(axes):
+    ax.imshow(images[i].permute(1, 2, 0).numpy())
+    ax.set_title(f"Trial {i}")
+    ax.axis("off")  # Hide axes for better visualization
+
+plt.tight_layout()
+# output_path = os.path.join(output_dir, "trials_plot.png")
+# plt.savefig(output_path, dpi=300)  # Save figure
+plt.show()
+
+
+# In[ ]:
+
+
+p=0
+
+# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)
+fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())
+ax[0].set_title(f"Repeat 1")
+
+ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())
+ax[1].set_title(f"Repeat 2")
+
+plt.setp(ax, xticks=[], yticks=[])
+plt.tight_layout()
+plt.show()
+
+
+# In[ ]:
+
+
+def get_image_pairs(sub, session, func_task_name, designdir):
+    """Loads design files and processes image pairs for a given session."""
+    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(
+        sub=sub,
+        session=session,
+        func_task_name=func_task_name,
+        designdir=designdir,
+        design_ses_list=[session]  # Ensure it's a list
+    )
+    return utils.process_images(image_names, unique_images)
+
+
+# In[ ]:
+
+
+from collections import defaultdict
+
+all_dicts = []
+for s_idx, s in enumerate(ses_list):
+    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)
+    assert len(im) == len(vo)
+    all_dicts.append({k:v for k,v in enumerate(vo)})
+
+# for the train set (ses-01-02 non-MST)
+image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])
+for ses_idx, idx_to_name in enumerate(all_dicts):
+    for idx, name in idx_to_name.items():
+        image_to_indices[name][ses_idx].append(idx)
+        
+image_to_indices = dict(image_to_indices)
+
+# for the test set (ses-03)
+# test_image_to_indices = defaultdict(lambda: [[] for _ in range(len([ses_list[-1]]))])
+# for ses_idx, idx_to_name in enumerate([all_dicts[-1]]):
+#     for idx, name in idx_to_name.items():
+#         test_image_to_indices[name][ses_idx].append(idx)
+        
+# test_image_to_indices = dict(test_image_to_indices)
+
+if sub == 'sub-005' and len(ses_list) > 1:
+    session_length = 693
+    for image, session_indices_list in image_to_indices.items():
+        new_indices_list = []
+        for idx, indices in enumerate(session_indices_list):
+            offset = idx * session_length
+            new_indices = [i + offset for i in indices]
+            new_indices_list.append(new_indices)
+        image_to_indices[image] = new_indices_list
+        
+    import itertools
+    assert max(itertools.chain.from_iterable(list(image_to_indices.values())))[0] == (len(ses_list)*session_length) - 1
+
+
+# In[ ]:
+
+
+if resample_voxel_size:
+    from nilearn.masking import apply_mask, unmask
+    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'
+    omat_name = f'{glmsingle_path}/boldref_omat'
+
+
+# In[ ]:
+
+
+from nilearn.plotting import plot_roi
+
+print('loading brain mask')
+avg_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')
+final_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')
+
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+plot_roi(final_mask, bg_img=avg_mask)
+plt.show()
+
+
+# In[ ]:
+
+
+# # create union of ses-01 and ses-02 reliability masks and plot against avg_mask 
+# rel_masks = []
+# 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'))
+# 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'))
+# rel_masks = np.array(rel_masks)
+# for r in rel_masks:
+#     assert r.shape[0] == int(final_mask.get_fdata().sum())
+#     assert r.dtype == bool
+    
+# assert len(rel_masks) == 2  # should be the case if there's 2 training sessions
+# union_mask = np.logical_or(rel_masks[0], rel_masks[1])
+# assert union_mask.sum() > rel_masks[0].sum()
+# assert union_mask.sum() > rel_masks[1].sum()
+# 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')
+# print(f'{(union_mask.sum() / int(final_mask.get_fdata().sum())):.2%} of the voxels in the roi were selected')
+# path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy'
+path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy'
+# np.save(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy', union_mask)
+# print(f'saved union mask to {path}!')
+union_mask = np.load(path)
+
+
+# ## Load GLMSingle voxel data
+
+# In[ ]:
+
+
+ses_mask = []
+
+for s in ses_list:
+    ses_mask_path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{s}_task-C/sub-005_{s}_task-C_brain.nii.gz'
+    ses_mask.append(nib.load(ses_mask_path))
+    
+    assert np.all(ses_mask[-1].affine == final_mask.affine)
+    assert np.all(ses_mask[-1].shape == final_mask.shape)
+
+
+# In[ ]:
+
+
+ses_vox = []
+vox = None
+needs_postprocessing = False
+params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)
+
+if resample_post_glmsingle == True:
+    glm_save_path_resampled = f"{glmsingle_path}/vox_resampled.nii.gz"
+    if load_from_resampled_file == True:
+        # resampling was done in this notebook so we can load from file
+        vox = nib.load(glm_save_path_resampled)
+    else:
+        # do resampling here
+        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"
+        vox = load_preprocess_betas(orig_glmsingle_path, *params)
+        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)
+    needs_postprocessing = True
+
+if vox is None:    
+    for i, s in enumerate(ses_list):
+        # either resampling was done in glmsingle or we aren't resampling 
+        ses_vox_path = f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{s}_task-C'
+        assert os.path.exists(ses_vox_path)
+        ses_vox.append(load_preprocess_betas(ses_vox_path, *params))
+        v = nilearn.masking.unmask(ses_vox[i], ses_mask[i])
+        ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)
+    vox = np.concatenate(ses_vox)
+    print("applied final brain mask")
+    print(vox.shape)
+    vox = vox[:, union_mask]
+    print("applied union roi mask")
+    print(vox.shape)
+    
+    
+if needs_postprocessing == True:
+    vox = apply_mask(vox, avg_mask)
+    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)
+    print(vox.shape)
+
+assert len(vox) == len(image_idx)
+
+
+# In[ ]:
+
+
+# # get vox into the same shape as the union mask
+# v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask
+# final_mask = nilearn.masking.intersect_masks([avg_mask, roi])
+# vox = nilearn.masking.apply_mask(vox, final_mask)  # re-flatten based on final mask so everything is in the same shape now
+# print(vox.shape)
+
+
+# In[ ]:
+
+
+pairs_homog = np.array([[p[0], p[1]] for p in pairs])
+
+
+# In[ ]:
+
+
+same_corrs = []
+diff_corrs = []
+for isamp, samp in enumerate(vox[pairs_homog]):
+    avg_same_img = []
+    for i in range(samp.shape[0]):
+        for j in range(i, samp.shape[0]):
+            if i != j:
+                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))
+    
+    same_corrs.append(np.mean(avg_same_img))
+                       
+    avg_diff_img = []
+    for isamp_j, samp_j in enumerate(vox[pairs_homog]):
+        if isamp_j != isamp:
+            for i in range(samp_j.shape[0]):
+                for j in range(i, samp_j.shape[0]):
+                    if i != j:
+                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))
+                                    
+    # print(len(avg_diff_img))
+    diff_corrs.append(np.mean(avg_diff_img))
+
+
+print(len(same_corrs), len(diff_corrs))
+same_corrs = np.array(same_corrs)
+diff_corrs = np.array(diff_corrs)
+
+
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same/diff Pearson corr.")
+plt.plot(np.sort(same_corrs),c='blue',label='same')
+plt.plot(np.sort(diff_corrs),c='cyan',label='diff')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# In[ ]:
+
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same minus diff difference Pearson corr.")
+plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# # Training MindEye
+
+# In[ ]:
+
+
+utils.seed_everything(seed)
+
+if train_test_split == 'orig':
+    # train = all images except images that were repeated
+    # test = average of the same-image presentations
+    imageTrain = np.arange(len(images))
+    train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])
+    test_image_indices = pairs
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+elif train_test_split == 'MST':
+    # non-MST images are the train split
+    # MST images are the test split
+    MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])
+    non_MST_idx = [v for k,v in image_to_indices.items() if 'MST_pairs' not in k]
+    non_MST_idx = np.array([z for y in non_MST_idx for x in y for z in x])  # flatten the indices
+    train_image_indices = non_MST_idx
+    test_image_indices = MST_idx.flatten()  # MST_idx contains the mapping for the different test sets; test_image_indices has all MST indices combined
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(vox)
+elif train_test_split == 'unique':
+    imageTest = np.arange(len(images))
+    train_image_indices = pairs.flatten()
+    test_image_indices = np.array([item for item in imageTest if item not in pairs.flatten()])
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+else:
+    raise Exception("invalid train_test_split")
+
+# TODO add assertion that verifies file names in train and test don't overlap, guards against repeats
+
+for i in train_image_indices:
+    assert i not in test_image_indices
+
+
+# In[ ]:
+
+
+ses_split = vox[train_image_indices].shape[0] // 2
+
+train_mean_s1 = np.mean(vox[train_image_indices][:ses_split], axis=0)
+train_std_s1 = np.std(vox[train_image_indices][:ses_split], axis=0)
+train_mean_s2 = np.mean(vox[train_image_indices][ses_split:], axis=0)
+train_std_s2 = np.std(vox[train_image_indices][ses_split:], axis=0)
+
+
+vox[:ses_split] = utils.zscore(vox[:ses_split],train_mean=train_mean_s1,train_std=train_std_s1)
+vox[ses_split:] = utils.zscore(vox[ses_split:],train_mean=train_mean_s2,train_std=train_std_s2)
+
+print("voxels have been zscored")
+print("ses-01:", vox[:ses_split,0].mean(), vox[:ses_split,0].std())
+print("ses-02:", vox[ses_split:,0].mean(), vox[ses_split:,0].std())
+print("vox", vox.shape)
+
+
+# In[ ]:
+
+
+# save the mean and std from ses-01 and 02
+train_test_mean_s1 = np.mean(vox[:ses_split], axis=0)
+train_test_std_s1 = np.std(vox[:ses_split], axis=0)
+train_test_mean_s2 = np.mean(vox[ses_split:], axis=0)
+train_test_std_s2 = np.std(vox[ses_split:], axis=0)
+print(train_test_mean_s1.shape)
+assert np.all(train_test_mean_s1.shape == train_test_std_s1.shape)
+assert np.all(train_test_mean_s1.shape == train_test_mean_s2.shape)
+assert np.all(train_test_mean_s1.shape == train_test_std_s2.shape)
+
+
+# In[ ]:
+
+
+# for idx in deleted_indices:
+#     # check image names to be deleted match
+#     original_name = vox_image_dict[idx]
+#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]
+#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \
+#         f"Mismatch in image names for deleted indices {matching_indices}"
+
+#     # check image data to be deleted match
+#     base_image = images[matching_indices[0]]  # Reference image
+#     for i in matching_indices[1:]:
+#         assert np.array_equal(base_image, images[i]), \
+#             f"Mismatch in image data for {vox_image_dict[i]} at index {i}"
+
+# images = images[kept_indices]
+
+
+# In[ ]:
+
+
+images = torch.Tensor(images)
+vox = torch.Tensor(vox)
+assert len(images) == len(vox)
+
+
+# In[ ]:
+
+
+### Multi-GPU config ###
+from accelerate import Accelerator, DeepSpeedPlugin
+
+local_rank = os.getenv('RANK')
+if local_rank is None: 
+    local_rank = 0
+else:
+    local_rank = int(local_rank)
+print("LOCAL RANK ", local_rank)  
+
+data_type = torch.float32 # change depending on your mixed_precision
+
+accelerator = Accelerator(split_batches=False)
+batch_size = 8 
+
+
+# In[ ]:
+
+
+print("PID of this process =",os.getpid())
+device = accelerator.device
+print("device:",device)
+world_size = accelerator.state.num_processes
+distributed = not accelerator.state.distributed_type == 'NO'
+num_devices = torch.cuda.device_count()
+global_batch_size = batch_size * num_devices
+print("global_batch_size", global_batch_size)
+if num_devices==0 or not distributed: num_devices = 1
+num_workers = num_devices
+print(accelerator.state)
+
+# set data_type to match your mixed precision (automatically set based on deepspeed config)
+if accelerator.mixed_precision == "bf16":
+    data_type = torch.bfloat16
+elif accelerator.mixed_precision == "fp16":
+    data_type = torch.float16
+else:
+    data_type = torch.float32
+
+print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type)
+print = accelerator.print # only print if local_rank=0
+
+
+# ## Configurations
+
+# In[ ]:
+
+
+# if running this interactively, can specify jupyter_args here for argparser to use
+if utils.is_interactive():
+    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'
+    print("model_name:", model_name)
+    
+    # global_batch_size and batch_size should already be defined in the above cells
+    # other variables can be specified in the following string:
+    # jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}"
+
+    jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \
+                    --model_name={model_name} \
+                    --no-multi_subject --subj=1 --batch_size={batch_size} \
+                    --hidden_dim=1024 --clip_scale=1. \
+                    --no-blurry_recon --blur_scale=.5 \
+                    --no-use_prior --prior_scale=30 \
+                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \
+                    --ckpt_interval=999 --no-ckpt_saving --new_test \
+                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep"
+    print(jupyter_args)
+    jupyter_args = jupyter_args.split()
+
+
+# In[ ]:
+
+
+parser = argparse.ArgumentParser(description="Model Training Configuration")
+parser.add_argument(
+    "--model_name", type=str, default="testing",
+    help="name of model, used for ckpt saving and wandb logging (if enabled)",
+)
+parser.add_argument(
+    "--data_path", type=str, default="/weka/proj-fmri/shared/natural-scenes-dataset",
+    help="Path to where NSD data is stored / where to download it to",
+)
+parser.add_argument(
+    "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8],
+    help="Validate on which subject?",
+)
+parser.add_argument(
+    "--multisubject_ckpt", type=str, default=None,
+    help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.",
+)
+parser.add_argument(
+    "--num_sessions", type=int, default=0,
+    help="Number of training sessions to include (if multi_subject, this variable doesnt matter)",
+)
+parser.add_argument(
+    "--use_prior",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)",
+)
+parser.add_argument(
+    "--batch_size", type=int, default=32,
+    help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser",
+)
+parser.add_argument(
+    "--wandb_log",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to log to wandb",
+)
+parser.add_argument(
+    "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False,
+    help="if not using wandb and want to resume from a ckpt",
+)
+parser.add_argument(
+    "--wandb_project",type=str,default="stability",
+    help="wandb project name",
+)
+parser.add_argument(
+    "--mixup_pct",type=float,default=.33,
+    help="proportion of way through training when to switch from BiMixCo to SoftCLIP",
+)
+parser.add_argument(
+    "--low_mem",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to preload images to cpu to speed things up but consume more memory",
+)
+parser.add_argument(
+    "--blurry_recon",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to output blurry reconstructions",
+)
+parser.add_argument(
+    "--blur_scale",type=float,default=.5,
+    help="multiply loss from blurry recons by this number",
+)
+parser.add_argument(
+    "--clip_scale",type=float,default=1.,
+    help="multiply contrastive loss by this number",
+)
+parser.add_argument(
+    "--prior_scale",type=float,default=30,
+    help="multiply diffusion prior loss by this",
+)
+parser.add_argument(
+    "--use_image_aug",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to use image augmentation",
+)
+parser.add_argument(
+    "--num_epochs",type=int,default=120,
+    help="number of epochs of training",
+)
+parser.add_argument(
+    "--multi_subject",action=argparse.BooleanOptionalAction,default=False,
+)
+parser.add_argument(
+    "--new_test",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--n_blocks",type=int,default=2,
+)
+parser.add_argument(
+    "--hidden_dim",type=int,default=1024,
+)
+parser.add_argument(
+    "--seq_past",type=int,default=0,
+)
+parser.add_argument(
+    "--seq_future",type=int,default=0,
+)
+parser.add_argument(
+    "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'],
+)
+parser.add_argument(
+    "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--ckpt_interval",type=int,default=5,
+    help="save backup ckpt and reconstruct every x epochs",
+)
+parser.add_argument(
+    "--seed",type=int,default=42,
+)
+parser.add_argument(
+    "--max_lr",type=float,default=3e-4,
+)
+
+if utils.is_interactive():
+    args = parser.parse_args(jupyter_args)
+else:
+    args = parser.parse_args()
+
+# create global variables without the args prefix
+for attribute_name in vars(args).keys():
+    globals()[attribute_name] = getattr(args, attribute_name)
+    
+outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+if not os.path.exists(outdir) and ckpt_saving:
+    os.makedirs(outdir,exist_ok=True)
+    
+if use_image_aug or blurry_recon:
+    import kornia
+    import kornia.augmentation as K
+    from kornia.augmentation.container import AugmentationSequential
+if use_image_aug:
+    img_augment = AugmentationSequential(
+        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),
+        same_on_batch=False,
+        data_keys=["input"],
+    )
+    # Define the blurring augmentations
+    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)
+    
+if multi_subject:
+    subj_list = np.arange(1,9)
+    subj_list = subj_list[subj_list != subj]
+else:
+    subj_list = [subj]
+
+print("subj_list", subj_list, "num_sessions", num_sessions)
+
+
+# ## Prep data, models, and dataloaders
+
+# In[ ]:
+
+
+if ckpt_saving:
+    # save MST_ID for 2-alternative forced-choice retrieval evaluation 
+    if 'MST' in model_name:
+        eval_dir = os.environ["eval_dir"]
+        print('saving MST info in', eval_dir)
+        # Saving ##
+        if not os.path.exists(eval_dir):
+            os.mkdir(eval_dir)
+
+        np.save(f"{eval_dir}/MST_ID.npy", MST_ID)
+        np.save(f"{eval_dir}/MST_pairmate_indices.npy", MST_pairmate_indices)
+
+    if remove_random_n:
+        np.save(f"{eval_dir}/imgs_to_remove.npy", imgs_to_remove)
+
+    np.save(f"{eval_dir}/train_image_indices.npy", train_image_indices)
+    np.save(f"{eval_dir}/test_image_indices.npy", test_image_indices)
+    np.save(f"{eval_dir}/images.npy", images)
+    np.save(f"{eval_dir}/vox.npy", vox)
+    
+    np.save(f'{eval_dir}/train_test_mean_s1.npy', train_test_mean_s1)
+    np.save(f'{eval_dir}/train_test_std_s1.npy', train_test_std_s1)
+    np.save(f'{eval_dir}/train_test_mean_s2.npy', train_test_mean_s2)
+    np.save(f'{eval_dir}/train_test_std_s2.npy', train_test_std_s2)
+
+
+# ### Creating wds dataloader, preload betas and all 73k possible images
+
+# In[ ]:
+
+
+def my_split_by_node(urls): return urls
+num_voxels_list = []
+
+if multi_subject:
+    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])
+    num_samples_per_epoch = (750*40) // num_devices 
+else:
+    # num_samples_per_epoch = (750*num_sessions) // num_devices 
+    num_samples_per_epoch = len(train_image_indices)
+
+print("dividing batch size by subj_list, which will then be concatenated across subj during training...") 
+batch_size = batch_size // len(subj_list)
+
+num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))
+
+print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch)
+
+
+# In[ ]:
+
+
+train_data = {}
+train_dl = {}
+
+train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))
+test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))
+
+
+# In[ ]:
+
+
+num_voxels = {}
+voxels = {}
+for s in subj_list:
+    print(f"Training with {num_sessions} sessions")
+    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True)
+
+    num_voxels_list.append(vox[0].shape[-1])
+    num_voxels[f'subj0{s}'] = vox[0].shape[-1]
+    voxels[f'subj0{s}'] = vox
+    print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}")
+
+print("Loaded all subj train dls and vox!\n")
+
+# Validate only on one subject
+if multi_subject: 
+    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list
+test_dl = torch.utils.data.DataLoader(test_data, batch_size=24, shuffle=False, drop_last=True, pin_memory=True)
+
+print(f"Loaded test dl for subj{subj}!\n")
+
+
+# ## Load models
+
+# ### CLIP image embeddings  model
+
+# In[ ]:
+
+
+## USING OpenCLIP ViT-bigG ###
+sys.path.append('generative_models/')
+import sgm
+from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder
+# from generative_models.sgm.models.diffusion import DiffusionEngine
+# from omegaconf import OmegaConf
+
+try:
+    print(clip_img_embedder)
+except:
+    clip_img_embedder = FrozenOpenCLIPImageEmbedder(
+        arch="ViT-bigG-14",
+        version="laion2b_s39b_b160k",
+        output_tokens=True,
+        only_tokens=True,
+    )
+    clip_img_embedder.to(device)
+clip_seq_dim = 256
+clip_emb_dim = 1664
+
+# ## USING OPEN AI CLIP ViT-L ###
+# import clip
+# try:
+#     print(clip_model)
+# except:
+#     clip_model, preprocess = clip.load("ViT-L/14", device=device)
+#     preprocess = transforms.Compose([
+#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),
+#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+#                              std=[0.26862954, 0.26130258, 0.27577711]),
+#     ])
+# def clip_img_embedder(image):
+#     preproc_img = preprocess(image)
+#     return clip_model.encode_image(preproc_img)
+# clip_seq_dim = 1
+# clip_emb_dim = 768
+
+
+# ### MindEye modules
+
+# In[ ]:
+
+
+model = utils.prepare_model_and_training(
+    num_voxels_list=num_voxels_list,
+    n_blocks=n_blocks,
+    hidden_dim=hidden_dim,
+    clip_emb_dim=clip_emb_dim,
+    clip_seq_dim=clip_seq_dim,
+    use_prior=use_prior,
+    clip_scale=clip_scale
+)
+
+
+# In[ ]:
+
+
+# test on subject 1 with fake data
+b = torch.randn((2,1,num_voxels_list[0]))
+print(b.shape, model.ridge(b,0).shape)
+
+
+# In[ ]:
+
+
+# test that the model works on some fake data
+b = torch.randn((2,1,hidden_dim))
+print("b.shape",b.shape)
+
+backbone_, clip_, blur_ = model.backbone(b)
+print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)
+
+
+# ### Adding diffusion prior + unCLIP if use_prior=True
+
+# In[ ]:
+
+
+if use_prior:
+    from models import *
+
+    # setup diffusion prior network
+    out_dim = clip_emb_dim
+    depth = 6
+    dim_head = 52
+    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+    timesteps = 100
+
+    prior_network = VersatileDiffusionPriorNetwork(
+            dim=out_dim,
+            depth=depth,
+            dim_head=dim_head,
+            heads=heads,
+            causal=False,
+            num_tokens = clip_seq_dim,
+            learned_query_mode="pos_emb"
+        )
+
+    model.diffusion_prior = BrainDiffusionPrior(
+        net=prior_network,
+        image_embed_dim=out_dim,
+        condition_on_text_encodings=False,
+        timesteps=timesteps,
+        cond_drop_prob=0.2,
+        image_embed_scale=None,
+    )
+    
+    utils.count_params(model.diffusion_prior)
+    utils.count_params(model)
+
+
+# ### Setup optimizer / lr / ckpt saving
+
+# In[ ]:
+
+
+no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+opt_grouped_parameters = [
+    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},
+    {'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},
+    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
+]
+# model.backbone.requires_grad_(False)
+
+if use_prior:
+    opt_grouped_parameters.extend([
+        {'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},
+        {'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}
+    ])
+
+optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)
+
+if lr_scheduler_type == 'linear':
+    lr_scheduler = torch.optim.lr_scheduler.LinearLR(
+        optimizer,
+        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),
+        last_epoch=-1
+    )
+elif lr_scheduler_type == 'cycle':
+    if num_iterations_per_epoch==0:
+        num_iterations_per_epoch=1
+    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))
+    print("total_steps", total_steps)
+    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, 
+        max_lr=max_lr,
+        total_steps=total_steps,
+        final_div_factor=1000,
+        last_epoch=-1, pct_start=2/num_epochs
+    )
+    
+def save_ckpt(tag):
+    ckpt_path = outdir+f'/{tag}.pth'
+    if accelerator.is_main_process:
+        unwrapped_model = accelerator.unwrap_model(model)
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': unwrapped_model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'lr_scheduler': lr_scheduler.state_dict(),
+            'train_losses': losses,
+            'test_losses': test_losses,
+            'lrs': lrs,
+            }, ckpt_path)
+    print(f"\n---saved {outdir}/{tag} ckpt!---\n")
+
+def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): 
+    print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')
+    state_dict = checkpoint['model_state_dict']
+    if multisubj_loading: # remove incompatible ridge layer that will otherwise error
+        state_dict.pop('ridge.linears.0.weight',None)
+    model.load_state_dict(state_dict, strict=strict)
+    if load_epoch:
+        globals()["epoch"] = checkpoint['epoch']
+        print("Epoch",epoch)
+    if load_optimizer:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    if load_lr:
+        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+    del checkpoint
+
+print("\nDone with model preparations!")
+num_params = utils.count_params(model)
+
+
+# # Wandb
+
+# In[ ]:
+
+
+if local_rank==0 and wandb_log: # only use main process for wandb logging
+    import wandb
+    import time
+    
+    wandb_project = 'rtmindeye'
+    print(f"wandb {wandb_project} run {model_name}")
+
+    # Need to configure wandb beforehand in terminal with "wandb init"!
+    wandb_config = {
+        "model_name": model_name,
+        "global_batch_size": global_batch_size,
+        "batch_size": batch_size,
+        "num_epochs": num_epochs,
+        "num_sessions": num_sessions,
+        "num_params": num_params,
+        "clip_scale": clip_scale,
+        "prior_scale": prior_scale,
+        "blur_scale": blur_scale,
+        "use_image_aug": use_image_aug,
+        "max_lr": max_lr,
+        "mixup_pct": mixup_pct,
+        "num_samples_per_epoch": num_samples_per_epoch,
+        "ckpt_interval": ckpt_interval,
+        "ckpt_saving": ckpt_saving,
+        "seed": seed,  # SLURM array task ID
+        "distributed": distributed,
+        "num_devices": num_devices,
+        "world_size": world_size,
+    }
+    print("wandb_config:\n", wandb_config)
+    print("wandb_id:", model_name)
+
+    # Initialize wandb
+    wandb.init(
+        id=model_name,
+        project=wandb_project,
+        name=model_name,
+        config=wandb_config,
+        resume="allow",
+        save_code=True,
+    )
+
+    # Get SLURM job & array ID
+    slurm_job_id = utils.get_slurm_job()
+    slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID
+
+    # Define SLURM log paths
+    log_dir = "slurms"
+    log_files = [
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.out",
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.err",
+    ]
+
+    # Ensure logs exist before logging them
+    for log_file in log_files:
+        wait_time = 0
+        while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s
+            time.sleep(5)
+            wait_time += 5
+
+    # Log SLURM logs as artifacts
+    artifact = wandb.Artifact(f"slurm_logs_{slurm_job_id}_{slurm_array_id}", type="logs")
+    for log_file in log_files:
+        if os.path.exists(log_file):
+            artifact.add_file(log_file)
+
+    wandb.log_artifact(artifact)
+else:
+    wandb_log = False
+
+
+# # Train the model
+
+# In[ ]:
+
+
+epoch = 0
+losses, test_losses, lrs = [], [], []
+best_test_loss = 1e9
+torch.cuda.empty_cache()
+
+
+# In[ ]:
+
+
+# load multisubject stage1 ckpt if set
+if multisubject_ckpt is not None and not resume_from_ckpt:
+    load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)
+
+
+# In[ ]:
+
+
+# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')
+# state_dict = checkpoint['model_state_dict']
+# model.load_state_dict(state_dict, strict=False)
+
+
+# In[ ]:
+
+
+# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]
+
+model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)
+# leaving out test_dl since we will only have local_rank 0 device do evals
+
+
+# In[ ]:
+
+
+print(f"{model_name} starting with epoch {epoch} / {num_epochs}")
+progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))
+test_image, test_voxel = None, None
+mse = nn.MSELoss()
+l1 = nn.L1Loss()
+soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))
+skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model
+
+for epoch in progress_bar:
+    model.train()
+
+    fwd_percent_correct = 0.
+    bwd_percent_correct = 0.
+    test_fwd_percent_correct = 0.
+    test_bwd_percent_correct = 0.
+    
+    recon_cossim = 0.
+    test_recon_cossim = 0.
+    recon_mse = 0.
+    test_recon_mse = 0.
+
+    loss_clip_total = 0.
+    loss_blurry_total = 0.
+    loss_blurry_cont_total = 0.
+    test_loss_clip_total = 0.
+    
+    loss_prior_total = 0.
+    test_loss_prior_total = 0.
+
+    blurry_pixcorr = 0.
+    test_blurry_pixcorr = 0. 
+
+    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each
+    for train_i, behav in enumerate(train_dl):  
+        with torch.cuda.amp.autocast(dtype=data_type):
+            optimizer.zero_grad()
+            loss = 0.
+            
+            behav = behav[0]
+
+            image = images[behav.long().cpu()].to(device)
+            voxel = vox[behav.long().cpu()]
+            # voxel = (voxel - train_mean) / train_std
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+            if use_image_aug: 
+                image = img_augment(image)
+
+            clip_target = clip_img_embedder(image)
+            assert not torch.any(torch.isnan(clip_target))
+
+            if epoch < int(mixup_pct * num_epochs):
+                voxel, perm, betas, select = utils.mixco(voxel)
+
+            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]
+            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)
+
+            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+            if clip_scale>0:
+                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+            if use_prior:
+                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)
+                loss_prior_total += loss_prior.item()
+                loss_prior *= prior_scale
+                loss += loss_prior
+
+                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()
+                recon_mse += mse(prior_out, clip_target).item()
+
+            if clip_scale>0:
+                if epoch < int(mixup_pct * num_epochs):                
+                    loss_clip = utils.mixco_nce(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=.006,
+                        perm=perm, betas=betas, select=select)
+                else:
+                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]
+                    loss_clip = utils.soft_clip_loss(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=epoch_temp)
+
+                loss_clip_total += loss_clip.item()
+                loss_clip *= clip_scale
+                loss += loss_clip
+
+            if blurry_recon:     
+                image_enc_pred, transformer_feats = blurry_image_enc_
+
+                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215
+                loss_blurry = l1(image_enc_pred, image_enc)
+                loss_blurry_total += loss_blurry.item()
+
+                if epoch < int(mixup_pct * num_epochs):
+                    image_enc_shuf = image_enc[perm]
+                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)
+                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \
+                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)
+
+                image_norm = (image - mean)/std
+                image_aug = (blur_augs(image) - mean)/std
+                _, cnx_embeds = cnx(image_norm)
+                _, cnx_aug_embeds = cnx(image_aug)
+
+                cont_loss = utils.soft_cont_loss(
+                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    temp=0.2)
+                loss_blurry_cont_total += cont_loss.item()
+
+                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215
+
+            if clip_scale>0:
+                # forward and backward top 1 accuracy        
+                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) 
+                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+            if blurry_recon:
+                with torch.no_grad():
+                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()
+                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)
+                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)
+                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                    blurry_pixcorr += pixcorr.item()
+            
+            utils.check_loss(loss)
+            accelerator.backward(loss)
+            optimizer.step()
+
+            losses.append(loss.item())
+            lrs.append(optimizer.param_groups[0]['lr'])
+
+            if lr_scheduler_type is not None:
+                lr_scheduler.step()
+                
+            if train_i >= num_iterations_per_epoch-1:
+                break
+                
+    model.eval()
+    logs = {}
+
+    if local_rank == 0:
+        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+            for i in range(2):
+                for j in range(2):
+                    subset_indices = MST_idx[:, i, j].reshape(-1)
+                    subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                    subset_dl = torch.utils.data.DataLoader(
+                        subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                        drop_last=True, pin_memory=True
+                    )
+
+                    # Reset metrics for this subset
+                    test_losses = []
+                    test_loss_clip_total = 0
+                    test_loss_prior_total = 0
+                    test_blurry_pixcorr = 0
+                    test_fwd_percent_correct = 0
+                    test_bwd_percent_correct = 0
+                    test_recon_cossim = 0
+                    test_recon_mse = 0
+
+                    for test_i, behav in enumerate(subset_dl):
+                        behav = behav[0]
+                        loss = 0.
+
+                        if behav.ndim > 1:
+                            image = images[behav[:, 0].long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()].mean(1)
+                        else:
+                            image = images[behav.long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()]
+
+                        voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+                        clip_img_embedder = clip_img_embedder.to(device)
+                        clip_target = clip_img_embedder(image.float())
+
+                        voxel_ridge = model.ridge(voxel, 0)
+                        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                        if clip_scale > 0:
+                            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                            clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+                        random_samps = np.random.choice(np.arange(len(image)), size=len(image) // 5, replace=False)
+
+                        if use_prior:
+                            loss_prior, contaminated_prior_out = model.diffusion_prior(
+                                text_embed=backbone[random_samps], image_embed=clip_target[random_samps])
+                            test_loss_prior_total += loss_prior.item()
+                            loss_prior *= prior_scale
+                            loss += loss_prior
+
+                        if clip_scale > 0:
+                            loss_clip = utils.soft_clip_loss(
+                                clip_voxels_norm,
+                                clip_target_norm,
+                                temp=0.006
+                            )
+                            test_loss_clip_total += loss_clip.item()
+                            loss_clip *= clip_scale
+                            loss += loss_clip
+
+                        if blurry_recon:
+                            image_enc_pred, _ = blurry_image_enc_
+                            blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps] / 0.18215).sample / 2 + 0.5).clamp(0, 1)
+                            pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                            test_blurry_pixcorr += pixcorr.item()
+
+                        if clip_scale > 0:
+                            labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                            test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                            test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+                        utils.check_loss(loss)
+                        test_losses.append(loss.item())
+
+                    logs.update({
+                        f"subset_{i}_{j}_test/loss": np.mean(test_losses),
+                        f"subset_{i}_{j}_test/loss_clip_total": test_loss_clip_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/loss_prior": test_loss_prior_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1),
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+                    print(f"--- Subset ({i},{j}) ---")
+                    for k, v in logs.items():
+                        if f"subset_{i}_{j}" in k:
+                            print(f"{k}: {v:.4f}")
+
+            # After subset loop: add train (and global test, if you want) metrics
+            logs.update({
+                "train/loss": np.mean(losses[-(train_i+1):]),
+                "train/lr": lrs[-1],
+                "train/num_steps": len(losses),
+                "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1),
+                "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1),
+                "train/loss_clip_total": loss_clip_total / (train_i + 1),
+                "train/loss_blurry_total": loss_blurry_total / (train_i + 1),
+                "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1),
+                "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1),
+                "train/recon_cossim": recon_cossim / (train_i + 1),
+                "train/recon_mse": recon_mse / (train_i + 1),
+                "train/loss_prior": loss_prior_total / (train_i + 1),
+            })
+
+
+            # if finished training, save jpg recons if they exist
+            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):
+                if blurry_recon:    
+                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215
+                    # transform blurry recon latents to images and plot it
+                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))
+                    jj=-1
+                    for j in [0,1,2,3]:
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                    plt.show()
+
+            progress_bar.set_postfix(**logs)
+
+            if wandb_log: wandb.log(logs)
+            
+    # Save model checkpoint and reconstruct
+    if (ckpt_saving) and (epoch % ckpt_interval == 0):
+        save_ckpt(f'last')
+
+    # wait for other GPUs to catch up if needed
+    accelerator.wait_for_everyone()
+    torch.cuda.empty_cache()
+
+print("\n===Finished!===\n")
+if ckpt_saving:
+    save_ckpt(f'last')
+
+
+# In[ ]:
+
+
+len(test_data)
+
+
+# In[ ]:
+
+
+# # Track metrics here:
+# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999
+
+
+# **To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**
+
+# In[ ]:
+
+
+# MST_pairmate_names
+
+
+# In[ ]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = []
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs.append([utils.find_all_indices(x,p[0]), utils.find_all_indices(x,p[1])])
+    
+pairs = np.array(pairs)
+
+
+# In[ ]:
+
+
+pairs.shape
+
+
+# In[ ]:
+
+
+model.eval()
+logs = {}
+if local_rank == 0:
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for i in range(2):
+            for j in range(2):
+                subset_indices = MST_idx[:, i, j].reshape(-1)
+                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                subset_dl = torch.utils.data.DataLoader(
+                    subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                    drop_last=True, pin_memory=True
+                )
+
+                # Reset metrics for this subset
+                test_fwd_percent_correct = 0
+                test_bwd_percent_correct = 0
+
+                for test_i, behav in enumerate(subset_dl):
+                    behav = behav[0]
+                    loss = 0.
+                    image = images[behav.long().cpu()].to(device)
+                    voxel = vox[behav.long().cpu()]
+                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+                    clip_img_embedder = clip_img_embedder.to(device)
+                    clip_target = clip_img_embedder(image.float())
+
+                    voxel_ridge = model.ridge(voxel, 0)
+                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)
+                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)
+
+                    if clip_scale > 0:
+                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+                    print(test_fwd_percent_correct)
+                    print(test_bwd_percent_correct)
+                    logs.update({
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+
+    print("--- Full Dataset Evaluation ---")
+    for k, v in logs.items():
+        print(f"{k}: {v:.4f}")
+
+
+# In[ ]:
+
+
+# if sub=="sub-002":
+#     unique_images_pairs = [
+#         (2,3),(4,5),(7,8),(15,16),
+#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),
+#         (503, 504), (512, 513), 
+#     ]
+# elif sub != 'sub-001' and session != 'ses-05':
+#     unique_images_pairs = [
+#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),
+#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),
+#         (31,32),(33,34),(35,36),
+#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),
+#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),
+#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),
+#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),
+#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),
+#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),
+#         (847, 848), (849, 850)
+#     ]
+# else:
+#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]
+#     unique_images_pairs = find_mst_pairs(x)
+# # unique_images[unique_images_pairs]
+
+
+# In[ ]:
+
+
+import pdb
+
+
+# In[ ]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        failed_A = []
+        failed_B = []
+        failed_non_corr = []
+
+        # Get all unique image indices
+        all_indices = np.unique(mst_pairs.flatten())
+        
+        # Pre-load all images and betas to device
+        all_images = images[image_idx[all_indices]].to(device)
+        all_voxels = torch.Tensor(vox[image_idx[all_indices]]).unsqueeze(1).to(device)
+        
+        # Get CLIP embeddings for all images
+        all_clip_targets = clip_img_embedder(all_images.float())
+        all_clip_targets_norm = nn.functional.normalize(all_clip_targets.flatten(1), dim=-1)
+        
+        # Pass all betas through model to get MindEye embeddings
+        all_voxel_ridge = model.ridge(all_voxels, 0)
+        _, all_clip_voxels, _ = model.backbone(all_voxel_ridge)
+        all_clip_voxels_norm = nn.functional.normalize(all_clip_voxels.flatten(1), dim=-1)
+        
+        # Dict mapping idx (which indexes the "vox" and "images" tensors) to pos (their position in the flattened array "all_indices")
+        idx_to_pos = {idx: pos for pos, idx in enumerate(all_indices)}
+        
+        # Initialize scores
+        corr_score = 0
+        non_corr_score = 0
+        corr_total = len(mst_pairs) * 2
+        non_corr_total = len(mst_pairs) * (len(mst_pairs)-1) * 4  # number of elements in the matrix excluding the diagonal is n*(n-1)*4 since we're doing this twice each for pairmate A and B
+
+        
+        # Pre-load voxelwise beta-based embeddings from MindEye and CLIP image embeddings
+        idxA = np.array([pair[0] for pair in mst_pairs])
+        idxB = np.array([pair[1] for pair in mst_pairs])
+        
+        posA = np.array([idx_to_pos[idx] for idx in idxA])
+        posB = np.array([idx_to_pos[idx] for idx in idxB])
+        
+        voxA_embeddings = all_clip_voxels_norm[posA]
+        voxB_embeddings = all_clip_voxels_norm[posB]
+        imgA_embeddings = all_clip_targets_norm[posA]
+        imgB_embeddings = all_clip_targets_norm[posB]
+        
+        simA_A = utils.batchwise_cosine_similarity(voxA_embeddings, imgA_embeddings)
+        simA_B = utils.batchwise_cosine_similarity(voxA_embeddings, imgB_embeddings)
+        simB_B = utils.batchwise_cosine_similarity(voxB_embeddings, imgB_embeddings)
+        simB_A = utils.batchwise_cosine_similarity(voxB_embeddings, imgA_embeddings)
+
+        
+        # corresponding 2-AFC
+        # is the voxel embedding for image 1 pairmate A more similar to the CLIP embedding for image 1 pairmate A or the CLIP embedding for image 1 pairmate B?
+        correct_A = torch.diag(simA_A) > torch.diag(simA_B)
+        # is the voxel embedding for image 1 pairmate B more similar to the CLIP embedding for image 1 pairmate B or the CLIP embedding for image 1 pairmate A?
+        correct_B = torch.diag(simB_B) > torch.diag(simB_A)
+
+        corr_score += correct_A.sum().item()
+        corr_score += correct_B.sum().item()
+
+        # Store indices where AFC fails
+        failed_A = [i for i, correct in enumerate(correct_A.cpu()) if not correct]
+        failed_B = [i for i, correct in enumerate(correct_B.cpu()) if not correct]
+        
+        # non-corresponding 2-AFC
+        N = len(mst_pairs)        
+        # Create a mask that is True for all off-diagonal elements
+        row_idx = torch.arange(N).unsqueeze(1)  # (N, 1)
+        col_idx = torch.arange(N).unsqueeze(0)  # (1, N)
+        off_diag_mask = row_idx != col_idx  # shape (N, N)
+        
+        diagA_A = simA_A.diag().unsqueeze(1).expand(-1, N)  # Get diagonal values and expand to (N, N) by duplicating the diagonal element along the rows (since each row is the cosine similarity between a single voxel embedding and all CLIP embeddings)
+        diagB_B = simB_B.diag().unsqueeze(1).expand(-1, N)
+        
+        # pdb.set_trace()
+
+        # Compare each element in the row to the diagonal element
+        off_diag_mask_device = off_diag_mask.to(device)
+
+        fail_AA = (simA_A < diagA_A) & off_diag_mask_device
+        fail_AB = (simA_B < diagA_A) & off_diag_mask_device
+        fail_BB = (simB_B < diagB_B) & off_diag_mask_device
+        fail_BA = (simB_A < diagB_B) & off_diag_mask_device
+
+        non_corr_score += fail_AA.sum().item()
+        non_corr_score += fail_AB.sum().item()
+        non_corr_score += fail_BB.sum().item()
+        non_corr_score += fail_BA.sum().item()
+
+        # Log failed indices
+        fail_sources = [fail_AA, fail_AB, fail_BB, fail_BA]
+        for fail_matrix, label in zip(fail_sources, ["AA", "AB", "BB", "BA"]):
+            fail_coords = torch.nonzero(fail_matrix, as_tuple=False).cpu().numpy()
+            for i, j in fail_coords:
+                failed_non_corr.append({"type": label, "i": i, "j": j, "pair_i": mst_pairs[i], "pair_j": mst_pairs[j]})
+
+    return corr_score, corr_total, int(non_corr_score), non_corr_total, failed_A, failed_B, failed_non_corr
+
+
+# In[ ]:
+
+
+all_scores = []
+all_failures = []
+
+for i in range(4):
+    for j in range(4):
+        mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)
+        corr_score, corr_total, non_corr_score, non_corr_total, failed_A, failed_B, failed_non_corr = evaluate_mst_pairs(mst_pairs)
+
+        # Store scores and failure info together
+        all_scores.append((corr_score, corr_total, non_corr_score, non_corr_total))
+        all_failures.append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "failed_A": failed_A,
+            "failed_B": failed_B,
+            "failed_non_corr": failed_non_corr,
+            "mst_pairs": mst_pairs,
+        })
+
+        # Print summary
+        print(f"pairmate A repeat {i} vs pairmate B repeat {j}:")
+        print(f"2-AFC corresponding = {corr_score}/{corr_total} ({corr_score/corr_total:.2%})")
+        print(f"2-AFC non-corresponding = {non_corr_score}/{non_corr_total} ({non_corr_score/non_corr_total:.2%})")
+        print("")
+
+
+# In[ ]:
+
+
+all_scores = np.array(all_scores)
+print(f"average 2-AFC corresponding: {all_scores[:,0].mean():.2f}/{all_scores[:,1].mean():.2f} ({(all_scores[:,0].sum()/all_scores[:,1].sum()):.2%})")
+print(f"average 2-AFC non-corresponding: {all_scores[:,2].mean():.2f}/{all_scores[:,3].mean():.2f} ({(all_scores[:,2].sum()/all_scores[:,3].sum()):.2%})")
+print(f'chance = 1/{corr_total} ({(1/corr_total):.2%})')
+
+
+# In[ ]:
+
+
+from collections import defaultdict
+
+# Map from image index to failure details
+failed_images = defaultdict(list)
+
+for failure_entry in all_failures:
+    mst_pairs = failure_entry["mst_pairs"]
+    i, j = failure_entry["repeat_A"], failure_entry["repeat_B"]
+
+    # A-side failures
+    for fail_idx in failure_entry["failed_A"]:
+        image_idx = mst_pairs[fail_idx][0]
+        pairmate_idx = mst_pairs[fail_idx][1]
+        failed_images[image_idx].append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "pairmate": pairmate_idx,
+            "type": "A",
+        })
+
+    # B-side failures
+    for fail_idx in failure_entry["failed_B"]:
+        image_idx = mst_pairs[fail_idx][1]
+        pairmate_idx = mst_pairs[fail_idx][0]
+        failed_images[image_idx].append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "pairmate": pairmate_idx,
+            "type": "B",
+        })
+
+
+# In[ ]:
+
+
+# import matplotlib.pyplot as plt
+
+# for img_idx, failure_list in failed_images.items():
+#     print(f"\n==== Failed Image {img_idx} ====")
+
+#     # Load and normalize the embeddings
+#     image = images[img_idx].unsqueeze(0).to(device).float()
+#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)
+
+#     # Get voxel→CLIP embedding
+#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)
+#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]
+#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)
+
+#     # Display original image
+#     print("Original image:")
+#     display(utils.torch_to_Image(images[img_idx]))
+
+#     # Collect unique pairmates involved in the failure
+#     pairmate_indices = list(set(entry["pairmate"] for entry in failure_list))
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     # Compute "correct" similarity — voxel to its own CLIP embedding
+#     correct_clip = image_clip.float()
+#     correct_voxel_sim = (voxel_embed.float() @ correct_clip.T).item()
+#     print(f"Correct voxel→CLIP similarity = {correct_voxel_sim:.4f}")
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     for ax, mate_idx in zip(axs, pairmate_indices):
+#         mate_image = images[mate_idx].unsqueeze(0).to(device).float()
+#         mate_clip = nn.functional.normalize(clip_img_embedder(mate_image).flatten(1), dim=-1).float()
+
+#         # Similarities
+#         clip_sim = (correct_clip @ mate_clip.T).item()
+#         voxel_sim = (voxel_embed.float() @ mate_clip.T).item()
+
+#         # Check if this was the mistaken "higher" match
+#         wrong_match = voxel_sim > correct_voxel_sim
+
+#         # Plot image and annotate
+#         ax.imshow(utils.torch_to_Image(images[mate_idx]))
+#         ax.axis("off")
+#         ax.set_title(f"Pairmate {mate_idx}\nCLIP={clip_sim:.3f}\nVoxel={voxel_sim:.3f}\n{'← WRONG' if wrong_match else ''}",
+#                      color="red" if wrong_match else "black")
+
+
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# comp[20,18] is the only False
+
+
+# In[ ]:
+
+
+# import matplotlib.pyplot as plt
+
+# for img_idx, failure_list in failed_images.items():
+#     print(f"\n==== Failed Image {img_idx} ====")
+
+#     # Load and normalize the embeddings
+#     image = images[img_idx].unsqueeze(0).to(device).float()
+#     image_clip = nn.functional.normalize(clip_img_embedder(image).flatten(1), dim=-1)
+
+#     # Get voxel→CLIP embedding
+#     voxel = torch.Tensor(vox[img_idx]).unsqueeze(0).unsqueeze(0).to(device)
+#     voxel_embed = model.backbone(model.ridge(voxel, 0))[1]
+#     voxel_embed = nn.functional.normalize(voxel_embed.flatten(1), dim=-1)
+
+#     # Display original image
+#     print("Original image:")
+#     display(utils.torch_to_Image(images[img_idx]))
+
+#     # Collect unique pairmates involved in the failure
+#     pairmate_indices = list(set(entry["pairmate"] for entry in failure_list))
+
+#     # Plot failed pairmates with similarity annotations
+#     fig, axs = plt.subplots(1, len(pairmate_indices), figsize=(4 * len(pairmate_indices), 4))
+#     if len(pairmate_indices) == 1:
+#         axs = [axs]
+
+#     for ax, mate_idx in zip(axs, pairmate_indices):
+#         # Get all CLIP embeddings for failed image and pairmates
+#         all_indices = [img_idx] + pairmate_indices
+#         all_images = images[all_indices].to(device).float()
+#         all_clip_embeds = clip_img_embedder(all_images)
+#         all_clip_embeds = nn.functional.normalize(all_clip_embeds.flatten(1), dim=-1).float()
+
+#         # Compare voxel embedding for the failed image to all CLIP embeddings
+#         sims = (voxel_embed.float() @ all_clip_embeds.T).squeeze().cpu().detach().numpy()  # shape: (1, N) → (N,)
+#         image_ids = ["correct"] + [f"pairmate {idx}" for idx in pairmate_indices]
+
+#         # Sort and display
+#         sorted_sims = sorted(zip(image_ids, all_indices, sims), key=lambda x: -x[2])
+
+#         print("\n🧠 Voxel→CLIP similarity ranking:")
+#         for label, idx, sim in sorted_sims:
+#             print(f"{label:12} (index {idx:3}): similarity = {sim:.4f}")
+
+#         # Optional assertion: did any pairmate score higher than the correct image?
+#         correct_sim = sims[0]
+#         higher = [(label, sim) for label, _, sim in sorted_sims[1:] if sim > correct_sim]
+#         if higher:
+#             print("\n❌ Mismatch detected: voxel embedding matched other images more than the correct one!")
+#         else:
+#             print("\n✅ Model correctly ranked the correct image highest (despite failure elsewhere)")
+
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+mst_pairs[:5]
+
+
+# In[ ]:
+
+
+pairs[0]
+
+
+# In[ ]:
+
+
+# images[image_idx[pairs[0][0]]].shape
+
+
+# In[ ]:
+
+
+ix = 0
+display(utils.torch_to_Image(images[pairs[ix][0]]))
+display(utils.torch_to_Image(images[pairs[ix][1]]))
+
+
+# In[ ]:
+
+
+# print(np.allclose(embed_A[0], embed_A[1]))  # across repeats
+# print(np.allclose(embed_A[0], embed_B[0]))  # across pairmates
+
+
+# In[ ]:
+
+
+# def generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=2):
+#     n_imgs, n_pairmates, n_repeats = pairs.shape
+#     nonmatch_pairs = []
+
+#     for i in range(n_imgs):
+#         other_idxs = [j for j in range(n_imgs) if j != i]
+#         sampled_j = np.random.choice(other_idxs, size=num_images_per_source, replace=False)
+
+#         for j in sampled_j:
+#             for _ in range(num_repeats):
+#                 a_side = np.random.randint(2)
+#                 b_side = np.random.randint(2)
+#                 a_repeat = np.random.randint(n_repeats)
+#                 b_repeat = np.random.randint(n_repeats)
+
+#                 pair_a = pairs[i, a_side, a_repeat]
+#                 pair_b = pairs[j, b_side, b_repeat]
+#                 nonmatch_pairs.append([pair_a, pair_b])
+
+#     return np.array(nonmatch_pairs)
+
+
+# In[ ]:
+
+
+# nonmatch_pairs = generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=1)
+# results = evaluate_mst_pairs(nonmatch_pairs)
+# print(results)
+
+
+# In[ ]:
+
+
+# # Compare first few pairs
+# for pair in pairs:  # Checking first 2 pairs
+#     print("Indices in mst_pairs:", pair)
+#     print("Corresponding filenames:")
+#     print(f"Image 1: {x[pair[0]]}")
+#     print(f"Image 2: {x[pair[1]]}\n")
+
+
+# In[ ]:
+
+
+# for i in range(len(pairs)):
+#     fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())
+#     ax[0].set_title(f"Repeat 1")
+
+#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())
+#     ax[1].set_title(f"Repeat 2")
+
+#     plt.setp(ax, xticks=[], yticks=[])
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# score = 0
+# total = 0
+# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): 
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageA_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimA > cossimB:
+#             score += 1
+#         total += 1
+        
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageB_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimB > cossimA:
+#             score += 1
+#         total += 1
+
+# print(score/total)
+
+
+# In[ ]:
+
+
+#display(utils.torch_to_Image(imageA))
+#display(utils.torch_to_Image(imageB))
+
+
+# In[ ]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(np.array(unique_images_pairs).flatten())
+# assert total_samples == 100
+
+# correct_predictions = int((score/total) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+
+

main-multisession-3tasks.py

@@ -0,0 +1,2269 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Import packages & functions
+
+# In[1]:
+
+
+print("importing modules")
+import os
+import sys
+import json
+import argparse
+import numpy as np
+import time
+import random
+import string
+import h5py
+from tqdm import tqdm
+import webdataset as wds
+from PIL import Image
+import pandas as pd
+import nibabel as nib
+import nilearn
+
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+# tf32 data type is faster than standard float32
+torch.backends.cuda.matmul.allow_tf32 = True
+
+import utils
+from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas
+
+# imports utils from mindeye_preproc as "preproc"
+import importlib.util
+parent_utils_path = "/home/ri4541/mindeye_preproc/analysis/utils.py"
+spec = importlib.util.spec_from_file_location("utils", parent_utils_path)
+preproc = importlib.util.module_from_spec(spec)
+parent_dir = os.path.dirname(parent_utils_path)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+spec.loader.exec_module(preproc)
+
+if utils.is_interactive():
+    from IPython.display import clear_output # function to clear print outputs in cell
+    get_ipython().run_line_magic('load_ext', 'autoreload')
+    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions
+    get_ipython().run_line_magic('autoreload', '2')
+    
+seed = utils.get_slurm_seed()
+
+
+# # Princeton data prep
+
+# ## Load Data & Design
+
+# In[67]:
+
+
+def get_flag(name, default, cast=int):
+    """Retrieve a flag from environment variables or return a default value."""
+    if utils.is_interactive():
+        return default
+    val = os.environ.get(name.upper(), str(default))
+    print(f"Retrieved {name.upper()} from environment: {val}")
+    
+    if cast == bool:
+        # Explicitly handle string conversion to boolean
+        if val.lower() in ['true', '1']:
+            return True
+        elif val.lower() in ['false', '0']:
+            return False
+        else:
+            return bool(val)  # Fallback to default casting behavior
+    
+    try:
+        return cast(val)
+    except Exception:
+        return val
+    
+if not utils.is_interactive():
+    print('running non-interactively')
+    
+# Define variables using get_flag
+sub = get_flag('SUB', 'sub-005', cast=str)
+session = get_flag('SESSION', 'ses-04', cast=str)  # 'ses-xx', 'all'
+task = get_flag('TASK', 'B', cast=str)  # 'study', 'A', or 'B'
+func_task_name = get_flag('FUNC_TASK_NAME', 'B', cast=str)
+
+if session == "all":
+    ses_list = ["ses-01", "ses-02"]  # list of actual session IDs
+    design_ses_list = ["ses-01", "ses-02"]  # list of session IDs to search for design matrix
+else:
+    ses_list = [session]
+    design_ses_list = [session]
+
+task_name = f"_task-{task}" if task != 'study' else ''
+resample_voxel_size = get_flag('RESAMPLE_VOXEL_SIZE', True, cast=bool)
+resample_post_glmsingle = get_flag('RESAMPLE_POST_GLMSINGLE', False, cast=bool)
+load_from_resampled_file = get_flag('LOAD_FROM_RESAMPLED_FILE', False, cast=bool)
+
+train_test_split = get_flag('TRAIN_TEST_SPLIT', 'MST', cast=str)
+remove_close_to_MST = get_flag('REMOVE_CLOSE_TO_MST', False, cast=bool)
+remove_random_n = get_flag('REMOVE_RANDOM_N', False, cast=bool)
+if remove_close_to_MST or remove_random_n:
+    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images
+
+n_to_remove = 0
+if remove_random_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_to_remove = 150
+    
+if resample_voxel_size:
+    resampled_vox_size = get_flag('RESAMPLED_VOX_SIZE', 2.0, cast=float)
+    resample_method = get_flag('RESAMPLE_METHOD', 'trilinear', cast=str)
+    
+    vox_dim_str = str(resampled_vox_size).replace('.', '_')
+    resampled_suffix = f"resampled_{vox_dim_str}mm_{resample_method}"
+    mask_resampled_suffix = resampled_suffix
+    if resample_post_glmsingle:
+        resampled_suffix += '_postglmsingle'      
+        
+    print('resample_voxel_size:', resample_voxel_size)
+    print('resample_post_glmsingle:', resample_post_glmsingle)
+    print('load_from_resampled_file:', load_from_resampled_file)
+    print('resampled_vox_size:', resampled_vox_size)
+    print('resample_method:', resample_method)
+    print('resampled_suffix:', resampled_suffix)
+    print('mask_resampled_suffix:', mask_resampled_suffix)
+print('sub:', sub)
+print('session:', session)
+print('task:', task)
+print('func_task_name:', func_task_name)
+print('ses_list:', ses_list)
+print('design_ses_list:', design_ses_list)
+print('task_name:', task_name)
+print('train_test_split:', train_test_split)
+print('remove_close_to_MST:', remove_close_to_MST)
+print('remove_random_n:', remove_random_n)
+print('n_to_remove:', n_to_remove)
+
+
+# In[7]:
+
+
+session_label = preproc.get_session_label(ses_list)
+print('session label:', session_label)
+n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)
+
+
+# In[8]:
+
+
+if utils.is_interactive():
+    glmsingle_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}"
+else:
+    glmsingle_path = os.environ["glmsingle_path"]
+    
+designdir = "/home/ri4541/real_time_mindEye2"
+print(glmsingle_path)
+
+if resample_voxel_size:
+    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here
+    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here
+    if resample_post_glmsingle:
+        # option 1
+        orig_glmsingle_path = glmsingle_path
+        glmsingle_path += f"_{resampled_suffix}"
+        print("resampled glmsingle path:", glmsingle_path)
+        if load_from_resampled_file:
+            # resampling is already done; load from file
+             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here
+        else:
+            # don't load from file; do resampling here
+            os.makedirs(glmsingle_path,exist_ok=True)
+    else:
+        # option 2
+        glmsingle_path += f"_{resampled_suffix}"
+        print("glmsingle path:", glmsingle_path)
+
+assert os.path.exists(glmsingle_path)
+print("glmsingle path exists!")
+
+
+# In[9]:
+
+
+data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(
+    sub=sub,
+    session=session,
+    func_task_name=task,
+    designdir=designdir,
+    design_ses_list=design_ses_list
+)
+
+if sub == 'sub-001':
+    if session == 'ses-01':
+        assert image_names[0] == 'images/image_686_seed_1.png'
+    elif session in ('ses-02', 'all'):
+        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'
+    elif session == 'ses-03':
+        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'
+    elif session == 'ses-04':
+        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+elif sub == 'sub-003':
+    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+
+unique_images = np.unique(image_names.astype(str))
+unique_images = unique_images[(unique_images!="nan")]
+len_unique_images = len(unique_images)
+print("n_runs",n_runs)
+
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(unique_images) == 851
+
+print(image_names[:4])
+print(starts[:4])
+print(is_new_run[:4])
+
+if remove_random_n:
+    # want to remove 150 imgs
+    # 100 special515 imgs are repeated 3x (300 total)
+    # all other train imgs are only shown once (558 total)
+    # of the 150, want to sample proportionally since we're cutting all repeats for special515
+    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total
+    np.random.seed(seed)
+    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)
+    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)
+    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)
+    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))
+
+image_idx = np.array([])  # contains the unique index of each presented image
+vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx
+all_MST_images = dict()
+for i, im in enumerate(image_names):
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    vox_image_names = np.append(vox_image_names, im)
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            i+=1
+            continue
+    elif remove_random_n:
+        if im in imgs_to_remove:
+            i+=1
+            continue
+            
+    image_idx_ = np.where(im==unique_images)[0].item()
+    image_idx = np.append(image_idx, image_idx_)
+    
+    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
+        import re
+        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)):  
+        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it
+            # print(im)
+            all_MST_images[i] = im
+            i+=1            
+    elif 'MST' in im:
+        all_MST_images[i] = im
+        i+=1
+    
+image_idx = torch.Tensor(image_idx).long()
+# for im in new_image_names[MST_images]:
+#     assert 'MST_pairs' in im
+# assert len(all_MST_images) == 300
+
+unique_MST_images = np.unique(list(all_MST_images.values())) 
+
+MST_ID = np.array([], dtype=int)
+if remove_close_to_MST:
+    close_to_MST_idx = np.array([], dtype=int)
+if remove_random_n:
+    random_n_idx = np.array([], dtype=int)
+
+vox_idx = np.array([], dtype=int)
+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
+for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            i+=1
+            continue
+    if remove_random_n:
+        if im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            i+=1
+            j+=1
+            continue
+    j+=1
+    curr = np.where(im == unique_MST_images)
+    # print(curr)
+    if curr[0].size == 0:
+        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
+    else:
+        MST_ID = np.append(MST_ID, curr)
+        
+assert len(MST_ID) == len(image_idx)
+# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)
+# 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
+print(MST_ID.shape)
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(all_MST_images) == 100
+
+
+# ## Load images
+
+# In[10]:
+
+
+import imageio.v2 as imageio
+resize_transform = transforms.Resize((224, 224))
+MST_images = []
+images = None
+for im_name in tqdm(image_idx):
+    if sub == 'sub-001' and session == 'ses-01':
+        image_file = f"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}"
+    else:
+        image_file = f"{unique_images[im_name]}"
+    im = imageio.imread(image_file)
+    im = torch.Tensor(im / 255).permute(2,0,1)
+    im = resize_transform(im.unsqueeze(0))
+    if images is None:
+        images = im
+    else:
+        images = torch.vstack((images, im))
+    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+        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)):  
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+    else:   
+        if ("MST_pairs" in image_file): # ("_seed_" not in unique_images[im_name]) and (unique_images[im_name] != "blank.jpg") 
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+
+print("images", images.shape)
+MST_images = np.array(MST_images)
+print("MST_images", len(MST_images))
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(MST_images[MST_images==True]) == 100
+print("MST_images==True", len(MST_images[MST_images==True]))
+
+
+# In[11]:
+
+
+# want IDs of pairmates based on MST_images
+# create "MST_pairmates" which is a 25x2 array with indices of the 25 pairs based on MST_images == True
+
+assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2
+MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)
+# print(MST_pairmate_names)
+
+MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for p, pair in enumerate(MST_pairmate_names):
+    for i, im in enumerate(pair):
+        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
+        
+print(MST_pairmate_indices.shape, MST_pairmate_indices)
+
+
+# In[12]:
+
+
+if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):
+    # MST_pairs contains the indices of repeats based on all_MST_images
+    # all_MST_images contains the indices of images from image_names
+    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))
+    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
+
+    # assert images[MST_pairs]
+
+    fig, ax = plt.subplots(1, 3, figsize=(10,4))
+    fig.suptitle('Sample MST pairs')
+
+    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())
+    ax[0].set_title(f"Trial 0")
+
+    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())
+    ax[1].set_title(f"Trial 1")
+
+    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())
+    ax[2].set_title(f"Trial 2")
+
+    plt.setp(ax, xticks=[], yticks=[])
+    plt.tight_layout()
+    plt.show()
+
+
+# In[13]:
+
+
+# pairs has the indices of all repeated images
+pairs = utils.find_paired_indices(image_idx)
+pairs = sorted(pairs, key=lambda x: x[0])
+
+fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns
+for i, ax in enumerate(axes):
+    ax.imshow(images[i].permute(1, 2, 0).numpy())
+    ax.set_title(f"Trial {i}")
+    ax.axis("off")  # Hide axes for better visualization
+
+plt.tight_layout()
+# output_path = os.path.join(output_dir, "trials_plot.png")
+# plt.savefig(output_path, dpi=300)  # Save figure
+plt.show()
+
+
+# In[14]:
+
+
+p=0
+
+# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)
+fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())
+ax[0].set_title(f"Repeat 1")
+
+ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())
+ax[1].set_title(f"Repeat 2")
+
+plt.setp(ax, xticks=[], yticks=[])
+plt.tight_layout()
+plt.show()
+
+
+# In[15]:
+
+
+def get_image_pairs(sub, session, func_task_name, designdir):
+    """Loads design files and processes image pairs for a given session."""
+    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(
+        sub=sub,
+        session=session,
+        func_task_name=func_task_name,
+        designdir=designdir,
+        design_ses_list=[session]  # Ensure it's a list
+    )
+    return utils.process_images(image_names, unique_images)
+
+
+# In[16]:
+
+
+from collections import defaultdict
+
+all_dicts = []
+for s_idx, s in enumerate(ses_list):
+    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)
+    assert len(im) == len(vo)
+    all_dicts.append({k:v for k,v in enumerate(vo)})
+
+# for the train set (ses-01-02 non-MST)
+image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])
+for ses_idx, idx_to_name in enumerate(all_dicts):
+    for idx, name in idx_to_name.items():
+        image_to_indices[name][ses_idx].append(idx)
+        
+image_to_indices = dict(image_to_indices)
+
+# for the test set (ses-03)
+# test_image_to_indices = defaultdict(lambda: [[] for _ in range(len([ses_list[-1]]))])
+# for ses_idx, idx_to_name in enumerate([all_dicts[-1]]):
+#     for idx, name in idx_to_name.items():
+#         test_image_to_indices[name][ses_idx].append(idx)
+        
+# test_image_to_indices = dict(test_image_to_indices)
+
+
+# In[17]:
+
+
+# train_pairs_list = []
+# test_pairs_list = []
+
+if sub == 'sub-005' and ses_list == ["ses-01", "ses-02"]:
+    for image, (ses0_indices, ses1_indices) in image_to_indices.items():
+        # Offset session 1 indices by 693
+        image_to_indices[image] = [ses0_indices, [i + 693 for i in ses1_indices]]
+
+#         # Combine all repeat indices (across both sessions)
+#         all_indices = ses0_indices + ses1_indices_offset
+
+#         # Only include if there are at least 2 repeats
+#         if len(all_indices) >= 2:
+#             train_pairs_list.append(all_indices)
+        
+#     for i in test_image_to_indices.values():
+#         # print(i[0])
+#         # Only include if there are at least 2 repeats
+#         if len(i[0]) >= 2:
+#             test_pairs_list.append(i[0])
+            
+#     train_test_pairs = [train_pairs_list, test_pairs_list]
+            
+# elif sub == 'sub-005' and ses_list == ["ses-01", "ses-03"]:
+#     pairs_list = []
+
+#     if len(ses_list) > 2:
+#         # Case 1: Aggregate results from multiple sessions (ses_list[:-1]), concatenating into a single list
+#         combined_pairs = sum([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list[:-1]], [])
+#         pairs_list.append(combined_pairs)
+
+#         # Case 2: Process last session separately
+#         pairs_list.append(get_image_pairs(sub, ses_list[-1], func_task_name, designdir))
+
+#     else:
+#         # Case 3: Process both sessions individually if ses_list has only 2 entries
+#         pairs_list.extend([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list])
+
+#     assert len(pairs_list) == 2
+
+
+# In[18]:
+
+
+if resample_voxel_size:
+    from nilearn.masking import apply_mask, unmask
+    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'
+    omat_name = f'{glmsingle_path}/boldref_omat'
+
+
+# In[19]:
+
+
+from nilearn.plotting import plot_roi, plot_anat, plot_epi
+
+mask_name = f'{glmsingle_path}/{sub}_{session_label}{task_name}_brain'
+if resample_voxel_size:
+    if resample_post_glmsingle is True:
+        # use original mask directory
+        mask_in_name = f'{orig_glmsingle_path}/{sub}_{session}{task_name}_brain.nii.gz'
+        mask_out_name = mask_name + f"_{mask_resampled_suffix}.nii.gz"
+        assert os.path.exists(mask_in_name)
+        applyxfm(mask_in_name, ref_name, omat_name, resample_method, output=mask_out_name)
+        apply_thresh(mask_out_name, 0.5, output=mask_out_name)  # binarize the mask since resampling can result in non- 0 or 1 values
+    mask_name += f"_{mask_resampled_suffix}"
+
+mask_name += ".nii.gz"
+print(mask_name)
+avg_mask = nib.load(mask_name)
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+
+# ## Load GLMSingle voxel data
+
+# In[20]:
+
+
+vox = None
+needs_postprocessing = False
+params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)
+
+if resample_post_glmsingle == True:
+    glm_save_path_resampled = f"{glmsingle_path}/vox_resampled.nii.gz"
+    if load_from_resampled_file == True:
+        # resampling was done in this notebook so we can load from file
+        vox = nib.load(glm_save_path_resampled)
+    else:
+        # do resampling here
+        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"
+        vox = load_preprocess_betas(orig_glmsingle_path, *params)
+        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)
+    needs_postprocessing = True
+
+if vox is None:
+    # either resampling was done in glmsingle or we aren't resampling 
+    vox = load_preprocess_betas(glmsingle_path, *params)
+
+if needs_postprocessing == True:
+    vox = apply_mask(vox, avg_mask)
+    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)
+    print(vox.shape)
+
+assert len(vox) == len(image_idx)
+
+
+# ### Load nsdgeneral ROI
+
+# In[28]:
+
+
+if resample_voxel_size:
+    nsdgeneral_path = f'{glmsingle_path}/{sub}_{session_label}_task-{task}_nsdgeneral_{resampled_suffix}.nii.gz'  
+    if resample_post_glmsingle:
+        assert os.path.exists(orig_glmsingle_path)
+        roi_in_path = f"{orig_glmsingle_path}/{sub}_{session_label}_task-{task}_nsdgeneral.nii.gz"  # the input file is the original nsdgeneral mask (without resampling), from the original glmsingle directory
+        applyxfm(roi_in_path, ref_name, omat_name, resample_method, output=nsdgeneral_path)
+else:
+    nsdgeneral_path = f'{glmsingle_path}/{sub}_{session_label}{task_name}_nsdgeneral.nii.gz'  
+    
+print(nsdgeneral_path)
+assert os.path.exists(nsdgeneral_path)
+print(f"nsdgeneral path exists!")
+
+
+# In[29]:
+
+
+roi = nib.load(nsdgeneral_path)
+print(roi.shape)
+plot_roi(roi, bg_img=avg_mask)
+plt.show()
+
+
+# In[30]:
+
+
+avg_mask = avg_mask.get_fdata().flatten()
+print(f"total voxels (whole brain) = {int(avg_mask.sum())}")
+
+roi = roi.get_fdata()
+roi = roi.flatten()
+roi = roi[avg_mask.astype(bool)]
+roi[np.isnan(roi)] = 0
+roi = roi.astype(bool)
+print(f"nsdgeneral voxels = {roi.sum()}")
+
+
+# ### ROI voxel exclusion
+
+# In[31]:
+
+
+# ROI masking?
+print(f"vox before ROI exclusion: {vox.shape}")
+vox = vox[:,roi]
+print(f"vox after ROI exclusion: {vox.shape}")
+
+if np.any(np.isnan(vox)):
+    print("NaNs found! Removing voxels...")
+    x,y = np.where(np.isnan(vox))
+    vox = vox[:,np.setdiff1d(np.arange(vox.shape[-1]), y)]
+
+
+# ## Reliability calculation
+
+# ### Calculate reliability (corr between first and second presentation of same image) for every voxel
+
+# In[32]:
+
+
+pairs_homog = np.array([[p[0], p[1]] for p in pairs])
+
+
+# In[33]:
+
+
+# vox_pairs = []
+# for i in pairs:
+#     vox_pairs.append(utils.zscore(vox[i]))
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+rels = np.full(vox.shape[-1],np.nan)
+for v in tqdm(range(vox.shape[-1])):
+    rels[v] = np.corrcoef(vox_pairs[:,0,v], vox_pairs[:,1,v])[1,0]
+# for v in tqdm(range(vox[0].shape[-1])):
+#     rep0 = []
+#     rep1 = []
+
+#     for vp in vox_pairs:
+#         rep0.append(vp[0, v])
+#         rep1.append(vp[1, v])
+
+#     rels[v] = np.corrcoef(rep0, rep1)[1, 0]
+
+print("rels", rels.shape)
+assert np.sum(np.all(np.isnan(rels))) == 0
+
+
+# ### Create representational similarity matrix
+
+# In[34]:
+
+
+# creating img x vox x repetitions matrix | shape=(150, 18419, 2)
+vox0 = np.zeros((len(pairs_homog), vox.shape[-1], 2))
+print(vox0.shape)
+for ipair, pair in enumerate(tqdm(pairs_homog)):
+    pair = pair[:2] # to keep things consistent, just using the first two repeats
+    i,j = pair
+    vox0[ipair, :, :] = vox[pair].T
+vox_avg = vox0.mean(-1) # average across the repetitions
+
+
+# In[35]:
+
+
+# Masking RDM for each reliability threshold
+r_thresholds = np.array([.2])
+rdm = np.zeros((len(r_thresholds), len(pairs), len(pairs))) 
+for ir_thresh, r_thresh in enumerate(r_thresholds):
+    print(f"reliability threshold = {r_thresh}")
+    for i in tqdm(range(len(pairs))):
+        for j in range(len(pairs)):
+            rdm[ir_thresh,i,j] = np.corrcoef(vox_avg[i,rels>r_thresh], 
+                                             vox_avg[j,rels>r_thresh])[0,1]
+# rdm is shape (4, 150, 150)
+
+
+# In[36]:
+
+
+thresh = .2
+plt.figure(figsize=(4,4))
+plt.imshow(rdm[np.where(r_thresholds==thresh)[0].item()], clim=(-1,1))
+plt.colorbar(shrink=0.8)
+plt.title(f"{sub}_{session}\nreliability threshold={thresh}\n")
+plt.show()
+
+
+# In[37]:
+
+
+for thresh in range(rdm.shape[0]):
+    for img in range(rdm.shape[1]):
+        assert np.isclose(rdm[thresh, img, img], 1)
+
+
+# In[38]:
+
+
+vox.shape
+
+
+# In[39]:
+
+
+# Reliability thresholding?
+print(f"\nvox before reliability thresholding: {vox.shape}")
+vox = vox[:,rels>.2]
+print(f"\nvox after reliability thresholding: {vox.shape}")
+
+
+# In[40]:
+
+
+print(images.shape)
+print(vox.shape)
+assert len(images) == len(vox)
+
+
+# In[41]:
+
+
+same_corrs = []
+diff_corrs = []
+for isamp, samp in enumerate(vox[pairs_homog]):
+    avg_same_img = []
+    for i in range(samp.shape[0]):
+        for j in range(i, samp.shape[0]):
+            if i != j:
+                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))
+    
+    same_corrs.append(np.mean(avg_same_img))
+                       
+    avg_diff_img = []
+    for isamp_j, samp_j in enumerate(vox[pairs_homog]):
+        if isamp_j != isamp:
+            for i in range(samp_j.shape[0]):
+                for j in range(i, samp_j.shape[0]):
+                    if i != j:
+                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))
+                                    
+    # print(len(avg_diff_img))
+    diff_corrs.append(np.mean(avg_diff_img))
+
+
+print(len(same_corrs), len(diff_corrs))
+same_corrs = np.array(same_corrs)
+diff_corrs = np.array(diff_corrs)
+
+
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same/diff Pearson corr.")
+plt.plot(np.sort(same_corrs),c='blue',label='same')
+plt.plot(np.sort(diff_corrs),c='cyan',label='diff')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# In[42]:
+
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same minus diff difference Pearson corr.")
+plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# # Training MindEye
+
+# In[43]:
+
+
+utils.seed_everything(seed)
+
+if train_test_split == 'orig':
+    # train = all images except images that were repeated
+    # test = average of the same-image presentations
+    imageTrain = np.arange(len(images))
+    train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])
+    test_image_indices = pairs
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+elif train_test_split == 'MST':
+    # non-MST images are the train split
+    # MST images are the test split
+    MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])
+    non_MST_idx = [v for k,v in image_to_indices.items() if 'MST_pairs' not in k]
+    non_MST_idx = np.array([z for y in non_MST_idx for x in y for z in x])  # flatten the indices
+    train_image_indices = non_MST_idx
+    test_image_indices = MST_idx.flatten()  # MST_idx contains the mapping for the different test sets; test_image_indices has all MST indices combined
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(vox)
+elif train_test_split == 'unique':
+    imageTest = np.arange(len(images))
+    train_image_indices = pairs.flatten()
+    test_image_indices = np.array([item for item in imageTest if item not in pairs.flatten()])
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+else:
+    raise Exception("invalid train_test_split")
+
+# TODO add assertion that verifies file names in train and test don't overlap, guards against repeats
+
+for i in train_image_indices:
+    assert i not in test_image_indices
+
+
+# In[44]:
+
+
+train_mean = np.mean(vox[train_image_indices],axis=0)
+train_std = np.std(vox[train_image_indices],axis=0)
+
+vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)
+print("voxels have been zscored")
+print(vox[:,0].mean(), vox[:,0].std())
+print("vox", vox.shape)
+
+
+# In[45]:
+
+
+# for idx in deleted_indices:
+#     # check image names to be deleted match
+#     original_name = vox_image_dict[idx]
+#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]
+#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \
+#         f"Mismatch in image names for deleted indices {matching_indices}"
+
+#     # check image data to be deleted match
+#     base_image = images[matching_indices[0]]  # Reference image
+#     for i in matching_indices[1:]:
+#         assert np.array_equal(base_image, images[i]), \
+#             f"Mismatch in image data for {vox_image_dict[i]} at index {i}"
+
+# images = images[kept_indices]
+
+
+# In[46]:
+
+
+images = torch.Tensor(images)
+vox = torch.Tensor(vox)
+assert len(images) == len(vox)
+
+
+# In[47]:
+
+
+### Multi-GPU config ###
+from accelerate import Accelerator, DeepSpeedPlugin
+
+local_rank = os.getenv('RANK')
+if local_rank is None: 
+    local_rank = 0
+else:
+    local_rank = int(local_rank)
+print("LOCAL RANK ", local_rank)  
+
+data_type = torch.float32 # change depending on your mixed_precision
+
+accelerator = Accelerator(split_batches=False)
+batch_size = 8 
+
+
+# In[48]:
+
+
+print("PID of this process =",os.getpid())
+device = accelerator.device
+print("device:",device)
+world_size = accelerator.state.num_processes
+distributed = not accelerator.state.distributed_type == 'NO'
+num_devices = torch.cuda.device_count()
+global_batch_size = batch_size * num_devices
+print("global_batch_size", global_batch_size)
+if num_devices==0 or not distributed: num_devices = 1
+num_workers = num_devices
+print(accelerator.state)
+
+# set data_type to match your mixed precision (automatically set based on deepspeed config)
+if accelerator.mixed_precision == "bf16":
+    data_type = torch.bfloat16
+elif accelerator.mixed_precision == "fp16":
+    data_type = torch.float16
+else:
+    data_type = torch.float32
+
+print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type)
+print = accelerator.print # only print if local_rank=0
+
+
+# ## Configurations
+
+# In[49]:
+
+
+# if running this interactively, can specify jupyter_args here for argparser to use
+if utils.is_interactive():
+    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'
+    print("model_name:", model_name)
+    
+    # global_batch_size and batch_size should already be defined in the above cells
+    # other variables can be specified in the following string:
+    # jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}"
+
+    jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \
+                    --model_name={model_name} \
+                    --no-multi_subject --subj=1 --batch_size={batch_size} \
+                    --hidden_dim=1024 --clip_scale=1. \
+                    --no-blurry_recon --blur_scale=.5 \
+                    --no-use_prior --prior_scale=30 \
+                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \
+                    --ckpt_interval=999 --no-ckpt_saving --new_test \
+                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep"
+    print(jupyter_args)
+    jupyter_args = jupyter_args.split()
+
+
+# In[50]:
+
+
+parser = argparse.ArgumentParser(description="Model Training Configuration")
+parser.add_argument(
+    "--model_name", type=str, default="testing",
+    help="name of model, used for ckpt saving and wandb logging (if enabled)",
+)
+parser.add_argument(
+    "--data_path", type=str, default="/weka/proj-fmri/shared/natural-scenes-dataset",
+    help="Path to where NSD data is stored / where to download it to",
+)
+parser.add_argument(
+    "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8],
+    help="Validate on which subject?",
+)
+parser.add_argument(
+    "--multisubject_ckpt", type=str, default=None,
+    help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.",
+)
+parser.add_argument(
+    "--num_sessions", type=int, default=0,
+    help="Number of training sessions to include (if multi_subject, this variable doesnt matter)",
+)
+parser.add_argument(
+    "--use_prior",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)",
+)
+parser.add_argument(
+    "--batch_size", type=int, default=32,
+    help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser",
+)
+parser.add_argument(
+    "--wandb_log",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to log to wandb",
+)
+parser.add_argument(
+    "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False,
+    help="if not using wandb and want to resume from a ckpt",
+)
+parser.add_argument(
+    "--wandb_project",type=str,default="stability",
+    help="wandb project name",
+)
+parser.add_argument(
+    "--mixup_pct",type=float,default=.33,
+    help="proportion of way through training when to switch from BiMixCo to SoftCLIP",
+)
+parser.add_argument(
+    "--low_mem",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to preload images to cpu to speed things up but consume more memory",
+)
+parser.add_argument(
+    "--blurry_recon",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to output blurry reconstructions",
+)
+parser.add_argument(
+    "--blur_scale",type=float,default=.5,
+    help="multiply loss from blurry recons by this number",
+)
+parser.add_argument(
+    "--clip_scale",type=float,default=1.,
+    help="multiply contrastive loss by this number",
+)
+parser.add_argument(
+    "--prior_scale",type=float,default=30,
+    help="multiply diffusion prior loss by this",
+)
+parser.add_argument(
+    "--use_image_aug",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to use image augmentation",
+)
+parser.add_argument(
+    "--num_epochs",type=int,default=120,
+    help="number of epochs of training",
+)
+parser.add_argument(
+    "--multi_subject",action=argparse.BooleanOptionalAction,default=False,
+)
+parser.add_argument(
+    "--new_test",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--n_blocks",type=int,default=2,
+)
+parser.add_argument(
+    "--hidden_dim",type=int,default=1024,
+)
+parser.add_argument(
+    "--seq_past",type=int,default=0,
+)
+parser.add_argument(
+    "--seq_future",type=int,default=0,
+)
+parser.add_argument(
+    "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'],
+)
+parser.add_argument(
+    "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--ckpt_interval",type=int,default=5,
+    help="save backup ckpt and reconstruct every x epochs",
+)
+parser.add_argument(
+    "--seed",type=int,default=42,
+)
+parser.add_argument(
+    "--max_lr",type=float,default=3e-4,
+)
+
+if utils.is_interactive():
+    args = parser.parse_args(jupyter_args)
+else:
+    args = parser.parse_args()
+
+# create global variables without the args prefix
+for attribute_name in vars(args).keys():
+    globals()[attribute_name] = getattr(args, attribute_name)
+    
+outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+if not os.path.exists(outdir) and ckpt_saving:
+    os.makedirs(outdir,exist_ok=True)
+    
+if use_image_aug or blurry_recon:
+    import kornia
+    import kornia.augmentation as K
+    from kornia.augmentation.container import AugmentationSequential
+if use_image_aug:
+    img_augment = AugmentationSequential(
+        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),
+        same_on_batch=False,
+        data_keys=["input"],
+    )
+    # Define the blurring augmentations
+    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)
+    
+if multi_subject:
+    subj_list = np.arange(1,9)
+    subj_list = subj_list[subj_list != subj]
+else:
+    subj_list = [subj]
+
+print("subj_list", subj_list, "num_sessions", num_sessions)
+
+
+# ## Prep data, models, and dataloaders
+
+# In[51]:
+
+
+if ckpt_saving:
+    # save MST_ID for 2-alternative forced-choice retrieval evaluation 
+    if 'MST' in model_name:
+        eval_dir = os.environ["eval_dir"]
+        print('saving MST info in', eval_dir)
+        # Saving ##
+        if not os.path.exists(eval_dir):
+            os.mkdir(eval_dir)
+
+        np.save(f"{eval_dir}/MST_ID.npy", MST_ID)
+        np.save(f"{eval_dir}/MST_pairmate_indices.npy", MST_pairmate_indices)
+
+    if remove_random_n:
+        np.save(f"{eval_dir}/imgs_to_remove.npy", imgs_to_remove)
+
+    np.save(f"{eval_dir}/train_image_indices.npy", train_image_indices)
+    np.save(f"{eval_dir}/test_image_indices.npy", test_image_indices)
+    np.save(f"{eval_dir}/images.npy", images)
+    np.save(f"{eval_dir}/vox.npy", vox)
+
+
+# ### Creating wds dataloader, preload betas and all 73k possible images
+
+# In[52]:
+
+
+def my_split_by_node(urls): return urls
+num_voxels_list = []
+
+if multi_subject:
+    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])
+    num_samples_per_epoch = (750*40) // num_devices 
+else:
+    # num_samples_per_epoch = (750*num_sessions) // num_devices 
+    num_samples_per_epoch = len(train_image_indices)
+
+print("dividing batch size by subj_list, which will then be concatenated across subj during training...") 
+batch_size = batch_size // len(subj_list)
+
+num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))
+
+print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch)
+
+
+# In[53]:
+
+
+train_data = {}
+train_dl = {}
+
+train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))
+test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))
+
+
+# In[54]:
+
+
+num_voxels = {}
+voxels = {}
+for s in subj_list:
+    print(f"Training with {num_sessions} sessions")
+    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True)
+
+    num_voxels_list.append(vox[0].shape[-1])
+    num_voxels[f'subj0{s}'] = vox[0].shape[-1]
+    voxels[f'subj0{s}'] = vox
+    print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}")
+
+print("Loaded all subj train dls and vox!\n")
+
+# Validate only on one subject
+if multi_subject: 
+    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list
+test_dl = torch.utils.data.DataLoader(test_data, batch_size=24, shuffle=False, drop_last=True, pin_memory=True)
+
+print(f"Loaded test dl for subj{subj}!\n")
+
+
+# ## Load models
+
+# ### CLIP image embeddings  model
+
+# In[55]:
+
+
+## USING OpenCLIP ViT-bigG ###
+sys.path.append('generative_models/')
+import sgm
+from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder
+# from generative_models.sgm.models.diffusion import DiffusionEngine
+# from omegaconf import OmegaConf
+
+try:
+    print(clip_img_embedder)
+except:
+    clip_img_embedder = FrozenOpenCLIPImageEmbedder(
+        arch="ViT-bigG-14",
+        version="laion2b_s39b_b160k",
+        output_tokens=True,
+        only_tokens=True,
+    )
+    clip_img_embedder.to(device)
+clip_seq_dim = 256
+clip_emb_dim = 1664
+
+# ## USING OPEN AI CLIP ViT-L ###
+# import clip
+# try:
+#     print(clip_model)
+# except:
+#     clip_model, preprocess = clip.load("ViT-L/14", device=device)
+#     preprocess = transforms.Compose([
+#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),
+#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+#                              std=[0.26862954, 0.26130258, 0.27577711]),
+#     ])
+# def clip_img_embedder(image):
+#     preproc_img = preprocess(image)
+#     return clip_model.encode_image(preproc_img)
+# clip_seq_dim = 1
+# clip_emb_dim = 768
+
+
+# ### MindEye modules
+
+# In[56]:
+
+
+model = utils.prepare_model_and_training(
+    num_voxels_list=num_voxels_list,
+    n_blocks=n_blocks,
+    hidden_dim=hidden_dim,
+    clip_emb_dim=clip_emb_dim,
+    clip_seq_dim=clip_seq_dim,
+    use_prior=use_prior,
+    clip_scale=clip_scale
+)
+
+
+# In[57]:
+
+
+# test on subject 1 with fake data
+b = torch.randn((2,1,num_voxels_list[0]))
+print(b.shape, model.ridge(b,0).shape)
+
+
+# In[58]:
+
+
+# test that the model works on some fake data
+b = torch.randn((2,1,hidden_dim))
+print("b.shape",b.shape)
+
+backbone_, clip_, blur_ = model.backbone(b)
+print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)
+
+
+# ### Adding diffusion prior + unCLIP if use_prior=True
+
+# In[59]:
+
+
+if use_prior:
+    from models import *
+
+    # setup diffusion prior network
+    out_dim = clip_emb_dim
+    depth = 6
+    dim_head = 52
+    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+    timesteps = 100
+
+    prior_network = VersatileDiffusionPriorNetwork(
+            dim=out_dim,
+            depth=depth,
+            dim_head=dim_head,
+            heads=heads,
+            causal=False,
+            num_tokens = clip_seq_dim,
+            learned_query_mode="pos_emb"
+        )
+
+    model.diffusion_prior = BrainDiffusionPrior(
+        net=prior_network,
+        image_embed_dim=out_dim,
+        condition_on_text_encodings=False,
+        timesteps=timesteps,
+        cond_drop_prob=0.2,
+        image_embed_scale=None,
+    )
+    
+    utils.count_params(model.diffusion_prior)
+    utils.count_params(model)
+
+
+# ### Setup optimizer / lr / ckpt saving
+
+# In[60]:
+
+
+no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+opt_grouped_parameters = [
+    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},
+    {'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},
+    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
+]
+# model.backbone.requires_grad_(False)
+
+if use_prior:
+    opt_grouped_parameters.extend([
+        {'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},
+        {'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}
+    ])
+
+optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)
+
+if lr_scheduler_type == 'linear':
+    lr_scheduler = torch.optim.lr_scheduler.LinearLR(
+        optimizer,
+        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),
+        last_epoch=-1
+    )
+elif lr_scheduler_type == 'cycle':
+    if num_iterations_per_epoch==0:
+        num_iterations_per_epoch=1
+    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))
+    print("total_steps", total_steps)
+    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, 
+        max_lr=max_lr,
+        total_steps=total_steps,
+        final_div_factor=1000,
+        last_epoch=-1, pct_start=2/num_epochs
+    )
+    
+def save_ckpt(tag):
+    ckpt_path = outdir+f'/{tag}.pth'
+    if accelerator.is_main_process:
+        unwrapped_model = accelerator.unwrap_model(model)
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': unwrapped_model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'lr_scheduler': lr_scheduler.state_dict(),
+            'train_losses': losses,
+            'test_losses': test_losses,
+            'lrs': lrs,
+            }, ckpt_path)
+    print(f"\n---saved {outdir}/{tag} ckpt!---\n")
+
+def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): 
+    print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')
+    state_dict = checkpoint['model_state_dict']
+    if multisubj_loading: # remove incompatible ridge layer that will otherwise error
+        state_dict.pop('ridge.linears.0.weight',None)
+    model.load_state_dict(state_dict, strict=strict)
+    if load_epoch:
+        globals()["epoch"] = checkpoint['epoch']
+        print("Epoch",epoch)
+    if load_optimizer:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    if load_lr:
+        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+    del checkpoint
+
+print("\nDone with model preparations!")
+num_params = utils.count_params(model)
+
+
+# # Wandb
+
+# In[61]:
+
+
+if local_rank==0 and wandb_log: # only use main process for wandb logging
+    import wandb
+    import time
+    
+    wandb_project = 'rtmindeye'
+    print(f"wandb {wandb_project} run {model_name}")
+
+    # Need to configure wandb beforehand in terminal with "wandb init"!
+    wandb_config = {
+        "model_name": model_name,
+        "global_batch_size": global_batch_size,
+        "batch_size": batch_size,
+        "num_epochs": num_epochs,
+        "num_sessions": num_sessions,
+        "num_params": num_params,
+        "clip_scale": clip_scale,
+        "prior_scale": prior_scale,
+        "blur_scale": blur_scale,
+        "use_image_aug": use_image_aug,
+        "max_lr": max_lr,
+        "mixup_pct": mixup_pct,
+        "num_samples_per_epoch": num_samples_per_epoch,
+        "ckpt_interval": ckpt_interval,
+        "ckpt_saving": ckpt_saving,
+        "seed": seed,  # SLURM array task ID
+        "distributed": distributed,
+        "num_devices": num_devices,
+        "world_size": world_size,
+    }
+    print("wandb_config:\n", wandb_config)
+    print("wandb_id:", model_name)
+
+    # Initialize wandb
+    wandb.init(
+        id=model_name,
+        project=wandb_project,
+        name=model_name,
+        config=wandb_config,
+        resume="allow",
+        save_code=True,
+    )
+
+    # Get SLURM job & array ID
+    slurm_job_id = utils.get_slurm_job()
+    slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID
+
+    # Define SLURM log paths
+    log_dir = "slurms"
+    log_files = [
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.out",
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.err",
+    ]
+
+    # Ensure logs exist before logging them
+    for log_file in log_files:
+        wait_time = 0
+        while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s
+            time.sleep(5)
+            wait_time += 5
+
+    # Log SLURM logs as artifacts
+    artifact = wandb.Artifact(f"slurm_logs_{slurm_job_id}_{slurm_array_id}", type="logs")
+    for log_file in log_files:
+        if os.path.exists(log_file):
+            artifact.add_file(log_file)
+
+    wandb.log_artifact(artifact)
+else:
+    wandb_log = False
+
+
+# # Train the model
+
+# In[62]:
+
+
+epoch = 0
+losses, test_losses, lrs = [], [], []
+best_test_loss = 1e9
+torch.cuda.empty_cache()
+
+
+# In[63]:
+
+
+# load multisubject stage1 ckpt if set
+if multisubject_ckpt is not None and not resume_from_ckpt:
+    load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)
+
+
+# In[64]:
+
+
+# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')
+# state_dict = checkpoint['model_state_dict']
+# model.load_state_dict(state_dict, strict=False)
+
+
+# In[65]:
+
+
+# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]
+
+model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)
+# leaving out test_dl since we will only have local_rank 0 device do evals
+
+
+# In[ ]:
+
+
+print(f"{model_name} starting with epoch {epoch} / {num_epochs}")
+progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))
+test_image, test_voxel = None, None
+mse = nn.MSELoss()
+l1 = nn.L1Loss()
+soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))
+skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model
+
+for epoch in progress_bar:
+    model.train()
+
+    fwd_percent_correct = 0.
+    bwd_percent_correct = 0.
+    test_fwd_percent_correct = 0.
+    test_bwd_percent_correct = 0.
+    
+    recon_cossim = 0.
+    test_recon_cossim = 0.
+    recon_mse = 0.
+    test_recon_mse = 0.
+
+    loss_clip_total = 0.
+    loss_blurry_total = 0.
+    loss_blurry_cont_total = 0.
+    test_loss_clip_total = 0.
+    
+    loss_prior_total = 0.
+    test_loss_prior_total = 0.
+
+    blurry_pixcorr = 0.
+    test_blurry_pixcorr = 0. 
+
+    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each
+    for train_i, behav in enumerate(train_dl):  
+        with torch.cuda.amp.autocast(dtype=data_type):
+            optimizer.zero_grad()
+            loss = 0.
+            
+            behav = behav[0]
+
+            image = images[behav.long().cpu()].to(device)
+            voxel = vox[behav.long().cpu()]
+            # voxel = (voxel - train_mean) / train_std
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+            if use_image_aug: 
+                image = img_augment(image)
+
+            clip_target = clip_img_embedder(image)
+            assert not torch.any(torch.isnan(clip_target))
+
+            if epoch < int(mixup_pct * num_epochs):
+                voxel, perm, betas, select = utils.mixco(voxel)
+
+            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]
+            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)
+
+            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+            if clip_scale>0:
+                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+            if use_prior:
+                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)
+                loss_prior_total += loss_prior.item()
+                loss_prior *= prior_scale
+                loss += loss_prior
+
+                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()
+                recon_mse += mse(prior_out, clip_target).item()
+
+            if clip_scale>0:
+                if epoch < int(mixup_pct * num_epochs):                
+                    loss_clip = utils.mixco_nce(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=.006,
+                        perm=perm, betas=betas, select=select)
+                else:
+                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]
+                    loss_clip = utils.soft_clip_loss(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=epoch_temp)
+
+                loss_clip_total += loss_clip.item()
+                loss_clip *= clip_scale
+                loss += loss_clip
+
+            if blurry_recon:     
+                image_enc_pred, transformer_feats = blurry_image_enc_
+
+                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215
+                loss_blurry = l1(image_enc_pred, image_enc)
+                loss_blurry_total += loss_blurry.item()
+
+                if epoch < int(mixup_pct * num_epochs):
+                    image_enc_shuf = image_enc[perm]
+                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)
+                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \
+                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)
+
+                image_norm = (image - mean)/std
+                image_aug = (blur_augs(image) - mean)/std
+                _, cnx_embeds = cnx(image_norm)
+                _, cnx_aug_embeds = cnx(image_aug)
+
+                cont_loss = utils.soft_cont_loss(
+                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    temp=0.2)
+                loss_blurry_cont_total += cont_loss.item()
+
+                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215
+
+            if clip_scale>0:
+                # forward and backward top 1 accuracy        
+                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) 
+                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+            if blurry_recon:
+                with torch.no_grad():
+                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()
+                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)
+                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)
+                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                    blurry_pixcorr += pixcorr.item()
+            
+            utils.check_loss(loss)
+            accelerator.backward(loss)
+            optimizer.step()
+
+            losses.append(loss.item())
+            lrs.append(optimizer.param_groups[0]['lr'])
+
+            if lr_scheduler_type is not None:
+                lr_scheduler.step()
+                
+            if train_i >= num_iterations_per_epoch-1:
+                break
+                
+    model.eval()
+    logs = {}
+
+    if local_rank == 0:
+        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+            for i in range(1):
+                for j in range(2):
+                    subset_indices = MST_idx[:, i, j].reshape(-1)
+                    subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                    subset_dl = torch.utils.data.DataLoader(
+                        subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                        drop_last=False, pin_memory=True
+                    )
+
+                    # Reset metrics for this subset
+                    test_losses = []
+                    test_loss_clip_total = 0
+                    test_loss_prior_total = 0
+                    test_blurry_pixcorr = 0
+                    test_fwd_percent_correct = 0
+                    test_bwd_percent_correct = 0
+                    test_recon_cossim = 0
+                    test_recon_mse = 0
+
+                    for test_i, behav in enumerate(subset_dl):
+                        behav = behav[0]
+                        loss = 0.
+
+                        if behav.ndim > 1:
+                            image = images[behav[:, 0].long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()].mean(1)
+                        else:
+                            image = images[behav.long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()]
+
+                        voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+                        clip_img_embedder = clip_img_embedder.to(device)
+                        clip_target = clip_img_embedder(image.float())
+
+                        voxel_ridge = model.ridge(voxel, 0)
+                        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                        if clip_scale > 0:
+                            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                            clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+                        random_samps = np.random.choice(np.arange(len(image)), size=len(image) // 5, replace=False)
+
+                        if use_prior:
+                            loss_prior, contaminated_prior_out = model.diffusion_prior(
+                                text_embed=backbone[random_samps], image_embed=clip_target[random_samps])
+                            test_loss_prior_total += loss_prior.item()
+                            loss_prior *= prior_scale
+                            loss += loss_prior
+
+                        if clip_scale > 0:
+                            loss_clip = utils.soft_clip_loss(
+                                clip_voxels_norm,
+                                clip_target_norm,
+                                temp=0.006
+                            )
+                            test_loss_clip_total += loss_clip.item()
+                            loss_clip *= clip_scale
+                            loss += loss_clip
+
+                        if blurry_recon:
+                            image_enc_pred, _ = blurry_image_enc_
+                            blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps] / 0.18215).sample / 2 + 0.5).clamp(0, 1)
+                            pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                            test_blurry_pixcorr += pixcorr.item()
+
+                        if clip_scale > 0:
+                            labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                            test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                            test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+                        utils.check_loss(loss)
+                        test_losses.append(loss.item())
+
+                    logs.update({
+                        f"subset_{i}_{j}_test/loss": np.mean(test_losses),
+                        f"subset_{i}_{j}_test/loss_clip_total": test_loss_clip_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/loss_prior": test_loss_prior_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1),
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+                    print(f"--- Subset ({i},{j}) ---")
+                    for k, v in logs.items():
+                        if f"subset_{i}_{j}" in k:
+                            print(f"{k}: {v:.4f}")
+
+            # After subset loop: add train (and global test, if you want) metrics
+            logs.update({
+                "train/loss": np.mean(losses[-(train_i+1):]),
+                "train/lr": lrs[-1],
+                "train/num_steps": len(losses),
+                "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1),
+                "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1),
+                "train/loss_clip_total": loss_clip_total / (train_i + 1),
+                "train/loss_blurry_total": loss_blurry_total / (train_i + 1),
+                "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1),
+                "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1),
+                "train/recon_cossim": recon_cossim / (train_i + 1),
+                "train/recon_mse": recon_mse / (train_i + 1),
+                "train/loss_prior": loss_prior_total / (train_i + 1),
+            })
+
+
+            # if finished training, save jpg recons if they exist
+            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):
+                if blurry_recon:    
+                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215
+                    # transform blurry recon latents to images and plot it
+                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))
+                    jj=-1
+                    for j in [0,1,2,3]:
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                    plt.show()
+
+            progress_bar.set_postfix(**logs)
+
+            if wandb_log: wandb.log(logs)
+            
+    # Save model checkpoint and reconstruct
+    if (ckpt_saving) and (epoch % ckpt_interval == 0):
+        save_ckpt(f'last')
+
+    # wait for other GPUs to catch up if needed
+    accelerator.wait_for_everyone()
+    torch.cuda.empty_cache()
+
+print("\n===Finished!===\n")
+if ckpt_saving:
+    save_ckpt(f'last')
+
+
+# In[68]:
+
+
+len(test_data)
+
+
+# In[69]:
+
+
+# # Track metrics here:
+# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999
+
+
+# **To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**
+
+# In[70]:
+
+
+# MST_pairmate_names
+
+
+# In[71]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs[i,0] = x.index(p[0])
+    pairs[i,1] = x.index(p[1])
+    
+# print(pairs)
+
+
+# In[72]:
+
+
+# if sub=="sub-002":
+#     unique_images_pairs = [
+#         (2,3),(4,5),(7,8),(15,16),
+#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),
+#         (503, 504), (512, 513), 
+#     ]
+# elif sub != 'sub-001' and session != 'ses-05':
+#     unique_images_pairs = [
+#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),
+#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),
+#         (31,32),(33,34),(35,36),
+#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),
+#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),
+#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),
+#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),
+#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),
+#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),
+#         (847, 848), (849, 850)
+#     ]
+# else:
+#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]
+#     unique_images_pairs = find_mst_pairs(x)
+# # unique_images[unique_images_pairs]
+
+
+# In[73]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    score = 0
+    total = 0
+    
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for pair in mst_pairs:
+            voxel = vox[image_idx[pair[0]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            imageA = images[image_idx[pair[0]]].to(device)[None]
+            imageB = images[image_idx[pair[1]]].to(device)[None]
+            
+            clip_targetA = clip_img_embedder(imageA.float())
+            clip_targetB = clip_img_embedder(imageB.float())
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+            clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm):
+                score += 1
+            total += 1
+            
+            voxel = vox[image_idx[pair[1]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm):
+                score += 1
+            total += 1
+            
+    return score/total
+
+print(evaluate_mst_pairs(pairs))
+
+
+# In[74]:
+
+
+model.eval()
+logs = {}
+if local_rank == 0:
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for i in range(1):
+            for j in range(2):
+                subset_indices = MST_idx[:, i, j].reshape(-1)
+                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                subset_dl = torch.utils.data.DataLoader(
+                    subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                    drop_last=True, pin_memory=True
+                )
+
+                # Reset metrics for this subset
+                test_fwd_percent_correct = 0
+                test_bwd_percent_correct = 0
+
+                for test_i, behav in enumerate(subset_dl):
+                    behav = behav[0]
+                    loss = 0.
+                    image = images[behav.long().cpu()].to(device)
+                    voxel = vox[behav.long().cpu()]
+                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+                    clip_img_embedder = clip_img_embedder.to(device)
+                    clip_target = clip_img_embedder(image.float())
+
+                    voxel_ridge = model.ridge(voxel, 0)
+                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)
+                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)
+
+                    if clip_scale > 0:
+                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+                    print(test_fwd_percent_correct)
+                    print(test_bwd_percent_correct)
+                    logs.update({
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+
+    print("--- Full Dataset Evaluation ---")
+    for k, v in logs.items():
+        print(f"{k}: {v:.4f}")
+
+
+# In[ ]:
+
+
+top_k = 5
+
+for x in range(len(MST_idx)):
+    # Get top-k indices
+    y = torch.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)[x], k=top_k).indices.to('cpu').tolist()
+
+    # Set up the plot with original + top_k images in one row
+    fig, axs = plt.subplots(1, top_k + 1, figsize=(3 * (top_k + 1), 3))
+    
+    # Plot the original image
+    orig_img = utils.torch_to_Image(images[MST_idx[x]])
+    axs[0].imshow(orig_img)
+    axs[0].set_title("Original")
+    axs[0].axis("off")
+
+    # Plot the top-k retrieved images
+    for idx, i in enumerate(y):
+        pred_img = utils.torch_to_Image(images[MST_idx[i]])
+        axs[idx + 1].imshow(pred_img)
+        axs[idx + 1].set_title(f"Top {idx+1}")
+        axs[idx + 1].axis("off")
+    
+    plt.tight_layout()
+    plt.show()
+
+
+# In[76]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        failed_A = []
+        failed_B = []
+        failed_non_corr = []
+
+        # Get all unique image indices
+        all_indices = np.unique(mst_pairs.flatten())
+        
+        # Pre-load all images and betas to device
+        all_images = images[image_idx[all_indices]].to(device)
+        all_voxels = torch.Tensor(vox[image_idx[all_indices]]).unsqueeze(1).to(device)
+        
+        # Get CLIP embeddings for all images
+        all_clip_targets = clip_img_embedder(all_images.float())
+        all_clip_targets_norm = nn.functional.normalize(all_clip_targets.flatten(1), dim=-1)
+        
+        # Pass all betas through model to get MindEye embeddings
+        all_voxel_ridge = model.ridge(all_voxels, 0)
+        _, all_clip_voxels, _ = model.backbone(all_voxel_ridge)
+        all_clip_voxels_norm = nn.functional.normalize(all_clip_voxels.flatten(1), dim=-1)
+        
+        # Dict mapping idx (which indexes the "vox" and "images" tensors) to pos (their position in the flattened array "all_indices")
+        idx_to_pos = {idx: pos for pos, idx in enumerate(all_indices)}
+        
+        # Initialize scores
+        corr_score = 0
+        non_corr_score = 0
+        corr_total = len(mst_pairs) * 2
+        non_corr_total = len(mst_pairs) * (len(mst_pairs)-1) * 4  # number of elements in the matrix excluding the diagonal is n*(n-1)*4 since we're doing this twice each for pairmate A and B
+
+        
+        # Pre-load voxelwise beta-based embeddings from MindEye and CLIP image embeddings
+        idxA = np.array([pair[0] for pair in mst_pairs])
+        idxB = np.array([pair[1] for pair in mst_pairs])
+        
+        posA = np.array([idx_to_pos[idx] for idx in idxA])
+        posB = np.array([idx_to_pos[idx] for idx in idxB])
+        
+        voxA_embeddings = all_clip_voxels_norm[posA]
+        voxB_embeddings = all_clip_voxels_norm[posB]
+        imgA_embeddings = all_clip_targets_norm[posA]
+        imgB_embeddings = all_clip_targets_norm[posB]
+        
+        simA_A = utils.batchwise_cosine_similarity(voxA_embeddings, imgA_embeddings)
+        simA_B = utils.batchwise_cosine_similarity(voxA_embeddings, imgB_embeddings)
+        simB_B = utils.batchwise_cosine_similarity(voxB_embeddings, imgB_embeddings)
+        simB_A = utils.batchwise_cosine_similarity(voxB_embeddings, imgA_embeddings)
+
+        
+        # corresponding 2-AFC
+        # is the voxel embedding for image 1 pairmate A more similar to the CLIP embedding for image 1 pairmate A or the CLIP embedding for image 1 pairmate B?
+        correct_A = torch.diag(simA_A) > torch.diag(simA_B)
+        # is the voxel embedding for image 1 pairmate B more similar to the CLIP embedding for image 1 pairmate B or the CLIP embedding for image 1 pairmate A?
+        correct_B = torch.diag(simB_B) > torch.diag(simB_A)
+
+        corr_score += correct_A.sum().item()
+        corr_score += correct_B.sum().item()
+
+        # Store indices where AFC fails
+        failed_A = [i for i, correct in enumerate(correct_A.cpu()) if not correct]
+        failed_B = [i for i, correct in enumerate(correct_B.cpu()) if not correct]
+        
+        # non-corresponding 2-AFC
+        N = len(mst_pairs)        
+        # Create a mask that is True for all off-diagonal elements
+        row_idx = torch.arange(N).unsqueeze(1)  # (N, 1)
+        col_idx = torch.arange(N).unsqueeze(0)  # (1, N)
+        off_diag_mask = row_idx != col_idx  # shape (N, N)
+        
+        diagA_A = simA_A.diag().unsqueeze(1).expand(-1, N)  # Get diagonal values and expand to (N, N) by duplicating the diagonal element along the rows (since each row is the cosine similarity between a single voxel embedding and all CLIP embeddings)
+        diagB_B = simB_B.diag().unsqueeze(1).expand(-1, N)
+        
+        # pdb.set_trace()
+
+        # Compare each element in the row to the diagonal element
+        off_diag_mask_device = off_diag_mask.to(device)
+
+        fail_AA = (simA_A < diagA_A) & off_diag_mask_device
+        fail_AB = (simA_B < diagA_A) & off_diag_mask_device
+        fail_BB = (simB_B < diagB_B) & off_diag_mask_device
+        fail_BA = (simB_A < diagB_B) & off_diag_mask_device
+
+        non_corr_score += fail_AA.sum().item()
+        non_corr_score += fail_AB.sum().item()
+        non_corr_score += fail_BB.sum().item()
+        non_corr_score += fail_BA.sum().item()
+
+        # Log failed indices
+        fail_sources = [fail_AA, fail_AB, fail_BB, fail_BA]
+        for fail_matrix, label in zip(fail_sources, ["AA", "AB", "BB", "BA"]):
+            fail_coords = torch.nonzero(fail_matrix, as_tuple=False).cpu().numpy()
+            for i, j in fail_coords:
+                failed_non_corr.append({"type": label, "i": i, "j": j, "pair_i": mst_pairs[i], "pair_j": mst_pairs[j]})
+
+    return corr_score, corr_total, int(non_corr_score), non_corr_total, failed_A, failed_B, failed_non_corr
+
+
+# In[77]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = []
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs.append([utils.find_all_indices(x,p[0]), utils.find_all_indices(x,p[1])])
+
+pairs = np.array(pairs)
+print(pairs.shape)
+
+
+# In[78]:
+
+
+all_scores = []
+all_failures = []
+
+for i in range(1):
+    for j in range(2):
+        mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)
+        corr_score, corr_total, non_corr_score, non_corr_total, failed_A, failed_B, failed_non_corr = evaluate_mst_pairs(mst_pairs)
+
+        # Store scores and failure info together
+        all_scores.append((corr_score, corr_total, non_corr_score, non_corr_total))
+        all_failures.append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "failed_A": failed_A,
+            "failed_B": failed_B,
+            "failed_non_corr": failed_non_corr,
+            "mst_pairs": mst_pairs,
+        })
+
+        # Print summary
+        print(f"pairmate A repeat {i} vs pairmate B repeat {j}:")
+        print(f"2-AFC corresponding = {corr_score}/{corr_total} ({corr_score/corr_total:.2%})")
+        print(f"2-AFC non-corresponding = {non_corr_score}/{non_corr_total} ({non_corr_score/non_corr_total:.2%})")
+        print("")
+
+
+# In[79]:
+
+
+# # Compare first few pairs
+# for pair in pairs:  # Checking first 2 pairs
+#     print("Indices in mst_pairs:", pair)
+#     print("Corresponding filenames:")
+#     print(f"Image 1: {x[pair[0]]}")
+#     print(f"Image 2: {x[pair[1]]}\n")
+
+
+# In[80]:
+
+
+# for i in range(len(pairs)):
+#     fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())
+#     ax[0].set_title(f"Repeat 1")
+
+#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())
+#     ax[1].set_title(f"Repeat 2")
+
+#     plt.setp(ax, xticks=[], yticks=[])
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[81]:
+
+
+# score = 0
+# total = 0
+# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): 
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageA_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimA > cossimB:
+#             score += 1
+#         total += 1
+        
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageB_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimB > cossimA:
+#             score += 1
+#         total += 1
+
+# print(score/total)
+
+
+# In[82]:
+
+
+#display(utils.torch_to_Image(imageA))
+#display(utils.torch_to_Image(imageB))
+
+
+# In[83]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(np.array(unique_images_pairs).flatten())
+# assert total_samples == 100
+
+# correct_predictions = int((score/total) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+
+
+
+# In[ ]:
+
+
+
+

main-multisession-sub-005_ses-03_union_mask.py

@@ -0,0 +1,1956 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Import packages & functions
+
+# In[1]:
+
+
+print("importing modules")
+import os
+import sys
+import json
+import argparse
+import numpy as np
+import time
+import random
+import string
+import h5py
+from tqdm import tqdm
+import webdataset as wds
+from PIL import Image
+import pandas as pd
+import nibabel as nib
+import nilearn
+
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+# tf32 data type is faster than standard float32
+torch.backends.cuda.matmul.allow_tf32 = True
+
+import utils
+from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas
+
+# imports utils from mindeye_preproc as "preproc"
+import importlib.util
+parent_utils_path = "/home/ri4541/mindeye_preproc/analysis/utils.py"
+spec = importlib.util.spec_from_file_location("utils", parent_utils_path)
+preproc = importlib.util.module_from_spec(spec)
+parent_dir = os.path.dirname(parent_utils_path)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+spec.loader.exec_module(preproc)
+
+if utils.is_interactive():
+    from IPython.display import clear_output # function to clear print outputs in cell
+    get_ipython().run_line_magic('load_ext', 'autoreload')
+    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions
+    get_ipython().run_line_magic('autoreload', '2')
+    
+seed = utils.get_slurm_seed()
+
+
+# # Princeton data prep
+
+# ## Load Data & Design
+
+# In[2]:
+
+
+if utils.is_interactive():
+    sub = "sub-005"
+    session = "ses-03"
+    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format
+    func_task_name = 'C'
+else:
+    sub = os.environ["sub"]
+    session = os.environ["session"]
+    task = os.environ["task"]
+    func_task_name = 'C'
+
+if session == "all":
+    ses_list = ["ses-01", "ses-02"]  # list of actual session IDs
+    design_ses_list = ["ses-01", "ses-02"]  # list of session IDs to search for design matrix
+else:
+    ses_list = [session]
+    design_ses_list = [session]
+    
+task_name = f"_task-{task}" if task != 'study' else ''
+resample_voxel_size = False
+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
+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
+    
+train_test_split = 'MST' # 'MST', 'orig', 'unique'
+remove_close_to_MST = False
+remove_random_n = False
+
+if remove_close_to_MST or remove_random_n:
+    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images
+
+n_to_remove = 0
+if remove_random_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_to_remove = 150
+    
+if resample_voxel_size:
+    # voxel size was unchanged in glmsingle, want to perform resampling here
+    resampled_vox_size = 2.5
+    resample_method = "sinc"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html
+    
+    # file name helper variables
+    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore
+    resampled_suffix = f"resampled_{vox_dim_str}mm_{resample_method}"
+    mask_resampled_suffix = resampled_suffix
+    if resample_post_glmsingle:
+        resampled_suffix += '_postglmsingle'
+    else:
+        resampled_suffix += '_preglmsingle'
+
+
+# In[3]:
+
+
+session_label = preproc.get_session_label(ses_list)
+print('session label:', session_label)
+n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)
+
+
+# In[4]:
+
+
+if utils.is_interactive():
+    glmsingle_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}"
+else:
+    glmsingle_path = os.environ["glmsingle_path"]
+    
+designdir = "/home/ri4541/real_time_mindEye2"
+print(glmsingle_path)
+
+if resample_voxel_size:
+    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here
+    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here
+    if resample_post_glmsingle:
+        # option 1
+        orig_glmsingle_path = glmsingle_path
+        glmsingle_path += f"_{resampled_suffix}"
+        print("resampled glmsingle path:", glmsingle_path)
+        if load_from_resampled_file:
+            # resampling is already done; load from file
+             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here
+        else:
+            # don't load from file; do resampling here
+            os.makedirs(glmsingle_path,exist_ok=True)
+    else:
+        # option 2
+        glmsingle_path += f"_{resampled_suffix}"
+        print("glmsingle path:", glmsingle_path)
+
+assert os.path.exists(glmsingle_path)
+print("glmsingle path exists!")
+
+
+# In[5]:
+
+
+data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(
+    sub=sub,
+    session=session,
+    func_task_name=task,
+    designdir=designdir,
+    design_ses_list=design_ses_list
+)
+
+if sub == 'sub-001':
+    if session == 'ses-01':
+        assert image_names[0] == 'images/image_686_seed_1.png'
+    elif session in ('ses-02', 'all'):
+        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'
+    elif session == 'ses-03':
+        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'
+    elif session == 'ses-04':
+        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+elif sub == 'sub-003':
+    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+
+unique_images = np.unique(image_names.astype(str))
+unique_images = unique_images[(unique_images!="nan")]
+len_unique_images = len(unique_images)
+print("n_runs",n_runs)
+
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(unique_images) == 851
+
+print(image_names[:4])
+print(starts[:4])
+print(is_new_run[:4])
+
+if remove_random_n:
+    # want to remove 150 imgs
+    # 100 special515 imgs are repeated 3x (300 total)
+    # all other train imgs are only shown once (558 total)
+    # of the 150, want to sample proportionally since we're cutting all repeats for special515
+    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total
+    np.random.seed(seed)
+    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)
+    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)
+    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)
+    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))
+
+image_idx = np.array([])  # contains the unique index of each presented image
+vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx
+all_MST_images = dict()
+for i, im in enumerate(image_names):
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    vox_image_names = np.append(vox_image_names, im)
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            i+=1
+            continue
+    elif remove_random_n:
+        if im in imgs_to_remove:
+            i+=1
+            continue
+            
+    image_idx_ = np.where(im==unique_images)[0].item()
+    image_idx = np.append(image_idx, image_idx_)
+    
+    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
+        import re
+        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)):  
+        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it
+            # print(im)
+            all_MST_images[i] = im
+            i+=1            
+    elif 'MST' in im:
+        all_MST_images[i] = im
+        i+=1
+    
+image_idx = torch.Tensor(image_idx).long()
+# for im in new_image_names[MST_images]:
+#     assert 'MST_pairs' in im
+# assert len(all_MST_images) == 300
+
+unique_MST_images = np.unique(list(all_MST_images.values())) 
+
+MST_ID = np.array([], dtype=int)
+if remove_close_to_MST:
+    close_to_MST_idx = np.array([], dtype=int)
+if remove_random_n:
+    random_n_idx = np.array([], dtype=int)
+
+vox_idx = np.array([], dtype=int)
+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
+for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            i+=1
+            continue
+    if remove_random_n:
+        if im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            i+=1
+            j+=1
+            continue
+    j+=1
+    curr = np.where(im == unique_MST_images)
+    # print(curr)
+    if curr[0].size == 0:
+        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
+    else:
+        MST_ID = np.append(MST_ID, curr)
+        
+assert len(MST_ID) == len(image_idx)
+# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)
+# 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
+print(MST_ID.shape)
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(all_MST_images) == 100
+
+
+# ## Load images
+
+# In[6]:
+
+
+import imageio.v2 as imageio
+resize_transform = transforms.Resize((224, 224))
+MST_images = []
+images = None
+for im_name in tqdm(image_idx):
+    if sub == 'sub-001' and session == 'ses-01':
+        image_file = f"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}"
+    else:
+        image_file = f"{unique_images[im_name]}"
+    im = imageio.imread(image_file)
+    im = torch.Tensor(im / 255).permute(2,0,1)
+    im = resize_transform(im.unsqueeze(0))
+    if images is None:
+        images = im
+    else:
+        images = torch.vstack((images, im))
+    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+        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)):  
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+    else:   
+        if ("MST_pairs" in image_file): # ("_seed_" not in unique_images[im_name]) and (unique_images[im_name] != "blank.jpg") 
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+
+print("images", images.shape)
+MST_images = np.array(MST_images)
+print("MST_images", len(MST_images))
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(MST_images[MST_images==True]) == 100
+print("MST_images==True", len(MST_images[MST_images==True]))
+
+
+# In[7]:
+
+
+# want IDs of pairmates based on MST_images
+# create "MST_pairmates" which is a 25x2 array with indices of the 25 pairs based on MST_images == True
+
+assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2
+MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)
+# print(MST_pairmate_names)
+
+MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for p, pair in enumerate(MST_pairmate_names):
+    for i, im in enumerate(pair):
+        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
+        
+print(MST_pairmate_indices.shape, MST_pairmate_indices)
+
+
+# In[8]:
+
+
+if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):
+    # MST_pairs contains the indices of repeats based on all_MST_images
+    # all_MST_images contains the indices of images from image_names
+    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))
+    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
+
+    # assert images[MST_pairs]
+
+    fig, ax = plt.subplots(1, 3, figsize=(10,4))
+    fig.suptitle('Sample MST pairs')
+
+    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())
+    ax[0].set_title(f"Trial 0")
+
+    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())
+    ax[1].set_title(f"Trial 1")
+
+    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())
+    ax[2].set_title(f"Trial 2")
+
+    plt.setp(ax, xticks=[], yticks=[])
+    plt.tight_layout()
+    plt.show()
+
+
+# In[9]:
+
+
+# pairs has the indices of all repeated images
+pairs = utils.find_paired_indices(image_idx)
+pairs = sorted(pairs, key=lambda x: x[0])
+
+fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns
+for i, ax in enumerate(axes):
+    ax.imshow(images[i].permute(1, 2, 0).numpy())
+    ax.set_title(f"Trial {i}")
+    ax.axis("off")  # Hide axes for better visualization
+
+plt.tight_layout()
+# output_path = os.path.join(output_dir, "trials_plot.png")
+# plt.savefig(output_path, dpi=300)  # Save figure
+plt.show()
+
+
+# In[10]:
+
+
+p=0
+
+# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)
+fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())
+ax[0].set_title(f"Repeat 1")
+
+ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())
+ax[1].set_title(f"Repeat 2")
+
+plt.setp(ax, xticks=[], yticks=[])
+plt.tight_layout()
+plt.show()
+
+
+# In[11]:
+
+
+def get_image_pairs(sub, session, func_task_name, designdir):
+    """Loads design files and processes image pairs for a given session."""
+    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(
+        sub=sub,
+        session=session,
+        func_task_name=func_task_name,
+        designdir=designdir,
+        design_ses_list=[session]  # Ensure it's a list
+    )
+    return utils.process_images(image_names, unique_images)
+
+
+# In[12]:
+
+
+from collections import defaultdict
+
+all_dicts = []
+for s_idx, s in enumerate(ses_list):
+    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)
+    assert len(im) == len(vo)
+    all_dicts.append({k:v for k,v in enumerate(vo)})
+
+# for the train set (ses-01-02 non-MST)
+image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])
+for ses_idx, idx_to_name in enumerate(all_dicts):
+    for idx, name in idx_to_name.items():
+        image_to_indices[name][ses_idx].append(idx)
+        
+image_to_indices = dict(image_to_indices)
+
+# for the test set (ses-03)
+# test_image_to_indices = defaultdict(lambda: [[] for _ in range(len([ses_list[-1]]))])
+# for ses_idx, idx_to_name in enumerate([all_dicts[-1]]):
+#     for idx, name in idx_to_name.items():
+#         test_image_to_indices[name][ses_idx].append(idx)
+        
+# test_image_to_indices = dict(test_image_to_indices)
+
+
+# In[13]:
+
+
+# train_pairs_list = []
+# test_pairs_list = []
+
+if sub == 'sub-005' and ses_list == ["ses-01", "ses-02"]:
+    for image, (ses0_indices, ses1_indices) in image_to_indices.items():
+        # Offset session 1 indices by 693
+        image_to_indices[image] = [ses0_indices, [i + 693 for i in ses1_indices]]
+
+#         # Combine all repeat indices (across both sessions)
+#         all_indices = ses0_indices + ses1_indices_offset
+
+#         # Only include if there are at least 2 repeats
+#         if len(all_indices) >= 2:
+#             train_pairs_list.append(all_indices)
+        
+#     for i in test_image_to_indices.values():
+#         # print(i[0])
+#         # Only include if there are at least 2 repeats
+#         if len(i[0]) >= 2:
+#             test_pairs_list.append(i[0])
+            
+#     train_test_pairs = [train_pairs_list, test_pairs_list]
+            
+# elif sub == 'sub-005' and ses_list == ["ses-01", "ses-03"]:
+#     pairs_list = []
+
+#     if len(ses_list) > 2:
+#         # Case 1: Aggregate results from multiple sessions (ses_list[:-1]), concatenating into a single list
+#         combined_pairs = sum([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list[:-1]], [])
+#         pairs_list.append(combined_pairs)
+
+#         # Case 2: Process last session separately
+#         pairs_list.append(get_image_pairs(sub, ses_list[-1], func_task_name, designdir))
+
+#     else:
+#         # Case 3: Process both sessions individually if ses_list has only 2 entries
+#         pairs_list.extend([get_image_pairs(sub, s, func_task_name, designdir) for s in ses_list])
+
+#     assert len(pairs_list) == 2
+
+
+# In[14]:
+
+
+if resample_voxel_size:
+    from nilearn.masking import apply_mask, unmask
+    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'
+    omat_name = f'{glmsingle_path}/boldref_omat'
+
+
+# In[15]:
+
+
+from nilearn.plotting import plot_roi, plot_anat, plot_epi
+
+mask_name = f'{glmsingle_path}/{sub}_{session_label}{task_name}_brain'
+if resample_voxel_size:
+    if resample_post_glmsingle is True:
+        # use original mask directory
+        mask_in_name = f'{orig_glmsingle_path}/{sub}_{session}{task_name}_brain.nii.gz'
+        mask_out_name = mask_name + f"_{mask_resampled_suffix}.nii.gz"
+        assert os.path.exists(mask_in_name)
+        applyxfm(mask_in_name, ref_name, omat_name, resample_method, output=mask_out_name)
+        apply_thresh(mask_out_name, 0.5, output=mask_out_name)  # binarize the mask since resampling can result in non- 0 or 1 values
+    mask_name += f"_{mask_resampled_suffix}"
+
+mask_name += ".nii.gz"
+print(mask_name)
+avg_mask = nib.load(mask_name)
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+
+# In[16]:
+
+
+from nilearn.plotting import plot_roi
+assert sub == 'sub-005' and session == "ses-03"
+print('loading brain mask')
+# func_masks, avg_mask, nsd_masks, roi = utils.get_mask(['ses-01', 'ses-02', 'ses-03'], sub, func_task_name)
+avg_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')
+final_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')
+
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+plot_roi(final_mask, bg_img=avg_mask)
+plt.show()
+
+
+# In[17]:
+
+
+union_mask = np.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy')
+
+
+# ## Load GLMSingle voxel data
+
+# In[18]:
+
+
+vox = None
+needs_postprocessing = False
+params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)
+
+if resample_post_glmsingle == True:
+    glm_save_path_resampled = f"{glmsingle_path}/vox_resampled.nii.gz"
+    if load_from_resampled_file == True:
+        # resampling was done in this notebook so we can load from file
+        vox = nib.load(glm_save_path_resampled)
+    else:
+        # do resampling here
+        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"
+        vox = load_preprocess_betas(orig_glmsingle_path, *params)
+        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)
+    needs_postprocessing = True
+
+if vox is None:
+    # either resampling was done in glmsingle or we aren't resampling 
+    vox = load_preprocess_betas(glmsingle_path, *params)
+
+if needs_postprocessing == True:
+    vox = apply_mask(vox, avg_mask)
+    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)
+    print(vox.shape)
+
+assert len(vox) == len(image_idx)
+
+
+# In[19]:
+
+
+ses_mask = nib.load(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{session_label}_task-C/sub-005_{session_label}_task-C_brain.nii.gz')
+assert np.all(ses_mask.affine == final_mask.affine)
+assert np.all(ses_mask.shape == final_mask.shape)
+
+
+# In[20]:
+
+
+# get vox into the same shape as the union mask
+v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask
+# final_mask = nilearn.masking.intersect_masks([avg_mask, roi])
+vox = nilearn.masking.apply_mask(v, final_mask)  # re-flatten based on final mask so everything is in the same shape now
+print(vox.shape)
+vox = vox[:, union_mask]
+print("applied union roi mask")
+print(vox.shape)
+
+
+# ## Reliability calculation
+
+# ### Calculate reliability (corr between first and second presentation of same image) for every voxel
+
+# In[21]:
+
+
+pairs_homog = np.array([[p[0], p[1]] for p in pairs])
+
+
+# In[22]:
+
+
+same_corrs = []
+diff_corrs = []
+for isamp, samp in enumerate(vox[pairs_homog]):
+    avg_same_img = []
+    for i in range(samp.shape[0]):
+        for j in range(i, samp.shape[0]):
+            if i != j:
+                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))
+    
+    same_corrs.append(np.mean(avg_same_img))
+                       
+    avg_diff_img = []
+    for isamp_j, samp_j in enumerate(vox[pairs_homog]):
+        if isamp_j != isamp:
+            for i in range(samp_j.shape[0]):
+                for j in range(i, samp_j.shape[0]):
+                    if i != j:
+                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))
+                                    
+    # print(len(avg_diff_img))
+    diff_corrs.append(np.mean(avg_diff_img))
+
+
+print(len(same_corrs), len(diff_corrs))
+same_corrs = np.array(same_corrs)
+diff_corrs = np.array(diff_corrs)
+
+
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same/diff Pearson corr.")
+plt.plot(np.sort(same_corrs),c='blue',label='same')
+plt.plot(np.sort(diff_corrs),c='cyan',label='diff')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# In[23]:
+
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same minus diff difference Pearson corr.")
+plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# # Training MindEye
+
+# In[24]:
+
+
+utils.seed_everything(seed)
+
+if train_test_split == 'orig':
+    # train = all images except images that were repeated
+    # test = average of the same-image presentations
+    imageTrain = np.arange(len(images))
+    train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])
+    test_image_indices = pairs
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+elif train_test_split == 'MST':
+    # non-MST images are the train split
+    # MST images are the test split
+    MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])
+    non_MST_idx = [v for k,v in image_to_indices.items() if 'MST_pairs' not in k]
+    non_MST_idx = np.array([z for y in non_MST_idx for x in y for z in x])  # flatten the indices
+    train_image_indices = non_MST_idx
+    test_image_indices = MST_idx.flatten()  # MST_idx contains the mapping for the different test sets; test_image_indices has all MST indices combined
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(vox)
+elif train_test_split == 'unique':
+    imageTest = np.arange(len(images))
+    train_image_indices = pairs.flatten()
+    test_image_indices = np.array([item for item in imageTest if item not in pairs.flatten()])
+    print(len(train_image_indices), len(test_image_indices))
+    assert len(train_image_indices) + len(test_image_indices) == len(image_idx)
+else:
+    raise Exception("invalid train_test_split")
+
+# TODO add assertion that verifies file names in train and test don't overlap, guards against repeats
+
+for i in train_image_indices:
+    assert i not in test_image_indices
+
+
+# In[25]:
+
+
+train_mean = np.mean(vox[train_image_indices],axis=0)
+train_std = np.std(vox[train_image_indices],axis=0)
+
+vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)
+print("voxels have been zscored")
+print(vox[:,0].mean(), vox[:,0].std())
+print("vox", vox.shape)
+
+
+# In[26]:
+
+
+# for idx in deleted_indices:
+#     # check image names to be deleted match
+#     original_name = vox_image_dict[idx]
+#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]
+#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \
+#         f"Mismatch in image names for deleted indices {matching_indices}"
+
+#     # check image data to be deleted match
+#     base_image = images[matching_indices[0]]  # Reference image
+#     for i in matching_indices[1:]:
+#         assert np.array_equal(base_image, images[i]), \
+#             f"Mismatch in image data for {vox_image_dict[i]} at index {i}"
+
+# images = images[kept_indices]
+
+
+# In[27]:
+
+
+images = torch.Tensor(images)
+vox = torch.Tensor(vox)
+assert len(images) == len(vox)
+
+
+# In[28]:
+
+
+### Multi-GPU config ###
+from accelerate import Accelerator, DeepSpeedPlugin
+
+local_rank = os.getenv('RANK')
+if local_rank is None: 
+    local_rank = 0
+else:
+    local_rank = int(local_rank)
+print("LOCAL RANK ", local_rank)  
+
+data_type = torch.float32 # change depending on your mixed_precision
+
+accelerator = Accelerator(split_batches=False)
+batch_size = 8 
+
+
+# In[29]:
+
+
+print("PID of this process =",os.getpid())
+device = accelerator.device
+print("device:",device)
+world_size = accelerator.state.num_processes
+distributed = not accelerator.state.distributed_type == 'NO'
+num_devices = torch.cuda.device_count()
+global_batch_size = batch_size * num_devices
+print("global_batch_size", global_batch_size)
+if num_devices==0 or not distributed: num_devices = 1
+num_workers = num_devices
+print(accelerator.state)
+
+# set data_type to match your mixed precision (automatically set based on deepspeed config)
+if accelerator.mixed_precision == "bf16":
+    data_type = torch.bfloat16
+elif accelerator.mixed_precision == "fp16":
+    data_type = torch.float16
+else:
+    data_type = torch.float32
+
+print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type)
+print = accelerator.print # only print if local_rank=0
+
+
+# ## Configurations
+
+# In[30]:
+
+
+# if running this interactively, can specify jupyter_args here for argparser to use
+if utils.is_interactive():
+    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'
+    print("model_name:", model_name)
+    
+    # global_batch_size and batch_size should already be defined in the above cells
+    # other variables can be specified in the following string:
+    # jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}"
+
+    jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \
+                    --model_name={model_name} \
+                    --no-multi_subject --subj=1 --batch_size={batch_size} \
+                    --hidden_dim=1024 --clip_scale=1. \
+                    --no-blurry_recon --blur_scale=.5 \
+                    --no-use_prior --prior_scale=30 \
+                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \
+                    --ckpt_interval=999 --no-ckpt_saving --new_test \
+                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep"
+    print(jupyter_args)
+    jupyter_args = jupyter_args.split()
+
+
+# In[31]:
+
+
+parser = argparse.ArgumentParser(description="Model Training Configuration")
+parser.add_argument(
+    "--model_name", type=str, default="testing",
+    help="name of model, used for ckpt saving and wandb logging (if enabled)",
+)
+parser.add_argument(
+    "--data_path", type=str, default="/weka/proj-fmri/shared/natural-scenes-dataset",
+    help="Path to where NSD data is stored / where to download it to",
+)
+parser.add_argument(
+    "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8],
+    help="Validate on which subject?",
+)
+parser.add_argument(
+    "--multisubject_ckpt", type=str, default=None,
+    help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.",
+)
+parser.add_argument(
+    "--num_sessions", type=int, default=0,
+    help="Number of training sessions to include (if multi_subject, this variable doesnt matter)",
+)
+parser.add_argument(
+    "--use_prior",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)",
+)
+parser.add_argument(
+    "--batch_size", type=int, default=32,
+    help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser",
+)
+parser.add_argument(
+    "--wandb_log",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to log to wandb",
+)
+parser.add_argument(
+    "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False,
+    help="if not using wandb and want to resume from a ckpt",
+)
+parser.add_argument(
+    "--wandb_project",type=str,default="stability",
+    help="wandb project name",
+)
+parser.add_argument(
+    "--mixup_pct",type=float,default=.33,
+    help="proportion of way through training when to switch from BiMixCo to SoftCLIP",
+)
+parser.add_argument(
+    "--low_mem",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to preload images to cpu to speed things up but consume more memory",
+)
+parser.add_argument(
+    "--blurry_recon",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to output blurry reconstructions",
+)
+parser.add_argument(
+    "--blur_scale",type=float,default=.5,
+    help="multiply loss from blurry recons by this number",
+)
+parser.add_argument(
+    "--clip_scale",type=float,default=1.,
+    help="multiply contrastive loss by this number",
+)
+parser.add_argument(
+    "--prior_scale",type=float,default=30,
+    help="multiply diffusion prior loss by this",
+)
+parser.add_argument(
+    "--use_image_aug",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to use image augmentation",
+)
+parser.add_argument(
+    "--num_epochs",type=int,default=120,
+    help="number of epochs of training",
+)
+parser.add_argument(
+    "--multi_subject",action=argparse.BooleanOptionalAction,default=False,
+)
+parser.add_argument(
+    "--new_test",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--n_blocks",type=int,default=2,
+)
+parser.add_argument(
+    "--hidden_dim",type=int,default=1024,
+)
+parser.add_argument(
+    "--seq_past",type=int,default=0,
+)
+parser.add_argument(
+    "--seq_future",type=int,default=0,
+)
+parser.add_argument(
+    "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'],
+)
+parser.add_argument(
+    "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--ckpt_interval",type=int,default=5,
+    help="save backup ckpt and reconstruct every x epochs",
+)
+parser.add_argument(
+    "--seed",type=int,default=42,
+)
+parser.add_argument(
+    "--max_lr",type=float,default=3e-4,
+)
+
+if utils.is_interactive():
+    args = parser.parse_args(jupyter_args)
+else:
+    args = parser.parse_args()
+
+# create global variables without the args prefix
+for attribute_name in vars(args).keys():
+    globals()[attribute_name] = getattr(args, attribute_name)
+    
+outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+if not os.path.exists(outdir) and ckpt_saving:
+    os.makedirs(outdir,exist_ok=True)
+    
+if use_image_aug or blurry_recon:
+    import kornia
+    import kornia.augmentation as K
+    from kornia.augmentation.container import AugmentationSequential
+if use_image_aug:
+    img_augment = AugmentationSequential(
+        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),
+        same_on_batch=False,
+        data_keys=["input"],
+    )
+    # Define the blurring augmentations
+    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)
+    
+if multi_subject:
+    subj_list = np.arange(1,9)
+    subj_list = subj_list[subj_list != subj]
+else:
+    subj_list = [subj]
+
+print("subj_list", subj_list, "num_sessions", num_sessions)
+
+
+# ## Prep data, models, and dataloaders
+
+# In[32]:
+
+
+if ckpt_saving:
+    # save MST_ID for 2-alternative forced-choice retrieval evaluation 
+    if 'MST' in model_name:
+        eval_dir = os.environ["eval_dir"]
+        print('saving MST info in', eval_dir)
+        # Saving ##
+        if not os.path.exists(eval_dir):
+            os.mkdir(eval_dir)
+
+        np.save(f"{eval_dir}/MST_ID.npy", MST_ID)
+        np.save(f"{eval_dir}/MST_pairmate_indices.npy", MST_pairmate_indices)
+
+    if remove_random_n:
+        np.save(f"{eval_dir}/imgs_to_remove.npy", imgs_to_remove)
+
+    np.save(f"{eval_dir}/train_image_indices.npy", train_image_indices)
+    np.save(f"{eval_dir}/test_image_indices.npy", test_image_indices)
+    np.save(f"{eval_dir}/images.npy", images)
+    np.save(f"{eval_dir}/vox.npy", vox)
+
+
+# ### Creating wds dataloader, preload betas and all 73k possible images
+
+# In[33]:
+
+
+def my_split_by_node(urls): return urls
+num_voxels_list = []
+
+if multi_subject:
+    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])
+    num_samples_per_epoch = (750*40) // num_devices 
+else:
+    # num_samples_per_epoch = (750*num_sessions) // num_devices 
+    num_samples_per_epoch = len(train_image_indices)
+
+print("dividing batch size by subj_list, which will then be concatenated across subj during training...") 
+batch_size = batch_size // len(subj_list)
+
+num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))
+
+print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch)
+
+
+# In[34]:
+
+
+train_data = {}
+train_dl = {}
+
+train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))
+test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))
+
+
+# In[35]:
+
+
+num_voxels = {}
+voxels = {}
+for s in subj_list:
+    print(f"Training with {num_sessions} sessions")
+    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=batch_size, shuffle=True, drop_last=True, pin_memory=True)
+
+    num_voxels_list.append(vox[0].shape[-1])
+    num_voxels[f'subj0{s}'] = vox[0].shape[-1]
+    voxels[f'subj0{s}'] = vox
+    print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}")
+
+print("Loaded all subj train dls and vox!\n")
+
+# Validate only on one subject
+if multi_subject: 
+    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list
+test_dl = torch.utils.data.DataLoader(test_data, batch_size=24, shuffle=False, drop_last=True, pin_memory=True)
+
+print(f"Loaded test dl for subj{subj}!\n")
+
+
+# ## Load models
+
+# ### CLIP image embeddings  model
+
+# In[36]:
+
+
+## USING OpenCLIP ViT-bigG ###
+sys.path.append('generative_models/')
+import sgm
+from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder
+# from generative_models.sgm.models.diffusion import DiffusionEngine
+# from omegaconf import OmegaConf
+
+try:
+    print(clip_img_embedder)
+except:
+    clip_img_embedder = FrozenOpenCLIPImageEmbedder(
+        arch="ViT-bigG-14",
+        version="laion2b_s39b_b160k",
+        output_tokens=True,
+        only_tokens=True,
+    )
+    clip_img_embedder.to(device)
+clip_seq_dim = 256
+clip_emb_dim = 1664
+
+# ## USING OPEN AI CLIP ViT-L ###
+# import clip
+# try:
+#     print(clip_model)
+# except:
+#     clip_model, preprocess = clip.load("ViT-L/14", device=device)
+#     preprocess = transforms.Compose([
+#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),
+#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+#                              std=[0.26862954, 0.26130258, 0.27577711]),
+#     ])
+# def clip_img_embedder(image):
+#     preproc_img = preprocess(image)
+#     return clip_model.encode_image(preproc_img)
+# clip_seq_dim = 1
+# clip_emb_dim = 768
+
+
+# ### MindEye modules
+
+# In[37]:
+
+
+model = utils.prepare_model_and_training(
+    num_voxels_list=num_voxels_list,
+    n_blocks=n_blocks,
+    hidden_dim=hidden_dim,
+    clip_emb_dim=clip_emb_dim,
+    clip_seq_dim=clip_seq_dim,
+    use_prior=use_prior,
+    clip_scale=clip_scale
+)
+
+
+# In[38]:
+
+
+# test on subject 1 with fake data
+b = torch.randn((2,1,num_voxels_list[0]))
+print(b.shape, model.ridge(b,0).shape)
+
+
+# In[39]:
+
+
+# test that the model works on some fake data
+b = torch.randn((2,1,hidden_dim))
+print("b.shape",b.shape)
+
+backbone_, clip_, blur_ = model.backbone(b)
+print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)
+
+
+# ### Adding diffusion prior + unCLIP if use_prior=True
+
+# In[40]:
+
+
+if use_prior:
+    from models import *
+
+    # setup diffusion prior network
+    out_dim = clip_emb_dim
+    depth = 6
+    dim_head = 52
+    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+    timesteps = 100
+
+    prior_network = VersatileDiffusionPriorNetwork(
+            dim=out_dim,
+            depth=depth,
+            dim_head=dim_head,
+            heads=heads,
+            causal=False,
+            num_tokens = clip_seq_dim,
+            learned_query_mode="pos_emb"
+        )
+
+    model.diffusion_prior = BrainDiffusionPrior(
+        net=prior_network,
+        image_embed_dim=out_dim,
+        condition_on_text_encodings=False,
+        timesteps=timesteps,
+        cond_drop_prob=0.2,
+        image_embed_scale=None,
+    )
+    
+    utils.count_params(model.diffusion_prior)
+    utils.count_params(model)
+
+
+# ### Setup optimizer / lr / ckpt saving
+
+# In[41]:
+
+
+no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+opt_grouped_parameters = [
+    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},
+    {'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},
+    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
+]
+# model.backbone.requires_grad_(False)
+
+if use_prior:
+    opt_grouped_parameters.extend([
+        {'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},
+        {'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}
+    ])
+
+optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)
+
+if lr_scheduler_type == 'linear':
+    lr_scheduler = torch.optim.lr_scheduler.LinearLR(
+        optimizer,
+        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),
+        last_epoch=-1
+    )
+elif lr_scheduler_type == 'cycle':
+    if num_iterations_per_epoch==0:
+        num_iterations_per_epoch=1
+    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))
+    print("total_steps", total_steps)
+    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, 
+        max_lr=max_lr,
+        total_steps=total_steps,
+        final_div_factor=1000,
+        last_epoch=-1, pct_start=2/num_epochs
+    )
+    
+def save_ckpt(tag):
+    ckpt_path = outdir+f'/{tag}.pth'
+    if accelerator.is_main_process:
+        unwrapped_model = accelerator.unwrap_model(model)
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': unwrapped_model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'lr_scheduler': lr_scheduler.state_dict(),
+            'train_losses': losses,
+            'test_losses': test_losses,
+            'lrs': lrs,
+            }, ckpt_path)
+    print(f"\n---saved {outdir}/{tag} ckpt!---\n")
+
+def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): 
+    print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')
+    state_dict = checkpoint['model_state_dict']
+    if multisubj_loading: # remove incompatible ridge layer that will otherwise error
+        state_dict.pop('ridge.linears.0.weight',None)
+    model.load_state_dict(state_dict, strict=strict)
+    if load_epoch:
+        globals()["epoch"] = checkpoint['epoch']
+        print("Epoch",epoch)
+    if load_optimizer:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    if load_lr:
+        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+    del checkpoint
+
+print("\nDone with model preparations!")
+num_params = utils.count_params(model)
+
+
+# # Wandb
+
+# In[42]:
+
+
+if local_rank==0 and wandb_log: # only use main process for wandb logging
+    import wandb
+    import time
+    
+    wandb_project = 'rtmindeye'
+    print(f"wandb {wandb_project} run {model_name}")
+
+    # Need to configure wandb beforehand in terminal with "wandb init"!
+    wandb_config = {
+        "model_name": model_name,
+        "global_batch_size": global_batch_size,
+        "batch_size": batch_size,
+        "num_epochs": num_epochs,
+        "num_sessions": num_sessions,
+        "num_params": num_params,
+        "clip_scale": clip_scale,
+        "prior_scale": prior_scale,
+        "blur_scale": blur_scale,
+        "use_image_aug": use_image_aug,
+        "max_lr": max_lr,
+        "mixup_pct": mixup_pct,
+        "num_samples_per_epoch": num_samples_per_epoch,
+        "ckpt_interval": ckpt_interval,
+        "ckpt_saving": ckpt_saving,
+        "seed": seed,  # SLURM array task ID
+        "distributed": distributed,
+        "num_devices": num_devices,
+        "world_size": world_size,
+    }
+    print("wandb_config:\n", wandb_config)
+    print("wandb_id:", model_name)
+
+    # Initialize wandb
+    wandb.init(
+        id=model_name,
+        project=wandb_project,
+        name=model_name,
+        config=wandb_config,
+        resume="allow",
+        save_code=True,
+    )
+
+    # Get SLURM job & array ID
+    slurm_job_id = utils.get_slurm_job()
+    slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID
+
+    # Define SLURM log paths
+    log_dir = "slurms"
+    log_files = [
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.out",
+        f"{log_dir}/{slurm_job_id}_{slurm_array_id}.err",
+    ]
+
+    # Ensure logs exist before logging them
+    for log_file in log_files:
+        wait_time = 0
+        while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s
+            time.sleep(5)
+            wait_time += 5
+
+    # Log SLURM logs as artifacts
+    artifact = wandb.Artifact(f"slurm_logs_{slurm_job_id}_{slurm_array_id}", type="logs")
+    for log_file in log_files:
+        if os.path.exists(log_file):
+            artifact.add_file(log_file)
+
+    wandb.log_artifact(artifact)
+else:
+    wandb_log = False
+
+
+# # Train the model
+
+# In[43]:
+
+
+epoch = 0
+losses, test_losses, lrs = [], [], []
+best_test_loss = 1e9
+torch.cuda.empty_cache()
+
+
+# In[44]:
+
+
+# load multisubject stage1 ckpt if set
+if multisubject_ckpt is not None and not resume_from_ckpt:
+    load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)
+
+
+# In[45]:
+
+
+# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')
+# state_dict = checkpoint['model_state_dict']
+# model.load_state_dict(state_dict, strict=False)
+
+
+# In[46]:
+
+
+# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]
+
+model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)
+# leaving out test_dl since we will only have local_rank 0 device do evals
+
+
+# In[56]:
+
+
+print(f"{model_name} starting with epoch {epoch} / {num_epochs}")
+progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))
+test_image, test_voxel = None, None
+mse = nn.MSELoss()
+l1 = nn.L1Loss()
+soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))
+skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model
+
+for epoch in progress_bar:
+    model.train()
+
+    fwd_percent_correct = 0.
+    bwd_percent_correct = 0.
+    test_fwd_percent_correct = 0.
+    test_bwd_percent_correct = 0.
+    
+    recon_cossim = 0.
+    test_recon_cossim = 0.
+    recon_mse = 0.
+    test_recon_mse = 0.
+
+    loss_clip_total = 0.
+    loss_blurry_total = 0.
+    loss_blurry_cont_total = 0.
+    test_loss_clip_total = 0.
+    
+    loss_prior_total = 0.
+    test_loss_prior_total = 0.
+
+    blurry_pixcorr = 0.
+    test_blurry_pixcorr = 0. 
+
+    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each
+    for train_i, behav in enumerate(train_dl):  
+        with torch.cuda.amp.autocast(dtype=data_type):
+            optimizer.zero_grad()
+            loss = 0.
+            
+            behav = behav[0]
+
+            image = images[behav.long().cpu()].to(device)
+            voxel = vox[behav.long().cpu()]
+            # voxel = (voxel - train_mean) / train_std
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+            if use_image_aug: 
+                image = img_augment(image)
+
+            clip_target = clip_img_embedder(image)
+            assert not torch.any(torch.isnan(clip_target))
+
+            if epoch < int(mixup_pct * num_epochs):
+                voxel, perm, betas, select = utils.mixco(voxel)
+
+            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]
+            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)
+
+            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+            if clip_scale>0:
+                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+            if use_prior:
+                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)
+                loss_prior_total += loss_prior.item()
+                loss_prior *= prior_scale
+                loss += loss_prior
+
+                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()
+                recon_mse += mse(prior_out, clip_target).item()
+
+            if clip_scale>0:
+                if epoch < int(mixup_pct * num_epochs):                
+                    loss_clip = utils.mixco_nce(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=.006,
+                        perm=perm, betas=betas, select=select)
+                else:
+                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]
+                    loss_clip = utils.soft_clip_loss(
+                        clip_voxels_norm,
+                        clip_target_norm,
+                        temp=epoch_temp)
+
+                loss_clip_total += loss_clip.item()
+                loss_clip *= clip_scale
+                loss += loss_clip
+
+            if blurry_recon:     
+                image_enc_pred, transformer_feats = blurry_image_enc_
+
+                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215
+                loss_blurry = l1(image_enc_pred, image_enc)
+                loss_blurry_total += loss_blurry.item()
+
+                if epoch < int(mixup_pct * num_epochs):
+                    image_enc_shuf = image_enc[perm]
+                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)
+                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \
+                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)
+
+                image_norm = (image - mean)/std
+                image_aug = (blur_augs(image) - mean)/std
+                _, cnx_embeds = cnx(image_norm)
+                _, cnx_aug_embeds = cnx(image_aug)
+
+                cont_loss = utils.soft_cont_loss(
+                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),
+                    temp=0.2)
+                loss_blurry_cont_total += cont_loss.item()
+
+                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215
+
+            if clip_scale>0:
+                # forward and backward top 1 accuracy        
+                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) 
+                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+            if blurry_recon:
+                with torch.no_grad():
+                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()
+                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)
+                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)
+                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                    blurry_pixcorr += pixcorr.item()
+            
+            utils.check_loss(loss)
+            accelerator.backward(loss)
+            optimizer.step()
+
+            losses.append(loss.item())
+            lrs.append(optimizer.param_groups[0]['lr'])
+
+            if lr_scheduler_type is not None:
+                lr_scheduler.step()
+                
+            if train_i >= num_iterations_per_epoch-1:
+                break
+                
+    model.eval()
+    logs = {}
+
+    if local_rank == 0:
+        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+            for i in range(1):
+                for j in range(2):
+                    subset_indices = MST_idx[:, i, j].reshape(-1)
+                    subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                    subset_dl = torch.utils.data.DataLoader(
+                        subset_dataset, batch_size=24, shuffle=False,
+                        drop_last=True, pin_memory=True
+                    )
+
+                    # Reset metrics for this subset
+                    test_losses = []
+                    test_loss_clip_total = 0
+                    test_loss_prior_total = 0
+                    test_blurry_pixcorr = 0
+                    test_fwd_percent_correct = 0
+                    test_bwd_percent_correct = 0
+                    test_recon_cossim = 0
+                    test_recon_mse = 0
+
+                    for test_i, behav in enumerate(subset_dl):
+                        behav = behav[0]
+                        loss = 0.
+
+                        if behav.ndim > 1:
+                            image = images[behav[:, 0].long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()].mean(1)
+                        else:
+                            image = images[behav.long().cpu()].to(device)
+                            voxel = vox[behav.long().cpu()]
+
+                        voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+
+                        clip_img_embedder = clip_img_embedder.to(device)
+                        clip_target = clip_img_embedder(image.float())
+
+                        voxel_ridge = model.ridge(voxel, 0)
+                        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                        if clip_scale > 0:
+                            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+                            clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)
+
+                        random_samps = np.random.choice(np.arange(len(image)), size=len(image) // 5, replace=False)
+
+                        if use_prior:
+                            loss_prior, contaminated_prior_out = model.diffusion_prior(
+                                text_embed=backbone[random_samps], image_embed=clip_target[random_samps])
+                            test_loss_prior_total += loss_prior.item()
+                            loss_prior *= prior_scale
+                            loss += loss_prior
+
+                        if clip_scale > 0:
+                            loss_clip = utils.soft_clip_loss(
+                                clip_voxels_norm,
+                                clip_target_norm,
+                                temp=0.006
+                            )
+                            test_loss_clip_total += loss_clip.item()
+                            loss_clip *= clip_scale
+                            loss += loss_clip
+
+                        if blurry_recon:
+                            image_enc_pred, _ = blurry_image_enc_
+                            blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps] / 0.18215).sample / 2 + 0.5).clamp(0, 1)
+                            pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)
+                            test_blurry_pixcorr += pixcorr.item()
+
+                        if clip_scale > 0:
+                            labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                            test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                            test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+
+                        utils.check_loss(loss)
+                        test_losses.append(loss.item())
+
+                    logs.update({
+                        f"subset_{i}_{j}_test/loss": np.mean(test_losses),
+                        f"subset_{i}_{j}_test/loss_clip_total": test_loss_clip_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/loss_prior": test_loss_prior_total / (test_i + 1),
+                        f"subset_{i}_{j}_test/blurry_pixcorr": test_blurry_pixcorr / (test_i + 1),
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+                    print(f"--- Subset ({i},{j}) ---")
+                    for k, v in logs.items():
+                        if f"subset_{i}_{j}" in k:
+                            print(f"{k}: {v:.4f}")
+
+            # After subset loop: add train (and global test, if you want) metrics
+            logs.update({
+                "train/loss": np.mean(losses[-(train_i+1):]),
+                "train/lr": lrs[-1],
+                "train/num_steps": len(losses),
+                "train/fwd_pct_correct": fwd_percent_correct / (train_i + 1),
+                "train/bwd_pct_correct": bwd_percent_correct / (train_i + 1),
+                "train/loss_clip_total": loss_clip_total / (train_i + 1),
+                "train/loss_blurry_total": loss_blurry_total / (train_i + 1),
+                "train/loss_blurry_cont_total": loss_blurry_cont_total / (train_i + 1),
+                "train/blurry_pixcorr": blurry_pixcorr / (train_i + 1),
+                "train/recon_cossim": recon_cossim / (train_i + 1),
+                "train/recon_mse": recon_mse / (train_i + 1),
+                "train/loss_prior": loss_prior_total / (train_i + 1),
+            })
+
+
+            # if finished training, save jpg recons if they exist
+            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):
+                if blurry_recon:    
+                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215
+                    # transform blurry recon latents to images and plot it
+                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))
+                    jj=-1
+                    for j in [0,1,2,3]:
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                        jj+=1
+                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))
+                        axes[jj].axis('off')
+                    plt.show()
+
+            progress_bar.set_postfix(**logs)
+
+            if wandb_log: wandb.log(logs)
+            
+    # Save model checkpoint and reconstruct
+    if (ckpt_saving) and (epoch % ckpt_interval == 0):
+        save_ckpt(f'last')
+
+    # wait for other GPUs to catch up if needed
+    accelerator.wait_for_everyone()
+    torch.cuda.empty_cache()
+
+print("\n===Finished!===\n")
+if ckpt_saving:
+    save_ckpt(f'last')
+
+
+# In[48]:
+
+
+len(test_data)
+
+
+# In[49]:
+
+
+# # Track metrics here:
+# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999
+
+
+# **To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**
+
+# In[50]:
+
+
+# MST_pairmate_names
+
+
+# In[51]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs[i,0] = x.index(p[0])
+    pairs[i,1] = x.index(p[1])
+    
+# print(pairs)
+
+
+# In[52]:
+
+
+# if sub=="sub-002":
+#     unique_images_pairs = [
+#         (2,3),(4,5),(7,8),(15,16),
+#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),
+#         (503, 504), (512, 513), 
+#     ]
+# elif sub != 'sub-001' and session != 'ses-05':
+#     unique_images_pairs = [
+#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),
+#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),
+#         (31,32),(33,34),(35,36),
+#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),
+#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),
+#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),
+#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),
+#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),
+#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),
+#         (847, 848), (849, 850)
+#     ]
+# else:
+#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]
+#     unique_images_pairs = find_mst_pairs(x)
+# # unique_images[unique_images_pairs]
+
+
+# In[53]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    score = 0
+    total = 0
+    
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for pair in mst_pairs:
+            voxel = vox[image_idx[pair[0]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            imageA = images[image_idx[pair[0]]].to(device)[None]
+            imageB = images[image_idx[pair[1]]].to(device)[None]
+            
+            clip_targetA = clip_img_embedder(imageA.float())
+            clip_targetB = clip_img_embedder(imageB.float())
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+            clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm):
+                score += 1
+            total += 1
+            
+            voxel = vox[image_idx[pair[1]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm):
+                score += 1
+            total += 1
+            
+    return score/total
+
+print(evaluate_mst_pairs(pairs))
+
+
+# In[55]:
+
+
+model.eval()
+logs = {}
+if local_rank == 0:
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for i in range(1):
+            for j in range(2):
+                subset_indices = MST_idx[:, i, j].reshape(-1)
+                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                subset_dl = torch.utils.data.DataLoader(
+                    subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                    drop_last=True, pin_memory=True
+                )
+
+                # Reset metrics for this subset
+                test_fwd_percent_correct = 0
+                test_bwd_percent_correct = 0
+
+                for test_i, behav in enumerate(subset_dl):
+                    behav = behav[0]
+                    loss = 0.
+                    image = images[behav.long().cpu()].to(device)
+                    voxel = vox[behav.long().cpu()]
+                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+                    clip_img_embedder = clip_img_embedder.to(device)
+                    clip_target = clip_img_embedder(image.float())
+
+                    voxel_ridge = model.ridge(voxel, 0)
+                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)
+                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)
+
+                    if clip_scale > 0:
+                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+                    print(test_fwd_percent_correct)
+                    print(test_bwd_percent_correct)
+                    logs.update({
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+
+    print("--- Full Dataset Evaluation ---")
+    for k, v in logs.items():
+        print(f"{k}: {v:.4f}")
+
+
+# In[54]:
+
+
+# Compare first few pairs
+for pair in pairs:  # Checking first 2 pairs
+    print("Indices in mst_pairs:", pair)
+    print("Corresponding filenames:")
+    print(f"Image 1: {x[pair[0]]}")
+    print(f"Image 2: {x[pair[1]]}\n")
+
+
+# In[ ]:
+
+
+# for i in range(len(pairs)):
+#     fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())
+#     ax[0].set_title(f"Repeat 1")
+
+#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())
+#     ax[1].set_title(f"Repeat 2")
+
+#     plt.setp(ax, xticks=[], yticks=[])
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# score = 0
+# total = 0
+# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): 
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageA_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimA > cossimB:
+#             score += 1
+#         total += 1
+        
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageB_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimB > cossimA:
+#             score += 1
+#         total += 1
+
+# print(score/total)
+
+
+# In[ ]:
+
+
+#display(utils.torch_to_Image(imageA))
+#display(utils.torch_to_Image(imageB))
+
+
+# In[ ]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(np.array(unique_images_pairs).flatten())
+# assert total_samples == 100
+
+# correct_predictions = int((score/total) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+
+

main-test.py

@@ -0,0 +1,1962 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Import packages & functions
+
+# In[1]:
+
+
+print("importing modules")
+import os
+import sys
+import json
+import argparse
+import numpy as np
+import time
+import random
+import string
+import h5py
+from tqdm import tqdm
+import webdataset as wds
+from PIL import Image
+import pandas as pd
+import nibabel as nib
+import nilearn
+
+import matplotlib.pyplot as plt
+import torch
+import torch.nn as nn
+from torchvision import transforms
+
+# tf32 data type is faster than standard float32
+torch.backends.cuda.matmul.allow_tf32 = True
+
+import utils
+from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas
+
+# imports utils from mindeye_preproc as "preproc"
+import importlib.util
+parent_utils_path = "/home/ri4541/mindeye_preproc/analysis/utils.py"
+spec = importlib.util.spec_from_file_location("utils", parent_utils_path)
+preproc = importlib.util.module_from_spec(spec)
+parent_dir = os.path.dirname(parent_utils_path)
+if parent_dir not in sys.path:
+    sys.path.append(parent_dir)
+spec.loader.exec_module(preproc)
+
+if utils.is_interactive():
+    from IPython.display import clear_output # function to clear print outputs in cell
+    get_ipython().run_line_magic('load_ext', 'autoreload')
+    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions
+    get_ipython().run_line_magic('autoreload', '2')
+    
+seed = utils.get_slurm_seed()
+
+
+# # Princeton data prep
+
+# ## Load Data & Design
+
+# In[2]:
+
+
+if utils.is_interactive():
+    sub = "sub-005"
+    session = "ses-03"
+    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format
+    func_task_name = 'C'  # 'study' or 'A'; used to search for functional run in bids format
+else:
+    sub = os.environ["sub"]
+    session = os.environ["session"]
+    task = os.environ["task"]
+
+if session == "all":
+    ses_list = ["ses-01", "ses-02", "ses-03"]  # list of actual session IDs
+    design_ses_list = ["ses-01", "ses-02", "ses-03"]  # list of session IDs to search for design matrix
+else:
+    ses_list = [session]
+    design_ses_list = [session]
+    
+task_name = f"_task-{task}" if task != 'study' else ''
+resample_voxel_size = False
+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
+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
+    
+train_test_split = 'MST' # 'MST', 'orig', 'unique'
+remove_close_to_MST = False
+remove_random_n = False
+
+if remove_close_to_MST or remove_random_n:
+    assert remove_close_to_MST != remove_random_n  # don't remove both sets of images
+
+n_to_remove = 0
+if remove_random_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_to_remove = 150
+    
+if resample_voxel_size:
+    # voxel size was unchanged in glmsingle, want to perform resampling here
+    resampled_vox_size = 2.5
+    resample_method = "sinc"  # {trilinear,nearestneighbour,sinc,spline}, credit: https://johnmuschelli.com/fslr/reference/flirt.help.html
+    
+    # file name helper variables
+    vox_dim_str = str(resampled_vox_size).replace('.', '_')  # in case the voxel size has a decimal, replace with an underscore
+    resampled_suffix = f"resampled_{vox_dim_str}mm_{resample_method}"
+    mask_resampled_suffix = resampled_suffix
+    if resample_post_glmsingle:
+        resampled_suffix += '_postglmsingle'
+    else:
+        resampled_suffix += '_preglmsingle'
+
+
+# In[3]:
+
+
+session_label = preproc.get_session_label(ses_list)
+print('session label:', session_label)
+n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)
+
+
+# In[4]:
+
+
+if utils.is_interactive():
+    glmsingle_path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}"
+else:
+    glmsingle_path = os.environ["glmsingle_path"]
+    
+designdir = "/home/ri4541/real_time_mindEye2"
+print(glmsingle_path)
+
+if resample_voxel_size:
+    # option 1: we are using original (non-resampled) GLMsingle outputs and doing the resampling here
+    # option 2: doing resampling pre-GLMsingle and using those outputs; no resampling involved here
+    if resample_post_glmsingle:
+        # option 1
+        orig_glmsingle_path = glmsingle_path
+        glmsingle_path += f"_{resampled_suffix}"
+        print("resampled glmsingle path:", glmsingle_path)
+        if load_from_resampled_file:
+            # resampling is already done; load from file
+             assert os.path.exists(glmsingle_path)  # the new directory must have been created if we reached here
+        else:
+            # don't load from file; do resampling here
+            os.makedirs(glmsingle_path,exist_ok=True)
+    else:
+        # option 2
+        glmsingle_path += f"_{resampled_suffix}"
+        print("glmsingle path:", glmsingle_path)
+
+assert os.path.exists(glmsingle_path)
+print("glmsingle path exists!")
+
+
+# In[ ]:
+
+
+data, starts, images, is_new_run, image_names, unique_images, len_unique_images = preproc.load_design_files(
+    sub=sub,
+    session=session,
+    func_task_name=task,
+    designdir=designdir,
+    design_ses_list=design_ses_list
+)
+
+if sub == 'sub-001':
+    if session == 'ses-01':
+        assert image_names[0] == 'images/image_686_seed_1.png'
+    elif session in ('ses-02', 'all'):
+        assert image_names[0] == 'all_stimuli/special515/special_40840.jpg'
+    elif session == 'ses-03':
+        assert image_names[0] == 'all_stimuli/special515/special_69839.jpg'
+    elif session == 'ses-04':
+        assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+elif sub == 'sub-003':
+    assert image_names[0] == 'all_stimuli/rtmindeye_stimuli/image_686_seed_1.png'
+
+unique_images = np.unique(image_names.astype(str))
+unique_images = unique_images[(unique_images!="nan")]
+len_unique_images = len(unique_images)
+print("n_runs",n_runs)
+
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(unique_images) == 851
+
+print(image_names[:4])
+print(starts[:4])
+print(is_new_run[:4])
+
+if remove_random_n:
+    # want to remove 150 imgs
+    # 100 special515 imgs are repeated 3x (300 total)
+    # all other train imgs are only shown once (558 total)
+    # of the 150, want to sample proportionally since we're cutting all repeats for special515
+    # so take out 51 (17 unique) from special515 and 99 from rest = removing 150 total
+    np.random.seed(seed)
+    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)
+    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)
+    imgs_to_remove = np.random.choice(options_to_remove, size=99, replace=False)
+    imgs_to_remove = np.append(imgs_to_remove, np.random.choice(options_to_remove_special515, size=17, replace=False))
+
+image_idx = np.array([])  # contains the unique index of each presented image
+vox_image_names = np.array([])  # contains the names of the images corresponding to image_idx
+all_MST_images = dict()
+for i, im in enumerate(image_names):
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    vox_image_names = np.append(vox_image_names, im)
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            i+=1
+            continue
+    elif remove_random_n:
+        if im in imgs_to_remove:
+            i+=1
+            continue
+            
+    image_idx_ = np.where(im==unique_images)[0].item()
+    image_idx = np.append(image_idx, image_idx_)
+    
+    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
+        import re
+        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)):  
+        # the regexp here looks for **_***.png, allows 1-2 chars before underscore and 1-3 chars after it
+            # print(im)
+            all_MST_images[i] = im
+            i+=1            
+    elif 'MST' in im:
+        all_MST_images[i] = im
+        i+=1
+    
+image_idx = torch.Tensor(image_idx).long()
+# for im in new_image_names[MST_images]:
+#     assert 'MST_pairs' in im
+# assert len(all_MST_images) == 300
+
+unique_MST_images = np.unique(list(all_MST_images.values())) 
+
+MST_ID = np.array([], dtype=int)
+if remove_close_to_MST:
+    close_to_MST_idx = np.array([], dtype=int)
+if remove_random_n:
+    random_n_idx = np.array([], dtype=int)
+
+vox_idx = np.array([], dtype=int)
+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
+for i, im in enumerate(image_names):  # need unique_MST_images to be defined, so repeating the same loop structure
+    # skip if blank, nan
+    if im == "blank.jpg":
+        i+=1
+        continue
+    if str(im) == "nan":
+        i+=1
+        continue
+    if remove_close_to_MST:  # optionally skip close_to_MST images 
+        if "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            i+=1
+            continue
+    if remove_random_n:
+        if im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            i+=1
+            j+=1
+            continue
+    j+=1
+    curr = np.where(im == unique_MST_images)
+    # print(curr)
+    if curr[0].size == 0:
+        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
+    else:
+        MST_ID = np.append(MST_ID, curr)
+        
+assert len(MST_ID) == len(image_idx)
+# assert len(np.argwhere(pd.isna(data['current_image']))) + len(np.argwhere(data['current_image'] == 'blank.jpg')) + len(image_idx) == len(data)
+# 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
+print(MST_ID.shape)
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(all_MST_images) == 100
+
+
+# ## Load images
+
+# In[ ]:
+
+
+import imageio.v2 as imageio
+resize_transform = transforms.Resize((224, 224))
+MST_images = []
+images = None
+for im_name in tqdm(image_idx):
+    if sub == 'sub-001' and session == 'ses-01':
+        image_file = f"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}"
+    else:
+        image_file = f"{unique_images[im_name]}"
+    im = imageio.imread(image_file)
+    im = torch.Tensor(im / 255).permute(2,0,1)
+    im = resize_transform(im.unsqueeze(0))
+    if images is None:
+        images = im
+    else:
+        images = torch.vstack((images, im))
+    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+        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)):  
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+    else:   
+        if ("MST_pairs" in image_file): # ("_seed_" not in unique_images[im_name]) and (unique_images[im_name] != "blank.jpg") 
+            MST_images.append(True)
+        else:
+            MST_images.append(False)
+
+print("images", images.shape)
+MST_images = np.array(MST_images)
+print("MST_images", len(MST_images))
+if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):
+    assert len(MST_images[MST_images==True]) == 100
+print("MST_images==True", len(MST_images[MST_images==True]))
+
+
+# In[ ]:
+
+
+# want IDs of pairmates based on MST_images
+# create "MST_pairmates" which is a 25x2 array with indices of the 25 pairs based on MST_images == True
+
+assert unique_MST_images.shape[0] % 2 == 0  # make sure it's divisible by 2
+MST_pairmate_names = unique_MST_images.reshape(int(unique_MST_images.shape[0]/2),2)
+# print(MST_pairmate_names)
+
+MST_pairmate_indices = np.empty(shape=MST_pairmate_names.shape, dtype=int)
+for p, pair in enumerate(MST_pairmate_names):
+    for i, im in enumerate(pair):
+        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
+        
+print(MST_pairmate_indices.shape, MST_pairmate_indices)
+
+
+# In[ ]:
+
+
+if (sub == 'sub-001' and session in ('ses-02', 'ses-03', 'all')):
+    # MST_pairs contains the indices of repeats based on all_MST_images
+    # all_MST_images contains the indices of images from image_names
+    MST_pairs = utils.find_paired_indices(torch.tensor(MST_ID))
+    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
+
+    # assert images[MST_pairs]
+
+    fig, ax = plt.subplots(1, 3, figsize=(10,4))
+    fig.suptitle('Sample MST pairs')
+
+    ax[0].imshow(images[MST_pairs[-1][0]].permute(1,2,0).numpy())
+    ax[0].set_title(f"Trial 0")
+
+    ax[1].imshow(images[MST_pairs[-1][1]].permute(1,2,0).numpy())
+    ax[1].set_title(f"Trial 1")
+
+    ax[2].imshow(images[MST_pairs[-1][2]].permute(1,2,0).numpy())
+    ax[2].set_title(f"Trial 2")
+
+    plt.setp(ax, xticks=[], yticks=[])
+    plt.tight_layout()
+    plt.show()
+
+
+# In[ ]:
+
+
+# pairs has the indices of all repeated images
+pairs = utils.find_paired_indices(image_idx)
+pairs = sorted(pairs, key=lambda x: x[0])
+
+fig, axes = plt.subplots(1, 3, figsize=(6, 2))  # 1 row, 3 columns
+for i, ax in enumerate(axes):
+    ax.imshow(images[i].permute(1, 2, 0).numpy())
+    ax.set_title(f"Trial {i}")
+    ax.axis("off")  # Hide axes for better visualization
+
+plt.tight_layout()
+# output_path = os.path.join(output_dir, "trials_plot.png")
+# plt.savefig(output_path, dpi=300)  # Save figure
+plt.show()
+
+
+# In[ ]:
+
+
+p=0
+
+# plot 2 repeats (anything in pairs should have 2 repeats, even if there's more)
+fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+ax[0].imshow(images[pairs[p][0]].permute(1,2,0).numpy())
+ax[0].set_title(f"Repeat 1")
+
+ax[1].imshow(images[pairs[p][1]].permute(1,2,0).numpy())
+ax[1].set_title(f"Repeat 2")
+
+plt.setp(ax, xticks=[], yticks=[])
+plt.tight_layout()
+plt.show()
+
+
+# In[ ]:
+
+
+if resample_voxel_size:
+    from nilearn.masking import apply_mask, unmask
+    ref_name = f'{glmsingle_path}/boldref_resampled.nii.gz'
+    omat_name = f'{glmsingle_path}/boldref_omat'
+
+
+# In[ ]:
+
+
+def get_image_pairs(sub, session, func_task_name, designdir):
+    """Loads design files and processes image pairs for a given session."""
+    _, _, _, _, image_names, unique_images, _ = preproc.load_design_files(
+        sub=sub,
+        session=session,
+        func_task_name=func_task_name,
+        designdir=designdir,
+        design_ses_list=[session]  # Ensure it's a list
+    )
+    return utils.process_images(image_names, unique_images)
+
+
+# In[ ]:
+
+
+from collections import defaultdict
+
+all_dicts = []
+for s_idx, s in enumerate(ses_list):
+    im, vo, _ = get_image_pairs(sub, s, func_task_name, designdir)
+    assert len(im) == len(vo)
+    all_dicts.append({k:v for k,v in enumerate(vo)})
+
+assert session_label == 'ses-03'
+image_to_indices = defaultdict(lambda: [[] for _ in range(len(ses_list))])
+for ses_idx, idx_to_name in enumerate(all_dicts):
+    for idx, name in idx_to_name.items():
+        image_to_indices[name][ses_idx].append(idx)
+        
+image_to_indices = dict(image_to_indices)
+
+
+# In[5]:
+
+
+from nilearn.plotting import plot_roi
+assert sub == 'sub-005' and session == "ses-03"
+print('loading brain mask')
+# func_masks, avg_mask, nsd_masks, roi = utils.get_mask(['ses-01', 'ses-02', 'ses-03'], sub, func_task_name)
+avg_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz')
+final_mask = nib.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz')
+
+# mask info
+dimsize=avg_mask.header.get_zooms()
+affine_mat = avg_mask.affine
+brain=avg_mask.get_fdata()
+xyz=brain.shape #xyz dimensionality of brain mask and epi data
+
+print('Mask dimensions:', dimsize)
+print('')
+print('Affine:')
+print(affine_mat)
+print('')
+print(f'There are {int(np.sum(brain))} voxels in the included brain mask\n')
+
+plot_roi(final_mask, bg_img=avg_mask)
+plt.show()
+
+
+# In[6]:
+
+
+union_mask = np.load('/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_ses-01-02.npy')
+
+
+# In[ ]:
+
+
+# path = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{s}_task-{func_task_name}/TYPED_FITHRF_GLMDENOISE_RR.npz"
+# vox = 
+# ses_vox = []
+# for i, s in enumerate([]):
+#     v = nilearn.masking.unmask(vox_list[i][:,0,0], func_masks[i])
+#     final_mask = nilearn.masking.intersect_masks([avg_mask, roi])
+#     ses_vox.append(nilearn.masking.apply_mask(v, final_mask))
+
+# vox = np.concatenate(ses_vox)
+# print('vox shape:', vox.shape)
+
+
+# ## Load GLMSingle voxel data
+
+# In[ ]:
+
+
+vox = None
+needs_postprocessing = False
+params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)
+
+if resample_post_glmsingle == True:
+    glm_save_path_resampled = f"{glmsingle_path}/vox_resampled.nii.gz"
+    if load_from_resampled_file == True:
+        # resampling was done in this notebook so we can load from file
+        vox = nib.load(glm_save_path_resampled)
+    else:
+        # do resampling here
+        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"
+        vox = load_preprocess_betas(orig_glmsingle_path, *params)
+        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)
+    needs_postprocessing = True
+
+if vox is None:
+    # either resampling was done in glmsingle or we aren't resampling 
+    vox = load_preprocess_betas(glmsingle_path, *params)
+
+if needs_postprocessing == True:
+    vox = nilearn.masking.apply_mask(vox, avg_mask)
+    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)
+    print(vox.shape)
+
+assert len(vox) == len(image_idx)
+
+
+# In[ ]:
+
+
+ses_mask = nib.load(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_{session_label}_task-C/sub-005_{session_label}_task-C_brain.nii.gz')
+assert np.all(ses_mask.affine == final_mask.affine)
+assert np.all(ses_mask.shape == final_mask.shape)
+
+
+# In[ ]:
+
+
+# get vox into the same shape as the union mask
+v = nilearn.masking.unmask(vox, ses_mask)  # move back to 3D based on own session mask
+# final_mask = nilearn.masking.intersect_masks([avg_mask, roi])
+vox = nilearn.masking.apply_mask(v, final_mask)  # re-flatten based on final mask so everything is in the same shape now
+print(vox.shape)
+vox = vox[:, union_mask]
+print("applied union roi mask")
+print(vox.shape)
+
+
+# In[ ]:
+
+
+pairs_homog = np.array([[p[0], p[1]] for p in pairs])
+
+
+# In[ ]:
+
+
+same_corrs = []
+diff_corrs = []
+for isamp, samp in enumerate(vox[pairs_homog]):
+    avg_same_img = []
+    for i in range(samp.shape[0]):
+        for j in range(i, samp.shape[0]):
+            if i != j:
+                avg_same_img.append(np.array([np.corrcoef(samp[i, :], samp[j, :])[0,1]]))
+    
+    same_corrs.append(np.mean(avg_same_img))
+                       
+    avg_diff_img = []
+    for isamp_j, samp_j in enumerate(vox[pairs_homog]):
+        if isamp_j != isamp:
+            for i in range(samp_j.shape[0]):
+                for j in range(i, samp_j.shape[0]):
+                    if i != j:
+                        avg_diff_img.append(np.array([np.corrcoef(samp[i, :], samp_j[j, :])[0,1]]))
+                                    
+    # print(len(avg_diff_img))
+    diff_corrs.append(np.mean(avg_diff_img))
+
+
+print(len(same_corrs), len(diff_corrs))
+same_corrs = np.array(same_corrs)
+diff_corrs = np.array(diff_corrs)
+
+
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same/diff Pearson corr.")
+plt.plot(np.sort(same_corrs),c='blue',label='same')
+plt.plot(np.sort(diff_corrs),c='cyan',label='diff')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# In[ ]:
+
+
+vox_pairs = utils.zscore(vox[pairs_homog])
+plt.figure(figsize=(5,4))
+plt.title(f"{sub}_{session} same minus diff difference Pearson corr.")
+plt.plot(np.sort(same_corrs) - np.sort(diff_corrs),c='cyan',label='difference')
+plt.axhline(0,c='k',ls='--')
+plt.legend()
+plt.xlabel("sample")
+plt.ylabel("Pearson R")
+plt.show()
+
+
+# # Training MindEye
+
+# In[ ]:
+
+
+utils.seed_everything(seed)
+MST_idx = np.array([v for k,v in image_to_indices.items() if 'MST_pairs' in k])
+# train_image_indices = np.array([]).astype(np.int8)
+# test_image_indices = np.concatenate([np.where(MST_images == True)[0], np.where(MST_images == False)[0]])
+train_image_indices = np.where(MST_images == False)[0]
+test_image_indices = np.where(MST_images == True)[0]
+print(len(train_image_indices), len(test_image_indices))
+
+
+# In[ ]:
+
+
+train_mean = np.mean(vox[train_image_indices],axis=0)
+train_std = np.std(vox[train_image_indices],axis=0)
+# no train imgs so use train mean and std from main-multisession-3tasks with ses-01-02 multisession
+# train_mean = -0.0318167
+# train_std = 1.0120773
+
+vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)
+print("voxels have been zscored")
+print(vox[:,0].mean(), vox[:,0].std())
+print("vox", vox.shape)
+
+
+# In[ ]:
+
+
+# for idx in deleted_indices:
+#     # check image names to be deleted match
+#     original_name = vox_image_dict[idx]
+#     matching_indices = [i for i in deleted_indices if vox_image_dict[i] == original_name]
+#     assert all(vox_image_dict[i] == original_name for i in matching_indices), \
+#         f"Mismatch in image names for deleted indices {matching_indices}"
+
+#     # check image data to be deleted match
+#     base_image = images[matching_indices[0]]  # Reference image
+#     for i in matching_indices[1:]:
+#         assert np.array_equal(base_image, images[i]), \
+#             f"Mismatch in image data for {vox_image_dict[i]} at index {i}"
+
+# images = images[kept_indices]
+
+
+# In[ ]:
+
+
+images = torch.Tensor(images)
+vox = torch.Tensor(vox)
+assert len(images) == len(vox)
+
+
+# In[ ]:
+
+
+### Multi-GPU config ###
+from accelerate import Accelerator, DeepSpeedPlugin
+
+local_rank = os.getenv('RANK')
+if local_rank is None: 
+    local_rank = 0
+else:
+    local_rank = int(local_rank)
+print("LOCAL RANK ", local_rank)  
+
+data_type = torch.float32 # change depending on your mixed_precision
+
+accelerator = Accelerator(split_batches=False)
+batch_size = 8 
+
+
+# In[ ]:
+
+
+print("PID of this process =",os.getpid())
+device = accelerator.device
+print("device:",device)
+world_size = accelerator.state.num_processes
+distributed = not accelerator.state.distributed_type == 'NO'
+num_devices = torch.cuda.device_count()
+global_batch_size = batch_size * num_devices
+print("global_batch_size", global_batch_size)
+if num_devices==0 or not distributed: num_devices = 1
+num_workers = num_devices
+print(accelerator.state)
+
+# set data_type to match your mixed precision (automatically set based on deepspeed config)
+if accelerator.mixed_precision == "bf16":
+    data_type = torch.bfloat16
+elif accelerator.mixed_precision == "fp16":
+    data_type = torch.float16
+else:
+    data_type = torch.float32
+
+print("distributed =",distributed, "num_devices =", num_devices, "local rank =", local_rank, "world size =", world_size, "data_type =", data_type)
+print = accelerator.print # only print if local_rank=0
+
+
+# ## Configurations
+
+# In[ ]:
+
+
+# if running this interactively, can specify jupyter_args here for argparser to use
+if utils.is_interactive():
+    model_name = 'testing_MST' # 'sub-001_multi_bs24_MST_rishab_MSTsplit_remove_150_random_seed_0'
+    print("model_name:", model_name)
+    
+    # global_batch_size and batch_size should already be defined in the above cells
+    # other variables can be specified in the following string:
+    # jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name={model_name}"
+
+    jupyter_args = f"--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \
+                    --model_name={model_name} \
+                    --no-multi_subject --subj=1 --batch_size={batch_size} \
+                    --hidden_dim=1024 --clip_scale=1. \
+                    --no-blurry_recon --blur_scale=.5 \
+                    --use_prior --prior_scale=30 \
+                    --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=30 --no-use_image_aug \
+                    --ckpt_interval=999 --no-ckpt_saving --new_test \
+                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep"
+    print(jupyter_args)
+    jupyter_args = jupyter_args.split()
+
+
+# In[ ]:
+
+
+parser = argparse.ArgumentParser(description="Model Training Configuration")
+parser.add_argument(
+    "--model_name", type=str, default="testing",
+    help="name of model, used for ckpt saving and wandb logging (if enabled)",
+)
+parser.add_argument(
+    "--data_path", type=str, default="/weka/proj-fmri/shared/natural-scenes-dataset",
+    help="Path to where NSD data is stored / where to download it to",
+)
+parser.add_argument(
+    "--subj",type=int, default=1, choices=[1,2,3,4,5,6,7,8],
+    help="Validate on which subject?",
+)
+parser.add_argument(
+    "--multisubject_ckpt", type=str, default=None,
+    help="Path to pre-trained multisubject model to finetune a single subject from. multisubject must be False.",
+)
+parser.add_argument(
+    "--num_sessions", type=int, default=0,
+    help="Number of training sessions to include (if multi_subject, this variable doesnt matter)",
+)
+parser.add_argument(
+    "--use_prior",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to train diffusion prior (True) or just rely on retrieval part of the pipeline (False)",
+)
+parser.add_argument(
+    "--batch_size", type=int, default=32,
+    help="Batch size can be increased by 10x if only training v2c and not diffusion diffuser",
+)
+parser.add_argument(
+    "--wandb_log",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to log to wandb",
+)
+parser.add_argument(
+    "--resume_from_ckpt",action=argparse.BooleanOptionalAction,default=False,
+    help="if not using wandb and want to resume from a ckpt",
+)
+parser.add_argument(
+    "--wandb_project",type=str,default="stability",
+    help="wandb project name",
+)
+parser.add_argument(
+    "--mixup_pct",type=float,default=.33,
+    help="proportion of way through training when to switch from BiMixCo to SoftCLIP",
+)
+parser.add_argument(
+    "--low_mem",action=argparse.BooleanOptionalAction,default=False,
+    help="whether to preload images to cpu to speed things up but consume more memory",
+)
+parser.add_argument(
+    "--blurry_recon",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to output blurry reconstructions",
+)
+parser.add_argument(
+    "--blur_scale",type=float,default=.5,
+    help="multiply loss from blurry recons by this number",
+)
+parser.add_argument(
+    "--clip_scale",type=float,default=1.,
+    help="multiply contrastive loss by this number",
+)
+parser.add_argument(
+    "--prior_scale",type=float,default=30,
+    help="multiply diffusion prior loss by this",
+)
+parser.add_argument(
+    "--use_image_aug",action=argparse.BooleanOptionalAction,default=True,
+    help="whether to use image augmentation",
+)
+parser.add_argument(
+    "--num_epochs",type=int,default=120,
+    help="number of epochs of training",
+)
+parser.add_argument(
+    "--multi_subject",action=argparse.BooleanOptionalAction,default=False,
+)
+parser.add_argument(
+    "--new_test",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--n_blocks",type=int,default=2,
+)
+parser.add_argument(
+    "--hidden_dim",type=int,default=1024,
+)
+parser.add_argument(
+    "--seq_past",type=int,default=0,
+)
+parser.add_argument(
+    "--seq_future",type=int,default=0,
+)
+parser.add_argument(
+    "--lr_scheduler_type",type=str,default='cycle',choices=['cycle','linear'],
+)
+parser.add_argument(
+    "--ckpt_saving",action=argparse.BooleanOptionalAction,default=True,
+)
+parser.add_argument(
+    "--ckpt_interval",type=int,default=5,
+    help="save backup ckpt and reconstruct every x epochs",
+)
+parser.add_argument(
+    "--seed",type=int,default=42,
+)
+parser.add_argument(
+    "--max_lr",type=float,default=3e-4,
+)
+
+if utils.is_interactive():
+    args = parser.parse_args(jupyter_args)
+else:
+    args = parser.parse_args()
+
+# create global variables without the args prefix
+for attribute_name in vars(args).keys():
+    globals()[attribute_name] = getattr(args, attribute_name)
+    
+outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+if not os.path.exists(outdir) and ckpt_saving:
+    os.makedirs(outdir,exist_ok=True)
+    
+if use_image_aug or blurry_recon:
+    import kornia
+    import kornia.augmentation as K
+    from kornia.augmentation.container import AugmentationSequential
+if use_image_aug:
+    img_augment = AugmentationSequential(
+        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),
+        same_on_batch=False,
+        data_keys=["input"],
+    )
+    # Define the blurring augmentations
+    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)
+    
+if multi_subject:
+    subj_list = np.arange(1,9)
+    subj_list = subj_list[subj_list != subj]
+else:
+    subj_list = [subj]
+
+print("subj_list", subj_list, "num_sessions", num_sessions)
+
+
+# ## Prep data, models, and dataloaders
+
+# In[ ]:
+
+
+if ckpt_saving:
+    # save MST_ID for 2-alternative forced-choice retrieval evaluation 
+    if 'MST' in model_name:
+        eval_dir = os.environ["eval_dir"]
+        print('saving MST info in', eval_dir)
+        # Saving ##
+        if not os.path.exists(eval_dir):
+            os.mkdir(eval_dir)
+
+        np.save(f"{eval_dir}/MST_ID.npy", MST_ID)
+        np.save(f"{eval_dir}/MST_pairmate_indices.npy", MST_pairmate_indices)
+
+    if remove_random_n:
+        np.save(f"{eval_dir}/imgs_to_remove.npy", imgs_to_remove)
+
+    np.save(f"{eval_dir}/train_image_indices.npy", train_image_indices)
+    np.save(f"{eval_dir}/test_image_indices.npy", test_image_indices)
+    np.save(f"{eval_dir}/images.npy", images)
+    np.save(f"{eval_dir}/vox.npy", vox)
+
+
+# ### Creating wds dataloader, preload betas and all 73k possible images
+
+# In[ ]:
+
+
+def my_split_by_node(urls): return urls
+num_voxels_list = []
+
+if multi_subject:
+    nsessions_allsubj=np.array([40, 40, 32, 30, 40, 32, 40, 30])
+    num_samples_per_epoch = (750*40) // num_devices 
+else:
+    # num_samples_per_epoch = (750*num_sessions) // num_devices 
+    num_samples_per_epoch = len(train_image_indices)
+
+print("dividing batch size by subj_list, which will then be concatenated across subj during training...") 
+batch_size = batch_size // len(subj_list)
+
+num_iterations_per_epoch = num_samples_per_epoch // (batch_size*len(subj_list))
+
+print("batch_size =", batch_size, "num_iterations_per_epoch =",num_iterations_per_epoch, "num_samples_per_epoch =",num_samples_per_epoch)
+
+
+# In[ ]:
+
+
+train_data = {}
+train_dl = {}
+
+train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))
+test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))
+
+
+# In[ ]:
+
+
+num_voxels = {}
+voxels = {}
+for s in subj_list:
+    print(f"Training with {num_sessions} sessions")
+    train_dl = torch.utils.data.DataLoader(train_data[f'subj0{s}'], batch_size=len(train_data), shuffle=False, drop_last=True, pin_memory=True)
+#     train_dl = []
+    
+    num_voxels_list.append(vox[0].shape[-1])
+    num_voxels[f'subj0{s}'] = vox[0].shape[-1]
+    voxels[f'subj0{s}'] = vox
+    print(f"num_voxels for subj0{s}: {num_voxels[f'subj0{s}']}")
+
+print("Loaded all subj train dls and vox!\n")
+
+# Validate only on one subject
+if multi_subject: 
+    subj = subj_list[0] # cant validate on the actual held out person so picking first in subj_list
+test_dl = torch.utils.data.DataLoader(test_data, batch_size=len(test_data), shuffle=False, drop_last=True, pin_memory=True)
+
+print(f"Loaded test dl for subj{subj}!\n")
+
+
+# ## Load models
+
+# ### CLIP image embeddings  model
+
+# In[ ]:
+
+
+## USING OpenCLIP ViT-bigG ###
+sys.path.append('generative_models/')
+import sgm
+from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder
+# from generative_models.sgm.models.diffusion import DiffusionEngine
+# from omegaconf import OmegaConf
+
+try:
+    print(clip_img_embedder)
+except:
+    clip_img_embedder = FrozenOpenCLIPImageEmbedder(
+        arch="ViT-bigG-14",
+        version="laion2b_s39b_b160k",
+        output_tokens=True,
+        only_tokens=True,
+    )
+    clip_img_embedder.to(device)
+clip_seq_dim = 256
+clip_emb_dim = 1664
+
+# ## USING OPEN AI CLIP ViT-L ###
+# import clip
+# try:
+#     print(clip_model)
+# except:
+#     clip_model, preprocess = clip.load("ViT-L/14", device=device)
+#     preprocess = transforms.Compose([
+#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),
+#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+#                              std=[0.26862954, 0.26130258, 0.27577711]),
+#     ])
+# def clip_img_embedder(image):
+#     preproc_img = preprocess(image)
+#     return clip_model.encode_image(preproc_img)
+# clip_seq_dim = 1
+# clip_emb_dim = 768
+
+
+# ### MindEye modules
+
+# In[ ]:
+
+
+model = utils.prepare_model_and_training(
+    num_voxels_list=num_voxels_list,
+    n_blocks=n_blocks,
+    hidden_dim=hidden_dim,
+    clip_emb_dim=clip_emb_dim,
+    clip_seq_dim=clip_seq_dim,
+    use_prior=use_prior,
+    clip_scale=clip_scale
+)
+
+
+# In[ ]:
+
+
+# test on subject 1 with fake data
+b = torch.randn((2,1,num_voxels_list[0]))
+print(b.shape, model.ridge(b,0).shape)
+
+
+# In[ ]:
+
+
+# test that the model works on some fake data
+b = torch.randn((2,1,hidden_dim))
+print("b.shape",b.shape)
+
+backbone_, clip_, blur_ = model.backbone(b)
+print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)
+
+
+# ### Adding diffusion prior + unCLIP if use_prior=True
+
+# In[ ]:
+
+
+if use_prior:
+    from models import *
+
+    # setup diffusion prior network
+    out_dim = clip_emb_dim
+    depth = 6
+    dim_head = 52
+    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+    timesteps = 100
+
+    prior_network = VersatileDiffusionPriorNetwork(
+            dim=out_dim,
+            depth=depth,
+            dim_head=dim_head,
+            heads=heads,
+            causal=False,
+            num_tokens = clip_seq_dim,
+            learned_query_mode="pos_emb"
+        )
+
+    model.diffusion_prior = BrainDiffusionPrior(
+        net=prior_network,
+        image_embed_dim=out_dim,
+        condition_on_text_encodings=False,
+        timesteps=timesteps,
+        cond_drop_prob=0.2,
+        image_embed_scale=None,
+    )
+    
+    utils.count_params(model.diffusion_prior)
+    utils.count_params(model)
+
+
+# ### Setup optimizer / lr / ckpt saving
+
+# In[ ]:
+
+
+no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']
+
+opt_grouped_parameters = [
+    {'params': [p for n, p in model.ridge.named_parameters()], 'weight_decay': 1e-2},
+    {'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},
+    {'params': [p for n, p in model.backbone.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
+]
+# model.backbone.requires_grad_(False)
+
+if use_prior:
+    opt_grouped_parameters.extend([
+        {'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},
+        {'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}
+    ])
+
+optimizer = torch.optim.AdamW(opt_grouped_parameters, lr=max_lr)
+
+if lr_scheduler_type == 'linear':
+    lr_scheduler = torch.optim.lr_scheduler.LinearLR(
+        optimizer,
+        total_iters=int(np.floor(num_epochs*num_iterations_per_epoch)),
+        last_epoch=-1
+    )
+elif lr_scheduler_type == 'cycle':
+    if num_iterations_per_epoch==0:
+        num_iterations_per_epoch=1
+    total_steps=int(np.floor(num_epochs*num_iterations_per_epoch))
+    print("total_steps", total_steps)
+    lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, 
+        max_lr=max_lr,
+        total_steps=total_steps,
+        final_div_factor=1000,
+        last_epoch=-1, pct_start=2/num_epochs
+    )
+    
+def save_ckpt(tag):
+    ckpt_path = outdir+f'/{tag}.pth'
+    if accelerator.is_main_process:
+        unwrapped_model = accelerator.unwrap_model(model)
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': unwrapped_model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'lr_scheduler': lr_scheduler.state_dict(),
+            'train_losses': losses,
+            'test_losses': test_losses,
+            'lrs': lrs,
+            }, ckpt_path)
+    print(f"\n---saved {outdir}/{tag} ckpt!---\n")
+
+def load_ckpt(tag,load_lr=True,load_optimizer=True,load_epoch=True,strict=True,outdir=outdir,multisubj_loading=False): 
+    print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+    checkpoint = torch.load(outdir+'/last.pth', map_location='cpu')
+    state_dict = checkpoint['model_state_dict']
+    if multisubj_loading: # remove incompatible ridge layer that will otherwise error
+        state_dict.pop('ridge.linears.0.weight',None)
+    model.load_state_dict(state_dict, strict=strict)
+    if load_epoch:
+        globals()["epoch"] = checkpoint['epoch']
+        print("Epoch",epoch)
+    if load_optimizer:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    if load_lr:
+        lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
+    del checkpoint
+
+print("\nDone with model preparations!")
+num_params = utils.count_params(model)
+
+
+# # Wandb
+
+# In[ ]:
+
+
+# if local_rank==0 and wandb_log: # only use main process for wandb logging
+#     import wandb
+#     import time
+    
+#     wandb_project = 'rtmindeye'
+#     print(f"wandb {wandb_project} run {model_name}")
+
+#     # Need to configure wandb beforehand in terminal with "wandb init"!
+#     wandb_config = {
+#         "model_name": model_name,
+#         "global_batch_size": global_batch_size,
+#         "batch_size": batch_size,
+#         "num_epochs": num_epochs,
+#         "num_sessions": num_sessions,
+#         "num_params": num_params,
+#         "clip_scale": clip_scale,
+#         "prior_scale": prior_scale,
+#         "blur_scale": blur_scale,
+#         "use_image_aug": use_image_aug,
+#         "max_lr": max_lr,
+#         "mixup_pct": mixup_pct,
+#         "num_samples_per_epoch": num_samples_per_epoch,
+#         "ckpt_interval": ckpt_interval,
+#         "ckpt_saving": ckpt_saving,
+#         "seed": seed,  # SLURM array task ID
+#         "distributed": distributed,
+#         "num_devices": num_devices,
+#         "world_size": world_size,
+#     }
+#     print("wandb_config:\n", wandb_config)
+#     print("wandb_id:", model_name)
+
+#     # Initialize wandb
+#     wandb.init(
+#         id=model_name,
+#         project=wandb_project,
+#         name=model_name,
+#         config=wandb_config,
+#         resume="allow",
+#         save_code=True,
+#     )
+
+#     # Get SLURM job & array ID
+#     slurm_job_id = utils.get_slurm_job()
+#     slurm_array_id = seed  # seed corresponds to SLURM_ARRAY_TASK_ID
+
+#     # Define SLURM log paths
+#     log_dir = "slurms"
+#     log_files = [
+#         f"{log_dir}/{slurm_job_id}_{slurm_array_id}.out",
+#         f"{log_dir}/{slurm_job_id}_{slurm_array_id}.err",
+#     ]
+
+#     # Ensure logs exist before logging them
+#     for log_file in log_files:
+#         wait_time = 0
+#         while not os.path.exists(log_file) and wait_time < 60:  # Wait max 60s
+#             time.sleep(5)
+#             wait_time += 5
+
+#     # Log SLURM logs as artifacts
+#     artifact = wandb.Artifact(f"slurm_logs_{slurm_job_id}_{slurm_array_id}", type="logs")
+#     for log_file in log_files:
+#         if os.path.exists(log_file):
+#             artifact.add_file(log_file)
+
+#     wandb.log_artifact(artifact)
+# else:
+#     wandb_log = False
+
+
+# # Train the model
+
+# In[ ]:
+
+
+epoch = 0
+losses, test_losses, lrs = [], [], []
+best_test_loss = 1e9
+torch.cuda.empty_cache()
+
+
+# In[ ]:
+
+
+# # load multisubject stage1 ckpt if set
+# multisubject_ckpt = '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0'
+# # multisubject_ckpt = '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep'
+# if multisubject_ckpt is not None and not resume_from_ckpt:
+#     load_ckpt("last",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)
+
+
+# In[ ]:
+
+
+# Load pretrained model ckpt
+tag='last'
+# outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')
+outdir = "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0"
+print(f"\n---loading {outdir}/{tag}.pth ckpt---\n")
+checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu')
+state_dict = checkpoint['model_state_dict']
+model.load_state_dict(state_dict, strict=True)
+del checkpoint
+print("ckpt loaded!")
+
+
+# In[ ]:
+
+
+# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')
+# state_dict = checkpoint['model_state_dict']
+# model.load_state_dict(state_dict, strict=False)
+
+
+# In[ ]:
+
+
+def freeze_model(model):
+    for param in model.parameters():
+        param.requires_grad = False
+        return model
+
+model = freeze_model(model)
+
+
+# In[ ]:
+
+
+# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]
+
+model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)
+# leaving out test_dl since we will only have local_rank 0 device do evals
+
+
+# In[ ]:
+
+
+model.eval()
+logs = {}
+if local_rank == 0:
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for i in range(1):
+            for j in range(2):
+                subset_indices = MST_idx[:, i, j].reshape(-1)
+                subset_dataset = torch.utils.data.TensorDataset(torch.tensor(subset_indices))
+                subset_dl = torch.utils.data.DataLoader(
+                    subset_dataset, batch_size=len(MST_idx), shuffle=False,
+                    drop_last=True, pin_memory=True
+                )
+
+                # Reset metrics for this subset
+                test_fwd_percent_correct = 0
+                test_bwd_percent_correct = 0
+
+                for test_i, behav in enumerate(subset_dl):
+                    behav = behav[0]
+                    loss = 0.
+                    image = images[behav.long().cpu()].to(device)
+                    voxel = vox[behav.long().cpu()]
+                    voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+                    clip_img_embedder = clip_img_embedder.to(device)
+                    clip_target = clip_img_embedder(image.float())
+
+                    voxel_ridge = model.ridge(voxel, 0)
+                    backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+                    clip_voxels_norm = torch.nn.functional.normalize(clip_voxels, dim=-1)
+                    clip_target_norm = torch.nn.functional.normalize(clip_target, dim=-1)
+
+                    if clip_scale > 0:
+                        labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device)
+                        test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()
+                        test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()
+                    print(test_fwd_percent_correct)
+                    print(test_bwd_percent_correct)
+                    logs.update({
+                        f"subset_{i}_{j}_test/fwd_pct_correct": test_fwd_percent_correct / (test_i + 1),
+                        f"subset_{i}_{j}_test/bwd_pct_correct": test_bwd_percent_correct / (test_i + 1),
+                    })
+
+    print("--- Full Dataset Evaluation ---")
+    for k, v in logs.items():
+        print(f"{k}: {v:.4f}")
+
+
+# In[ ]:
+
+
+top_k = 5
+
+for x in range(len(MST_idx)):
+    # Get top-k indices
+    y = torch.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm)[x], k=top_k).indices.to('cpu').tolist()
+
+    # Set up the plot with original + top_k images in one row
+    fig, axs = plt.subplots(1, top_k + 1, figsize=(3 * (top_k + 1), 3))
+    
+    # Plot the original image
+    orig_img = utils.torch_to_Image(images[MST_idx[x]])
+    axs[0].imshow(orig_img)
+    axs[0].set_title("Original")
+    axs[0].axis("off")
+
+    # Plot the top-k retrieved images
+    for idx, i in enumerate(y):
+        pred_img = utils.torch_to_Image(images[MST_idx[i]])
+        axs[idx + 1].imshow(pred_img)
+        axs[idx + 1].set_title(f"Top {idx+1}")
+        axs[idx + 1].axis("off")
+    
+    plt.tight_layout()
+    plt.show()
+
+
+# In[ ]:
+
+
+clip_voxels_norm.shape, clip_target_norm.shape
+
+
+# In[ ]:
+
+
+len(test_data)
+
+
+# In[ ]:
+
+
+# # Track metrics here:
+# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999
+
+
+# **To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**
+
+# In[ ]:
+
+
+# MST_pairmate_names
+
+
+# In[ ]:
+
+
+x = [im for im in image_names if str(im) not in ('blank.jpg', 'nan')]
+assert len(image_idx) == len(x)
+pairs = []
+for i, p in enumerate(MST_pairmate_names):
+    assert p[0] != p[1]  # no duplicate images
+    pairs.append([utils.find_all_indices(x,p[0]), utils.find_all_indices(x,p[1])])
+
+pairs = np.array(pairs)
+# print(pairs)
+
+
+# In[ ]:
+
+
+pairs[0][0][0]
+
+
+# In[ ]:
+
+
+pairs[0]
+
+
+# In[ ]:
+
+
+ix = 2
+x[pairs[ix][0][0]], x[pairs[ix][0][1]], x[pairs[ix][1][0]], x[pairs[ix][1][1]]
+
+
+# In[ ]:
+
+
+pairs.shape
+
+
+# In[ ]:
+
+
+# if sub=="sub-002":
+#     unique_images_pairs = [
+#         (2,3),(4,5),(7,8),(15,16),
+#         (483, 484), (485, 486), (487, 488), (491, 492), (495, 496), (499, 500), (501, 502),
+#         (503, 504), (512, 513), 
+#     ]
+# elif sub != 'sub-001' and session != 'ses-05':
+#     unique_images_pairs = [
+#         (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),
+#         (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),
+#         (31,32),(33,34),(35,36),
+#         (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),
+#         (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),
+#         (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),
+#         (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),
+#         (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),
+#         (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),
+#         (847, 848), (849, 850)
+#     ]
+# else:
+#     # unique_images = unique_images[unique_images!='blank.jpg'][:50]
+#     unique_images_pairs = find_mst_pairs(x)
+# # unique_images[unique_images_pairs]
+
+
+# In[ ]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    score = 0
+    total = 0
+    
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        for pair in tqdm(mst_pairs):
+            voxel = vox[image_idx[pair[0]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            imageA = images[image_idx[pair[0]]].to(device)[None]
+            imageB = images[image_idx[pair[1]]].to(device)[None]
+            
+            clip_targetA = clip_img_embedder(imageA.float())
+            clip_targetB = clip_img_embedder(imageB.float())
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            
+            u = clip_voxels.flatten(1)[0]
+            a = clip_targetA.flatten(1)[0]
+            b = clip_targetB.flatten(1)[0]
+            
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+            clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+            
+            u_norm = clip_voxels_norm.flatten(1)[0]
+            a_norm = clip_targetA_norm.flatten(1)[0]
+            b_norm = clip_targetB_norm.flatten(1)[0]
+
+            assert not torch.allclose(u, u_norm)
+            assert not torch.allclose(a, a_norm)
+            assert not torch.allclose(b, b_norm)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm):
+                score += 1
+            total += 1
+            
+            voxel = vox[image_idx[pair[1]]].to(device)[None]
+            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+            
+            voxel_ridge = model.ridge(voxel,0)
+            backbone, clip_voxels, _ = model.backbone(voxel_ridge)
+            clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+            
+            if utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm) > utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm):
+                score += 1
+            total += 1
+            
+            sim_A = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+            sim_B = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+            
+    return score/total, score, total
+
+
+# In[ ]:
+
+
+def evaluate_mst_pairs(mst_pairs):
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type):
+        failed_A = []
+        failed_B = []
+        failed_non_corr = []
+
+        # Get all unique image indices
+        all_indices = np.unique(mst_pairs.flatten())
+        
+        # Pre-load all images and betas to device
+        all_images = images[image_idx[all_indices]].to(device)
+        all_voxels = torch.Tensor(vox[image_idx[all_indices]]).unsqueeze(1).to(device)
+        
+        # Get CLIP embeddings for all images
+        all_clip_targets = clip_img_embedder(all_images.float())
+        all_clip_targets_norm = nn.functional.normalize(all_clip_targets.flatten(1), dim=-1)
+        
+        # Pass all betas through model to get MindEye embeddings
+        all_voxel_ridge = model.ridge(all_voxels, 0)
+        _, all_clip_voxels, _ = model.backbone(all_voxel_ridge)
+        all_clip_voxels_norm = nn.functional.normalize(all_clip_voxels.flatten(1), dim=-1)
+        
+        # Dict mapping idx (which indexes the "vox" and "images" tensors) to pos (their position in the flattened array "all_indices")
+        idx_to_pos = {idx: pos for pos, idx in enumerate(all_indices)}
+        
+        # Initialize scores
+        corr_score = 0
+        non_corr_score = 0
+        corr_total = len(mst_pairs) * 2
+        non_corr_total = len(mst_pairs) * (len(mst_pairs)-1) * 4  # number of elements in the matrix excluding the diagonal is n*(n-1)*4 since we're doing this twice each for pairmate A and B
+
+        
+        # Pre-load voxelwise beta-based embeddings from MindEye and CLIP image embeddings
+        idxA = np.array([pair[0] for pair in mst_pairs])
+        idxB = np.array([pair[1] for pair in mst_pairs])
+        
+        posA = np.array([idx_to_pos[idx] for idx in idxA])
+        posB = np.array([idx_to_pos[idx] for idx in idxB])
+        
+        voxA_embeddings = all_clip_voxels_norm[posA]
+        voxB_embeddings = all_clip_voxels_norm[posB]
+        imgA_embeddings = all_clip_targets_norm[posA]
+        imgB_embeddings = all_clip_targets_norm[posB]
+        
+        simA_A = utils.batchwise_cosine_similarity(voxA_embeddings, imgA_embeddings)
+        simA_B = utils.batchwise_cosine_similarity(voxA_embeddings, imgB_embeddings)
+        simB_B = utils.batchwise_cosine_similarity(voxB_embeddings, imgB_embeddings)
+        simB_A = utils.batchwise_cosine_similarity(voxB_embeddings, imgA_embeddings)
+
+        
+        # corresponding 2-AFC
+        # is the voxel embedding for image 1 pairmate A more similar to the CLIP embedding for image 1 pairmate A or the CLIP embedding for image 1 pairmate B?
+        correct_A = torch.diag(simA_A) > torch.diag(simA_B)
+        # is the voxel embedding for image 1 pairmate B more similar to the CLIP embedding for image 1 pairmate B or the CLIP embedding for image 1 pairmate A?
+        correct_B = torch.diag(simB_B) > torch.diag(simB_A)
+
+        corr_score += correct_A.sum().item()
+        corr_score += correct_B.sum().item()
+
+        # Store indices where AFC fails
+        failed_A = [i for i, correct in enumerate(correct_A.cpu()) if not correct]
+        failed_B = [i for i, correct in enumerate(correct_B.cpu()) if not correct]
+        
+        # non-corresponding 2-AFC
+        N = len(mst_pairs)        
+        # Create a mask that is True for all off-diagonal elements
+        row_idx = torch.arange(N).unsqueeze(1)  # (N, 1)
+        col_idx = torch.arange(N).unsqueeze(0)  # (1, N)
+        off_diag_mask = row_idx != col_idx  # shape (N, N)
+        
+        diagA_A = simA_A.diag().unsqueeze(1).expand(-1, N)  # Get diagonal values and expand to (N, N) by duplicating the diagonal element along the rows (since each row is the cosine similarity between a single voxel embedding and all CLIP embeddings)
+        diagB_B = simB_B.diag().unsqueeze(1).expand(-1, N)
+        
+        # pdb.set_trace()
+
+        # Compare each element in the row to the diagonal element
+        off_diag_mask_device = off_diag_mask.to(device)
+
+        fail_AA = (simA_A < diagA_A) & off_diag_mask_device
+        fail_AB = (simA_B < diagA_A) & off_diag_mask_device
+        fail_BB = (simB_B < diagB_B) & off_diag_mask_device
+        fail_BA = (simB_A < diagB_B) & off_diag_mask_device
+
+        non_corr_score += fail_AA.sum().item()
+        non_corr_score += fail_AB.sum().item()
+        non_corr_score += fail_BB.sum().item()
+        non_corr_score += fail_BA.sum().item()
+
+        # Log failed indices
+        fail_sources = [fail_AA, fail_AB, fail_BB, fail_BA]
+        for fail_matrix, label in zip(fail_sources, ["AA", "AB", "BB", "BA"]):
+            fail_coords = torch.nonzero(fail_matrix, as_tuple=False).cpu().numpy()
+            for i, j in fail_coords:
+                failed_non_corr.append({"type": label, "i": i, "j": j, "pair_i": mst_pairs[i], "pair_j": mst_pairs[j]})
+
+    return corr_score, corr_total, int(non_corr_score), non_corr_total, failed_A, failed_B, failed_non_corr
+
+
+# In[ ]:
+
+
+all_scores = []
+all_failures = []
+
+for i in range(2):
+    for j in range(2):
+        mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)
+        corr_score, corr_total, non_corr_score, non_corr_total, failed_A, failed_B, failed_non_corr = evaluate_mst_pairs(mst_pairs)
+
+        # Store scores and failure info together
+        all_scores.append((corr_score, corr_total, non_corr_score, non_corr_total))
+        all_failures.append({
+            "repeat_A": i,
+            "repeat_B": j,
+            "failed_A": failed_A,
+            "failed_B": failed_B,
+            "failed_non_corr": failed_non_corr,
+            "mst_pairs": mst_pairs,
+        })
+
+        # Print summary
+        print(f"pairmate A repeat {i} vs pairmate B repeat {j}:")
+        print(f"2-AFC corresponding = {corr_score}/{corr_total} ({corr_score/corr_total:.2%})")
+        print(f"2-AFC non-corresponding = {non_corr_score}/{non_corr_total} ({non_corr_score/non_corr_total:.2%})")
+        print("")
+
+
+# In[ ]:
+
+
+# def generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=2):
+#     n_imgs, n_pairmates, n_repeats = pairs.shape
+#     nonmatch_pairs = []
+
+#     for i in range(n_imgs):
+#         other_idxs = [j for j in range(n_imgs) if j != i]
+#         sampled_j = np.random.choice(other_idxs, size=num_images_per_source, replace=False)
+
+#         for j in sampled_j:
+#             for _ in range(num_repeats):
+#                 a_side = np.random.randint(2)
+#                 b_side = np.random.randint(2)
+#                 a_repeat = np.random.randint(n_repeats)
+#                 b_repeat = np.random.randint(n_repeats)
+
+#                 pair_a = pairs[i, a_side, a_repeat]
+#                 pair_b = pairs[j, b_side, b_repeat]
+#                 nonmatch_pairs.append([pair_a, pair_b])
+
+#     return np.array(nonmatch_pairs)
+
+
+# In[ ]:
+
+
+# images[nonmatch_pairs[0]].shape, vox[
+
+
+# In[ ]:
+
+
+# nonmatch_pairs = generate_random_nonmatching_pairs(pairs, num_images_per_source=5, num_repeats=2)
+# results = evaluate_mst_pairs(nonmatch_pairs)
+# print(results[0])
+# nonmatch_score = results[1]
+# nonmatch_total = results[2]
+
+
+# In[ ]:
+
+
+# scores = []
+# totals = []
+# for i in range(pairs.shape[-1]):
+#     for j in range(pairs.shape[-1]):
+#         mst_pairs = np.stack([pairs[:, 0, i], pairs[:, 1, j]], axis=1)  # shape (31, 2)
+#         results = evaluate_mst_pairs(mst_pairs)
+#         scores.append(results[1])
+#         totals.append(results[2])
+#         print(f"pairmate A repeat {i} vs pairmate B repeat {j}: {results[0]}")
+
+
+# In[ ]:
+
+
+print(np.all(pairs[:, 0, 0] == pairs[:, 0, 1]))
+print(np.all(pairs[:, 1, 0] == pairs[:, 1, 1]))
+
+
+# In[ ]:
+
+
+print(np.unique(pairs[:, 0, :], axis=1).shape[-1])
+print(np.unique(pairs[:, 1, :], axis=1).shape[-1])
+
+
+# In[ ]:
+
+
+test1 = np.stack([pairs[:, 0, 0], pairs[:, 1, 0]], axis=1)
+test2 = np.stack([pairs[:, 0, 0], pairs[:, 1, 1]], axis=1)
+print(np.array_equal(test1, test2))  # Should be False
+# print(evaluate_mst_pairs(test1))
+# print(evaluate_mst_pairs(test2))
+
+
+# In[ ]:
+
+
+a = pairs[:, 0, 0]
+b = pairs[:, 1, 0]
+c = pairs[:, 1, 1]
+
+print(np.mean(np.abs(b - c)))  # should be > 0
+print(np.mean(np.abs(a - b)))  # should also be > 0
+print(np.mean(np.abs(a - c)))  # also > 0
+
+
+# In[ ]:
+
+
+ix = 5
+display(utils.torch_to_Image(images[mst_pairs[ix][0]]))
+display(utils.torch_to_Image(images[mst_pairs[ix][1]]))
+
+
+# In[ ]:
+
+
+subset_indices
+
+
+# In[ ]:
+
+
+MST_idx.shape
+
+
+# In[ ]:
+
+
+# utils.torch_to_Image(images[x[i]]) == utils.torch_to_Image(images[y[i]])
+
+
+# In[ ]:
+
+
+x = MST_idx[:, 0, 0].reshape(-1)
+y = MST_idx[:, 0, 1].reshape(-1)
+for i in range(len(x)):
+    assert utils.torch_to_Image(images[x[i]]) == utils.torch_to_Image(images[y[i]])
+    display(utils.torch_to_Image(images[x[i]]))
+
+
+# In[ ]:
+
+
+# # Compare first few pairs
+# for pair in pairs:  # Checking first 2 pairs
+#     print("Indices in mst_pairs:", pair)
+#     print("Corresponding filenames:")
+#     print(f"Image 1: {x[pair[0]]}")
+#     print(f"Image 2: {x[pair[1]]}\n")
+
+
+# In[ ]:
+
+
+scores, totals
+
+
+# In[ ]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(pairs.flatten())
+# assert total_samples == 124
+
+# correct_predictions = int((np.mean(scores)/np.mean(totals)) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+# from scipy.stats import binomtest
+
+# total_samples = len(nonmatch_pairs.flatten())
+# # assert total_samples == 124
+
+# correct_predictions = int((np.mean(nonmatch_score)/np.mean(nonmatch_total)) * total_samples)  # calculate the number of correct predictions
+# expected_accuracy = 0.5  # expected accuracy under the null hypothesis
+
+# # Perform the binomial test
+# binom_stats = binomtest(correct_predictions, total_samples, expected_accuracy, alternative='greater')
+# p_value = binom_stats.pvalue
+
+# # Output the result
+# print(f"P-value: {p_value}")
+# if p_value < 0.05:
+#     print("The decoder's accuracy is significantly better than chance.")
+# else:
+#     print("The decoder's accuracy is not significantly better than chance.")
+
+
+# In[ ]:
+
+
+# for i in range(len(pairs)):
+#     fig, ax = plt.subplots(1, 2, figsize=(10,8))
+
+#     ax[0].imshow(images[pairs[i][0]].permute(1,2,0).numpy())
+#     ax[0].set_title(f"Repeat 1")
+
+#     ax[1].imshow(images[pairs[i][1]].permute(1,2,0).numpy())
+#     ax[1].set_title(f"Repeat 2")
+
+#     plt.setp(ax, xticks=[], yticks=[])
+#     plt.tight_layout()
+#     plt.show()
+
+
+# In[ ]:
+
+
+# score = 0
+# total = 0
+# with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): 
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageA_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimA > cossimB:
+#             score += 1
+#         total += 1
+        
+#     for pair in unique_images_pairs:
+#         imageA_idx, imageB_idx = pair
+#         imageA_idx = np.where(image_idx == imageA_idx)[0].item()
+#         imageB_idx = np.where(image_idx == imageB_idx)[0].item()
+        
+#         voxel = vox[imageB_idx].to(device)[None]
+#         voxel = torch.Tensor(voxel).unsqueeze(1).to(device)
+        
+#         imageA = images[imageA_idx].to(device)[None]
+#         imageB = images[imageB_idx].to(device)[None]
+
+#         clip_targetA = clip_img_embedder(imageA.float())
+#         clip_targetB = clip_img_embedder(imageB.float())
+        
+#         voxel_ridge = model.ridge(voxel,0)
+#         backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)
+
+#         clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)
+#         clip_targetA_norm = nn.functional.normalize(clip_targetA.flatten(1), dim=-1)
+#         clip_targetB_norm = nn.functional.normalize(clip_targetB.flatten(1), dim=-1)
+
+#         cossimA = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetA_norm)
+#         cossimB = utils.batchwise_cosine_similarity(clip_voxels_norm, clip_targetB_norm)
+        
+#         if cossimB > cossimA:
+#             score += 1
+#         total += 1
+
+# print(score/total)
+
+
+# In[ ]:
+
+
+#display(utils.torch_to_Image(imageA))
+#display(utils.torch_to_Image(imageB))
+
+
+# In[ ]:
+
+
+
+
+
+# In[ ]:
+
+
+
+

main.ipynb

@@ -0,0 +1,1950 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b0f0f4f3",
+   "metadata": {},
+   "source": [
+    "# Import packages & functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5bad764b-45c1-45ce-a716-8d055e09821a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "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",
+    "\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",
+    "# custom functions #\n",
+    "seed = 0\n",
+    "import utils\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 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bae2b2ad-e1ef-4262-8263-6ae9a0766caa",
+   "metadata": {},
+   "source": [
+    "# Princeton data prep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6dbeabe-9e9c-4d8d-a8c3-414d79d14e63",
+   "metadata": {},
+   "source": [
+    "## Load Data & Design"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0f2d14fc-bfe3-40dc-b14e-070812c43406",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sub = \"sub-001\"\n",
+    "session = \"ses-02\"\n",
+    "n_runs = 16\n",
+    "train_test_split = 'MST'\n",
+    "remove_close_to_MST = True  # optionally skip close_to_MST images "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "34c1e0c6-0641-4239-8201-f2c676532302",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "csv/sub-001_ses-02.csv\n",
+      "len_unique_images 708\n",
+      "n_runs 16\n",
+      "['all_stimuli/special515/special_40840.jpg'\n",
+      " 'all_stimuli/unchosen_nsd_1000_images/unchosen_5137_cocoid_57944.png'\n",
+      " 'all_stimuli/shared1000_notspecial/notspecial_38278.png'\n",
+      " 'all_stimuli/special515/special_30632.jpg']\n",
+      "[658.05201488 662.06546921 666.06833092 670.06900812]\n",
+      "[0. 0. 0. 0.]\n",
+      "torch.Size([933])\n"
+     ]
+    }
+   ],
+   "source": [
+    "filename = f\"csv/{sub}_{session}.csv\"\n",
+    "print(filename)\n",
+    "data = pd.read_csv(filename)\n",
+    "image_names = data['current_image'].values[14:]\n",
+    "starts = data['trial.started'].values[14:]\n",
+    "is_new_run = data['is_new_run'].values[14:]\n",
+    "\n",
+    "unique_images = np.unique(image_names.astype(str))\n",
+    "unique_images = unique_images[(unique_images!=\"nan\")]\n",
+    "unique_images = unique_images[(unique_images!=\"blank.jpg\")]\n",
+    "len_unique_images = len(unique_images)\n",
+    "print(\"len_unique_images\",len_unique_images)\n",
+    "print(\"n_runs\",n_runs)\n",
+    "\n",
+    "print(image_names[:4])\n",
+    "print(starts[:4])\n",
+    "print(is_new_run[:4])\n",
+    "\n",
+    "image_idx = np.array([])\n",
+    "for i in range(len(image_names)):\n",
+    "    if image_names[i] == \"blank.jpg\":\n",
+    "        continue\n",
+    "    if str(image_names[i]) == \"nan\":\n",
+    "        continue\n",
+    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
+    "        if \"closest_pairs\" in image_names[i]:\n",
+    "            continue\n",
+    "\n",
+    "\n",
+    "    image_idx_ = np.where(image_names[i]==unique_images)[0].item()\n",
+    "    image_idx = np.append(image_idx, image_idx_)\n",
+    "image_idx = torch.Tensor(image_idx).long()\n",
+    "\n",
+    "all_MST_images = []\n",
+    "for im in image_names:\n",
+    "    if im == \"blank.jpg\":\n",
+    "        continue\n",
+    "    if str(im) == \"nan\":\n",
+    "        continue\n",
+    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
+    "        if \"closest_pairs\" in im:\n",
+    "            continue\n",
+    "\n",
+    "    # print(im)\n",
+    "    if 'MST' in im:\n",
+    "        all_MST_images.append(im)\n",
+    "assert len(all_MST_images) == 150\n",
+    "\n",
+    "unique_MST_images = np.unique(all_MST_images) \n",
+    "\n",
+    "MST_ID = np.array([], dtype=int)\n",
+    "\n",
+    "for i in range(len(image_names)):\n",
+    "    if image_names[i] == \"blank.jpg\":\n",
+    "        continue\n",
+    "    if str(image_names[i]) == \"nan\":\n",
+    "        continue\n",
+    "    if remove_close_to_MST:  # optionally skip close_to_MST images \n",
+    "        if \"closest_pairs\" in image_names[i]:\n",
+    "            continue\n",
+    "    # print(image_names[i])\n",
+    "    curr = np.where(image_names[i] == unique_MST_images)\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",
+    "MST_ID = torch.Tensor(MST_ID)\n",
+    "# assert len(MST_ID) == len(images)\n",
+    "print(MST_ID.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e48ffe08-71ec-4a3f-9371-66fed2c21de4",
+   "metadata": {},
+   "source": [
+    "## Load images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ceb404f-b04f-42b6-afc4-283bb2b40c08",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/933 [00:00<?, ?it/s]/tmp/ipykernel_983337/3793407494.py:7: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n",
+      "  im = imageio.imread(f\"{unique_images[im_name]}\")\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n",
+      " 81%|████████  | 752/933 [00:14<00:06, 28.50it/s] "
+     ]
+    }
+   ],
+   "source": [
+    "import imageio\n",
+    "resize_transform = transforms.Resize((224, 224))\n",
+    "MST_images = []\n",
+    "images = None\n",
+    "for im_name in tqdm(image_idx):\n",
+    "    # im = imageio.imread(f\"rtmindeye_stimuli/{(unique_images[im_name]).split('/')[-1]}\")\n",
+    "    im = imageio.imread(f\"{unique_images[im_name]}\")\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 (\"MST_pairs\" in unique_images[im_name]): # (\"_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",
+    "print(\"MST_images==True\", len(MST_images[MST_images==True]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dbb17afa-579e-40ee-9cd3-3083ad31b94c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# pairs is a matrix of the trial numbers where the same image was repeated\n",
+    "pairs = utils.find_paired_indices(image_idx)\n",
+    "pairs = np.array(sorted(pairs, key=lambda x: x[0]))\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(10,8))\n",
+    "\n",
+    "ax[0].imshow(images[pairs[-1][0]].permute(1,2,0).numpy())\n",
+    "ax[0].set_title(f\"Trial 0\")\n",
+    "\n",
+    "ax[1].imshow(images[pairs[-1][1]].permute(1,2,0).numpy())\n",
+    "ax[1].set_title(f\"Trial 1\")\n",
+    "\n",
+    "ax[2].imshow(images[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": null,
+   "id": "9ffc1697-09fd-4be2-b8b1-bf6d935e7cc6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "int(len(unique_MST_images)/2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d79c57ec-e4b6-464a-940f-4047f81ddd99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MST_pairmate_names = unique_MST_images.reshape(int(len(unique_MST_images)/2),2)\n",
+    "print(MST_pairmate_names[:5])\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.array(all_MST_images) == im)[0][0]  # just take the first repeated instance of an image\n",
+    "        \n",
+    "# print(MST_pairmate_indices, MST_pairmate_indices.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7804edab-5dc2-4499-8a91-91d77f78bd77",
+   "metadata": {},
+   "source": [
+    "## Load GLMSingle voxel data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3a5e1904-4944-4a5d-9b8d-d85f7cd161e4",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox (1008, 1, 1, 194410)\n",
+      "vox (1008, 194410)\n"
+     ]
+    }
+   ],
+   "source": [
+    "glmsingle = np.load(f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{session}/TYPED_FITHRF_GLMDENOISE_RR.npz\",allow_pickle=True) # moved this dir to scratch mindeyev2 src mindeye\n",
+    "\n",
+    "vox = glmsingle['betasmd'].T\n",
+    "print(\"vox\", vox.shape)\n",
+    "\n",
+    "if vox.ndim==4:\n",
+    "    vox = vox[:,0,0]\n",
+    "    print(\"vox\", vox.shape)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e98f085f-d20d-4f9e-abc5-f823c90d7f49",
+   "metadata": {},
+   "source": [
+    "### Load nsdgeneral ROI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "12ecfa73-dd47-47dd-afcb-b23651185ee8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(78, 102, 78)\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_mask=nib.load(f'masks/{sub}_{session}_brain.nii.gz')\n",
+    "print(avg_mask.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "96be660e-55bb-4297-a824-73acb4e8a6e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[  1.79999995   0.           0.         -71.30000305]\n",
+      " [  0.           1.79999995   0.         -78.40000153]\n",
+      " [  0.           0.           1.79999995 -47.80000305]\n",
+      " [  0.           0.           0.           1.        ]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from nilearn.plotting import plot_roi, plot_anat, plot_epi\n",
+    "\n",
+    "avg_mask=nib.load(f'masks/{sub}_{session}_brain.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",
+    "print(affine_mat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e846060a-d9c0-43d3-824b-08fa2b4b354e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mask dimensions: (1.8, 1.8, 1.8)\n",
+      "\n",
+      "Affine:\n",
+      "[[  1.79999995   0.           0.         -71.30000305]\n",
+      " [  0.           1.79999995   0.         -78.40000153]\n",
+      " [  0.           0.           1.79999995 -47.80000305]\n",
+      " [  0.           0.           0.           1.        ]]\n",
+      "\n",
+      "There are 194410 voxels in the included brain mask\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<nilearn.plotting.displays._slicers.OrthoSlicer at 0x14e3a9783a90>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 660x350 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from nilearn.plotting import plot_roi, plot_anat, plot_epi\n",
+    "\n",
+    "avg_mask=nib.load(f'masks/{sub}_{session}_brain.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",
+    "roi = nib.load(f'masks/{sub}_nsdgeneral.nii.gz')\n",
+    "\n",
+    "plot_roi(roi, bg_img=avg_mask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f7f2e9dd-88af-4ca9-bd80-17cbe429b6ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total voxels (whole brain) = 194410\n",
+      "nsdgeneral voxels = 25069\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_mask = avg_mask.get_fdata().flatten()\n",
+    "print(f\"total voxels (whole brain) = {int(avg_mask.sum())}\")\n",
+    "\n",
+    "roi = roi.get_fdata()\n",
+    "roi = roi.flatten()\n",
+    "roi = roi[avg_mask.astype(bool)]\n",
+    "roi[np.isnan(roi)] = 0\n",
+    "roi = roi.astype(bool)\n",
+    "print(f\"nsdgeneral voxels = {roi.sum()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bf38b1b-1270-4f65-bc01-07f90343963d",
+   "metadata": {},
+   "source": [
+    "### ROI voxel exclusion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "de856487-6f6b-4971-8e84-8b30c9a9e943",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox before ROI exclusion: (1008, 194410)\n",
+      "vox after ROI exclusion: (1008, 25069)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ROI masking?\n",
+    "print(f\"vox before ROI exclusion: {vox.shape}\")\n",
+    "vox = vox[:,roi]\n",
+    "print(f\"vox after ROI exclusion: {vox.shape}\")\n",
+    "\n",
+    "if np.any(np.isnan(vox)):\n",
+    "    print(\"NaNs found! Removing voxels...\")\n",
+    "    x,y = np.where(np.isnan(vox))\n",
+    "    vox = vox[:,np.setdiff1d(np.arange(vox.shape[-1]), y)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "903c4f38-4f6e-44d7-8186-44c47c77507a",
+   "metadata": {},
+   "source": [
+    "## Reliability calculation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "288e757f-fe51-4c3b-bb3c-e78b18c755c5",
+   "metadata": {},
+   "source": [
+    "### Calculate reliability (corr between first and second presentation of same image) for every voxel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "765ab07f-dbb3-4bdd-8de1-57fe85231d82",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vox_pairs = utils.zscore(vox[pairs])\n",
+    "rels = np.full(vox.shape[-1],np.nan)\n",
+    "for v in tqdm(range(vox.shape[-1])):\n",
+    "    rels[v] = np.corrcoef(vox_pairs[:,0,v], vox_pairs[:,1,v])[1,0]\n",
+    "print(\"rels\", rels.shape)\n",
+    "assert np.sum(np.all(np.isnan(rels))) == 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b646ecf4-dd03-4352-abcf-6c6ccb54d96b",
+   "metadata": {},
+   "source": [
+    "### Create representational similarity matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81aebd28-a66b-43fd-8123-fbcd99851383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# creating img x vox x repetitions matrix | shape=(150, 18419, 2)\n",
+    "vox0 = np.zeros((len(pairs), vox.shape[-1], 2))\n",
+    "for ipair, pair in enumerate(tqdm(pairs)):\n",
+    "    pair = pair[:2] # to keep things consistent, just using the first two repeats\n",
+    "    i,j = pair\n",
+    "    vox0[ipair, :, :] = vox[pair].T\n",
+    "vox_avg = vox0.mean(-1) # average across the repetitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30fad9fc-5399-4820-8a8a-8b63fec5d371",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Masking RDM for each reliability threshold\n",
+    "r_thresholds = np.array([.0, .1, .2, .3])\n",
+    "rdm = np.zeros((len(r_thresholds), len(pairs), len(pairs))) \n",
+    "for ir_thresh, r_thresh in enumerate(r_thresholds):\n",
+    "    print(f\"reliability threshold = {r_thresh}\")\n",
+    "    for i in tqdm(range(len(pairs))):\n",
+    "        for j in range(len(pairs)):\n",
+    "            rdm[ir_thresh,i,j] = np.corrcoef(vox_avg[i,rels>r_thresh], \n",
+    "                                             vox_avg[j,rels>r_thresh])[0,1]\n",
+    "# rdm is shape (4, 150, 150)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "feac20e6-d50f-466f-98c9-eab730db65e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reliability_threshold_to_visualize = .1\n",
+    "plt.figure(figsize=(4,4))\n",
+    "plt.imshow(rdm[np.where(r_thresholds==reliability_threshold_to_visualize)[0].item()], clim=(-1,1))\n",
+    "plt.colorbar(shrink=0.8)\n",
+    "plt.title(f\"{sub}_{session}\\nreliability threshold={reliability_threshold_to_visualize}\\n\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a4575dc-a6b1-449b-bcb8-31b3eef348ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for thresh in range(rdm.shape[0]):\n",
+    "    for img in range(rdm.shape[1]):\n",
+    "        assert np.isclose(rdm[thresh, img, img], 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef19ef06-afc2-408d-b870-fe4df3473f90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vox0.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fafa9cf-0638-4a4d-9743-70e15bbc8801",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "r=0\n",
+    "for isamp, samp in enumerate(vox0):\n",
+    "    while r==isamp:\n",
+    "        r = np.random.randint(len(vox0))\n",
+    "    if isamp==0:\n",
+    "        same_corrs = np.array([np.corrcoef(samp[:,0], samp[:,1])[0,1]])\n",
+    "        diff_corrs = np.array([np.corrcoef(samp[:,0], vox0[r][:,0])[0,1]])\n",
+    "    else:\n",
+    "        same_corrs = np.append(same_corrs, np.corrcoef(samp[:,0], samp[:,1])[0,1])\n",
+    "        diff_corrs = np.append(diff_corrs, np.corrcoef(samp[:,0], vox0[r][:,0])[0,1])\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": null,
+   "id": "31646431-10ac-4820-ba5d-c35f1e104557",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vox_pairs = utils.zscore(vox[pairs])\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 - diff_corrs),c='cyan',label='difference')\n",
+    "plt.axhline(0,c='k',ls='--')\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"sample\")\n",
+    "plt.ylabel(\"Pearson R\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8866ce2-1cf2-459e-aa81-dec26a3dcd33",
+   "metadata": {},
+   "source": [
+    "# Training MindEye"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "248ce3a0-f03b-4c97-aee1-920432664ae1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Reliability thresholding?\n",
+    "print(f\"\\nvox before reliability thresholding: {vox.shape}\")\n",
+    "vox = vox[:,rels>.2]\n",
+    "print(f\"\\nvox after reliability thresholding: {vox.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b80aeb2d-6d53-431c-90ed-658dca7ecebd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(images.shape)\n",
+    "print(vox.shape)\n",
+    "assert len(images) == len(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8f554db1-f7cd-40d2-ab62-5d1e282c2bc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "utils.seed_everything(0)\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",
+    "elif train_test_split == 'MST':\n",
+    "    # non-MST images are the train split\n",
+    "    # MST images are the test split\n",
+    "    train_image_indices = np.where(MST_images==False)[0]\n",
+    "    test_image_indices = np.where(MST_images==True)[0]\n",
+    "    print(len(train_image_indices), len(test_image_indices))\n",
+    "else:\n",
+    "    raise Exception(\"invalid train_test_split\")\n",
+    "    \n",
+    "for i in train_image_indices:\n",
+    "    assert i not in test_image_indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "590f2b4b-db7c-42a1-bfd0-cc578e6af988",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_mean = np.mean(vox[train_image_indices],axis=0)\n",
+    "train_std = np.std(vox[train_image_indices],axis=0)\n",
+    "\n",
+    "vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)\n",
+    "print(\"voxels have been zscored\")\n",
+    "print(vox[:,0].mean(), vox[:,0].std())\n",
+    "print(\"vox\", vox.shape)\n",
+    "\n",
+    "images = torch.Tensor(images)\n",
+    "vox = torch.Tensor(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cc5d2e32-6027-4a19-bef4-5ca068db35bb",
+   "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": null,
+   "id": "b767ab6f-d4a9-47a5-b3bf-f56bf6760c0c",
+   "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": "markdown",
+   "id": "9018b82b-c054-4463-9527-4b0c2a75bda6",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Configurations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2b61fec7-72a0-4b67-86da-1375f1d9fbd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: sub-001_ses-02_bs24_MST_rishab_MSTsplit\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'batch_size' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[6], line 10\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_name:\u001b[39m\u001b[38;5;124m\"\u001b[39m, model_name)\n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m# global_batch_size and batch_size should already be defined in the above cells\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;66;03m# other variables can be specified in the following string:\u001b[39;00m\n\u001b[1;32m      8\u001b[0m jupyter_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;124m                --model_name=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;124m                --no-multi_subject --subj=1 --batch_size=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mbatch_size\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;124m                --hidden_dim=1024 --clip_scale=1. \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     12\u001b[0m \u001b[38;5;124m                --no-blurry_recon --blur_scale=.5 \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;124m                --no-use_prior --prior_scale=30 \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;124m                --n_blocks=4 --max_lr=3e-4 --mixup_pct=.33 --num_epochs=10 --no-use_image_aug \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     15\u001b[0m \u001b[38;5;124m                --ckpt_interval=999 --no-ckpt_saving --new_test \u001b[39m\u001b[38;5;130;01m\\\u001b[39;00m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;124m                --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;28mprint\u001b[39m(jupyter_args)\n\u001b[1;32m     18\u001b[0m jupyter_args \u001b[38;5;241m=\u001b[39m jupyter_args\u001b[38;5;241m.\u001b[39msplit()\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'batch_size' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    model_name = f\"sub-001_{session}_bs24_MST_rishab_{train_test_split}split\"\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 \\\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=10 --no-use_image_aug \\\n",
+    "                    --ckpt_interval=999 --no-ckpt_saving --new_test \\\n",
+    "                    --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep\"\n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2028bdf0-2f41-46d9-b6e7-86b870dbf16c",
+   "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",
+    "# seed all random functions\n",
+    "utils.seed_everything(seed)\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",
+    "cache_dir = \"/scratch/gpfs/ri4541/MindEyeV2/src\"\n",
+    "\n",
+    "    \n",
+    "if use_image_aug or blurry_recon:\n",
+    "    import kornia\n",
+    "    import kornia.augmentation as K\n",
+    "    from kornia.augmentation.container import AugmentationSequential\n",
+    "if use_image_aug:\n",
+    "    img_augment = AugmentationSequential(\n",
+    "        kornia.augmentation.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1, p=0.3),\n",
+    "        same_on_batch=False,\n",
+    "        data_keys=[\"input\"],\n",
+    "    )\n",
+    "    # Define the blurring augmentations\n",
+    "    blur_augment = K.RandomGaussianBlur(kernel_size=(21, 21), sigma=(51.0, 51.0), p=1.)\n",
+    "    \n",
+    "if multi_subject:\n",
+    "    subj_list = np.arange(1,9)\n",
+    "    subj_list = subj_list[subj_list != subj]\n",
+    "else:\n",
+    "    subj_list = [subj]\n",
+    "\n",
+    "print(\"subj_list\", subj_list, \"num_sessions\", num_sessions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42d13c25-1369-4c49-81d4-83d713586096",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Prep data, models, and dataloaders"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c023f24-5233-4a15-a2f5-78487b3a8546",
+   "metadata": {},
+   "source": [
+    "### Creating wds dataloader, preload betas and all 73k possible images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "78dc192e-40dd-4d84-96c8-1c6b78fcb5bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/sub-001_ses-02_bs24_MST_rishab_MSTsplit\n"
+     ]
+    }
+   ],
+   "source": [
+    "# save MST_ID for 2-alternative forced-choice retrieval evaluation \n",
+    "if 'MST' in model_name:\n",
+    "    eval_dir = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/{model_name}\"\n",
+    "    print(eval_dir)\n",
+    "    # Saving ##\n",
+    "    if not os.path.exists(eval_dir):\n",
+    "        os.mkdir(eval_dir)\n",
+    "\n",
+    "    np.save(f\"{eval_dir}/{model_name}_MST_ID.npy\", MST_ID)\n",
+    "    np.save(f\"{eval_dir}/{model_name}_MST_pairmate_indices.npy\", MST_pairmate_indices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aefe7c27-ab39-4b2c-90f4-480f4087b7ab",
+   "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": null,
+   "id": "e1942b0e-1223-40e6-b543-2f7ff2e8ebcd",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "train_data = {}\n",
+    "train_dl = {}\n",
+    "\n",
+    "train_data[f'subj0{subj}'] = torch.utils.data.TensorDataset(torch.tensor(train_image_indices))\n",
+    "\n",
+    "test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81084834-035f-4465-ad59-59e6b806a2f5",
+   "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": "markdown",
+   "id": "10ec4517-dbdf-4ece-98f6-4714d5de4e15",
+   "metadata": {},
+   "source": [
+    "## Load models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "48d6160e-1ee8-4da7-a755-9dbb452a6fa5",
+   "metadata": {},
+   "source": [
+    "### CLIP image embeddings  model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0420dc0-199e-4c1a-857d-b1747058b467",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## USING OpenCLIP ViT-bigG ###\n",
+    "sys.path.append('generative_models/')\n",
+    "import sgm\n",
+    "from generative_models.sgm.modules.encoders.modules import FrozenOpenCLIPImageEmbedder\n",
+    "# from generative_models.sgm.models.diffusion import DiffusionEngine\n",
+    "# from omegaconf import OmegaConf\n",
+    "\n",
+    "try:\n",
+    "    print(clip_img_embedder)\n",
+    "except:\n",
+    "    clip_img_embedder = FrozenOpenCLIPImageEmbedder(\n",
+    "        arch=\"ViT-bigG-14\",\n",
+    "        version=\"laion2b_s39b_b160k\",\n",
+    "        output_tokens=True,\n",
+    "        only_tokens=True,\n",
+    "        cache_dir=cache_dir\n",
+    "    )\n",
+    "    clip_img_embedder.to(device)\n",
+    "clip_seq_dim = 256\n",
+    "clip_emb_dim = 1664\n",
+    "\n",
+    "# ## USING OPEN AI CLIP ViT-L ###\n",
+    "# import clip\n",
+    "# try:\n",
+    "#     print(clip_model)\n",
+    "# except:\n",
+    "#     clip_model, preprocess = clip.load(\"ViT-L/14\", device=device)\n",
+    "#     preprocess = transforms.Compose([\n",
+    "#         transforms.Resize(224, interpolation=transforms.InterpolationMode.BILINEAR),\n",
+    "#         transforms.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],\n",
+    "#                              std=[0.26862954, 0.26130258, 0.27577711]),\n",
+    "#     ])\n",
+    "# def clip_img_embedder(image):\n",
+    "#     preproc_img = preprocess(image)\n",
+    "#     return clip_model.encode_image(preproc_img)\n",
+    "# clip_seq_dim = 1\n",
+    "# clip_emb_dim = 768"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "260e5e4a-f697-4b2c-88fc-01f6a54886c0",
+   "metadata": {},
+   "source": [
+    "### MindEye modules"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c44c271b-173f-472e-b059-a2eda0f4c4c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MindEyeModule(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MindEyeModule, self).__init__()\n",
+    "    def forward(self, x):\n",
+    "        return x\n",
+    "        \n",
+    "model = MindEyeModule()\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "038a5d61-4769-40b9-a004-f4e7b5b38bb0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class RidgeRegression(torch.nn.Module):\n",
+    "    # make sure to add weight_decay when initializing optimizer\n",
+    "    def __init__(self, input_sizes, out_features, seq_len=1): \n",
+    "        super(RidgeRegression, self).__init__()\n",
+    "        self.seq_len = seq_len\n",
+    "        self.out_features = out_features\n",
+    "        self.linears = torch.nn.ModuleList([\n",
+    "                torch.nn.Linear(input_size, out_features) for input_size in input_sizes\n",
+    "            ])\n",
+    "    def forward(self, x, subj_idx=0):\n",
+    "        out = torch.cat([self.linears[subj_idx](x[:,seq]).unsqueeze(1) for seq in range(self.seq_len)], dim=1)\n",
+    "        return out\n",
+    "        \n",
+    "model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim)\n",
+    "utils.count_params(model.ridge)\n",
+    "utils.count_params(model)\n",
+    "\n",
+    "# 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": null,
+   "id": "7b8de65a-6d3b-4248-bea9-9b6f4d562321",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from functools import partial\n",
+    "from diffusers.models.vae import Decoder\n",
+    "class BrainNetwork(nn.Module):\n",
+    "    def __init__(self, h=4096, in_dim=15724, out_dim=768, seq_len=1, n_blocks=n_blocks, drop=.15, \n",
+    "                 clip_size=768):\n",
+    "        super().__init__()\n",
+    "        self.seq_len = seq_len\n",
+    "        self.h = h\n",
+    "        self.clip_size = clip_size\n",
+    "        \n",
+    "        self.mixer_blocks1 = nn.ModuleList([\n",
+    "            self.mixer_block1(h, drop) for _ in range(n_blocks)\n",
+    "        ])\n",
+    "        self.mixer_blocks2 = nn.ModuleList([\n",
+    "            self.mixer_block2(seq_len, drop) for _ in range(n_blocks)\n",
+    "        ])\n",
+    "        \n",
+    "        # Output linear layer\n",
+    "        self.backbone_linear = nn.Linear(h * seq_len, out_dim, bias=True) \n",
+    "        if clip_scale>0:\n",
+    "            self.clip_proj = self.projector(clip_size, clip_size, h=clip_size)\n",
+    "            \n",
+    "    def projector(self, in_dim, out_dim, h=2048):\n",
+    "        return nn.Sequential(\n",
+    "            nn.LayerNorm(in_dim),\n",
+    "            nn.GELU(),\n",
+    "            nn.Linear(in_dim, h),\n",
+    "            nn.LayerNorm(h),\n",
+    "            nn.GELU(),\n",
+    "            nn.Linear(h, h),\n",
+    "            nn.LayerNorm(h),\n",
+    "            nn.GELU(),\n",
+    "            nn.Linear(h, out_dim)\n",
+    "        )\n",
+    "    \n",
+    "    def mlp(self, in_dim, out_dim, drop):\n",
+    "        return nn.Sequential(\n",
+    "            nn.Linear(in_dim, out_dim),\n",
+    "            nn.GELU(),\n",
+    "            nn.Dropout(drop),\n",
+    "            nn.Linear(out_dim, out_dim),\n",
+    "        )\n",
+    "    \n",
+    "    def mixer_block1(self, h, drop):\n",
+    "        return nn.Sequential(\n",
+    "            nn.LayerNorm(h),\n",
+    "            self.mlp(h, h, drop),  # Token mixing\n",
+    "        )\n",
+    "\n",
+    "    def mixer_block2(self, seq_len, drop):\n",
+    "        return nn.Sequential(\n",
+    "            nn.LayerNorm(seq_len),\n",
+    "            self.mlp(seq_len, seq_len, drop)  # Channel mixing\n",
+    "        )\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        # make empty tensors\n",
+    "        c,b = torch.Tensor([0.]), torch.Tensor([[0.],[0.]])\n",
+    "        \n",
+    "        # Mixer blocks\n",
+    "        residual1 = x\n",
+    "        residual2 = x.permute(0,2,1)\n",
+    "        for block1, block2 in zip(self.mixer_blocks1,self.mixer_blocks2):\n",
+    "            x = block1(x) + residual1\n",
+    "            residual1 = x\n",
+    "            x = x.permute(0,2,1)\n",
+    "            \n",
+    "            x = block2(x) + residual2\n",
+    "            residual2 = x\n",
+    "            x = x.permute(0,2,1)\n",
+    "            \n",
+    "        x = x.reshape(x.size(0), -1)\n",
+    "        backbone = self.backbone_linear(x).reshape(len(x), -1, self.clip_size)\n",
+    "        if clip_scale>0:\n",
+    "            c = self.clip_proj(backbone)\n",
+    "        \n",
+    "        return backbone, c, b\n",
+    "\n",
+    "model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, seq_len=1, \n",
+    "                          clip_size=clip_emb_dim, out_dim=clip_emb_dim*clip_seq_dim)\n",
+    "utils.count_params(model.backbone)\n",
+    "utils.count_params(model)\n",
+    "\n",
+    "# test that the model works on some fake data\n",
+    "b = torch.randn((2,1,hidden_dim))\n",
+    "print(\"b.shape\",b.shape)\n",
+    "\n",
+    "backbone_, clip_, blur_ = model.backbone(b)\n",
+    "print(backbone_.shape, clip_.shape, blur_[0].shape, blur_[1].shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b397c0d7-52a3-4153-823b-c27d2eb3eeba",
+   "metadata": {},
+   "source": [
+    "### Adding diffusion prior + unCLIP if use_prior=True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "69965344-9346-4592-9cc5-e537e31d5fce",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "if use_prior:\n",
+    "    from models import *\n",
+    "\n",
+    "    # setup diffusion prior network\n",
+    "    out_dim = clip_emb_dim\n",
+    "    depth = 6\n",
+    "    dim_head = 52\n",
+    "    heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim\n",
+    "    timesteps = 100\n",
+    "\n",
+    "    prior_network = VersatileDiffusionPriorNetwork(\n",
+    "            dim=out_dim,\n",
+    "            depth=depth,\n",
+    "            dim_head=dim_head,\n",
+    "            heads=heads,\n",
+    "            causal=False,\n",
+    "            num_tokens = clip_seq_dim,\n",
+    "            learned_query_mode=\"pos_emb\"\n",
+    "        )\n",
+    "\n",
+    "    model.diffusion_prior = BrainDiffusionPrior(\n",
+    "        net=prior_network,\n",
+    "        image_embed_dim=out_dim,\n",
+    "        condition_on_text_encodings=False,\n",
+    "        timesteps=timesteps,\n",
+    "        cond_drop_prob=0.2,\n",
+    "        image_embed_scale=None,\n",
+    "    )\n",
+    "    \n",
+    "    utils.count_params(model.diffusion_prior)\n",
+    "    utils.count_params(model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ec25271a-2209-400c-8026-df3b8ddc1eef",
+   "metadata": {},
+   "source": [
+    "### Setup optimizer / lr / ckpt saving"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e14d0482-dc42-43b9-9ce1-953c32f2c9c1",
+   "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": "markdown",
+   "id": "b1e8dcc4-5ce2-4206-88dc-a68d1dd701cd",
+   "metadata": {},
+   "source": [
+    "# Wandb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "990cce8c-df83-473a-93c8-c47ba355eccd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if local_rank==0 and wandb_log: # only use main process for wandb logging\n",
+    "    import wandb\n",
+    "    wandb_project = 'rtmindeye'\n",
+    "    print(f\"wandb {wandb_project} run {model_name}\")\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,\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",
+    "    wandb.init(\n",
+    "        id=model_name,\n",
+    "        project=wandb_project,\n",
+    "        name=model_name,\n",
+    "        config=wandb_config,\n",
+    "        resume=\"allow\",\n",
+    "    )\n",
+    "else:\n",
+    "    wandb_log = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5690151-2131-4918-b750-e869cbd1a8a8",
+   "metadata": {},
+   "source": [
+    "# Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12de6387-6e18-4e4b-b5ce-a847d625330a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epoch = 0\n",
+    "losses, test_losses, lrs = [], [], []\n",
+    "best_test_loss = 1e9\n",
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "607a7c7b-fe5e-41a4-80bf-d2814b3a57cc",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# load multisubject stage1 ckpt if set\n",
+    "if multisubject_ckpt is not None and not resume_from_ckpt:\n",
+    "    load_ckpt(\"last\",outdir=multisubject_ckpt,load_lr=False,load_optimizer=False,load_epoch=False,strict=False,multisubj_loading=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "927350ea-b234-48e6-ae7b-2eee41ec0358",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00ea5ae0-5c92-4276-af5b-25a17ba4dc17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# checkpoint = torch.load(multisubject_ckpt+'/last.pth', map_location='cpu')\n",
+    "# state_dict = checkpoint['model_state_dict']\n",
+    "# model.load_state_dict(state_dict, strict=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99f09f76-4481-4133-b09a-a22b10dbc0c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train_dls = [train_dl[f'subj0{s}'] for s in subj_list]\n",
+    "\n",
+    "model, optimizer, train_dl, lr_scheduler = accelerator.prepare(model, optimizer, train_dl, lr_scheduler)\n",
+    "# leaving out test_dl since we will only have local_rank 0 device do evals"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60be0d5f-3e94-4612-9373-61b53d836393",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "print(f\"{model_name} starting with epoch {epoch} / {num_epochs}\")\n",
+    "progress_bar = tqdm(range(epoch,num_epochs), ncols=1200, disable=(local_rank!=0))\n",
+    "test_image, test_voxel = None, None\n",
+    "mse = nn.MSELoss()\n",
+    "l1 = nn.L1Loss()\n",
+    "soft_loss_temps = utils.cosine_anneal(0.004, 0.0075, num_epochs - int(mixup_pct * num_epochs))\n",
+    "skip_train = True if epoch>=(num_epochs-1) else False # skip training if you are resuming from a fully trained model\n",
+    "\n",
+    "for epoch in progress_bar:\n",
+    "    model.train()\n",
+    "\n",
+    "    fwd_percent_correct = 0.\n",
+    "    bwd_percent_correct = 0.\n",
+    "    test_fwd_percent_correct = 0.\n",
+    "    test_bwd_percent_correct = 0.\n",
+    "    \n",
+    "    recon_cossim = 0.\n",
+    "    test_recon_cossim = 0.\n",
+    "    recon_mse = 0.\n",
+    "    test_recon_mse = 0.\n",
+    "\n",
+    "    loss_clip_total = 0.\n",
+    "    loss_blurry_total = 0.\n",
+    "    loss_blurry_cont_total = 0.\n",
+    "    test_loss_clip_total = 0.\n",
+    "    \n",
+    "    loss_prior_total = 0.\n",
+    "    test_loss_prior_total = 0.\n",
+    "\n",
+    "    blurry_pixcorr = 0.\n",
+    "    test_blurry_pixcorr = 0. \n",
+    "\n",
+    "    # you now have voxel_iters and image_iters with num_iterations_per_epoch batches each\n",
+    "    for train_i, behav in enumerate(train_dl):  \n",
+    "        with torch.cuda.amp.autocast(dtype=data_type):\n",
+    "            optimizer.zero_grad()\n",
+    "            loss = 0.\n",
+    "            \n",
+    "            behav = behav[0]\n",
+    "\n",
+    "            image = images[behav.long().cpu()].to(device)\n",
+    "            voxel = vox[behav.long().cpu()]\n",
+    "            # voxel = (voxel - train_mean) / train_std\n",
+    "            voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "\n",
+    "            if use_image_aug: \n",
+    "                image = img_augment(image)\n",
+    "\n",
+    "            clip_target = clip_img_embedder(image)\n",
+    "            assert not torch.any(torch.isnan(clip_target))\n",
+    "\n",
+    "            if epoch < int(mixup_pct * num_epochs):\n",
+    "                voxel, perm, betas, select = utils.mixco(voxel)\n",
+    "\n",
+    "            voxel_ridge = model.ridge(voxel,0) #[model.ridge(voxel_list[si],si) for si,s in enumerate(subj_list)]\n",
+    "            # voxel_ridge = torch.cat(voxel_ridge_list, dim=0)\n",
+    "\n",
+    "            backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "                clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n",
+    "\n",
+    "            if use_prior:\n",
+    "                loss_prior, prior_out = model.diffusion_prior(text_embed=backbone, image_embed=clip_target)\n",
+    "                loss_prior_total += loss_prior.item()\n",
+    "                loss_prior *= prior_scale\n",
+    "                loss += loss_prior\n",
+    "\n",
+    "                recon_cossim += nn.functional.cosine_similarity(prior_out, clip_target).mean().item()\n",
+    "                recon_mse += mse(prior_out, clip_target).item()\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                if epoch < int(mixup_pct * num_epochs):                \n",
+    "                    loss_clip = utils.mixco_nce(\n",
+    "                        clip_voxels_norm,\n",
+    "                        clip_target_norm,\n",
+    "                        temp=.006,\n",
+    "                        perm=perm, betas=betas, select=select)\n",
+    "                else:\n",
+    "                    epoch_temp = soft_loss_temps[epoch-int(mixup_pct*num_epochs)]\n",
+    "                    loss_clip = utils.soft_clip_loss(\n",
+    "                        clip_voxels_norm,\n",
+    "                        clip_target_norm,\n",
+    "                        temp=epoch_temp)\n",
+    "\n",
+    "                loss_clip_total += loss_clip.item()\n",
+    "                loss_clip *= clip_scale\n",
+    "                loss += loss_clip\n",
+    "\n",
+    "            if blurry_recon:     \n",
+    "                image_enc_pred, transformer_feats = blurry_image_enc_\n",
+    "\n",
+    "                image_enc = autoenc.encode(2*image-1).latent_dist.mode() * 0.18215\n",
+    "                loss_blurry = l1(image_enc_pred, image_enc)\n",
+    "                loss_blurry_total += loss_blurry.item()\n",
+    "\n",
+    "                if epoch < int(mixup_pct * num_epochs):\n",
+    "                    image_enc_shuf = image_enc[perm]\n",
+    "                    betas_shape = [-1] + [1]*(len(image_enc.shape)-1)\n",
+    "                    image_enc[select] = image_enc[select] * betas[select].reshape(*betas_shape) + \\\n",
+    "                        image_enc_shuf[select] * (1 - betas[select]).reshape(*betas_shape)\n",
+    "\n",
+    "                image_norm = (image - mean)/std\n",
+    "                image_aug = (blur_augs(image) - mean)/std\n",
+    "                _, cnx_embeds = cnx(image_norm)\n",
+    "                _, cnx_aug_embeds = cnx(image_aug)\n",
+    "\n",
+    "                cont_loss = utils.soft_cont_loss(\n",
+    "                    nn.functional.normalize(transformer_feats.reshape(-1, transformer_feats.shape[-1]), dim=-1),\n",
+    "                    nn.functional.normalize(cnx_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n",
+    "                    nn.functional.normalize(cnx_aug_embeds.reshape(-1, cnx_embeds.shape[-1]), dim=-1),\n",
+    "                    temp=0.2)\n",
+    "                loss_blurry_cont_total += cont_loss.item()\n",
+    "\n",
+    "                loss += (loss_blurry + 0.1*cont_loss) * blur_scale #/.18215\n",
+    "\n",
+    "            if clip_scale>0:\n",
+    "                # forward and backward top 1 accuracy        \n",
+    "                labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n",
+    "                fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n",
+    "                bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n",
+    "\n",
+    "            if blurry_recon:\n",
+    "                with torch.no_grad():\n",
+    "                    # only doing pixcorr eval on a subset of the samples per batch because its costly & slow to compute autoenc.decode()\n",
+    "                    random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n",
+    "                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample/ 2 + 0.5).clamp(0,1)\n",
+    "                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n",
+    "                    blurry_pixcorr += pixcorr.item()\n",
+    "            \n",
+    "            utils.check_loss(loss)\n",
+    "            accelerator.backward(loss)\n",
+    "            optimizer.step()\n",
+    "\n",
+    "            losses.append(loss.item())\n",
+    "            lrs.append(optimizer.param_groups[0]['lr'])\n",
+    "\n",
+    "            if lr_scheduler_type is not None:\n",
+    "                lr_scheduler.step()\n",
+    "                \n",
+    "            if train_i >= num_iterations_per_epoch-1:\n",
+    "                break\n",
+    "                \n",
+    "    model.eval()\n",
+    "    if local_rank==0:\n",
+    "        with torch.no_grad(), torch.cuda.amp.autocast(dtype=data_type): \n",
+    "            for test_i, behav in enumerate(test_dl):  \n",
+    "                behav = behav[0]\n",
+    "\n",
+    "                loss=0.\n",
+    "\n",
+    "                if behav.ndim>1:\n",
+    "                    image = images[behav[:,0].long().cpu()].to(device)\n",
+    "                    voxel = vox[behav.long().cpu()].mean(1)\n",
+    "                else:\n",
+    "                    image = images[behav.long().cpu()].to(device)\n",
+    "                    voxel = vox[behav.long().cpu()]\n",
+    "                    \n",
+    "                voxel = torch.Tensor(voxel).unsqueeze(1).to(device)\n",
+    "\n",
+    "                clip_img_embedder = clip_img_embedder.to(device)\n",
+    "                clip_target = clip_img_embedder(image.float())\n",
+    "                \n",
+    "                voxel_ridge = model.ridge(voxel,0)\n",
+    "\n",
+    "                backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "\n",
+    "                if clip_scale>0:\n",
+    "                    clip_voxels_norm = nn.functional.normalize(clip_voxels.flatten(1), dim=-1)\n",
+    "                    clip_target_norm = nn.functional.normalize(clip_target.flatten(1), dim=-1)\n",
+    "                \n",
+    "                # for some evals, only doing a subset of the samples per batch because of computational cost\n",
+    "                random_samps = np.random.choice(np.arange(len(image)), size=len(image)//5, replace=False)\n",
+    "                \n",
+    "                if use_prior:\n",
+    "                    loss_prior, contaminated_prior_out = model.diffusion_prior(text_embed=backbone[random_samps], image_embed=clip_target[random_samps])\n",
+    "                    test_loss_prior_total += loss_prior.item()\n",
+    "                    loss_prior *= prior_scale\n",
+    "                    loss += loss_prior\n",
+    "                        \n",
+    "                if clip_scale>0:\n",
+    "                    loss_clip = utils.soft_clip_loss(\n",
+    "                        clip_voxels_norm,\n",
+    "                        clip_target_norm,\n",
+    "                        temp=.006)\n",
+    "\n",
+    "                    test_loss_clip_total += loss_clip.item()\n",
+    "                    loss_clip = loss_clip * clip_scale\n",
+    "                    loss += loss_clip\n",
+    "\n",
+    "                if blurry_recon:\n",
+    "                    image_enc_pred, _ = blurry_image_enc_\n",
+    "                    blurry_recon_images = (autoenc.decode(image_enc_pred[random_samps]/0.18215).sample / 2 + 0.5).clamp(0,1)\n",
+    "                    pixcorr = utils.pixcorr(image[random_samps], blurry_recon_images)\n",
+    "                    test_blurry_pixcorr += pixcorr.item()\n",
+    "\n",
+    "                if clip_scale>0:\n",
+    "                    # forward and backward top 1 accuracy        \n",
+    "                    labels = torch.arange(len(clip_voxels_norm)).to(clip_voxels_norm.device) \n",
+    "                    test_fwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_voxels_norm, clip_target_norm), labels, k=1).item()\n",
+    "                    test_bwd_percent_correct += utils.topk(utils.batchwise_cosine_similarity(clip_target_norm, clip_voxels_norm), labels, k=1).item()\n",
+    "                \n",
+    "                utils.check_loss(loss)                \n",
+    "                test_losses.append(loss.item())\n",
+    "\n",
+    "            # if utils.is_interactive(): clear_output(wait=True)\n",
+    "            if skip_train: break\n",
+    "            print(\"---\")\n",
+    "\n",
+    "            # assert (test_i+1) == 1\n",
+    "            logs = {\"train/loss\": np.mean(losses[-(train_i+1):]),\n",
+    "                \"test/loss\": np.mean(test_losses[-(test_i+1):]),\n",
+    "                \"train/lr\": lrs[-1],\n",
+    "                \"train/num_steps\": len(losses),\n",
+    "                \"test/num_steps\": len(test_losses),\n",
+    "                \"train/fwd_pct_correct\": fwd_percent_correct / (train_i + 1),\n",
+    "                \"train/bwd_pct_correct\": bwd_percent_correct / (train_i + 1),\n",
+    "                \"test/test_fwd_pct_correct\": test_fwd_percent_correct / (test_i + 1),\n",
+    "                \"test/test_bwd_pct_correct\": test_bwd_percent_correct / (test_i + 1),\n",
+    "                \"train/loss_clip_total\": loss_clip_total / (train_i + 1),\n",
+    "                \"train/loss_blurry_total\": loss_blurry_total / (train_i + 1),\n",
+    "                \"train/loss_blurry_cont_total\": loss_blurry_cont_total / (train_i + 1),\n",
+    "                \"test/loss_clip_total\": test_loss_clip_total / (test_i + 1),\n",
+    "                \"train/blurry_pixcorr\": blurry_pixcorr / (train_i + 1),\n",
+    "                \"test/blurry_pixcorr\": test_blurry_pixcorr / (test_i + 1),\n",
+    "                \"train/recon_cossim\": recon_cossim / (train_i + 1),\n",
+    "                \"test/recon_cossim\": test_recon_cossim / (test_i + 1),\n",
+    "                \"train/recon_mse\": recon_mse / (train_i + 1),\n",
+    "                \"test/recon_mse\": test_recon_mse / (test_i + 1),\n",
+    "                \"train/loss_prior\": loss_prior_total / (train_i + 1),\n",
+    "                \"test/loss_prior\": test_loss_prior_total / (test_i + 1),\n",
+    "                }\n",
+    "\n",
+    "            # if finished training, save jpg recons if they exist\n",
+    "            if (epoch == num_epochs-1) or (epoch % ckpt_interval == 0):\n",
+    "                if blurry_recon:    \n",
+    "                    image_enc = autoenc.encode(2*image[:4]-1).latent_dist.mode() * 0.18215\n",
+    "                    # transform blurry recon latents to images and plot it\n",
+    "                    fig, axes = plt.subplots(1, 8, figsize=(10, 4))\n",
+    "                    jj=-1\n",
+    "                    for j in [0,1,2,3]:\n",
+    "                        jj+=1\n",
+    "                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n",
+    "                        axes[jj].axis('off')\n",
+    "                        jj+=1\n",
+    "                        axes[jj].imshow(utils.torch_to_Image((autoenc.decode(image_enc_pred[[j]]/0.18215).sample / 2 + 0.5).clamp(0,1)))\n",
+    "                        axes[jj].axis('off')\n",
+    "                    plt.show()\n",
+    "\n",
+    "            progress_bar.set_postfix(**logs)\n",
+    "\n",
+    "            if wandb_log: wandb.log(logs)\n",
+    "            \n",
+    "    # Save model checkpoint and reconstruct\n",
+    "    if (ckpt_saving) and (epoch % ckpt_interval == 0):\n",
+    "        save_ckpt(f'last')\n",
+    "\n",
+    "    # wait for other GPUs to catch up if needed\n",
+    "    accelerator.wait_for_everyone()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "print(\"\\n===Finished!===\\n\")\n",
+    "if ckpt_saving:\n",
+    "    save_ckpt(f'last')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0af03cb-58c3-4e3e-9e2b-a3485635864b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "blurry_recon"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5702acf6-45fe-44f5-8842-c0e2d4d8e8ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Track metrics here:\n",
+    "# https://docs.google.com/spreadsheets/d/1-dbmr4ovl2-4-MFNAL1DqLS651KM_ihjDkkUeP1kHXs/edit?gid=1494588999#gid=1494588999"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23a54acc-1dce-4de4-9d5f-d0582f5097c5",
+   "metadata": {},
+   "source": [
+    "**To tell if the model is working I'm looking at test_bwd/fwd_pct_correct and seeing if that is doing better than chance (1/batch_size)**"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "165px"
+   },
+   "toc_section_display": true,
+   "toc_window_display": true
+  },
+  "toc-autonumbering": true,
+  "vscode": {
+   "interpreter": {
+    "hash": "62aae01ef0cf7b6af841ab1c8ce59175c4332e693ab3d00bc32ceffb78a35376"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

modeling_git.py

@@ -0,0 +1,2050 @@
+# coding=utf-8
+# Copyright 2022 Microsoft Research and The HuggingFace Inc. team.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""PyTorch GIT model."""
+
+
+import math
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import CrossEntropyLoss
+
+from transformers.activations import ACT2FN
+from transformers.file_utils import ModelOutput
+from transformers.modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPast,
+    BaseModelOutputWithPooling,
+    CausalLMOutputWithPast,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.pytorch_utils import apply_chunking_to_forward, find_pruneable_heads_and_indices, prune_linear_layer
+from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
+from transformers.models.git.configuration_git import GitConfig, GitVisionConfig
+
+
+logger = logging.get_logger(__name__)
+
+_CHECKPOINT_FOR_DOC = "microsoft/git-large"
+_CONFIG_FOR_DOC = "GitConfig"
+
+GIT_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "microsoft/git-large",
+    # See all GIT models at https://huggingface.co/models?filter=git
+]
+
+
+@dataclass
+# Copied from transformers.models.clip.modeling_clip.CLIPVisionModelOutput with CLIP->Git
+class GitVisionModelOutput(ModelOutput):
+    """
+    Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states.
+
+    Args:
+        image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+            The image embeddings obtained by applying the projection layer to the pooler_output.
+        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+            Sequence of hidden-states at the output of the last layer of the model.
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+            one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+    """
+
+    image_embeds: Optional[torch.FloatTensor] = None
+    last_hidden_state: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+
+
+# Copied from transformers.models.bart.modeling_bart._expand_mask
+def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
+    """
+    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
+    """
+    bsz, src_len = mask.size()
+    tgt_len = tgt_len if tgt_len is not None else src_len
+
+    expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
+
+    inverted_mask = 1.0 - expanded_mask
+
+    return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
+
+
+class GitEmbeddings(nn.Module):
+    """Construct the embeddings from word and position embeddings."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+
+        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
+        # any TensorFlow checkpoint file
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+
+    def forward(
+        self,
+        input_ids: Optional[torch.LongTensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        past_key_values_length: int = 0,
+    ) -> torch.Tensor:
+        if input_ids is not None:
+            input_shape = input_ids.size()
+        else:
+            input_shape = inputs_embeds.size()[:-1]
+
+        seq_length = input_shape[1]
+
+        if position_ids is None:
+            position_ids = self.position_ids[:, past_key_values_length : seq_length + past_key_values_length]
+
+        if inputs_embeds is None:
+            embeddings = self.word_embeddings(input_ids)
+        else:
+            embeddings = inputs_embeds
+
+        if self.position_embedding_type == "absolute":
+            position_embeddings = self.position_embeddings(position_ids)
+            embeddings += position_embeddings
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+
+
+class GitSelfAttention(nn.Module):
+    def __init__(self, config, position_embedding_type=None):
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
+                f"heads ({config.num_attention_heads})"
+            )
+
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        self.image_patch_tokens = int((config.vision_config.image_size / config.vision_config.patch_size) ** 2 + 1)
+        if config.num_image_with_embedding is not None:
+            self.image_patch_tokens *= config.num_image_with_embedding
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.position_embedding_type = position_embedding_type or getattr(
+            config, "position_embedding_type", "absolute"
+        )
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            self.max_position_embeddings = config.max_position_embeddings
+            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
+
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        output_attentions: Optional[bool] = False,
+        pixel_values_present: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        mixed_query_layer = self.query(hidden_states)
+
+        cutoff = self.image_patch_tokens if pixel_values_present else 0
+        if past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([key_layer[:, :, :cutoff, :], past_key_value[0], key_layer[:, :, -1:, :]], dim=2)
+            value_layer = torch.cat(
+                [value_layer[:, :, :cutoff, :], past_key_value[1], value_layer[:, :, -1:, :]], dim=2
+            )
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        use_cache = past_key_value is not None
+        # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
+        # Further calls to cross_attention layer can then reuse all cross-attention
+        # key/value_states (first "if" case)
+        # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
+        # all previous decoder key/value_states. Further calls to uni-directional self-attention
+        # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
+        # if encoder bi-directional self-attention `past_key_value` is always `None`
+        # NOTE: like in other caches, we store the text component. In GIT it means we discard the image component.
+        past_key_value = (
+            key_layer[:, :, cutoff:, :],
+            value_layer[:, :, cutoff:, :],
+        )
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            query_length, key_length = query_layer.shape[2], key_layer.shape[2]
+            if use_cache:
+                position_ids_l = torch.tensor(key_length - 1, dtype=torch.long, device=hidden_states.device).view(
+                    -1, 1
+                )
+            else:
+                position_ids_l = torch.arange(query_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
+            position_ids_r = torch.arange(key_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
+            distance = position_ids_l - position_ids_r
+
+            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
+            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
+
+            if self.position_embedding_type == "relative_key":
+                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores
+            elif self.position_embedding_type == "relative_key_query":
+                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
+
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in GitModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        outputs = outputs + (past_key_value,)
+        return outputs
+
+
+# Copied from transformers.models.bert.modeling_bert.BertSelfOutput
+class GitSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class GitAttention(nn.Module):
+    # Copied from transformers.models.bert.modeling_bert.BertAttention.__init__ with Bert->Git
+    def __init__(self, config, position_embedding_type=None):
+        super().__init__()
+        self.self = GitSelfAttention(config, position_embedding_type=position_embedding_type)
+        self.output = GitSelfOutput(config)
+        self.pruned_heads = set()
+
+    # Copied from transformers.models.bert.modeling_bert.BertAttention.prune_heads
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.self.num_attention_heads, self.self.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.self.query = prune_linear_layer(self.self.query, index)
+        self.self.key = prune_linear_layer(self.self.key, index)
+        self.self.value = prune_linear_layer(self.self.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
+        self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        output_attentions: Optional[bool] = False,
+        pixel_values_present: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        self_outputs = self.self(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            past_key_value,
+            output_attentions,
+            pixel_values_present,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+# Copied from transformers.models.bert.modeling_bert.BertIntermediate
+class GitIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+
+# Copied from transformers.models.bert.modeling_bert.BertOutput
+class GitOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class GitLayer(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = GitAttention(config)
+        self.intermediate = GitIntermediate(config)
+        self.output = GitOutput(config)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        output_attentions: Optional[bool] = False,
+        pixel_values_present: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
+        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
+        self_attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            output_attentions=output_attentions,
+            past_key_value=self_attn_past_key_value,
+            pixel_values_present=pixel_values_present,
+        )
+        attention_output = self_attention_outputs[0]
+
+        # if decoder, the last output is tuple of self-attn cache
+        outputs = self_attention_outputs[1:-1]
+        present_key_value = self_attention_outputs[-1]
+
+        layer_output = apply_chunking_to_forward(
+            self.feed_forward_chunk, self.chunk_size_feed_forward, self.seq_len_dim, attention_output
+        )
+        outputs = (layer_output,) + outputs
+
+        # if decoder, return the attn key/values as the last output
+        outputs = outputs + (present_key_value,)
+
+        return outputs
+
+    def feed_forward_chunk(self, attention_output):
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+
+class GitEncoder(nn.Module):
+    # Copied from transformers.models.bert.modeling_bert.BertEncoder.__init__ with Bert->Git
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([GitLayer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.FloatTensor] = None,
+        head_mask: Optional[torch.FloatTensor] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = False,
+        output_hidden_states: Optional[bool] = False,
+        pixel_values_present: Optional[bool] = False,
+        return_dict: Optional[bool] = True,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPast]:
+        if self.gradient_checkpointing and self.training:
+            if use_cache:
+                logger.warning_once(
+                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                )
+                use_cache = False
+
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        next_decoder_cache = () if use_cache else None
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+            past_key_value = past_key_values[i] if past_key_values is not None else None
+
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, past_key_value, output_attentions)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(layer_module),
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    past_key_value,
+                    output_attentions,
+                    pixel_values_present,
+                )
+
+            hidden_states = layer_outputs[0]
+            if use_cache:
+                next_decoder_cache += (layer_outputs[-1],)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=next_decoder_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+        )
+
+
+class GitPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = GitConfig
+    base_model_prefix = "git"
+    supports_gradient_checkpointing = True
+    _keys_to_ignore_on_load_missing = [r"position_ids"]
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        if isinstance(module, GitVisionEmbeddings):
+            nn.init.normal_(module.class_embedding, mean=0.0, std=self.config.initializer_range)
+            nn.init.normal_(module.patch_embedding.weight, std=self.config.initializer_range)
+            nn.init.normal_(module.position_embedding.weight, std=self.config.initializer_range)
+        if isinstance(module, nn.Linear):
+            # Slightly different from the TF version which uses truncated_normal for initialization
+            # cf https://github.com/pytorch/pytorch/pull/5617
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, (GitEncoder, GitVisionEncoder)):
+            module.gradient_checkpointing = value
+
+
+GIT_START_DOCSTRING = r"""
+
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+
+    Parameters:
+        config ([`GitConfig`]): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+GIT_INPUTS_DOCSTRING = r"""
+    Args:
+        input_ids (`torch.LongTensor` of shape `({0})`):
+            Indices of input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are input IDs?](../glossary#input-ids)
+        attention_mask (`torch.FloatTensor` of shape `({0})`, *optional*):
+            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+            - 1 for tokens that are **not masked**,
+            - 0 for tokens that are **masked**.
+
+            [What are attention masks?](../glossary#attention-mask)
+
+        position_ids (`torch.LongTensor` of shape `({0})`, *optional*):
+            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
+            config.max_position_embeddings - 1]`.
+
+            [What are position IDs?](../glossary#position-ids)
+
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
+            [`CLIPImageProcessor.__call__`] for details.
+
+        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
+            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        inputs_embeds (`torch.FloatTensor` of shape `({0}, hidden_size)`, *optional*):
+            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
+            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
+            model's internal embedding lookup matrix.
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPVisionEmbeddings with CLIP->Git
+class GitVisionEmbeddings(nn.Module):
+    def __init__(self, config: GitVisionConfig):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.image_size = config.image_size
+        self.patch_size = config.patch_size
+
+        self.class_embedding = nn.Parameter(torch.randn(self.embed_dim))
+
+        self.patch_embedding = nn.Conv2d(
+            in_channels=config.num_channels,
+            out_channels=self.embed_dim,
+            kernel_size=self.patch_size,
+            stride=self.patch_size,
+            bias=False,
+        )
+
+        self.num_patches = (self.image_size // self.patch_size) ** 2
+        self.num_positions = self.num_patches + 1
+        self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
+        self.register_buffer("position_ids", torch.arange(self.num_positions).expand((1, -1)))
+
+    def forward(self, pixel_values: torch.FloatTensor) -> torch.Tensor:
+        batch_size = pixel_values.shape[0]
+        patch_embeds = self.patch_embedding(pixel_values)  # shape = [*, width, grid, grid]
+        patch_embeds = patch_embeds.flatten(2).transpose(1, 2)
+
+        class_embeds = self.class_embedding.expand(batch_size, 1, -1)
+        embeddings = torch.cat([class_embeds, patch_embeds], dim=1)
+        embeddings = embeddings + self.position_embedding(self.position_ids)
+        return embeddings
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPMLP
+class GitVisionMLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.activation_fn = ACT2FN[config.hidden_act]
+        self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.fc1(hidden_states)
+        hidden_states = self.activation_fn(hidden_states)
+        hidden_states = self.fc2(hidden_states)
+        return hidden_states
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPAttention
+class GitVisionAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.embed_dim // self.num_heads
+        if self.head_dim * self.num_heads != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+                f" {self.num_heads})."
+            )
+        self.scale = self.head_dim**-0.5
+        self.dropout = config.attention_dropout
+
+        self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
+        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        causal_attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        """Input shape: Batch x Time x Channel"""
+
+        bsz, tgt_len, embed_dim = hidden_states.size()
+
+        # get query proj
+        query_states = self.q_proj(hidden_states) * self.scale
+        key_states = self._shape(self.k_proj(hidden_states), -1, bsz)
+        value_states = self._shape(self.v_proj(hidden_states), -1, bsz)
+
+        proj_shape = (bsz * self.num_heads, -1, self.head_dim)
+        query_states = self._shape(query_states, tgt_len, bsz).view(*proj_shape)
+        key_states = key_states.view(*proj_shape)
+        value_states = value_states.view(*proj_shape)
+
+        src_len = key_states.size(1)
+        attn_weights = torch.bmm(query_states, key_states.transpose(1, 2))
+
+        if attn_weights.size() != (bsz * self.num_heads, tgt_len, src_len):
+            raise ValueError(
+                f"Attention weights should be of size {(bsz * self.num_heads, tgt_len, src_len)}, but is"
+                f" {attn_weights.size()}"
+            )
+
+        # apply the causal_attention_mask first
+        if causal_attention_mask is not None:
+            if causal_attention_mask.size() != (bsz, 1, tgt_len, src_len):
+                raise ValueError(
+                    f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is"
+                    f" {causal_attention_mask.size()}"
+                )
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + causal_attention_mask
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if attention_mask is not None:
+            if attention_mask.size() != (bsz, 1, tgt_len, src_len):
+                raise ValueError(
+                    f"Attention mask should be of size {(bsz, 1, tgt_len, src_len)}, but is {attention_mask.size()}"
+                )
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len) + attention_mask
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+
+        if output_attentions:
+            # this operation is a bit akward, but it's required to
+            # make sure that attn_weights keeps its gradient.
+            # In order to do so, attn_weights have to reshaped
+            # twice and have to be reused in the following
+            attn_weights_reshaped = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            attn_weights = attn_weights_reshaped.view(bsz * self.num_heads, tgt_len, src_len)
+        else:
+            attn_weights_reshaped = None
+
+        attn_probs = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+
+        attn_output = torch.bmm(attn_probs, value_states)
+
+        if attn_output.size() != (bsz * self.num_heads, tgt_len, self.head_dim):
+            raise ValueError(
+                f"`attn_output` should be of size {(bsz, self.num_heads, tgt_len, self.head_dim)}, but is"
+                f" {attn_output.size()}"
+            )
+
+        attn_output = attn_output.view(bsz, self.num_heads, tgt_len, self.head_dim)
+        attn_output = attn_output.transpose(1, 2)
+        attn_output = attn_output.reshape(bsz, tgt_len, embed_dim)
+
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output, attn_weights_reshaped
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPEncoderLayer with CLIP->GitVision
+class GitVisionEncoderLayer(nn.Module):
+    def __init__(self, config: GitVisionConfig):
+        super().__init__()
+        self.embed_dim = config.hidden_size
+        self.self_attn = GitVisionAttention(config)
+        self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+        self.mlp = GitVisionMLP(config)
+        self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor,
+        causal_attention_mask: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.FloatTensor]:
+        """
+        Args:
+            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
+            attention_mask (`torch.FloatTensor`): attention mask of size
+                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
+                `(config.encoder_attention_heads,)`.
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+        """
+        residual = hidden_states
+
+        hidden_states = self.layer_norm1(hidden_states)
+        hidden_states, attn_weights = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            causal_attention_mask=causal_attention_mask,
+            output_attentions=output_attentions,
+        )
+        hidden_states = residual + hidden_states
+
+        residual = hidden_states
+        hidden_states = self.layer_norm2(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (attn_weights,)
+
+        return outputs
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPEncoder with CLIP->GitVision, CLIPConfig
+class GitVisionEncoder(nn.Module):
+    """
+    Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+    [`GitVisionEncoderLayer`].
+
+    Args:
+        config: GitVisionConfig
+    """
+
+    def __init__(self, config: GitVisionConfig):
+        super().__init__()
+        self.config = config
+        self.layers = nn.ModuleList([GitVisionEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        inputs_embeds,
+        attention_mask: Optional[torch.Tensor] = None,
+        causal_attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        r"""
+        Args:
+            inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+                Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+                This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+                than the model's internal embedding lookup matrix.
+            attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+
+                [What are attention masks?](../glossary#attention-mask)
+            causal_attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Causal mask for the text model. Mask values selected in `[0, 1]`:
+
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+
+                [What are attention masks?](../glossary#attention-mask)
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            output_hidden_states (`bool`, *optional*):
+                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+                for more detail.
+            return_dict (`bool`, *optional*):
+                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+
+        hidden_states = inputs_embeds
+        for idx, encoder_layer in enumerate(self.layers):
+            if output_hidden_states:
+                encoder_states = encoder_states + (hidden_states,)
+            if self.gradient_checkpointing and self.training:
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        return module(*inputs, output_attentions)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(encoder_layer),
+                    hidden_states,
+                    attention_mask,
+                    causal_attention_mask,
+                )
+            else:
+                layer_outputs = encoder_layer(
+                    hidden_states,
+                    attention_mask,
+                    causal_attention_mask,
+                    output_attentions=output_attentions,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if output_attentions:
+                all_attentions = all_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            encoder_states = encoder_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions
+        )
+
+
+GIT_VISION_INPUTS_DOCSTRING = r"""
+    Args:
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using
+            [`AutoImageProcessor`]. See [`CLIPImageProcessor.__call__`] for details.
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+class GitVisionTransformer(nn.Module):
+    # Copied from transformers.models.clip.modeling_clip.CLIPVisionTransformer.__init__ with CLIPEncoder->GitVisionEncoder, CLIP->Git
+    def __init__(self, config: GitVisionConfig):
+        super().__init__()
+        self.config = config
+        embed_dim = config.hidden_size
+
+        self.embeddings = GitVisionEmbeddings(config)
+        self.pre_layrnorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+        self.encoder = GitVisionEncoder(config)
+        self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+
+    @add_start_docstrings_to_model_forward(GIT_VISION_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=BaseModelOutput, config_class=GitVisionConfig)
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        r"""
+        Returns:
+
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if pixel_values is None:
+            raise ValueError("You have to specify pixel_values")
+
+        hidden_states = self.embeddings(pixel_values)
+        hidden_states = self.pre_layrnorm(hidden_states)
+
+        encoder_outputs = self.encoder(
+            inputs_embeds=hidden_states,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        last_hidden_state = encoder_outputs[0]
+
+        last_hidden_state = self.post_layernorm(last_hidden_state)
+
+        if not return_dict:
+            return (last_hidden_state,) + encoder_outputs[1:]
+
+        return BaseModelOutput(
+            last_hidden_state=last_hidden_state,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """The vision model from CLIP, used in GIT, without any head or projection on top.""",
+    GIT_START_DOCSTRING,
+)
+class GitVisionModel(GitPreTrainedModel):
+    config_class = GitVisionConfig
+    main_input_name = "pixel_values"
+
+    # Copied from transformers.models.clip.modeling_clip.CLIPVisionModel.__init__ with CLIP->Git
+    def __init__(self, config: GitVisionConfig):
+        super().__init__(config)
+        self.vision_model = GitVisionTransformer(config)
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self) -> nn.Module:
+        return self.vision_model.embeddings.patch_embedding
+
+    @add_start_docstrings_to_model_forward(GIT_VISION_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=BaseModelOutput, config_class=GitVisionConfig)
+    def forward(
+        self,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        r"""
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from PIL import Image
+        >>> import requests
+        >>> from transformers import AutoProcessor, GitVisionModel
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large")
+        >>> model = GitVisionModel.from_pretrained("microsoft/git-large")
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> inputs = processor(images=image, return_tensors="pt")
+
+        >>> outputs = model(**inputs)
+        >>> last_hidden_state = outputs.last_hidden_state
+        ```"""
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        return self.vision_model(
+            pixel_values=pixel_values,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+
+class GitProjection(nn.Module):
+    def __init__(self, config: GitConfig):
+        super().__init__()
+        self.config = config
+        self.visual_projection = nn.Sequential(
+            nn.Linear(config.vision_config.hidden_size, config.hidden_size),
+            nn.LayerNorm(config.hidden_size, eps=config.vision_config.layer_norm_eps),
+        )
+
+    def forward(self, embeddings: torch.Tensor) -> torch.Tensor:
+        return self.visual_projection(embeddings)
+
+
+@add_start_docstrings(
+    "The bare GIT Model transformer consisting of a CLIP image encoder and text decoder outputting raw hidden-states"
+    " without any specific head on top.",
+    GIT_START_DOCSTRING,
+)
+class GitModel(GitPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = GitEmbeddings(config)
+        self.image_encoder = GitVisionModel(config.vision_config)
+        self.encoder = GitEncoder(config)
+
+        self.visual_projection = GitProjection(config)
+
+        if config.num_image_with_embedding is not None:
+            self.img_temperal_embedding = nn.ParameterList(
+                nn.Parameter(torch.zeros(1, 1, config.vision_config.hidden_size))
+                for _ in range(config.num_image_with_embedding)
+            )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    def _generate_future_mask(self, size: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+        # Default mask is for forward direction. Flip for backward direction.
+        mask = torch.triu(torch.ones(size, size, device=device, dtype=dtype), diagonal=1)
+        mask = mask.masked_fill(mask == 1, float("-inf"))
+        return mask
+
+    def create_attention_mask(self, tgt, memory, tgt_mask, past_key_values_length, memory_key_padding_mask=None):
+        num_tgt = tgt.shape[1]
+        num_memory = memory.shape[1]
+        device = tgt.device
+        dtype = tgt.dtype
+        top_left = torch.zeros((num_memory, num_memory), device=device, dtype=dtype)
+        top_right = torch.full(
+            (num_memory, num_tgt + past_key_values_length),
+            float("-inf"),
+            device=tgt.device,
+            dtype=dtype,
+        )
+        bottom_left = torch.zeros(
+            (num_tgt, num_memory),
+            dtype=dtype,
+            device=tgt_mask.device,
+        )
+
+        if past_key_values_length > 0:
+            tgt_mask = torch.zeros(
+                (tgt_mask.shape[0], tgt_mask.shape[0] + past_key_values_length),
+                dtype=dtype,
+                device=tgt_mask.device,
+            )
+
+        left = torch.cat((top_left, bottom_left), dim=0)
+        right = torch.cat((top_right, tgt_mask.to(dtype)), dim=0)
+
+        full_attention_mask = torch.cat((left, right), dim=1)[None, :]
+
+        if memory_key_padding_mask is None:
+            memory_key_padding_mask = torch.full((memory.shape[0], memory.shape[1]), fill_value=False, device=device)
+        # if it is False, it means valid. That is, it is not a padding
+        if memory_key_padding_mask.dtype != torch.bool:
+            raise ValueError("Memory key padding mask must be a boolean tensor.")
+        zero_negative_infinity = torch.zeros_like(memory_key_padding_mask, dtype=tgt.dtype)
+        zero_negative_infinity[memory_key_padding_mask] = float("-inf")
+        full_attention_mask = full_attention_mask.expand(
+            (memory_key_padding_mask.shape[0], num_memory + num_tgt, num_memory + past_key_values_length + num_tgt)
+        )
+        full_attention_mask = full_attention_mask.clone()
+        origin_left = full_attention_mask[:, :, :num_memory]
+        update = zero_negative_infinity[:, None, :]
+        full_attention_mask[:, :, :num_memory] = origin_left + update
+
+        # add axis for multi-head
+        full_attention_mask = full_attention_mask[:, None, :, :]
+
+        return full_attention_mask
+
+    @add_start_docstrings_to_model_forward(GIT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @replace_return_docstrings(output_type=BaseModelOutputWithPooling, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPooling]:
+        r"""
+        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModel
+        >>> import requests
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large")
+        >>> model = AutoModel.from_pretrained("microsoft/git-large")
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> text = "this is an image of two cats"
+
+        >>> inputs = processor(text, images=image, return_tensors="pt")
+
+        >>> outputs = model(**inputs)
+        >>> last_hidden_state = outputs.last_hidden_state
+        ```"""
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        seq_length = input_shape[1]
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        projected_visual_features = None
+        
+        # print(input_ids)
+        if pixel_values is not None:
+            if pixel_values.ndim == 4:
+                # here we assume pixel_values is of shape (batch_size, num_channels, height, width)
+                visual_features = self.image_encoder(pixel_values).last_hidden_state
+
+            elif pixel_values.ndim == 5:
+                # here we assume pixel_values is of shape (batch_size, num_frames, num_channels, height, width)
+                visual_features = []
+                for frame_idx in range(pixel_values.shape[1]):
+                    visual_features_frame = self.image_encoder(pixel_values[:, frame_idx, :, :]).last_hidden_state
+                    visual_features_frame += self.img_temperal_embedding[frame_idx]
+                    visual_features.append(visual_features_frame)
+
+                # finally, concatenate all features along sequence dimension
+                visual_features = torch.cat(visual_features, dim=1)
+
+            else:
+                raise ValueError("pixel_values must be of rank 4 or 5")
+
+            projected_visual_features = self.visual_projection(visual_features)
+
+        embedding_output = self.embeddings(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            inputs_embeds=inputs_embeds,
+            past_key_values_length=past_key_values_length,
+        )
+
+        if projected_visual_features is None:
+            projected_visual_features = torch.zeros(
+                (embedding_output.shape[0], 0, embedding_output.shape[2]),
+                dtype=embedding_output.dtype,
+                device=embedding_output.device,
+            )
+
+        # Repeat visual features to match embedding batch size.
+        projected_visual_features = projected_visual_features.repeat(
+            embedding_output.size(0) // projected_visual_features.size(0), 1, 1
+        )
+
+        # concatenate patch token and text token embeddings
+        hidden_states = torch.cat((projected_visual_features, embedding_output), dim=1)
+
+        # By default, an additive causal mask is created
+        # for masking the future (one direction).
+        tgt_mask = self._generate_future_mask(seq_length, embedding_output.dtype, embedding_output.device)
+
+        # Create an attention mask of shape (batch_size, 1, tgt_seq_len, src_seq_len)
+        combined_attention_mask = self.create_attention_mask(
+            tgt=embedding_output,
+            memory=projected_visual_features,
+            tgt_mask=tgt_mask,
+            past_key_values_length=past_key_values_length,
+        )
+
+        if attention_mask is not None:
+            # if the user provides an attention mask, we add it to the default one
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            expanded_attn_mask = _expand_mask(attention_mask, embedding_output.dtype, tgt_len=input_shape[-1]).to(
+                embedding_output.device
+            )
+            if past_key_values_length > 0:
+                expanded_attn_mask = expanded_attn_mask[:, :, -past_key_values_length:, :]
+            else:
+                combined_attention_mask[:, :, -input_shape[1] :, -input_shape[1] :] += expanded_attn_mask
+
+        encoder_outputs = self.encoder(
+            hidden_states,
+            attention_mask=combined_attention_mask,
+            head_mask=head_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            pixel_values_present=pixel_values is not None,
+        )
+        sequence_output = encoder_outputs[0]
+
+        if not return_dict:
+            return (sequence_output,) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPast(
+            last_hidden_state=sequence_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """GIT Model with a `language modeling` head on top for autoregressive language modeling.""", GIT_START_DOCSTRING
+)
+class GitForCausalLM(GitPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.git = GitModel(config)
+        self.output = nn.Linear(config.hidden_size, config.vocab_size)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_output_embeddings(self):
+        return self.output
+
+    def set_output_embeddings(self, new_embeddings):
+        self.output = new_embeddings
+
+    @add_start_docstrings_to_model_forward(GIT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.Tensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], CausalLMOutputWithPast]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
+            `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are
+            ignored (masked), the loss is only computed for the tokens with labels n `[0, ..., config.vocab_size]`
+        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+
+        Returns:
+
+        Examples:
+
+        Image captioning example:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+        >>> import requests
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-coco")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-coco")
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
+        >>> generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        >>> print(generated_caption)
+        two cats sleeping on a pink blanket next to remotes.
+        ```
+
+        Visual question answering (VQA) example:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+        >>> from huggingface_hub import hf_hub_download
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-textvqa")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-textvqa")
+
+        >>> file_path = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
+        >>> image = Image.open(file_path).convert("RGB")
+
+        >>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
+
+        >>> question = "what does the front of the bus say at the top?"
+
+        >>> input_ids = processor(text=question, add_special_tokens=False).input_ids
+        >>> input_ids = [processor.tokenizer.cls_token_id] + input_ids
+        >>> input_ids = torch.tensor(input_ids).unsqueeze(0)
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
+        >>> print(processor.batch_decode(generated_ids, skip_special_tokens=True))
+        ['what does the front of the bus say at the top? special']
+        ```
+
+        Video captioning example:
+
+        ```python
+        >>> import av
+        >>> import numpy as np
+        >>> from PIL import Image
+        >>> from huggingface_hub import hf_hub_download
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-vatex")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-vatex")
+
+        >>> # set seed for reproducability
+        >>> np.random.seed(45)
+
+
+        >>> def read_video_pyav(container, indices):
+        ...     '''
+        ...     Decode the video with PyAV decoder.
+        ...     Args:
+        ...         container (`av.container.input.InputContainer`): PyAV container.
+        ...         indices (`List[int]`): List of frame indices to decode.
+        ...     Returns:
+        ...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
+        ...     '''
+        ...     frames = []
+        ...     container.seek(0)
+        ...     start_index = indices[0]
+        ...     end_index = indices[-1]
+        ...     for i, frame in enumerate(container.decode(video=0)):
+        ...         if i > end_index:
+        ...             break
+        ...         if i >= start_index and i in indices:
+        ...             frames.append(frame)
+        ...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+
+        >>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
+        ...     converted_len = int(clip_len * frame_sample_rate)
+        ...     end_idx = np.random.randint(converted_len, seg_len)
+        ...     start_idx = end_idx - converted_len
+        ...     indices = np.linspace(start_idx, end_idx, num=clip_len)
+        ...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
+        ...     return indices
+
+
+        >>> # load video
+        >>> file_path = hf_hub_download(
+        ...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+        ... )
+        >>> container = av.open(file_path)
+
+        >>> # sample frames
+        >>> num_frames = model.config.num_image_with_embedding
+        >>> indices = sample_frame_indices(
+        ...     clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
+        ... )
+        >>> frames = read_video_pyav(container, indices)
+
+        >>> pixel_values = processor(images=list(frames), return_tensors="pt").pixel_values
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
+
+        >>> print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
+        Generated caption: ['a woman is sitting at a table and she is talking about the food she is holding.']
+        ```
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if labels is not None:
+            use_cache = False
+
+        outputs = self.git(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            pixel_values=pixel_values,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = outputs[0]
+        logits = self.output(sequence_output)
+
+        loss = None
+        if labels is not None:
+            # we are doing next-token prediction; shift prediction scores and input ids by one
+            num_image_tokens = self.git.encoder.layer[0].attention.self.image_patch_tokens
+            shifted_logits = logits[:, num_image_tokens:-1, :].contiguous()
+            labels = labels[:, 1:].contiguous()
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(shifted_logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, attention_mask=None, use_cache=None, **kwargs
+    ):
+        # cut decoder_input_ids if past_key_values is used
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+
+        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
+        input_shape = input_ids.shape
+        if attention_mask is None:
+            attention_mask = input_ids.new_ones(input_shape)
+
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "pixel_values": kwargs.get("pixel_values", None),
+            "past_key_values": past_key_values,
+            "use_cache": use_cache,
+        }
+
+    def _reorder_cache(self, past_key_values, beam_idx):
+        reordered_past = ()
+        for layer_past in past_key_values:
+            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
+        return reordered_past
+    
+    
+    
+### MOD
+
+
+class GitForCausalLMClipEmb(GitPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.git = GitModelClipEmb(config)
+        self.output = nn.Linear(config.hidden_size, config.vocab_size)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_output_embeddings(self):
+        return self.output
+
+    def set_output_embeddings(self, new_embeddings):
+        self.output = new_embeddings
+
+    @add_start_docstrings_to_model_forward(GIT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.Tensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], CausalLMOutputWithPast]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
+            `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are
+            ignored (masked), the loss is only computed for the tokens with labels n `[0, ..., config.vocab_size]`
+        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+
+        Returns:
+
+        Examples:
+
+        Image captioning example:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+        >>> import requests
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-coco")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-coco")
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
+        >>> generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+        >>> print(generated_caption)
+        two cats sleeping on a pink blanket next to remotes.
+        ```
+
+        Visual question answering (VQA) example:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+        >>> from huggingface_hub import hf_hub_download
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-textvqa")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-textvqa")
+
+        >>> file_path = hf_hub_download(repo_id="nielsr/textvqa-sample", filename="bus.png", repo_type="dataset")
+        >>> image = Image.open(file_path).convert("RGB")
+
+        >>> pixel_values = processor(images=image, return_tensors="pt").pixel_values
+
+        >>> question = "what does the front of the bus say at the top?"
+
+        >>> input_ids = processor(text=question, add_special_tokens=False).input_ids
+        >>> input_ids = [processor.tokenizer.cls_token_id] + input_ids
+        >>> input_ids = torch.tensor(input_ids).unsqueeze(0)
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, input_ids=input_ids, max_length=50)
+        >>> print(processor.batch_decode(generated_ids, skip_special_tokens=True))
+        ['what does the front of the bus say at the top? special']
+        ```
+
+        Video captioning example:
+
+        ```python
+        >>> import av
+        >>> import numpy as np
+        >>> from PIL import Image
+        >>> from huggingface_hub import hf_hub_download
+        >>> from transformers import AutoProcessor, AutoModelForCausalLM
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large-vatex")
+        >>> model = AutoModelForCausalLM.from_pretrained("microsoft/git-large-vatex")
+
+        >>> # set seed for reproducability
+        >>> np.random.seed(45)
+
+
+        >>> def read_video_pyav(container, indices):
+        ...     '''
+        ...     Decode the video with PyAV decoder.
+        ...     Args:
+        ...         container (`av.container.input.InputContainer`): PyAV container.
+        ...         indices (`List[int]`): List of frame indices to decode.
+        ...     Returns:
+        ...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
+        ...     '''
+        ...     frames = []
+        ...     container.seek(0)
+        ...     start_index = indices[0]
+        ...     end_index = indices[-1]
+        ...     for i, frame in enumerate(container.decode(video=0)):
+        ...         if i > end_index:
+        ...             break
+        ...         if i >= start_index and i in indices:
+        ...             frames.append(frame)
+        ...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])
+
+
+        >>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
+        ...     converted_len = int(clip_len * frame_sample_rate)
+        ...     end_idx = np.random.randint(converted_len, seg_len)
+        ...     start_idx = end_idx - converted_len
+        ...     indices = np.linspace(start_idx, end_idx, num=clip_len)
+        ...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
+        ...     return indices
+
+
+        >>> # load video
+        >>> file_path = hf_hub_download(
+        ...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
+        ... )
+        >>> container = av.open(file_path)
+
+        >>> # sample frames
+        >>> num_frames = model.config.num_image_with_embedding
+        >>> indices = sample_frame_indices(
+        ...     clip_len=num_frames, frame_sample_rate=4, seg_len=container.streams.video[0].frames
+        ... )
+        >>> frames = read_video_pyav(container, indices)
+
+        >>> pixel_values = processor(images=list(frames), return_tensors="pt").pixel_values
+
+        >>> generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
+
+        >>> print("Generated caption:", processor.batch_decode(generated_ids, skip_special_tokens=True))
+        Generated caption: ['a woman is sitting at a table and she is talking about the food she is holding.']
+        ```
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        if labels is not None:
+            use_cache = False
+
+        outputs = self.git(
+            input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            pixel_values=pixel_values,
+            head_mask=head_mask,
+            inputs_embeds=inputs_embeds,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = outputs[0]
+        logits = self.output(sequence_output)
+
+        loss = None
+        if labels is not None:
+            # we are doing next-token prediction; shift prediction scores and input ids by one
+            num_image_tokens = self.git.encoder.layer[0].attention.self.image_patch_tokens
+            shifted_logits = logits[:, num_image_tokens:-1, :].contiguous()
+            labels = labels[:, 1:].contiguous()
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(shifted_logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return ((loss,) + output) if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, attention_mask=None, use_cache=None, **kwargs
+    ):
+        # cut decoder_input_ids if past_key_values is used
+        if past_key_values is not None:
+            input_ids = input_ids[:, -1:]
+
+        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
+        input_shape = input_ids.shape
+        if attention_mask is None:
+            attention_mask = input_ids.new_ones(input_shape)
+
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "pixel_values": kwargs.get("pixel_values", None),
+            "past_key_values": past_key_values,
+            "use_cache": use_cache,
+        }
+
+    def _reorder_cache(self, past_key_values, beam_idx):
+        reordered_past = ()
+        for layer_past in past_key_values:
+            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
+        return reordered_past
+    
+    
+class GitModelClipEmb(GitPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = GitEmbeddings(config)
+        self.image_encoder = GitVisionModel(config.vision_config)
+        self.encoder = GitEncoder(config)
+
+        self.visual_projection = GitProjection(config)
+
+        if config.num_image_with_embedding is not None:
+            self.img_temperal_embedding = nn.ParameterList(
+                nn.Parameter(torch.zeros(1, 1, config.vision_config.hidden_size))
+                for _ in range(config.num_image_with_embedding)
+            )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def _prune_heads(self, heads_to_prune):
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    def _generate_future_mask(self, size: int, dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+        # Default mask is for forward direction. Flip for backward direction.
+        mask = torch.triu(torch.ones(size, size, device=device, dtype=dtype), diagonal=1)
+        mask = mask.masked_fill(mask == 1, float("-inf"))
+        return mask
+
+    def create_attention_mask(self, tgt, memory, tgt_mask, past_key_values_length, memory_key_padding_mask=None):
+        num_tgt = tgt.shape[1]
+        num_memory = memory.shape[1]
+        device = tgt.device
+        dtype = tgt.dtype
+        top_left = torch.zeros((num_memory, num_memory), device=device, dtype=dtype)
+        top_right = torch.full(
+            (num_memory, num_tgt + past_key_values_length),
+            float("-inf"),
+            device=tgt.device,
+            dtype=dtype,
+        )
+        bottom_left = torch.zeros(
+            (num_tgt, num_memory),
+            dtype=dtype,
+            device=tgt_mask.device,
+        )
+
+        if past_key_values_length > 0:
+            tgt_mask = torch.zeros(
+                (tgt_mask.shape[0], tgt_mask.shape[0] + past_key_values_length),
+                dtype=dtype,
+                device=tgt_mask.device,
+            )
+
+        left = torch.cat((top_left, bottom_left), dim=0)
+        right = torch.cat((top_right, tgt_mask.to(dtype)), dim=0)
+
+        full_attention_mask = torch.cat((left, right), dim=1)[None, :]
+
+        if memory_key_padding_mask is None:
+            memory_key_padding_mask = torch.full((memory.shape[0], memory.shape[1]), fill_value=False, device=device)
+        # if it is False, it means valid. That is, it is not a padding
+        if memory_key_padding_mask.dtype != torch.bool:
+            raise ValueError("Memory key padding mask must be a boolean tensor.")
+        zero_negative_infinity = torch.zeros_like(memory_key_padding_mask, dtype=tgt.dtype)
+        zero_negative_infinity[memory_key_padding_mask] = float("-inf")
+        full_attention_mask = full_attention_mask.expand(
+            (memory_key_padding_mask.shape[0], num_memory + num_tgt, num_memory + past_key_values_length + num_tgt)
+        )
+        full_attention_mask = full_attention_mask.clone()
+        origin_left = full_attention_mask[:, :, :num_memory]
+        update = zero_negative_infinity[:, None, :]
+        full_attention_mask[:, :, :num_memory] = origin_left + update
+
+        # add axis for multi-head
+        full_attention_mask = full_attention_mask[:, None, :, :]
+
+        return full_attention_mask
+
+    @add_start_docstrings_to_model_forward(GIT_INPUTS_DOCSTRING.format("batch_size, sequence_length"))
+    @replace_return_docstrings(output_type=BaseModelOutputWithPooling, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        inputs_embeds: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPooling]:
+        r"""
+        past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
+            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
+
+            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
+            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
+            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
+        use_cache (`bool`, *optional*):
+            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
+            `past_key_values`).
+
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from transformers import AutoProcessor, AutoModel
+        >>> import requests
+        >>> from PIL import Image
+
+        >>> processor = AutoProcessor.from_pretrained("microsoft/git-large")
+        >>> model = AutoModel.from_pretrained("microsoft/git-large")
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> text = "this is an image of two cats"
+
+        >>> inputs = processor(text, images=image, return_tensors="pt")
+
+        >>> outputs = model(**inputs)
+        >>> last_hidden_state = outputs.last_hidden_state
+        ```"""
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time")
+        elif input_ids is not None:
+            input_shape = input_ids.size()
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+        else:
+            raise ValueError("You have to specify either input_ids or inputs_embeds")
+
+        seq_length = input_shape[1]
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        projected_visual_features = None
+        if pixel_values is not None:
+            
+            # print("turning pixel_values in visual_features")
+            visual_features = pixel_values
+            # if pixel_values.ndim == 4:
+            #     # here we assume pixel_values is of shape (batch_size, num_channels, height, width)
+            #     visual_features = self.image_encoder(pixel_values).last_hidden_state
+
+
+            # else:
+            #     raise ValueError("pixel_values must be of rank 4 or 5")
+
+            projected_visual_features = self.visual_projection(visual_features)
+
+        embedding_output = self.embeddings(
+            input_ids=input_ids,
+            position_ids=position_ids,
+            inputs_embeds=inputs_embeds,
+            past_key_values_length=past_key_values_length,
+        )
+
+        if projected_visual_features is None:
+            projected_visual_features = torch.zeros(
+                (embedding_output.shape[0], 0, embedding_output.shape[2]),
+                dtype=embedding_output.dtype,
+                device=embedding_output.device,
+            )
+
+        # Repeat visual features to match embedding batch size.
+        projected_visual_features = projected_visual_features.repeat(
+            embedding_output.size(0) // projected_visual_features.size(0), 1, 1
+        )
+
+        # concatenate patch token and text token embeddings
+        hidden_states = torch.cat((projected_visual_features, embedding_output), dim=1)
+
+        # By default, an additive causal mask is created
+        # for masking the future (one direction).
+        tgt_mask = self._generate_future_mask(seq_length, embedding_output.dtype, embedding_output.device)
+
+        # Create an attention mask of shape (batch_size, 1, tgt_seq_len, src_seq_len)
+        combined_attention_mask = self.create_attention_mask(
+            tgt=embedding_output,
+            memory=projected_visual_features,
+            tgt_mask=tgt_mask,
+            past_key_values_length=past_key_values_length,
+        )
+
+        if attention_mask is not None:
+            # if the user provides an attention mask, we add it to the default one
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            expanded_attn_mask = _expand_mask(attention_mask, embedding_output.dtype, tgt_len=input_shape[-1]).to(
+                embedding_output.device
+            )
+            if past_key_values_length > 0:
+                expanded_attn_mask = expanded_attn_mask[:, :, -past_key_values_length:, :]
+            else:
+                combined_attention_mask[:, :, -input_shape[1] :, -input_shape[1] :] += expanded_attn_mask
+
+        encoder_outputs = self.encoder(
+            hidden_states,
+            attention_mask=combined_attention_mask,
+            head_mask=head_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            pixel_values_present=pixel_values is not None,
+        )
+        sequence_output = encoder_outputs[0]
+
+        if not return_dict:
+            return (sequence_output,) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPast(
+            last_hidden_state=sequence_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )

models.py

@@ -0,0 +1,756 @@
+import os
+import numpy as np
+from torchvision import transforms
+import torch
+import torch.nn as nn
+import PIL
+import clip
+import open_clip
+from functools import partial
+import random
+import json
+from tqdm import tqdm
+import utils
+
+# class BrainMLP(nn.Module):
+#     def __init__(self, out_dim=257*768, in_dim=15724, clip_size=768, h=4096):
+#         super().__init__()
+#         self.lin0 = nn.Sequential(
+#             nn.Linear(in_dim, h, bias=False),
+#             nn.LayerNorm(h),
+#             nn.GELU(inplace=True),
+#             nn.Dropout(0.5))
+#         self.mlp = nn.ModuleList([
+#             nn.Sequential(
+#                 nn.Linear(h, h),
+#                 nn.LayerNorm(h),
+#                 nn.GELU(inplace=True),
+#                 nn.Dropout(0.15)
+#             ) for _ in range(4)])
+#         self.lin1 = nn.Linear(h, out_dim, bias=True)
+#         self.proj = nn.Sequential(
+#             nn.LayerNorm(clip_size),
+#             nn.GELU(),
+#             nn.Linear(clip_size, 2048),
+#             nn.LayerNorm(2048),
+#             nn.GELU(),
+#             nn.Linear(2048, 2048),
+#             nn.LayerNorm(2048),
+#             nn.GELU(),
+#             nn.Linear(2048, clip_size))
+#     def forward(self, x):
+#         x = self.lin0(x)
+#         residual = x
+#         for res_block in range(self.n_blocks):
+#             x = self.mlp[res_block](x)
+#             x += residual
+#             residual = x
+#         diffusion_prior_input = self.lin1(x.reshape(len(x), -1))
+#         disjointed_clip_fmri = self.proj(diffusion_prior_input.reshape(
+#                                         len(x),-1, self.clip_size))
+#         return diffusion_prior_input, disjointed_clip_fmri
+
+
+
+class Clipper(torch.nn.Module):
+    def __init__(self, clip_variant, clamp_embs=False, norm_embs=False,
+                 hidden_state=False, device=torch.device('cpu')):
+        super().__init__()
+        assert clip_variant in ("RN50", "ViT-L/14", "ViT-B/32", "RN50x64"), \
+            "clip_variant must be one of RN50, ViT-L/14, ViT-B/32, RN50x64"
+        print(clip_variant, device)
+        
+        if clip_variant=="ViT-L/14" and hidden_state:
+            # from transformers import CLIPVisionModelWithProjection
+            # image_encoder = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-large-patch14",cache_dir="/fsx/proj-medarc/fmri/cache")
+            from transformers import CLIPVisionModelWithProjection
+            sd_cache_dir = '/fsx/proj-fmri/shared/cache/models--shi-labs--versatile-diffusion/snapshots/2926f8e11ea526b562cd592b099fcf9c2985d0b7'
+            image_encoder = CLIPVisionModelWithProjection.from_pretrained(sd_cache_dir, subfolder='image_encoder').eval()
+            image_encoder = image_encoder.to(device)
+            for param in image_encoder.parameters():
+                param.requires_grad = False # dont need to calculate gradients
+            self.image_encoder = image_encoder
+        elif hidden_state:
+            raise Exception("hidden_state embeddings only works with ViT-L/14 right now")
+        
+        clip_model, preprocess = clip.load(clip_variant, device=device)
+        clip_model.eval() # dont want to train model
+        for param in clip_model.parameters():
+            param.requires_grad = False # dont need to calculate gradients
+            
+        self.clip = clip_model
+        self.clip_variant = clip_variant
+        if clip_variant == "RN50x64":
+            self.clip_size = (448,448)
+        else:
+            self.clip_size = (224,224)
+            
+        preproc = transforms.Compose([
+            transforms.Resize(size=self.clip_size[0], interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(size=self.clip_size),
+            transforms.Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))
+        ])
+        self.preprocess = preproc
+        self.hidden_state = hidden_state
+        self.mean = np.array([0.48145466, 0.4578275, 0.40821073])
+        self.std = np.array([0.26862954, 0.26130258, 0.27577711])
+        self.normalize = transforms.Normalize(self.mean, self.std)
+        self.denormalize = transforms.Normalize((-self.mean / self.std).tolist(), (1.0 / self.std).tolist())
+        self.clamp_embs = clamp_embs
+        self.norm_embs = norm_embs
+        self.device= device
+        
+        def versatile_normalize_embeddings(encoder_output):
+            embeds = encoder_output.last_hidden_state
+            embeds = image_encoder.vision_model.post_layernorm(embeds)
+            embeds = image_encoder.visual_projection(embeds)
+            return embeds
+        self.versatile_normalize_embeddings = versatile_normalize_embeddings
+
+    def resize_image(self, image):
+        # note: antialias should be False if planning to use Pinkney's Image Variation SD model
+        return transforms.Resize(self.clip_size)(image.to(self.device))
+
+    def embed_image(self, image):
+        """Expects images in -1 to 1 range"""
+        if self.hidden_state:
+            # clip_emb = self.preprocess((image/1.5+.25).to(self.device)) # for some reason the /1.5+.25 prevents oversaturation
+            clip_emb = self.preprocess((image).to(self.device))
+            clip_emb = self.image_encoder(clip_emb)
+            clip_emb = self.versatile_normalize_embeddings(clip_emb)
+        else:
+            clip_emb = self.preprocess(image.to(self.device))
+            clip_emb = self.clip.encode_image(clip_emb)
+        # input is now in CLIP space, but mind-reader preprint further processes embeddings:
+        if self.clamp_embs:
+            clip_emb = torch.clamp(clip_emb, -1.5, 1.5)
+        if self.norm_embs:
+            if self.hidden_state:        
+                # normalize all tokens by cls token's norm
+                clip_emb = clip_emb / torch.norm(clip_emb[:, 0], dim=-1).reshape(-1, 1, 1)
+            else:
+                clip_emb = nn.functional.normalize(clip_emb, dim=-1)
+        return clip_emb
+
+    def embed_text(self, text_samples):
+        clip_text = clip.tokenize(text_samples).to(self.device)
+        clip_text = self.clip.encode_text(clip_text)
+        if self.clamp_embs:
+            clip_text = torch.clamp(clip_text, -1.5, 1.5)
+        if self.norm_embs:
+            clip_text = nn.functional.normalize(clip_text, dim=-1)
+        return clip_text
+
+    def embed_curated_annotations(self, annots):
+        for i,b in enumerate(annots):
+            t = ''
+            while t == '':
+                rand = torch.randint(5,(1,1))[0][0]
+                t = b[0,rand]
+            if i==0:
+                txt = np.array(t)
+            else:
+                txt = np.vstack((txt,t))
+        txt = txt.flatten()
+        return self.embed_text(txt)
+
+# for prior
+from dalle2_pytorch import DiffusionPrior
+from dalle2_pytorch.dalle2_pytorch import l2norm, default, exists
+from dalle2_pytorch.train_configs import DiffusionPriorNetworkConfig
+# vd prior
+from dalle2_pytorch.dalle2_pytorch import RotaryEmbedding, CausalTransformer, SinusoidalPosEmb, MLP, Rearrange, repeat, rearrange, prob_mask_like, LayerNorm, RelPosBias, Attention, FeedForward
+
+
+class BrainDiffusionPrior(DiffusionPrior):
+    """ 
+    Differences from original:
+    - Allow for passing of generators to torch random functions
+    - Option to include the voxel2clip model and pass voxels into forward method
+    - Return predictions when computing loss
+    - Load pretrained model from @nousr trained on LAION aesthetics
+    """
+    def __init__(self, *args, **kwargs):
+        voxel2clip = kwargs.pop('voxel2clip', None)
+        super().__init__(*args, **kwargs)
+        self.voxel2clip = voxel2clip
+
+    @torch.no_grad()
+    def p_sample(self, x, t, text_cond = None, self_cond = None, clip_denoised = True, cond_scale = 1.,
+                generator=None):
+        b, *_, device = *x.shape, x.device
+        model_mean, _, model_log_variance, x_start = self.p_mean_variance(x = x, t = t, text_cond = text_cond, self_cond = self_cond, clip_denoised = clip_denoised, cond_scale = cond_scale)
+        if generator is None:
+            noise = torch.randn_like(x)
+        else:
+            noise = torch.randn_like(x)
+            # noise = torch.randn(x.size(), device=x.device, dtype=x.dtype, generator=generator)
+        # no noise when t == 0
+        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
+        pred = model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
+        return pred, x_start
+
+    @torch.no_grad()
+    def p_sample_loop(self, *args, timesteps = None, **kwargs):
+        timesteps = default(timesteps, self.noise_scheduler.num_timesteps)
+        assert timesteps <= self.noise_scheduler.num_timesteps
+        is_ddim = timesteps < self.noise_scheduler.num_timesteps
+
+        if not is_ddim:
+            normalized_image_embed = self.p_sample_loop_ddpm(*args, **kwargs)
+        else:
+            normalized_image_embed = self.p_sample_loop_ddim(*args, **kwargs, timesteps = timesteps)
+
+        # print("PS removed all image_embed_scale instances!")
+        image_embed = normalized_image_embed #/ self.image_embed_scale
+        return image_embed
+
+    @torch.no_grad()
+    def p_sample_loop_ddpm(self, shape, text_cond, cond_scale = 1., generator=None):
+        batch, device = shape[0], self.device
+
+        if generator is None:
+            image_embed = torch.randn(shape, device = device)
+        else:
+            image_embed = torch.randn(shape, device = device, generator=generator)
+        x_start = None # for self-conditioning
+
+        if self.init_image_embed_l2norm:
+            image_embed = l2norm(image_embed) * self.image_embed_scale
+
+        for i in tqdm(reversed(range(0, self.noise_scheduler.num_timesteps)), desc='sampling loop time step', total=self.noise_scheduler.num_timesteps, disable=True):
+            times = torch.full((batch,), i, device = device, dtype = torch.long)
+
+            self_cond = x_start if self.net.self_cond else None
+            image_embed, x_start = self.p_sample(image_embed, times, text_cond = text_cond, self_cond = self_cond, cond_scale = cond_scale, 
+                                                 generator=generator)
+
+        if self.sampling_final_clamp_l2norm and self.predict_x_start:
+            image_embed = self.l2norm_clamp_embed(image_embed)
+
+        return image_embed
+
+    def p_losses(self, image_embed, times, text_cond, noise = None):
+        noise = default(noise, lambda: torch.randn_like(image_embed))
+
+        image_embed_noisy = self.noise_scheduler.q_sample(x_start = image_embed, t = times, noise = noise)
+
+        self_cond = None
+        if self.net.self_cond and random.random() < 0.5:
+            with torch.no_grad():
+                self_cond = self.net(image_embed_noisy, times, **text_cond).detach()
+
+        pred = self.net(
+            image_embed_noisy,
+            times,
+            self_cond = self_cond,
+            text_cond_drop_prob = self.text_cond_drop_prob,
+            image_cond_drop_prob = self.image_cond_drop_prob,
+            **text_cond
+        )
+
+        if self.predict_x_start and self.training_clamp_l2norm:
+            pred = self.l2norm_clamp_embed(pred)
+
+        if self.predict_v:
+            target = self.noise_scheduler.calculate_v(image_embed, times, noise)
+        elif self.predict_x_start:
+            target = image_embed
+        else:
+            target = noise
+
+        loss = nn.functional.mse_loss(pred, target) # mse
+        # print("1", loss)
+        # loss += (1 - nn.functional.cosine_similarity(pred, target).mean())
+        # print("2", (1 - nn.functional.cosine_similarity(pred, target).mean()))
+        return loss, pred
+
+    def forward(
+        self,
+        text = None,
+        image = None,
+        voxel = None,
+        text_embed = None,      # allow for training on preprocessed CLIP text and image embeddings
+        image_embed = None,
+        text_encodings = None,  # as well as CLIP text encodings
+        *args,
+        **kwargs
+    ):
+        assert exists(text) ^ exists(text_embed) ^ exists(voxel), 'either text, text embedding, or voxel must be supplied'
+        assert exists(image) ^ exists(image_embed), 'either image or image embedding must be supplied'
+        assert not (self.condition_on_text_encodings and (not exists(text_encodings) and not exists(text))), 'text encodings must be present if you specified you wish to condition on it on initialization'
+
+        if exists(voxel):
+            assert exists(self.voxel2clip), 'voxel2clip must be trained if you wish to pass in voxels'
+            assert not exists(text_embed), 'cannot pass in both text and voxels'
+            if self.voxel2clip.use_projector:
+                clip_voxels_mse, clip_voxels = self.voxel2clip(voxel)
+                text_embed = clip_voxels_mse
+            else:
+                clip_voxels = self.voxel2clip(voxel)
+                text_embed = clip_voxels_mse = clip_voxels
+            # text_embed = self.voxel2clip(voxel)
+
+        if exists(image):
+            image_embed, _ = self.clip.embed_image(image)
+
+        # calculate text conditionings, based on what is passed in
+
+        if exists(text):
+            text_embed, text_encodings = self.clip.embed_text(text)
+
+        text_cond = dict(text_embed = text_embed)
+
+        if self.condition_on_text_encodings:
+            assert exists(text_encodings), 'text encodings must be present for diffusion prior if specified'
+            text_cond = {**text_cond, 'text_encodings': text_encodings}
+
+        # timestep conditioning from ddpm
+
+        batch, device = image_embed.shape[0], image_embed.device
+        times = self.noise_scheduler.sample_random_times(batch)
+
+        # PS: I dont think we need this? also if uncommented this does in-place global variable change
+        # scale image embed (Katherine)
+        # image_embed *= self.image_embed_scale
+
+        # calculate forward loss
+
+        loss, pred = self.p_losses(image_embed, times, text_cond = text_cond, *args, **kwargs)
+        
+        # undo the scaling so we can directly use it for real mse loss and reconstruction
+        return loss, pred
+
+    
+class VersatileDiffusionPriorNetwork(nn.Module):
+    def __init__(
+        self,
+        dim,
+        num_timesteps = None,
+        num_time_embeds = 1,
+        # num_image_embeds = 1,
+        # num_brain_embeds = 1,
+        num_tokens = 257,
+        causal = True,
+        learned_query_mode = 'none',
+        **kwargs
+    ):
+        super().__init__()
+        self.dim = dim
+        self.num_time_embeds = num_time_embeds
+        self.continuous_embedded_time = not exists(num_timesteps)
+        self.learned_query_mode = learned_query_mode
+
+        self.to_time_embeds = nn.Sequential(
+            nn.Embedding(num_timesteps, dim * num_time_embeds) if exists(num_timesteps) else nn.Sequential(SinusoidalPosEmb(dim), MLP(dim, dim * num_time_embeds)), # also offer a continuous version of timestep embeddings, with a 2 layer MLP
+            Rearrange('b (n d) -> b n d', n = num_time_embeds)
+        )
+
+        if self.learned_query_mode == 'token':
+            self.learned_query = nn.Parameter(torch.randn(num_tokens, dim))
+        if self.learned_query_mode == 'pos_emb':
+            scale = dim ** -0.5
+            self.learned_query = nn.Parameter(torch.randn(num_tokens, dim) * scale)
+        if self.learned_query_mode == 'all_pos_emb':
+            scale = dim ** -0.5
+            self.learned_query = nn.Parameter(torch.randn(num_tokens*2+1, dim) * scale)
+        self.causal_transformer = FlaggedCausalTransformer(dim = dim, causal=causal, **kwargs)
+
+        self.null_brain_embeds = nn.Parameter(torch.randn(num_tokens, dim))
+        self.null_image_embed = nn.Parameter(torch.randn(num_tokens, dim))
+
+        self.num_tokens = num_tokens
+        self.self_cond = False
+
+    def forward_with_cond_scale(
+        self,
+        *args,
+        cond_scale = 1.,
+        **kwargs
+    ):
+        logits = self.forward(*args, **kwargs)
+
+        if cond_scale == 1:
+            return logits
+
+        null_logits = self.forward(*args, brain_cond_drop_prob = 1., image_cond_drop_prob = 1, **kwargs)
+        return null_logits + (logits - null_logits) * cond_scale
+
+    def forward(
+        self,
+        image_embed,
+        diffusion_timesteps,
+        *,
+        self_cond=None,
+        brain_embed=None,
+        text_embed=None,
+        brain_cond_drop_prob = 0.,
+        text_cond_drop_prob = None,
+        image_cond_drop_prob = 0.
+    ):
+        if text_embed is not None:
+            brain_embed = text_embed
+        if text_cond_drop_prob is not None:
+            brain_cond_drop_prob = text_cond_drop_prob
+        
+        # image_embed = image_embed.view(len(image_embed),-1,16*16)
+        # text_embed = text_embed.view(len(text_embed),-1,768)
+        # brain_embed = brain_embed.view(len(brain_embed),-1,16*16)
+        # print(*image_embed.shape)
+        # print(*image_embed.shape, image_embed.device, image_embed.dtype)
+        
+        batch, _, dim, device, dtype = *image_embed.shape, image_embed.device, image_embed.dtype
+        # num_time_embeds, num_image_embeds, num_brain_embeds = self.num_time_embeds, self.num_image_embeds, self.num_brain_embeds
+        
+        # classifier free guidance masks
+        brain_keep_mask = prob_mask_like((batch,), 1 - brain_cond_drop_prob, device = device)
+        brain_keep_mask = rearrange(brain_keep_mask, 'b -> b 1 1')
+
+        image_keep_mask = prob_mask_like((batch,), 1 - image_cond_drop_prob, device = device)
+        image_keep_mask = rearrange(image_keep_mask, 'b -> b 1 1')
+
+        # mask out brain embeddings with null brain embeddings
+
+        # import pdb; pdb.set_trace()
+        null_brain_embeds = self.null_brain_embeds.to(brain_embed.dtype)
+        brain_embed = torch.where(
+            brain_keep_mask,
+            brain_embed,
+            null_brain_embeds[None]
+        )
+
+        # mask out image embeddings with null image embeddings
+        null_image_embed = self.null_image_embed.to(image_embed.dtype)
+        image_embed = torch.where(
+            image_keep_mask,
+            image_embed,
+            null_image_embed[None]
+        )
+
+        # whether brain embedding is used for conditioning depends on whether brain encodings are available for attention (for classifier free guidance, even though it seems from the paper it was not used in the prior ddpm, as the objective is different)
+        # but let's just do it right
+        if self.continuous_embedded_time:
+            # if continuous cast to flat, else keep int for indexing embeddings
+            diffusion_timesteps = diffusion_timesteps.type(dtype)
+        time_embed = self.to_time_embeds(diffusion_timesteps)
+
+        if self.learned_query_mode == 'token':
+            learned_queries = repeat(self.learned_query, 'n d -> b n d', b = batch)
+        elif self.learned_query_mode == 'pos_emb':
+            pos_embs = repeat(self.learned_query, 'n d -> b n d', b = batch)
+            image_embed = image_embed + pos_embs
+            learned_queries = torch.empty((batch, 0, dim), device=brain_embed.device)
+        elif self.learned_query_mode == 'all_pos_emb':
+            pos_embs = repeat(self.learned_query, 'n d -> b n d', b = batch)
+            learned_queries = torch.empty((batch, 0, dim), device=brain_embed.device)
+        else:
+            learned_queries = torch.empty((batch, 0, dim), device=brain_embed.device)
+        
+        tokens = torch.cat((
+            brain_embed,  # 257
+            time_embed,  # 1
+            image_embed,  # 257
+            learned_queries  # 257
+        ), dim = -2)
+        if self.learned_query_mode == 'all_pos_emb':
+            tokens = tokens + pos_embs
+
+        # attend
+        tokens = self.causal_transformer(tokens)
+
+        # get learned query, which should predict the image embedding (per DDPM timestep)
+        pred_image_embed = tokens[..., -self.num_tokens:, :]
+
+        return pred_image_embed
+
+class FlaggedCausalTransformer(nn.Module):
+    def __init__(
+        self,
+        *,
+        dim,
+        depth,
+        dim_head = 64,
+        heads = 8,
+        ff_mult = 4,
+        norm_in = False,
+        norm_out = True,
+        attn_dropout = 0.,
+        ff_dropout = 0.,
+        final_proj = True,
+        normformer = False,
+        rotary_emb = True,
+        causal=True
+    ):
+        super().__init__()
+        self.init_norm = LayerNorm(dim) if norm_in else nn.Identity() # from latest BLOOM model and Yandex's YaLM
+
+        self.rel_pos_bias = RelPosBias(heads = heads)
+
+        rotary_emb = RotaryEmbedding(dim = min(32, dim_head)) if rotary_emb else None
+
+        self.layers = nn.ModuleList([])
+        for _ in range(depth):
+            self.layers.append(nn.ModuleList([
+                Attention(dim = dim, causal = causal, dim_head = dim_head, heads = heads, dropout = attn_dropout, rotary_emb = rotary_emb),
+                FeedForward(dim = dim, mult = ff_mult, dropout = ff_dropout, post_activation_norm = normformer)
+            ]))
+
+        self.norm = LayerNorm(dim, stable = True) if norm_out else nn.Identity()  # unclear in paper whether they projected after the classic layer norm for the final denoised image embedding, or just had the transformer output it directly: plan on offering both options
+        self.project_out = nn.Linear(dim, dim, bias = False) if final_proj else nn.Identity()
+
+    def forward(self, x):
+        n, device = x.shape[1], x.device
+
+        x = self.init_norm(x)
+
+        attn_bias = self.rel_pos_bias(n, n + 1, device = device)
+
+        for attn, ff in self.layers:
+            x = attn(x, attn_bias = attn_bias) + x
+            x = ff(x) + x
+
+        out = self.norm(x)
+        return self.project_out(out)
+    
+#Subclass for GNET
+class TrunkBlock(nn.Module):
+    def __init__(self, feat_in, feat_out):
+        super(TrunkBlock, self).__init__()
+        self.conv1 = nn.Conv2d(feat_in, int(feat_out*1.), kernel_size=3, stride=1, padding=1, dilation=1)
+        self.drop1 = nn.Dropout2d(p=0.5, inplace=False)
+        self.bn1 = nn.BatchNorm2d(feat_in, eps=1e-05, momentum=0.25, affine=True, track_running_stats=True)
+
+        torch.nn.init.xavier_normal_(self.conv1.weight, gain=torch.nn.init.calculate_gain('relu'))
+        torch.nn.init.constant_(self.conv1.bias, 0.0) # current
+        
+    def forward(self, x):
+        return torch.nn.functional.relu(self.conv1(self.drop1(self.bn1(x))))
+
+#Subclass for GNET
+class PreFilter(nn.Module):
+    def __init__(self):
+        super(PreFilter, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2)
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True)
+        )        
+        
+    def forward(self, x):
+        c1 = self.conv1(x)
+        y = self.conv2(c1)
+        return y 
+
+#Subclass for GNET
+class EncStage(nn.Module):
+    def __init__(self, trunk_width=64, pass_through=64):
+        super(EncStage, self).__init__()
+        self.conv3  = nn.Conv2d(192, 128, kernel_size=3, stride=1, padding=0)
+        self.drop1  = nn.Dropout2d(p=0.5, inplace=False) ##
+        self.bn1    = nn.BatchNorm2d(192, eps=1e-05, momentum=0.25, affine=True, track_running_stats=True) ##
+        self.pool1  = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        ##
+        self.tw = int(trunk_width)
+        self.pt = int(pass_through)
+        ss = (self.tw + self.pt)
+        self.conv4a  = TrunkBlock(128, ss)
+        self.conv5a  = TrunkBlock(ss, ss)
+        self.conv6a  = TrunkBlock(ss, ss)
+        self.conv4b  = TrunkBlock(ss, ss)
+        self.conv5b  = TrunkBlock(ss, ss)
+        self.conv6b  = TrunkBlock(ss, self.tw)
+        ##
+        torch.nn.init.xavier_normal_(self.conv3.weight, gain=torch.nn.init.calculate_gain('relu'))        
+        torch.nn.init.constant_(self.conv3.bias, 0.0)
+        
+    def forward(self, x):
+        c3 = (torch.nn.functional.relu(self.conv3(self.drop1(self.bn1(x))), inplace=False))
+        c4a = self.conv4a(c3)
+        c4b = self.conv4b(c4a)
+        c5a = self.conv5a(self.pool1(c4b))
+        c5b = self.conv5b(c5a)
+        c6a = self.conv6a(c5b)
+        c6b = self.conv6b(c6a)
+
+        return [torch.cat([c3, c4a[:,:self.tw], c4b[:,:self.tw]], dim=1), 
+                torch.cat([c5a[:,:self.tw], c5b[:,:self.tw], c6a[:,:self.tw], c6b], dim=1)], c6b
+    
+#Subclass for GNET
+class GEncoder(nn.Module):
+    def __init__(self, mu, trunk_width, pass_through=64 ):
+        super(GEncoder, self).__init__()
+        self.mu = nn.Parameter(torch.from_numpy(mu), requires_grad=False) #.to(device)
+        self.pre = PreFilter()
+        self.enc = EncStage(trunk_width, pass_through) 
+
+    def forward(self, x):
+        fmaps, h = self.enc(self.pre(x - self.mu))
+        return x, fmaps, h
+
+#Main GNET model class
+class Torch_LayerwiseFWRF(nn.Module):
+    def __init__(self, fmaps, nv=1, pre_nl=None, post_nl=None, dtype=np.float32):
+        super(Torch_LayerwiseFWRF, self).__init__()
+        self.fmaps_shapes = [list(f.size()) for f in fmaps]
+        self.nf = np.sum([s[1] for s in self.fmaps_shapes])
+        self.pre_nl  = pre_nl
+        self.post_nl = post_nl
+        self.nv = nv
+        ##
+        self.rfs = []
+        self.sm = nn.Softmax(dim=1)
+        for k,fm_rez in enumerate(self.fmaps_shapes):
+            rf = nn.Parameter(torch.tensor(np.ones(shape=(self.nv, fm_rez[2], fm_rez[2]), dtype=dtype), requires_grad=True))
+            self.register_parameter('rf%d'%k, rf)
+            self.rfs += [rf,]
+        self.w  = nn.Parameter(torch.tensor(np.random.normal(0, 0.01, size=(self.nv, self.nf)).astype(dtype=dtype), requires_grad=True))
+        self.b  = nn.Parameter(torch.tensor(np.random.normal(0, 0.01, size=(self.nv,)).astype(dtype=dtype), requires_grad=True))
+        
+    def forward(self, fmaps):
+        phi = []
+        for fm,rf in zip(fmaps, self.rfs): #, self.scales):
+            g = self.sm(torch.flatten(rf, start_dim=1))
+            f = torch.flatten(fm, start_dim=2)  # *s
+            if self.pre_nl is not None:          
+                f = self.pre_nl(f)
+            # fmaps : [batch, features, space]
+            # v     : [nv, space]
+            phi += [torch.tensordot(g, f, dims=[[1],[2]]),] # apply pooling field and add to list.
+            # phi : [nv, batch, features] 
+        Phi = torch.cat(phi, dim=2)
+        if self.post_nl is not None:
+            Phi = self.post_nl(Phi)
+        vr = torch.squeeze(torch.bmm(Phi, torch.unsqueeze(self.w,2))).t() + torch.unsqueeze(self.b,0)
+        return vr
+    
+class GNet8_Encoder():
+    
+    def __init__(self, subject = 1, device = "cuda", model_path = "gnet_multisubject.pt"):
+        
+        # Setting up Cuda
+        self.device = torch.device(device)
+        torch.backends.cudnn.enabled=True
+        # Subject number
+        self.subject = subject
+        
+        # Vector type
+        self.vector = "images"
+        
+        # x size
+        subject_sizes = [0, 15724, 14278, 15226, 13153, 13039, 17907, 12682, 14386]
+        self.x_size = subject_sizes[self.subject]
+        
+        # Reload joined GNet model files
+        self.joined_checkpoint = torch.load(model_path, map_location=self.device)
+        
+        self.subjects = list(self.joined_checkpoint['voxel_mask'].keys())
+        self.gnet8j_voxel_mask = self.joined_checkpoint['voxel_mask']
+        self.gnet8j_voxel_roi  = self.joined_checkpoint['voxel_roi']
+        self.gnet8j_voxel_index= self.joined_checkpoint['voxel_index']
+        self.gnet8j_brain_nii_shape= self.joined_checkpoint['brain_nii_shape']
+        self.gnet8j_val_cc = self.joined_checkpoint['val_cc']
+        
+            
+    
+    def load_image(self, image_path):
+        
+        image = PIL.Image.open(image_path).convert('RGB')
+        
+        w, h = 227, 227  # resize to integer multiple of 64
+        imagePil = image.resize((w, h), resample=PIL.Image.Resampling.LANCZOS)
+        image = np.array(imagePil).astype(np.float32) / 255.0
+        
+        return image  
+    
+    # Rebuild Model
+    def _model_fn(self, _ext, _con, _x):
+        '''model consists of an extractor (_ext) and a connection model (_con)'''
+        _y, _fm, _h = _ext(_x)
+        return _con(_fm)
+
+    def _pred_fn(self, _ext, _con, xb):
+        return self._model_fn(_ext, _con, torch.from_numpy(xb).to(self.device))  
+                    
+    def subject_pred_pass(self, _pred_fn, _ext, _con, x, batch_size):
+        pred = _pred_fn(_ext, _con, x[:batch_size]) # this is just to get the shape
+        pred = np.zeros(shape=(len(x), pred.shape[1]), dtype=np.float32) # allocate
+        for rb,_ in utils.iterate_range(0, len(x), batch_size):
+            pred[rb] = utils.get_value(_pred_fn(_ext, _con, x[rb]))
+        return pred
+
+    def gnet8j_predictions(self, image_data, _pred_fn, trunk_width, pass_through, checkpoint, mask, batch_size, device=torch.device("cuda:0")):
+        
+        subjects = list(image_data.keys())
+
+        if(mask is None):
+            subject_nv = {s: len(v) for s,v in checkpoint['val_cc'].items()} 
+        else:
+            subject_nv = {s: len(v) for s,v in checkpoint['val_cc'].items()}    
+            subject_nv[subjects[0]] = int(torch.sum(mask == True)) 
+
+        # allocate
+        subject_image_pred = {s: np.zeros(shape=(len(image_data[s]), subject_nv[s]), dtype=np.float32) for s in subjects}
+        # print(subject_image_pred)
+        _log_act_fn = lambda _x: torch.log(1 + torch.abs(_x))*torch.tanh(_x)
+        
+        best_params = checkpoint['best_params']
+        # print(best_params)
+        shared_model = GEncoder(np.array(checkpoint['input_mean']).astype(np.float32), trunk_width=trunk_width, pass_through=pass_through).to(device)
+        shared_model.load_state_dict(best_params['enc'])
+        shared_model.eval() 
+
+        # example fmaps
+        rec, fmaps, h = shared_model(torch.from_numpy(image_data[list(image_data.keys())[0]][:20]).to(device))                                     
+        for s in subjects:
+            sd = Torch_LayerwiseFWRF(fmaps, nv=subject_nv[s], pre_nl=_log_act_fn, post_nl=_log_act_fn, dtype=np.float32).to(device) 
+            params = best_params['fwrfs'][s]
+            
+            if(mask is None):
+                sd.load_state_dict(params)
+            
+            else:
+                masked_params = {}
+                for key, value in params.items():
+                    masked_params[key] = value[mask]
+                    
+                sd.load_state_dict(masked_params)
+                
+            # print(params['w'].shape)
+            # print(params['b'].shape)
+            # sd.load_state_dict(best_params['fwrfs'][s])
+            sd.eval() 
+            # print(sd)
+            
+            subject_image_pred[s] = self.subject_pred_pass(_pred_fn, shared_model, sd, image_data[s], batch_size)
+
+        return subject_image_pred
+
+    def predict(self, images, mask = None):
+        self.stim_data = {}
+        data = []
+        w, h = 227, 227  # resize to integer multiple of 64
+        
+        if(isinstance(images, list)):
+            for i in range(len(images)):
+                
+                imagePil = images[i].convert("RGB").resize((w, h), resample=PIL.Image.Resampling.LANCZOS)
+                image = np.array(imagePil).astype(np.float32) / 255.0
+                data.append(image)
+            
+        elif(isinstance(images, torch.Tensor)):
+            for i in range(images.shape[0]):
+                
+                imagePil = utils.process_image(images[i], w, h)
+                image = np.array(imagePil).astype(np.float32) / 255.0
+                data.append(image)
+            
+        
+        self.stim_data[self.subject] = np.moveaxis(np.array(data), 3, 1)
+
+        gnet8j_image_pred = self.gnet8j_predictions(self.stim_data, self._pred_fn, 64, 192, self.joined_checkpoint, mask, batch_size=100, device=self.device)
+
+        return torch.from_numpy(gnet8j_image_pred[self.subject])

recon_inference-multisession.ipynb

@@ -0,0 +1,1689 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f16c9d4c-66cb-4692-a61d-9aa86a8765d0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "importing modules\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"importing modules\")\n",
+    "import os\n",
+    "import sys\n",
+    "import json\n",
+    "import argparse\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import random\n",
+    "import string\n",
+    "import h5py\n",
+    "from tqdm import tqdm\n",
+    "import webdataset as wds\n",
+    "from PIL import Image\n",
+    "import pandas as pd\n",
+    "import nibabel as nib\n",
+    "import nilearn\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "# tf32 data type is faster than standard float32\n",
+    "torch.backends.cuda.matmul.allow_tf32 = True\n",
+    "\n",
+    "import utils\n",
+    "from utils import load_preprocess_betas, resample, applyxfm, apply_thresh, resample_betas\n",
+    "\n",
+    "# this block imports utils from mindeye_preproc as \"preproc\"\n",
+    "import importlib.util\n",
+    "parent_utils_path = \"/home/ri4541/mindeye_preproc/analysis/utils.py\"\n",
+    "spec = importlib.util.spec_from_file_location(\"utils\", parent_utils_path)\n",
+    "preproc = importlib.util.module_from_spec(spec)\n",
+    "parent_dir = os.path.dirname(parent_utils_path)\n",
+    "if parent_dir not in sys.path:\n",
+    "    sys.path.append(parent_dir)\n",
+    "spec.loader.exec_module(preproc)\n",
+    "\n",
+    "if utils.is_interactive():\n",
+    "    from IPython.display import clear_output # function to clear print outputs in cell\n",
+    "    %load_ext autoreload \n",
+    "    # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n",
+    "    %autoreload 2 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "33a4a539-7c94-4447-b3a4-9208c6af7920",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LOCAL RANK  0\n",
+      "device: cuda\n"
+     ]
+    }
+   ],
+   "source": [
+    "from accelerate import Accelerator, DeepSpeedPlugin\n",
+    "from generative_models.sgm.models.diffusion import DiffusionEngine\n",
+    "from omegaconf import OmegaConf\n",
+    "\n",
+    "import os\n",
+    "### Multi-GPU config ###\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",
+    "accelerator = Accelerator(split_batches=False, mixed_precision=\"fp16\")\n",
+    "device = accelerator.device\n",
+    "print(\"device:\",device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d2d8de1-d0ca-4b5f-84d8-2560f0399a5a",
+   "metadata": {},
+   "source": [
+    "# Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84c47b5b-869f-468c-bb93-43610ee5dbe0",
+   "metadata": {},
+   "source": [
+    "## New Design"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "69037852-cdbd-4eac-a720-3fca5dc48a61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if utils.is_interactive():\n",
+    "    sub = \"sub-005\"\n",
+    "    session = \"ses-03\"\n",
+    "    task = 'C'  # 'study' or 'A'; used to search for functional run in bids format\n",
+    "else:\n",
+    "    sub = os.environ[\"sub\"]\n",
+    "    session = os.environ[\"session\"]\n",
+    "    task = os.environ[\"task\"]\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": 4,
+   "id": "2ece766e-4272-4ca3-81e9-9ea5dccd2279",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "session label: ses-03\n"
+     ]
+    }
+   ],
+   "source": [
+    "session_label = preproc.get_session_label(ses_list)\n",
+    "print('session label:', session_label)\n",
+    "n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model_name: sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0\n",
+      "glmsingle_path: /scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-03_task-C\n",
+      "glmsingle path exists!\n",
+      "--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2                     --glmsingle_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-03_task-C                     --model_name=sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0 --subj=1                     --no-blurry_recon --use_prior                     --hidden_dim=1024 --n_blocks=4\n",
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "# if running this interactively, can specify jupyter_args here for argparser to use\n",
+    "if utils.is_interactive():\n",
+    "    # model_name=f\"{sub}_{session}_task-{task}_bs24_MST_rishab_{train_test_split}split\"\n",
+    "    model_name = \"sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0\"\n",
+    "    print(\"model_name:\", model_name)\n",
+    "    glmsingle_path = f\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{session_label}_task-{task}\"\n",
+    "    print(\"glmsingle_path:\", glmsingle_path)\n",
+    "    assert os.path.exists(glmsingle_path)\n",
+    "    print(\"glmsingle path exists!\")\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 \\\n",
+    "                    --glmsingle_path={glmsingle_path} \\\n",
+    "                    --model_name={model_name} --subj=1 \\\n",
+    "                    --no-blurry_recon --use_prior \\\n",
+    "                    --hidden_dim=1024 --n_blocks=4\"\n",
+    "    \n",
+    "    print(jupyter_args)\n",
+    "    jupyter_args = jupyter_args.split()\n",
+    "    \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 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "49e5dae4-606d-4dc6-b420-df9e4c14737e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "parser = argparse.ArgumentParser(description=\"Model Training Configuration\")\n",
+    "parser.add_argument(\n",
+    "    \"--model_name\", type=str, default=\"testing\",\n",
+    "    help=\"will load ckpt for model found in ../train_logs/model_name\",\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--data_path\", type=str, default=\"/weka/proj-fmri/shared/mindeyev2_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",
+    "    \"--blurry_recon\",action=argparse.BooleanOptionalAction,default=True,\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",
+    "    \"--clip_scale\",type=float,default=1.,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--n_blocks\",type=int,default=4,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--hidden_dim\",type=int,default=2048,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--new_test\",action=argparse.BooleanOptionalAction,default=True,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seq_len\",type=int,default=1,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--seed\",type=int,default=42,\n",
+    ")\n",
+    "parser.add_argument(\n",
+    "    \"--glmsingle_path\",type=str,default=\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_ses-01\",\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",
+    "# make output directory\n",
+    "# os.makedirs(\"evals\",exist_ok=True)\n",
+    "# os.makedirs(f\"evals/{model_name}\",exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "34c1e0c6-0641-4239-8201-f2c676532302",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "csv/sub-005_ses-03.csv\n",
+      "(785, 126)\n",
+      "len_unique_images 532\n",
+      "n_runs 11\n",
+      "['all_stimuli/unchosen_nsd_1000_images/unchosen_7211_cocoid_59250.png'\n",
+      " 'all_stimuli/special515/special_67295.jpg'\n",
+      " 'all_stimuli/unchosen_nsd_1000_images/unchosen_5729_cocoid_53029.png'\n",
+      " 'all_stimuli/special515/special_70232.jpg']\n",
+      "[174.7109683 178.7049172 182.7072832 186.7297016]\n",
+      "[0. 0. 0. 0.]\n",
+      "(693,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "if session == \"all\":\n",
+    "    filename = f\"csv/{sub}_{ses_list[0]}.csv\"\n",
+    "    data = pd.read_csv(filename)[14:]\n",
+    "    print(filename)\n",
+    "    print(data.shape)\n",
+    "    for s in ses_list[1:]:\n",
+    "        filename = f\"csv/{sub}_{s}.csv\"\n",
+    "        print(filename)\n",
+    "        data = pd.concat([data, pd.read_csv(filename)[14:]])\n",
+    "        print(data.shape)\n",
+    "else:\n",
+    "    filename = f\"csv/{sub}_{session}.csv\"\n",
+    "    if sub == 'sub-001' and session == 'ses-01':\n",
+    "        data = pd.read_csv(filename)[23:]\n",
+    "    else: \n",
+    "        data = pd.read_csv(filename)[14:]\n",
+    "    print(filename)\n",
+    "    print(data.shape)\n",
+    "\n",
+    "image_names = data['current_image'].values\n",
+    "starts = data['trial.started'].values\n",
+    "is_new_run = data['is_new_run'].values\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",
+    "# unique_images = unique_images[(unique_images!=\"blank.jpg\")]\n",
+    "len_unique_images = len(unique_images)\n",
+    "print(\"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": 9,
+   "id": "dd08fa34-ebd0-482a-bc29-8fb32c8b888b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# unique_images_pairs = [\n",
+    "#     (1,2),(3,4),(5,6),(7,8),(9,10),(11,12),(13,14),(15,16),\n",
+    "#     (17,18),(19,20),(21,22),(23,24),(25,26),(27,28),(29,30),\n",
+    "#     (31,32),(33,34),(35,36),\n",
+    "#     (787, 788), (789, 790), (791, 792), (793, 794), (795, 796),\n",
+    "#     (797, 798), (799, 800), (801, 802), (803, 804), (805, 806),\n",
+    "#     (807, 808), (809, 810), (811, 812), (813, 814), (815, 816),\n",
+    "#     (817, 818), (819, 820), (821, 822), (823, 824), (825, 826),\n",
+    "#     (827, 828), (829, 830), (831, 832), (833, 834), (835, 836),\n",
+    "#     (837, 838), (839, 840), (841, 842), (843, 844), (845, 846),\n",
+    "#     (847, 848), (849, 850)\n",
+    "# ]\n",
+    "# unique_images[unique_images_pairs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "59bc3b21-e29d-4d2b-8223-cd704e3f058a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 1/693 [00:00<03:38,  3.16it/s]/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n",
+      "100%|██████████| 693/693 [00:33<00:00, 20.78it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "images torch.Size([693, 3, 224, 224])\n",
+      "MST_images 693\n",
+      "MST_images==True 124\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import imageio.v2 as imageio\n",
+    "resize_transform = transforms.Resize((224, 224))\n",
+    "MST_images = []\n",
+    "images = None\n",
+    "for im_name in tqdm(image_idx):\n",
+    "    if sub == 'sub-001' and session == 'ses-01':\n",
+    "        image_file = f\"all_stimuli/rtmindeye_stimuli/{unique_images[im_name]}\"\n",
+    "    else:\n",
+    "        image_file = f\"{unique_images[im_name]}\"\n",
+    "    im = imageio.imread(image_file)\n",
+    "    im = torch.Tensor(im / 255).permute(2,0,1)\n",
+    "    im = resize_transform(im.unsqueeze(0))\n",
+    "    if images is None:\n",
+    "        images = im\n",
+    "    else:\n",
+    "        images = torch.vstack((images, im))\n",
+    "    if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "        if ('w_' in image_file or 'paired_image_' in image_file or re.match(r'all_stimuli/rtmindeye_stimuli/\\d{1,2}_\\d{1,3}\\.png$', image_file) or re.match(r'all_stimuli/rtmindeye_stimuli/images/\\d{1,2}_\\d{1,3}\\.png$', image_file)):  \n",
+    "            MST_images.append(True)\n",
+    "        else:\n",
+    "            MST_images.append(False)\n",
+    "    else:   \n",
+    "        if (\"MST_pairs\" in image_file): # (\"_seed_\" not in unique_images[im_name]) and (unique_images[im_name] != \"blank.jpg\") \n",
+    "            MST_images.append(True)\n",
+    "        else:\n",
+    "            MST_images.append(False)\n",
+    "\n",
+    "print(\"images\", images.shape)\n",
+    "MST_images = np.array(MST_images)\n",
+    "print(\"MST_images\", len(MST_images))\n",
+    "if (sub == 'sub-001' and session == 'ses-04') or (sub == 'sub-003' and session == 'ses-01'):\n",
+    "    assert len(MST_images[MST_images==True]) == 100\n",
+    "print(\"MST_images==True\", len(MST_images[MST_images==True]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6f440a02-dd8a-4a13-9c90-bd07253f6910",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs = utils.find_paired_indices(image_idx)\n",
+    "pairs = sorted(pairs, key=lambda x: x[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c5f61515-d4fa-419b-b945-cdedc8f24669",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox (693, 1, 1, 183408)\n",
+      "vox (693, 183408)\n"
+     ]
+    }
+   ],
+   "source": [
+    "vox = None\n",
+    "needs_postprocessing = False\n",
+    "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n",
+    "\n",
+    "if resample_post_glmsingle == True:\n",
+    "    glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n",
+    "    if load_from_resampled_file == True:\n",
+    "        # resampling was done in this notebook so we can load from file\n",
+    "        vox = nib.load(glm_save_path_resampled)\n",
+    "    else:\n",
+    "        # do resampling here\n",
+    "        assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n",
+    "        vox = load_preprocess_betas(orig_glmsingle_path, *params)\n",
+    "        vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n",
+    "    needs_postprocessing = True\n",
+    "\n",
+    "if vox is None:\n",
+    "    # either resampling was done in glmsingle or we aren't resampling \n",
+    "    vox = load_preprocess_betas(glmsingle_path, *params)\n",
+    "\n",
+    "if needs_postprocessing == True:\n",
+    "    vox = apply_mask(vox, avg_mask)\n",
+    "    vox = vox.reshape(-1, vox.shape[-1])  # flatten the 3D image into np array with shape (voxels, images)\n",
+    "    print(vox.shape)\n",
+    "\n",
+    "assert len(vox) == len(image_idx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a4675ba2-b27c-48db-893c-d81f978ba93b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-03_task-C/sub-005_ses-03_task-C_brain.nii.gz\n",
+      "Mask dimensions: (2.0, 2.0, 2.0)\n",
+      "\n",
+      "Affine:\n",
+      "[[  2.           0.           0.         -76.29234314]\n",
+      " [  0.           2.           0.         -84.79180908]\n",
+      " [  0.           0.           2.         -62.80359268]\n",
+      " [  0.           0.           0.           1.        ]]\n",
+      "\n",
+      "There are 183408 voxels in the included brain mask\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from nilearn.plotting import plot_roi, plot_anat, plot_epi\n",
+    "\n",
+    "mask_name = f'{glmsingle_path}/{sub}_{session_label}{task_name}_brain'\n",
+    "if resample_voxel_size:\n",
+    "    if resample_post_glmsingle is True:\n",
+    "        # use original mask directory\n",
+    "        mask_in_name = f'{orig_glmsingle_path}/{sub}_{session}{task_name}_brain.nii.gz'\n",
+    "        mask_out_name = mask_name + f\"_{mask_resampled_suffix}.nii.gz\"\n",
+    "        assert os.path.exists(mask_in_name)\n",
+    "        applyxfm(mask_in_name, ref_name, omat_name, resample_method, output=mask_out_name)\n",
+    "        apply_thresh(mask_out_name, 0.5, output=mask_out_name)  # binarize the mask since resampling can result in non- 0 or 1 values\n",
+    "    mask_name += f\"_{mask_resampled_suffix}\"\n",
+    "\n",
+    "mask_name += \".nii.gz\"\n",
+    "print(mask_name)\n",
+    "avg_mask = nib.load(mask_name)\n",
+    "# mask info\n",
+    "dimsize=avg_mask.header.get_zooms()\n",
+    "affine_mat = avg_mask.affine\n",
+    "brain=avg_mask.get_fdata()\n",
+    "xyz=brain.shape #xyz dimensionality of brain mask and epi data\n",
+    "\n",
+    "print('Mask dimensions:', dimsize)\n",
+    "print('')\n",
+    "print('Affine:')\n",
+    "print(affine_mat)\n",
+    "print('')\n",
+    "print(f'There are {int(np.sum(brain))} voxels in the included brain mask\\n')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "8a5573cf-19b5-40e6-b21c-883e762f5f35",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-03_task-C/sub-005_ses-03_task-C_nsdgeneral.nii.gz\n",
+      "nsdgeneral path exists!\n"
+     ]
+    }
+   ],
+   "source": [
+    "nsdgeneral_path = f'{glmsingle_path}/{sub}_{session_label}{task_name}_nsdgeneral.nii.gz'  \n",
+    "print(nsdgeneral_path)\n",
+    "assert os.path.exists(nsdgeneral_path)\n",
+    "print(f\"nsdgeneral path exists!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "b940e5dc-ac25-4f48-9764-6030cf18ff1e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if resample_voxel_size:\n",
+    "    nsdgeneral_path = f'{glmsingle_path}/{sub}_task-{task}_nsdgeneral_resampled.nii.gz'  \n",
+    "    if resample_post_glmsingle:\n",
+    "        assert os.path.exists(orig_glmsingle_path)\n",
+    "        roi_in_path = f\"{orig_glmsingle_path}/{sub}_task-{task}_nsdgeneral.nii.gz\"  # the input file is the original nsdgeneral mask (without resampling), from the original glmsingle directory\n",
+    "        applyxfm(roi_in_path, ref_name, omat_name, resample_method, output=nsdgeneral_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "a3187c14-13df-4e51-915c-bb866eec413f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(76, 90, 74)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 660x350 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "roi = nib.load(nsdgeneral_path)\n",
+    "print(roi.shape)\n",
+    "plot_roi(roi, bg_img=avg_mask)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d906312b-ea5d-418d-8326-e8b395c9a9c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total voxels (whole brain) = 183408\n",
+      "nsdgeneral voxels = 19577\n"
+     ]
+    }
+   ],
+   "source": [
+    "avg_mask = avg_mask.get_fdata().flatten()\n",
+    "print(f\"total voxels (whole brain) = {int(avg_mask.sum())}\")\n",
+    "\n",
+    "roi = roi.get_fdata()\n",
+    "roi = roi.flatten()\n",
+    "roi = roi[avg_mask.astype(bool)]\n",
+    "roi[np.isnan(roi)] = 0\n",
+    "roi = roi.astype(bool)\n",
+    "print(f\"nsdgeneral voxels = {roi.sum()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ce12274a-3b35-444d-92b0-7cfd0949badc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "vox before ROI exclusion: (693, 183408)\n",
+      "vox after ROI exclusion: (693, 19577)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# ROI masking?\n",
+    "print(f\"vox before ROI exclusion: {vox.shape}\")\n",
+    "vox = vox[:,roi]\n",
+    "print(f\"vox after ROI exclusion: {vox.shape}\")\n",
+    "\n",
+    "if np.any(np.isnan(vox)):\n",
+    "    print(\"NaNs found! Removing voxels...\")\n",
+    "    x,y = np.where(np.isnan(vox))\n",
+    "    vox = vox[:,np.setdiff1d(np.arange(vox.shape[-1]), y)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "26802a5b-7bc8-4d47-b8e0-1dfa557fc6ad",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pairs_homog = np.array([[p[0], p[1]] for p in pairs])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "50d52f93-af1d-448d-92e4-5af8096aaaf2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 19302/19302 [00:01<00:00, 17349.27it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rels (19302,)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "vox_pairs = utils.zscore(vox[pairs_homog])\n",
+    "rels = np.full(vox.shape[-1],np.nan)\n",
+    "for v in tqdm(range(vox.shape[-1])):\n",
+    "    rels[v] = np.corrcoef(vox_pairs[:,0,v], vox_pairs[:,1,v])[1,0]\n",
+    "print(\"rels\", rels.shape)\n",
+    "assert np.sum(np.all(np.isnan(rels))) == 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "84be077b-fbef-4b23-895c-4928228229d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(162, 19302, 2)\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 162/162 [00:00<00:00, 3290.51it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# creating img x vox x repetitions matrix | shape=(150, 18419, 2)\n",
+    "vox0 = np.zeros((len(pairs_homog), vox.shape[-1], 2))\n",
+    "print(vox0.shape)\n",
+    "for ipair, pair in enumerate(tqdm(pairs_homog)):\n",
+    "    pair = pair[:2] # to keep things consistent, just using the first two repeats\n",
+    "    i,j = pair\n",
+    "    vox0[ipair, :, :] = vox[pair].T\n",
+    "vox_avg = vox0.mean(-1) # average across the repetitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "6206a31e-3d0a-4a30-ada2-4cffa1009856",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "vox before reliability thresholding: (1386, 19302)\n",
+      "\n",
+      "vox after reliability thresholding: (1386, 1053)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reliability thresholding?\n",
+    "print(f\"\\nvox before reliability thresholding: {vox.shape}\")\n",
+    "vox = vox[:,rels>.2]\n",
+    "print(f\"\\nvox after reliability thresholding: {vox.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "e6f632cc-2b26-4dc8-a4d5-12b641765601",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([1386, 3, 224, 224])\n",
+      "(1386, 1053)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(images.shape)\n",
+    "print(vox.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "735dfc27-a9bd-4a22-ac3f-a1f44515293e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1138 248\n"
+     ]
+    }
+   ],
+   "source": [
+    "utils.seed_everything(seed)\n",
+    "\n",
+    "# add_repeats = 48\n",
+    "# imageTrain = np.arange(len(images))\n",
+    "# train_image_indices = np.array([item for item in imageTrain if item not in pairs.flatten()])\n",
+    "# train_image_indices = np.sort(np.append(train_image_indices, np.array(pairs[:add_repeats].flatten())))\n",
+    "\n",
+    "# # check that there's no repeat indices in training data\n",
+    "# assert len(sorted(np.append(np.array([item for item in imageTrain if item not in pairs.flatten()]), np.array(pairs[:add_repeats].flatten())))) == len(set(sorted(np.append(np.array([item for item in imageTrain if item not in pairs.flatten()]), np.array(pairs[:add_repeats].flatten())))))\n",
+    "\n",
+    "# test_image_indices = pairs[add_repeats:]\n",
+    "# print(len(train_image_indices), len(test_image_indices))\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",
+    "elif train_test_split == 'MST':\n",
+    "    # non-MST images are the train split\n",
+    "    # MST images are the test split\n",
+    "    train_image_indices = np.where(MST_images==False)[0]\n",
+    "    test_image_indices = np.where(MST_images==True)[0]\n",
+    "    print(len(train_image_indices), len(test_image_indices))\n",
+    "    # for i in test_image_indices:\n",
+    "    #     assert i in pairs  # all MST images have pairs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "a292cfad-83f4-4bf8-994e-da2c871c0a6c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test_image_indices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "b81220cd-c11d-4a2a-8755-53b70d90cfe7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# repeats_in_test = []\n",
+    "# for p in pairs:\n",
+    "#     group = []\n",
+    "#     for item in p:\n",
+    "#         curr = np.where(test_image_indices == item)\n",
+    "#         if curr[0].size > 0:\n",
+    "#             group.append(curr[0][0])\n",
+    "#     # print(np.array(group))\n",
+    "#     if len(group) > 0:\n",
+    "#         repeats_in_test.append(np.array(group))\n",
+    "#     # if p[0] in test_image_indices:\n",
+    "#     #     repeats_in_test.append(p)\n",
+    "        \n",
+    "# repeats_in_test = np.array(repeats_in_test)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "5528d877-b662-41f7-8982-3f31051871f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "voxels have been zscored\n",
+      "-0.0318167 1.0120775\n",
+      "vox (1386, 1053)\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_mean = np.mean(vox[train_image_indices],axis=0)\n",
+    "train_std = np.std(vox[train_image_indices],axis=0)\n",
+    "\n",
+    "vox = utils.zscore(vox,train_mean=train_mean,train_std=train_std)\n",
+    "print(\"voxels have been zscored\")\n",
+    "print(vox[:,0].mean(), vox[:,0].std())\n",
+    "print(\"vox\", vox.shape)\n",
+    "\n",
+    "images = torch.Tensor(images)\n",
+    "vox = torch.Tensor(vox)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "1eb5d464-7ffa-419a-a6b4-d0108f8e196a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_data = torch.utils.data.TensorDataset(torch.tensor(test_image_indices))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8a3901c-60dd-4ae2-b0f5-8a55aa231908",
+   "metadata": {},
+   "source": [
+    "# Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "64672583-9f00-46f5-8d4e-00e4c7068a1d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded test dl for subj1!\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "subj_list = [subj]\n",
+    "subj = subj_list[0]\n",
+    "test_dl = torch.utils.data.DataLoader(test_data, batch_size=len(test_data), shuffle=False, drop_last=True, pin_memory=True)\n",
+    "print(f\"Loaded test dl for subj{subj}!\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "a3cbeea8-e95b-48d9-9bc2-91af260c93d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 248 248\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_voxels, test_images = None, None\n",
+    "for test_i, behav in enumerate(test_dl):\n",
+    "    behav = behav[0]\n",
+    "\n",
+    "    if behav.ndim>1:\n",
+    "        test_image = images[behav[:,0].long().cpu()].to(device)\n",
+    "        test_vox = vox[behav.long().cpu()].mean(1)\n",
+    "    else:\n",
+    "        test_image = images[behav.long().cpu()].to(device)\n",
+    "        test_vox = vox[behav.long().cpu()]\n",
+    "    \n",
+    "    if test_voxels is None:\n",
+    "        test_voxels = test_vox\n",
+    "        test_images = test_image\n",
+    "    else:\n",
+    "        test_voxels = torch.vstack((test_voxels, test_vox))\n",
+    "        test_images = torch.vstack((test_images, test_image))\n",
+    "\n",
+    "print(test_i, len(test_voxels), len(test_images))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "a3ae7a06-7135-4073-b315-59579e35e2a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_voxels_list = []\n",
+    "num_voxels_list.append(test_voxels.shape[-1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "de0400d4-cbd6-4941-a0b2-1a4bc2ae97da",
+   "metadata": {
+    "tags": []
+   },
+   "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",
+    "\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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "56b606a4-7302-4ac5-b89d-bbe4fcb00d11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "e452b5b2-47d9-4271-b9fc-ea331fbac1bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MindEyeModule()\n",
+      "param counts:\n",
+      "1,079,296 total\n",
+      "1,079,296 trainable\n",
+      "param counts:\n",
+      "1,079,296 total\n",
+      "1,079,296 trainable\n",
+      "param counts:\n",
+      "453,360,280 total\n",
+      "453,360,280 trainable\n",
+      "param counts:\n",
+      "454,439,576 total\n",
+      "454,439,576 trainable\n",
+      "param counts:\n",
+      "259,865,216 total\n",
+      "259,865,200 trainable\n",
+      "param counts:\n",
+      "714,304,792 total\n",
+      "714,304,776 trainable\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = utils.prepare_model_and_training(\n",
+    "    num_voxels_list=num_voxels_list,\n",
+    "    n_blocks=n_blocks,\n",
+    "    hidden_dim=hidden_dim,\n",
+    "    clip_emb_dim=clip_emb_dim,\n",
+    "    clip_seq_dim=clip_seq_dim,\n",
+    "    use_prior=use_prior,\n",
+    "    clip_scale=clip_scale\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f726f617-39f5-49e2-8d0c-d11d27d01c30",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n",
+      "WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# prep unCLIP\n",
+    "config = OmegaConf.load(\"/scratch/gpfs/ri4541/MindEyeV2/src/generative_models/configs/unclip6.yaml\")\n",
+    "config = OmegaConf.to_container(config, resolve=True)\n",
+    "unclip_params = config[\"model\"][\"params\"]\n",
+    "network_config = unclip_params[\"network_config\"]\n",
+    "denoiser_config = unclip_params[\"denoiser_config\"]\n",
+    "first_stage_config = unclip_params[\"first_stage_config\"]\n",
+    "conditioner_config = unclip_params[\"conditioner_config\"]\n",
+    "sampler_config = unclip_params[\"sampler_config\"]\n",
+    "scale_factor = unclip_params[\"scale_factor\"]\n",
+    "disable_first_stage_autocast = unclip_params[\"disable_first_stage_autocast\"]\n",
+    "offset_noise_level = unclip_params[\"loss_fn_config\"][\"params\"][\"offset_noise_level\"]\n",
+    "\n",
+    "first_stage_config['target'] = 'sgm.models.autoencoder.AutoencoderKL'\n",
+    "sampler_config['params']['num_steps'] = 38\n",
+    "\n",
+    "diffusion_engine = DiffusionEngine(network_config=network_config,\n",
+    "                       denoiser_config=denoiser_config,\n",
+    "                       first_stage_config=first_stage_config,\n",
+    "                       conditioner_config=conditioner_config,\n",
+    "                       sampler_config=sampler_config,\n",
+    "                       scale_factor=scale_factor,\n",
+    "                       disable_first_stage_autocast=disable_first_stage_autocast)\n",
+    "# set to inference\n",
+    "diffusion_engine.eval().requires_grad_(False)\n",
+    "diffusion_engine.to(device)\n",
+    "\n",
+    "ckpt_path = '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/unclip6_epoch0_step110000.ckpt' \n",
+    "ckpt = torch.load(ckpt_path, map_location='cpu')\n",
+    "diffusion_engine.load_state_dict(ckpt['state_dict'])\n",
+    "\n",
+    "batch={\"jpg\": torch.randn(1,3,1,1).to(device), # jpg doesnt get used, it's just a placeholder\n",
+    "      \"original_size_as_tuple\": torch.ones(1, 2).to(device) * 768,\n",
+    "      \"crop_coords_top_left\": torch.zeros(1, 2).to(device)}\n",
+    "out = diffusion_engine.conditioner(batch)\n",
+    "vector_suffix = out[\"vector\"].to(device)\n",
+    "print(\"vector_suffix\", vector_suffix.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68abd440-7e6b-4023-9dc8-05b1b5c0baa9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setup text caption networks\n",
+    "from transformers import AutoProcessor, AutoModelForCausalLM\n",
+    "from modeling_git import GitForCausalLMClipEmb\n",
+    "# processor = AutoProcessor.from_pretrained(\"microsoft/git-large-coco\")\n",
+    "# clip_text_model = GitForCausalLMClipEmb.from_pretrained(\"microsoft/git-large-coco\")\n",
+    "processor = AutoProcessor.from_pretrained(\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2\")\n",
+    "clip_text_model = GitForCausalLMClipEmb.from_pretrained(\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2\")\n",
+    "\n",
+    "clip_text_model.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4\n",
+    "clip_text_model.eval().requires_grad_(False)\n",
+    "clip_text_seq_dim = 257\n",
+    "clip_text_emb_dim = 1024\n",
+    "\n",
+    "class CLIPConverter(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(CLIPConverter, self).__init__()\n",
+    "        self.linear1 = nn.Linear(clip_seq_dim, clip_text_seq_dim)\n",
+    "        self.linear2 = nn.Linear(clip_emb_dim, clip_text_emb_dim)\n",
+    "    def forward(self, x):\n",
+    "        x = x.permute(0,2,1)\n",
+    "        x = self.linear1(x)\n",
+    "        x = self.linear2(x.permute(0,2,1))\n",
+    "        return x\n",
+    "        \n",
+    "clip_convert = CLIPConverter()\n",
+    "state_dict = torch.load(\"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/bigG_to_L_epoch8.pth\", map_location='cpu')['model_state_dict']\n",
+    "clip_convert.load_state_dict(state_dict, strict=True)\n",
+    "clip_convert.to(device) # if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4\n",
+    "del state_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "41b4a640",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load pretrained model ckpt\n",
+    "tag='last'\n",
+    "outdir = os.path.abspath(f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/{model_name}')\n",
+    "print(f\"\\n---loading {outdir}/{tag}.pth ckpt---\\n\")\n",
+    "checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu')\n",
+    "state_dict = checkpoint['model_state_dict']\n",
+    "model.load_state_dict(state_dict, strict=True)\n",
+    "del checkpoint\n",
+    "print(\"ckpt loaded!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "c6a706a3-d151-4643-bb34-7d08aa7361c8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/4 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1899d669587f464ba356a29615d5b8be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sampling loop time step:   0%|          | 0/19 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['a kitchen with a counter and a microwave.', 'a cat is sitting on a table.', 'a large room with a lot of furniture.', 'a giraffe standing next to a tree.', 'a room with a view.', 'a room with a lot of furniture.', 'a large field with a lot of grass.', 'a kitchen with a lot of furniture.', 'a large room with a lot of furniture.', 'a garden with a plant and a fence.', 'a kitchen with a lot of furniture.', 'a kitchen with a counter and a stove', 'a room with a view', 'a plate with a cake on it', 'a snowboarder is skiing down a hill.', 'a clock on a building.', 'a young boy is standing in a pool of water.', 'a bed or beds in a room at the inn', 'a large building with a clock on it.', 'a room with a lot of furniture.', 'a table with a bunch of items on it', 'a tree with a lot of leaves.', 'a night view of a city.', 'a white wall', 'a large building with a clock on it.', 'a large group of people.', 'a small room with a clock and a vase.', 'a large truck is parked next to a building.', 'a room with a view.', 'a table with a lot of items on it', 'a picture of a room with a lot of things in it.', 'a room with a lot of furniture.']\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/utils/checkpoint.py:429: UserWarning: torch.utils.checkpoint: please pass in use_reentrant=True or use_reentrant=False explicitly. The default value of use_reentrant will be updated to be False in the future. To maintain current behavior, pass use_reentrant=True. It is recommended that you use use_reentrant=False. Refer to docs for more details on the differences between the two variants.\n",
+      "  warnings.warn(\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torch/utils/checkpoint.py:61: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n",
+      "  warnings.warn(\n",
+      " 25%|██▌       | 1/4 [02:21<07:04, 141.65s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_rishab_MSTsplit\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a0628499d46941cf9f65527d8eb5d525",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sampling loop time step:   0%|          | 0/19 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['a train is driving through a field.', 'a cat sitting on a table.', 'a zebra standing in a field.', 'a plate of food', 'a car driving down a street.', 'a large field with a bunch of people on it', 'a man on a boat in a lake.', 'a view of a table.', 'a large area with a lot of grass.', 'a display of a cell phone.', 'a bunch of different types of flowers', 'a large open area with a lot of space for a small table.', 'a room with a lot of furniture.', 'a large planter with a bunch of flowers on it.', 'a bathroom with a shower and a sink.', 'a large body of water.', 'a street light and a street sign', 'a plate with a piece of food on it', 'a room with a view', 'a bunch of flowers on a table.', 'a small table with a small display.', 'a glass door with a window.', 'a stuffed toy bear is sitting on a table.', 'a small tree in a field.', 'a plate of food with a fork.', 'a snowboarder is on a hill.', 'a room with a lot of furniture.', 'a bathroom with a toilet and a sink.', 'a table with a bunch of food on it', 'a small white and black wall', 'a person sitting down.', 'a clock tower with a clock on it.']\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 50%|█████     | 2/4 [04:42<04:42, 141.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_rishab_MSTsplit\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "518fa75876214f5f857ebdb9c0c9da3c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sampling loop time step:   0%|          | 0/19 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['a man on a surfboard in the water.', 'a woman standing on a sidewalk next to a water.', 'a table with a plate and a plate on it', 'a large truck is parked on the side of the road.', 'a clock tower with a tower in the background.', 'a room with a lot of furniture.', 'a white wall with a window', 'a glass door with a window.', 'a picture of a tree.', 'a view of a large room.', 'a grassy field with a few animals in it.', 'a white wall', 'a plate of food with a fork.', 'a plate with a piece of food on it', 'a clock tower with a tower in the background.', 'a clock tower with a tower in the background.', 'a room with a view.', 'a laptop computer sitting on top of a table.', 'a zebra standing on a dirt field.', 'a surfer riding a wave on a sunny day.', 'a toilet with a lid', 'a room with a table and chairs.', 'a kitchen with a sink and a counter', 'a bathroom with a sink and a mirror.', \"a close up of a person's head\", 'a group of animals standing on a field.', 'a white table with a glass top', 'a white room with a toilet and a sink', 'a plate of food with a fork on it.', 'a picture of a large group of trees.', 'a table with a plate of food on it', 'a kitchen with a counter and a sink.']\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 75%|███████▌  | 3/4 [07:04<02:21, 141.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_rishab_MSTsplit\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "40c339474faf47bc9795754130e0060b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sampling loop time step:   0%|          | 0/19 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['a room with a bed and a television.', 'a large building with a clock on it.', 'a man on a surfboard in the water.', 'a train is driving down the tracks.']\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 4/4 [07:22<00:00, 110.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sub-001_ses-01_bs24_MST_rishab_MSTsplit\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "/home/ri4541/.conda/envs/rt_mindEye2/lib/python3.11/site-packages/torchvision/transforms/functional.py:1603: UserWarning: The default value of the antialias parameter of all the resizing transforms (Resize(), RandomResizedCrop(), etc.) will change from None to True in v0.17, in order to be consistent across the PIL and Tensor backends. To suppress this warning, directly pass antialias=True (recommended, future default), antialias=None (current default, which means False for Tensors and True for PIL), or antialias=False (only works on Tensors - PIL will still use antialiasing). This also applies if you are using the inference transforms from the models weights: update the call to weights.transforms(antialias=True).\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "saved sub-001_ses-01_bs24_MST_rishab_MSTsplit outputs!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get all reconstructions\n",
+    "model.to(device)\n",
+    "model.eval().requires_grad_(False)\n",
+    "\n",
+    "all_blurryrecons = None\n",
+    "all_images = None\n",
+    "all_recons = None\n",
+    "all_predcaptions = []\n",
+    "all_clipvoxels = None\n",
+    "all_prior_out = None\n",
+    "all_backbones = None\n",
+    "\n",
+    "minibatch_size = 32\n",
+    "num_samples_per_image = 1\n",
+    "plotting = True\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for batch in tqdm(range(0,len(test_images),minibatch_size)):\n",
+    "        start_time = time.time() \n",
+    "\n",
+    "        image = test_images[batch:batch+minibatch_size]\n",
+    "        voxel = test_voxels[batch:batch+minibatch_size].unsqueeze(1).to(device)\n",
+    "\n",
+    "        # Save ground truth images\n",
+    "        if all_images is None:\n",
+    "            all_images = image\n",
+    "        else:\n",
+    "            all_images = torch.vstack((all_images, image))\n",
+    "        \n",
+    "        voxel_ridge = model.ridge(voxel,0)\n",
+    "        backbone, clip_voxels, blurry_image_enc_ = model.backbone(voxel_ridge)\n",
+    "                \n",
+    "        # Save retrieval submodule outputs\n",
+    "        if clip_scale>0:\n",
+    "            if all_clipvoxels is None:\n",
+    "                all_clipvoxels = clip_voxels.cpu()\n",
+    "            else:\n",
+    "                all_clipvoxels = torch.vstack((all_clipvoxels, clip_voxels.cpu()))\n",
+    "                \n",
+    "        # Feed voxels through OpenCLIP-bigG diffusion prior\n",
+    "        prior_out = model.diffusion_prior.p_sample_loop(backbone.shape, \n",
+    "                        text_cond = dict(text_embed = backbone), \n",
+    "                        cond_scale = 1., timesteps = 20).cpu()\n",
+    "        \n",
+    "        if all_prior_out is None:\n",
+    "            all_prior_out = prior_out\n",
+    "        else:\n",
+    "            all_prior_out = torch.vstack((all_prior_out, prior_out))\n",
+    "\n",
+    "        pred_caption_emb = clip_convert(prior_out.to(device).float())\n",
+    "        generated_ids = clip_text_model.generate(pixel_values=pred_caption_emb, max_length=20)\n",
+    "        generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)\n",
+    "        all_predcaptions = np.hstack((all_predcaptions, generated_caption))\n",
+    "        print(generated_caption)\n",
+    "        \n",
+    "        # Feed diffusion prior outputs through unCLIP\n",
+    "        if plotting:\n",
+    "            jj=-1\n",
+    "            fig, axes = plt.subplots(1, 12, figsize=(10, 4))\n",
+    "\n",
+    "        for i in range(len(voxel)):\n",
+    "            samples = utils.unclip_recon(prior_out[[i]],\n",
+    "                             diffusion_engine,\n",
+    "                             vector_suffix,\n",
+    "                             num_samples=num_samples_per_image)\n",
+    "            if all_recons is None:\n",
+    "                all_recons = samples.cpu()\n",
+    "            else:\n",
+    "                all_recons = torch.vstack((all_recons, samples.cpu()))\n",
+    "                \n",
+    "            if plotting:  \n",
+    "                jj+=1\n",
+    "                axes[jj].imshow(utils.torch_to_Image(image[i]))\n",
+    "                axes[jj].axis('off')\n",
+    "                jj+=1\n",
+    "                axes[jj].imshow(utils.torch_to_Image(samples.cpu()[0]))\n",
+    "                axes[jj].axis('off')\n",
+    "        \n",
+    "        plt.show()\n",
+    "\n",
+    "        print(model_name)\n",
+    "        # err # dont actually want to run the whole thing with plotting=True\n",
+    "\n",
+    "# resize outputs before saving\n",
+    "imsize = 256\n",
+    "all_images = transforms.Resize((imsize,imsize))(all_images).float()\n",
+    "all_recons = transforms.Resize((imsize,imsize))(all_recons).float()\n",
+    "if blurry_recon: \n",
+    "    all_blurryrecons = transforms.Resize((imsize,imsize))(all_blurryrecons).float()\n",
+    "        \n",
+    "## Saving ##\n",
+    "if not os.path.exists(eval_dir):\n",
+    "    os.mkdir(eval_dir)\n",
+    "\n",
+    "if \"MST\" in model_name:\n",
+    "    np.save(f\"{eval_dir}/{model_name}_MST_ID.npy\", MST_ID)\n",
+    "torch.save(all_images.cpu(),f\"{eval_dir}/{model_name}_all_images.pt\")\n",
+    "\n",
+    "# repeats_in_test = []\n",
+    "# for p in pairs:\n",
+    "#     if p[0] in test_image_indices:\n",
+    "#         repeats_in_test.append(p)\n",
+    "        \n",
+    "# repeats_in_test = np.array(repeats_in_test)\n",
+    "\n",
+    "# torch.save(test_image_indices, f\"{eval_dir}/{model_name}_test_image_indices.pt\")\n",
+    "# torch.save(repeats_in_test, f\"{eval_dir}/{model_name}_repeats_in_test.pt\")\n",
+    "torch.save(all_recons,f\"{eval_dir}/{model_name}_all_recons.pt\")\n",
+    "if clip_scale>0:\n",
+    "    torch.save(all_clipvoxels,f\"{eval_dir}/{model_name}_all_clipvoxels.pt\")\n",
+    "torch.save(all_prior_out,f\"{eval_dir}/{model_name}_all_prior_out.pt\")\n",
+    "torch.save(all_predcaptions,f\"{eval_dir}/{model_name}_all_predcaptions.pt\")\n",
+    "print(f\"saved {model_name} outputs!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "73b243d7-6552-4fc8-bef7-d5ad03b17cb2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if \"MST\" in model_name:\n",
+    "    np.save(f\"{eval_dir}/{model_name}_MST_ID.npy\", MST_ID)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c6856c3-9205-48f5-bfb2-7e0099f429a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_images.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9a7162f-ca3b-4b14-9676-3037094994c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = torch.permute(all_images, (0,2,3,1))\n",
+    "y = torch.permute(all_recons, (0,2,3,1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7fa41429-ab6a-4aa6-96b9-5c963016b33a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(5, 2, figsize=(8, 8))\n",
+    "for row, _ in enumerate(ax):\n",
+    "    ax[row][0].imshow(x.cpu()[row])\n",
+    "    ax[row][1].imshow(y.cpu()[row])\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d553a7b3-9bdf-44b3-a0bf-398cf5cf402b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rt_mindEye2 [~/.conda/envs/rt_mindEye2/]",
+   "language": "python",
+   "name": "conda_rt_mindeye2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

run_all_batch.slurm

@@ -0,0 +1,109 @@
+#!/bin/bash
+#SBATCH --job-name=sub-005_ses-01-02_task-C_finetune_rtpreproc_unionmask
+#SBATCH --ntasks-per-node=1
+#SBATCH --nodes=1              
+#SBATCH --gres=gpu:1
+#SBATCH --constraint=gpu80
+#SBATCH --gpus-per-task=1       # Set to equal gres=gpu:#!
+#SBATCH --cpus-per-task=1      # 40 / 80 / 176 distributed across node
+#SBATCH --time=02:35:00         # total run time limit (HH:MM:SS)
+#SBATCH -e slurms/%A_%a.err     # first create a "slurms" folder in current directory to store logs
+#SBATCH -o slurms/%A_%a.out
+#SBATCH --no-requeue
+#SBATCH --array=0               # 0 or 0-9
+#SBATCH --mail-type=END
+#SBATCH [email protected]
+
+echo "My SLURM_ARRAY_JOB_ID is ${SLURM_ARRAY_JOB_ID}"
+echo "My SLURM_ARRAY_TASK_ID is ${SLURM_ARRAY_TASK_ID}"
+echo "Executing on the machine: $(hostname)"
+
+module purge
+module load anaconda3/2023.3
+module load fsl/6.0.6.2
+conda activate rt_mindEye2
+# source /scratch/gpfs/ri4541/MindEyeV2/src/fmri/bin/activate
+
+# verify these variables before submitting
+# ---
+sub="sub-005"
+session="all"
+session_label='ses-01-02'
+split=MST  # MST train/test split, alternative would be train on non-repeats and test on images that repeat (split=orig) 
+task=C
+func_task_name=C
+resample_voxel_size=False
+resample_post_glmsingle=False
+load_from_resampled_file=True
+remove_close_to_MST=False
+remove_random_n=False
+resampled_vox_size=2.0
+resample_method="trilinear"
+# Convert decimal point to underscore
+vox_dim_str=${resampled_vox_size//./_}
+
+# model_name="${sub}_multi_task-${task}_bs24_MST_rishab_${split}split"
+model_name="${sub}_${session}_task-${task}_bs24_MST_rishab_${split}split_finetune_rtpreproc_unionmask"
+# model_name="${sub}_${session}_task-${task}_bs24_MST_rishab_${split}split_resampled_${vox_dim_str}mm_${resample_method}_seed${SLURM_ARRAY_TASK_ID}"
+main_script="main-finetune-rt-preproc"
+# glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle-multi"
+glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_${sub}_${session_label}_task-${task}"
+# --- 
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) 
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+echo model_name=${model_name}
+
+eval_dir="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}"
+export SUB=${sub}
+export SESSION=${session}
+export SESSION_LABEL=${session_label}
+export SPLIT=${split}
+export TASK=${task}
+export FUNC_TASK_NAME=${func_task_name}
+export RESAMPLE_VOXEL_SIZE=${resample_voxel_size}
+export RESAMPLE_POST_GLMSINGLE=${resample_post_glmsingle}
+export LOAD_FROM_RESAMPLED_FILE=${load_from_resampled_file}
+export REMOVE_CLOSE_TO_MST=${remove_close_to_MST}
+export REMOVE_RANDOM_N=${remove_random_n}
+export RESAMPLED_VOX_SIZE=${resampled_vox_size}
+export RESAMPLE_METHOD=${resample_method}
+
+export glmsingle_path=${glmsingle_path}
+export eval_dir=${eval_dir}
+export WANDB_MODE="offline"
+
+# singlesubject finetuning
+jupyter nbconvert "${main_script}.ipynb" --to python && \
+accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT "${main_script}.py" --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep --seed="${SLURM_ARRAY_TASK_ID}" && \
+
+# jupyter nbconvert recon_inference-multisession.ipynb --to python && \
+# python recon_inference-multisession.py --model_name=${model_name} --subj=1 --no-blurry_recon --use_prior --hidden_dim=1024 --n_blocks=4 --glmsingle_path="${glmsingle_path}" && \
+
+# #jupyter nbconvert recon_inference_orig.ipynb --to python && \
+# #python recon_inference_orig.py --model_name=${model_name} --subj=1 --no-blurry_recon --use_prior --hidden_dim=1024 --n_blocks=4 && \ 
+
+# jupyter nbconvert enhanced_recon_inference.ipynb --to python && \
+# python enhanced_recon_inference.py --model_name=${model_name} --all_recons_path=${eval_dir}/${model_name}_all_recons.pt && \
+
+# #jupyter nbconvert enhanced_recon_inference_orig.ipynb --to python && \
+# #python enhanced_recon_inference_orig.py --model_name=${model_name} && \
+
+# jupyter nbconvert final_evaluations.ipynb --to python && \
+# python final_evaluations.py --model_name=${model_name} --all_recons_path=${eval_dir}/all_enhancedrecons.pt --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --eval_dir=${eval_dir} && \
+
+#jupyter nbconvert final_evaluations_orig.ipynb --to python && \
+#python final_evaluations_orig.py --model_name=${model_name} --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}/${model_name}_all_recons.pt --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --eval_dir=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}
+
+echo "Remember to sync wandb logs with online node!"

run_all_nb.slurm

@@ -0,0 +1,64 @@
+#!/bin/bash
+#SBATCH --job-name=ses-01_old
+#SBATCH --ntasks-per-node=1
+#SBATCH --nodes=1              
+#SBATCH --gres=gpu:1
+##SBATCH --constraint=gpu80
+#SBATCH --gpus-per-task=1       # Set to equal gres=gpu:#!
+#SBATCH --cpus-per-task=40      # 40 / 80 / 176 distributed across node
+#SBATCH --time=00:20:00         # total run time limit (HH:MM:SS)
+#SBATCH -e slurms/%j.err        # first create a "slurms" folder in current directory to store logs
+#SBATCH -o slurms/%j.out
+#SBATCH --no-requeue
+#SBATCH --array=0               # 0-9
+#SBATCH --mail-type=END
+#SBATCH [email protected]
+
+echo "My SLURM_ARRAY_JOB_ID is ${SLURM_ARRAY_JOB_ID}"
+echo "My SLURM_ARRAY_TASK_ID is ${SLURM_ARRAY_TASK_ID}"
+echo "Executing on the machine: $(hostname)"
+
+module purge
+module load anaconda3/2023.3
+conda activate rt_mindEye2
+#source /scratch/gpfs/ri4541/MindEyeV2/src/fmri/bin/activate
+
+# verify these variables before submitting
+# ---
+sub=sub-001
+session=ses-01
+split=MST  # MST train/test split, alternative would be train on non-repeats and test on images that repeat (split=orig) 
+model_name=${sub}_${session}_bs24_MST_rishab_${split}split_old
+main_script='main-multisession_old'
+# --- 
+
+jupyter nbconvert "${main_script}.ipynb" --to python
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+# Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) 
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+# singlesubject finetuning
+echo model_name=${model_name}
+#accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT "${main_script}.py" --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep && \
+
+#jupyter nbconvert recon_inference-multisession-simple.ipynb --to python && \
+#python recon_inference-multisession-simple.py --model_name=${model_name} --subj=1 --no-blurry_recon --use_prior --hidden_dim=1024 --n_blocks=4 --glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_${session}" && \
+
+#jupyter nbconvert recon_inference-multisession.ipynb --to python && \
+#python recon_inference-multisession.py --model_name=${model_name} --subj=1 --no-blurry_recon --use_prior --hidden_dim=1024 --n_blocks=4 --glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_${session}_paul" && \
+
+jupyter nbconvert enhanced_recon_inference.ipynb --to python && \
+python enhanced_recon_inference.py --model_name=${model_name} --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}/${model_name}_all_recons.pt && \
+
+jupyter nbconvert final_evaluations.ipynb --to python && \
+python final_evaluations.py --model_name=${model_name} --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}/all_enhancedrecons.pt --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --eval_dir=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}

run_all_workstation.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+echo "Executing on the machine: $(hostname)"
+
+module purge
+source ~/rt_mindeye/bin/activate
+
+# verify these variables before submitting
+# ---
+sub=sub-001
+session=ses-01
+split=MST  # MST train/test split, alternative would be train on non-repeats and test on images that repeat (split=orig)
+model_name="${sub}_${session}_bs24_MST_rishab_${split}split"
+main_script='main-multisession'
+# ---
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000))
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+echo model_name=${model_name}
+
+# singlesubject finetuning
+jupyter nbconvert "${main_script}.ipynb" --to python && \
+accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT "${main_script}.py" --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep --seed="${SLURM_ARRAY_TASK_ID}" && \
+
+jupyter nbconvert recon_inference-multisession.ipynb --to python && \
+python recon_inference-multisession.py --model_name=${model_name} --subj=1 --no-blurry_recon --use_prior --hidden_dim=1024 --n_blocks=4 --glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_${session}_paul" && \
+
+jupyter nbconvert enhanced_recon_inference.ipynb --to python && \
+python enhanced_recon_inference.py --model_name=${model_name} --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}/${model_name}_all_recons.pt && \
+
+jupyter nbconvert final_evaluations.ipynb --to python && \
+python final_evaluations.py --model_name=${model_name} --all_recons_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}/all_enhancedrecons.pt --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --eval_dir=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}

run_main_finetune.slurm

@@ -0,0 +1,90 @@
+#!/bin/bash
+#SBATCH --job-name=sub-005_ses-01-03_finetune_unionmask
+#SBATCH --ntasks-per-node=1
+#SBATCH --nodes=1              
+#SBATCH --gres=gpu:1
+#SBATCH --constraint=gpu80
+#SBATCH --gpus-per-task=1       # Set to equal gres=gpu:#!
+#SBATCH --cpus-per-task=40      # 40 / 80 / 176 distributed across node
+#SBATCH --time=02:35:00         # total run time limit (HH:MM:SS)
+#SBATCH -e slurms/%A_%a.err     # first create a "slurms" folder in current directory to store logs
+#SBATCH -o slurms/%A_%a.out
+#SBATCH --no-requeue
+#SBATCH --array=0               # 0 or 0-9
+#SBATCH --mail-type=END
+#SBATCH [email protected]
+
+echo "My SLURM_ARRAY_JOB_ID is ${SLURM_ARRAY_JOB_ID}"
+echo "My SLURM_ARRAY_TASK_ID is ${SLURM_ARRAY_TASK_ID}"
+echo "Executing on the machine: $(hostname)"
+
+module purge
+module load anaconda3/2023.3
+module load fsl/6.0.6.2
+conda activate rt_mindEye2
+# source /scratch/gpfs/ri4541/MindEyeV2/src/fmri/bin/activate
+
+# verify these variables before submitting
+# ---
+sub="sub-005"
+session="all"
+session_label='ses-01-03'
+split=MST  # MST train/test split, alternative would be train on non-repeats and test on images that repeat (split=orig) 
+task=C
+func_task_name=C
+# resample_voxel_size=True
+# resample_post_glmsingle=False
+# load_from_resampled_file=True
+# remove_close_to_MST=False
+# remove_random_n=False
+# resampled_vox_size=2.0
+# resample_method="trilinear"
+# # Convert decimal point to underscore
+# vox_dim_str=${resampled_vox_size//./_}
+
+# model_name="${sub}_multi_task-${task}_bs24_MST_rishab_${split}split"
+model_name="${sub}_${session_label}_task-${task}_bs24_MST_rishab_${split}split_unionmask_ses-01-03_finetune"
+main_script="main-finetune"
+# glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle-multi"
+glmsingle_path="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_${sub}_${session_label}_task-${task}"
+# --- 
+
+export NUM_GPUS=1  # Set to equal gres=gpu:#!
+export BATCH_SIZE=24
+export GLOBAL_BATCH_SIZE=$((BATCH_SIZE * NUM_GPUS))
+
+Make sure another job doesnt use same port, here using random number
+export MASTER_PORT=$((RANDOM % (19000 - 11000 + 1) + 11000)) 
+export HOSTNAMES=$(scontrol show hostnames "$SLURM_JOB_NODELIST")
+export MASTER_ADDR=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)
+export COUNT_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | wc -l)
+echo MASTER_ADDR=${MASTER_ADDR}
+echo MASTER_PORT=${MASTER_PORT}
+echo WORLD_SIZE=${COUNT_NODE}
+
+echo model_name=${model_name}
+
+eval_dir="/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals/${model_name}"
+export sub=${sub}
+export session=${session}
+export session_label=${session_label}
+export SPLIT=${split}
+export task=${task}
+export FUNC_TASK_NAME=${func_task_name}
+export RESAMPLE_VOXEL_SIZE=${resample_voxel_size}
+export RESAMPLE_POST_GLMSINGLE=${resample_post_glmsingle}
+export LOAD_FROM_RESAMPLED_FILE=${load_from_resampled_file}
+export REMOVE_CLOSE_TO_MST=${remove_close_to_MST}
+export REMOVE_RANDOM_N=${remove_random_n}
+export RESAMPLED_VOX_SIZE=${resampled_vox_size}
+export RESAMPLE_METHOD=${resample_method}
+
+export glmsingle_path=${glmsingle_path}
+export eval_dir=${eval_dir}
+export WANDB_MODE="offline"
+
+# singlesubject finetuning
+jupyter nbconvert "${main_script}.ipynb" --to python && \
+accelerate launch --num_processes=$(($NUM_GPUS * $COUNT_NODE)) --num_machines=$COUNT_NODE --main_process_ip=$MASTER_ADDR --main_process_port=$MASTER_PORT "${main_script}.py" --data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --model_name=${model_name} --no-multi_subject --subj=1 --batch_size=${BATCH_SIZE} --max_lr=3e-4 --mixup_pct=.33 --num_epochs=150 --use_prior --prior_scale=30 --clip_scale=1 --no-blurry_recon --blur_scale=.5 --no-use_image_aug --n_blocks=4 --hidden_dim=1024 --num_sessions=40 --ckpt_interval=999 --ckpt_saving --wandb_log --multisubject_ckpt=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/train_logs/multisubject_subj01_1024hid_nolow_300ep --seed="${SLURM_ARRAY_TASK_ID}" && \
+
+echo "Remember to sync wandb logs with online node!"

unit_test.py

@@ -0,0 +1,234 @@
+import numpy as np
+import pytest
+from utils import filter_and_average_mst, verify_image_patterns, compute_vox_rels, compute_avg_repeat_corrs
+
+# === filter_and_average_mst tests ===
+
+def test_no_mst_images():
+    vox = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    vox_image_dict = {0: 'image1.jpg', 1: 'image2.jpg', 2: 'image3.jpg'}
+    
+    filtered_vox, kept_indices = filter_and_average_mst(vox, vox_image_dict)
+    
+    np.testing.assert_array_equal(filtered_vox, vox)
+    np.testing.assert_array_equal(kept_indices, [0, 1, 2])
+
+def test_single_mst_image_set():
+    vox = np.array([[1,2,3], [4,5,6], [7,8,9], [10,11,12]])
+    vox_image_dict = {0: 'image1.jpg', 1: 'MST_pairs/image2.jpg', 2: 'image3.jpg', 3: 'MST_pairs/image2.jpg'}
+    
+    filtered_vox, kept_indices = filter_and_average_mst(vox, vox_image_dict)
+    
+    expected_vox = np.array([[1,2,3], [7,8,9], [7,8,9]])
+    expected_indices = [0, 1, 2]
+    
+    np.testing.assert_array_equal(filtered_vox, expected_vox)
+    np.testing.assert_array_equal(kept_indices, expected_indices)
+
+def test_multiple_mst_image_sets():
+    vox = np.array([[1,2,3], [4,5,6], [7,8,9], [7,8,9], [10,11,12], [12,15,12]])
+    vox_image_dict = {
+        0: 'image1.jpg', 
+        1: 'MST_pairs/image2.jpg', 
+        2: 'image3.jpg', 
+        3: 'MST_pairs/image2.jpg', 
+        4: 'MST_pairs/image4.jpg', 
+        5: 'MST_pairs/image4.jpg'
+    }
+    
+    filtered_vox, kept_indices = filter_and_average_mst(vox, vox_image_dict)
+    
+    expected_vox = np.array([[1,2,3], [5.5, 6.5, 7.5], [7,8,9], [11,13,12]])
+    expected_indices = [0, 1, 2, 4]
+    
+    np.testing.assert_array_equal(filtered_vox, expected_vox)
+    np.testing.assert_array_equal(kept_indices, expected_indices)
+
+def test_empty_input():
+    vox = np.array([])
+    vox_image_dict = {}
+    
+    filtered_vox, kept_indices = filter_and_average_mst(vox, vox_image_dict)
+    
+    assert len(filtered_vox) == 0
+    assert len(kept_indices) == 0
+
+def test_input_shape():
+    vox = np.random.rand(5, 3)
+    vox_image_dict = {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}
+    
+    filtered_vox, _ = filter_and_average_mst(vox, vox_image_dict)
+    
+    assert filtered_vox.shape[1] == vox.shape[1]
+
+
+# === verify_image_patterns tests ===
+
+def test_valid_special515():
+    image_to_indices = {
+        "all_stimuli/special515/image1.jpg": [[1, 2, 3], []],
+        "all_stimuli/special515/image2.jpg": [[], [10, 11, 12]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert failures == []
+
+def test_invalid_special515():
+    image_to_indices = {
+        "all_stimuli/special515/image1.jpg": [[1, 2], []],
+        "all_stimuli/special515/image2.jpg": [[1, 2], [3]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert len(failures) == 2
+
+def test_valid_MST_pairs():
+    image_to_indices = {
+        "all_stimuli/MST_pairs/image1.png": [[4, 5], [6, 7]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert failures == []
+
+def test_invalid_MST_pairs():
+    image_to_indices = {
+        "all_stimuli/MST_pairs/image1.png": [[4, 5, 6], [7]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert len(failures) == 1
+
+def test_valid_other_images():
+    image_to_indices = {
+        "all_stimuli/other/image1.png": [[123], []],
+        "all_stimuli/other/image2.png": [[], [456]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert failures == []
+
+def test_invalid_other_images():
+    image_to_indices = {
+        "all_stimuli/other/image1.png": [[123, 124], []],
+        "all_stimuli/other/image2.png": [[123], [456]],
+    }
+    failures = verify_image_patterns(image_to_indices)
+    assert len(failures) == 2
+
+
+# === compute_vox_rels tests ===
+
+# def test_reliability_two_repeats():
+#     np.random.seed(0)
+#     vox = np.random.rand(70, 10)  # 50 trials, 10 voxels
+#     pairs = [
+#         [0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14],
+#         [15, 16, 17], [18, 19, 20], [21, 22, 23], [24, 25, 26], [27, 28, 29],
+#         [30, 31, 32], [33, 34, 35], [36, 37, 38], [39, 40, 41], [42, 43, 44],
+#         [45, 46, 47], [48, 49, 50], [51, 52, 53], [54, 55, 56], 
+#         [57, 58, 59, 60], [61, 62, 63, 64]
+#     ]
+
+#     rels = compute_vox_rels(vox, pairs, "sub-01", "ses-01")
+
+#     assert rels.shape == (10,)
+#     assert not np.all(np.isnan(rels)), "All voxel reliabilities are NaN!"
+#     assert np.all((rels >= -1) & (rels <= 1))
+
+
+# def test_reliability_three_repeats():
+#     np.random.seed(1)
+#     vox = np.random.rand(15, 3)  # 15 trials, 3 voxels
+#     pairs = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+
+#     rels = compute_vox_rels(vox, pairs, "sub-01", "ses-02")
+
+#     assert rels.shape == (3,)
+#     assert not np.all(np.isnan(rels)), "All voxel reliabilities are NaN!"
+#     assert np.all((rels >= -1) & (rels <= 1))
+
+
+# def test_reliability_four_repeats_mixed():
+#     np.random.seed(2)
+#     vox = np.random.rand(20, 4)  # 20 trials, 4 voxels
+#     pairs = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]]  # includes 2 and 4 repeats
+
+#     rels = compute_vox_rels(vox, pairs, "sub-test", "ses-test")
+
+#     assert rels.shape == (4,)
+#     assert not np.all(np.isnan(rels)), "All voxel reliabilities are NaN!"
+#     assert np.all((rels >= -1) & (rels <= 1))
+
+
+# def test_near_uniform_data():
+#     np.random.seed(42)
+#     # Add very small noise to a constant baseline
+#     vox = np.ones((6, 3)) + np.random.normal(0, 1e-5, (6, 3))
+#     pairs = [[0, 1], [2, 3], [4, 5]]
+
+#     rels = compute_vox_rels(vox, pairs, "sub-near-uniform", "ses-01")
+
+#     assert rels.shape == (3,)
+#     assert not np.all(np.isnan(rels)), "All voxel reliabilities are NaN!"
+#     assert np.all((rels >= -1) & (rels <= 1))
+
+# def test_invalid_pairs_length():
+#     vox = np.random.rand(10, 3)
+#     pairs = [[0]]  # should raise due to too few repeats
+
+#     with pytest.raises(AssertionError):
+#         compute_vox_rels(vox, pairs, "sub-err", "ses-01")
+
+        
+def test_basic_case():
+    """Test with 2 repeats and 2 voxels, with basic correlation"""
+    vox_repeats = np.random.rand(30, 50)
+    breakpoint()
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    # Expected correlation for each voxel should be the correlation between repeat 0 and repeat 1
+    assert rels.shape == (2,)  # Should return a vector of size 2 (one per voxel)
+    
+    # Check that the correlation is valid and close to expected value
+    assert np.all(np.isfinite(rels))  # Ensure no NaNs in the results
+    
+    for v in range(2):  # Check correlation for each voxel
+        expected_corr = np.corrcoef(vox_repeats[:, v])[0, 1]
+        assert np.allclose(rels[v], expected_corr, atol=1e-5)  # Allow for floating point errors
+
+def test_multiple_repeats():
+    """Test with more repeats (3) and multiple voxels (3)"""
+    vox_repeats = np.array([[1, 2, 3], [2, 3, 4], [3, 4, 5]])  # 3 repeats, 3 voxels
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    assert rels.shape == (3,)  # Should return a vector of size 3 (one per voxel)
+    for v in range(3):
+        assert not np.isnan(rels[v])  # Ensure no NaNs are present
+
+def test_identical_repeats():
+    """Test with all identical repeats (perfect correlation)"""
+    vox_repeats = np.array([[1, 1], [1, 1]])  # Identical repeats, 2 voxels
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    assert rels.shape == (2,)
+    assert np.allclose(rels, 1)  # Perfect correlation (should be 1 for all voxels)
+
+def test_anticorrelation():
+    """Test with perfect anti-correlation (correlation = -1)"""
+    vox_repeats = np.array([[1, 2], [2, 1]])  # Perfect anti-correlation between repeats
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    assert rels.shape == (2,)
+    assert np.allclose(rels, -1)  # Perfect negative correlation
+
+def test_zero_variance_repeats():
+    """Test with repeats having zero variance (e.g., all values are the same)"""
+    vox_repeats = np.array([[1, 1], [1, 1], [1, 1]])  # Zero variance across repeats
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    assert rels.shape == (2,)
+    # Since variance is zero, the correlation will be NaN
+    assert np.all(np.isnan(rels))
+
+def test_edge_case_two_repeats_and_one_voxel():
+    """Test with only 2 repeats and 1 voxel (minimal edge case)"""
+    vox_repeats = np.array([[1], [2]])  # 2 repeats, 1 voxel
+    rels = compute_avg_repeat_corrs(vox_repeats)
+    
+    assert rels.shape == (1,)
+    assert np.allclose(rels[0], np.corrcoef([1], [2])[1, 0])  # Correlation between the two repeats

utils.py

@@ -0,0 +1,1151 @@
+import numpy as np
+from torchvision import transforms
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import PIL
+import random
+import os
+import matplotlib.pyplot as plt
+import pandas as pd
+import math
+import webdataset as wds
+import tempfile
+from torchvision.utils import make_grid
+
+import json
+from torchmetrics.image.fid import FrechetInceptionDistance
+from PIL import Image
+import requests
+import io
+import time 
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def is_interactive():
+    import __main__ as main
+    return not hasattr(main, '__file__')
+
+def seed_everything(seed=0, cudnn_deterministic=True):
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    if cudnn_deterministic:
+        torch.backends.cudnn.deterministic = True
+    else:
+        ## needs to be False to use conv3D
+        print('Note: not using cudnn.deterministic')
+
+def np_to_Image(x):
+    if x.ndim==4:
+        x=x[0]
+    return PIL.Image.fromarray((x.transpose(1, 2, 0)*127.5+128).clip(0,255).astype('uint8'))
+
+def torch_to_Image(x):
+    if x.ndim==4:
+        x=x[0]
+    return transforms.ToPILImage()(x)
+
+def Image_to_torch(x):
+    try:
+        x = (transforms.ToTensor()(x)[:3].unsqueeze(0)-.5)/.5
+    except:
+        x = (transforms.ToTensor()(x[0])[:3].unsqueeze(0)-.5)/.5
+    return x
+
+def torch_to_matplotlib(x,device=device):
+    if torch.mean(x)>10:
+        x = (x.permute(0, 2, 3, 1)).clamp(0, 255).to(torch.uint8)
+    else:
+        x = (x.permute(0, 2, 3, 1) * 255).clamp(0, 255).to(torch.uint8)
+    if device=='cpu':
+        return x[0]
+    else:
+        return x.cpu().numpy()[0]
+
+def pairwise_cosine_similarity(A, B, dim=1, eps=1e-8):
+    #https://stackoverflow.com/questions/67199317/pytorch-cosine-similarity-nxn-elements
+    numerator = A @ B.T
+    A_l2 = torch.mul(A, A).sum(axis=dim)
+    B_l2 = torch.mul(B, B).sum(axis=dim)
+    denominator = torch.max(torch.sqrt(torch.outer(A_l2, B_l2)), torch.tensor(eps))
+    return torch.div(numerator, denominator)
+
+def batchwise_pearson_correlation(Z, B):
+    # Calculate means
+    Z_mean = torch.mean(Z, dim=1, keepdim=True)
+    B_mean = torch.mean(B, dim=1, keepdim=True)
+
+    # Subtract means
+    Z_centered = Z - Z_mean
+    B_centered = B - B_mean
+
+    # Calculate Pearson correlation coefficient
+    numerator = Z_centered @ B_centered.T
+    Z_centered_norm = torch.linalg.norm(Z_centered, dim=1, keepdim=True)
+    B_centered_norm = torch.linalg.norm(B_centered, dim=1, keepdim=True)
+    denominator = Z_centered_norm @ B_centered_norm.T
+
+    pearson_correlation = (numerator / denominator)
+    return pearson_correlation
+
+def batchwise_cosine_similarity(Z,B):
+    Z = Z.flatten(1)
+    B = B.flatten(1).T
+    Z_norm = torch.linalg.norm(Z, dim=1, keepdim=True)  # Size (n, 1).
+    B_norm = torch.linalg.norm(B, dim=0, keepdim=True)  # Size (1, b).
+    cosine_similarity = ((Z @ B) / (Z_norm @ B_norm)).T
+    return cosine_similarity
+
+def prenormed_batchwise_cosine_similarity(Z,B):\
+    return (Z @ B.T).T
+
+def cosine_similarity(Z,B,l=0):
+    Z = nn.functional.normalize(Z, p=2, dim=1)
+    B = nn.functional.normalize(B, p=2, dim=1)
+    # if l>0, use distribution normalization
+    # https://twitter.com/YifeiZhou02/status/1716513495087472880
+    Z = Z - l * torch.mean(Z,dim=0)
+    B = B - l * torch.mean(B,dim=0)
+    cosine_similarity = (Z @ B.T).T
+    return cosine_similarity
+
+def topk(similarities,labels,k=5):
+    if k > similarities.shape[0]:
+        k = similarities.shape[0]
+    topsum=0
+    for i in range(k):
+        topsum += torch.sum(torch.argsort(similarities,axis=1)[:,-(i+1)] == labels)/len(labels)
+    return topsum
+
+def get_non_diagonals(a):
+    a = torch.triu(a,diagonal=1)+torch.tril(a,diagonal=-1)
+    # make diagonals -1
+    a=a.fill_diagonal_(-1)
+    return a
+
+def gather_features(image_features, voxel_features, accelerator):  
+    all_image_features = accelerator.gather(image_features.contiguous())
+    if voxel_features is not None:
+        all_voxel_features = accelerator.gather(voxel_features.contiguous())
+        return all_image_features, all_voxel_features
+    return all_image_features
+
+def soft_clip_loss(preds, targs, temp=0.125): #, distributed=False, accelerator=None):
+    # if not distributed:
+    clip_clip = (targs @ targs.T)/temp
+    brain_clip = (preds @ targs.T)/temp
+    # else:
+    #     all_targs = gather_features(targs, None, accelerator)
+    #     clip_clip = (targs @ all_targs.T)/temp
+    #     brain_clip = (preds @ all_targs.T)/temp
+    
+    loss1 = -(brain_clip.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean()
+    loss2 = -(brain_clip.T.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean()
+    
+    loss = (loss1 + loss2)/2
+    return loss
+
+def soft_siglip_loss(preds, targs, temp, bias):
+    temp = torch.exp(temp)
+    
+    logits = (preds @ targs.T) * temp + bias
+    # diagonals (aka paired samples) should be >0 and off-diagonals <0
+    labels = (targs @ targs.T) - 1 + (torch.eye(len(targs)).to(targs.dtype).to(targs.device))
+
+    loss1 = -torch.sum(nn.functional.logsigmoid(logits * labels[:len(preds)])) / len(preds)
+    loss2 = -torch.sum(nn.functional.logsigmoid(logits.T * labels[:,:len(preds)])) / len(preds)
+    loss = (loss1 + loss2)/2
+    return loss
+
+def mixco_hard_siglip_loss(preds, targs, temp, bias, perm, betas):
+    temp = torch.exp(temp)
+    
+    probs = torch.diag(betas)
+    probs[torch.arange(preds.shape[0]).to(preds.device), perm] = 1 - betas
+
+    logits = (preds @ targs.T) * temp + bias
+    labels = probs * 2 - 1
+    #labels = torch.eye(len(targs)).to(targs.dtype).to(targs.device) * 2 - 1
+    
+    loss1 = -torch.sum(nn.functional.logsigmoid(logits * labels)) / len(preds)
+    loss2 = -torch.sum(nn.functional.logsigmoid(logits.T * labels)) / len(preds)
+    loss = (loss1 + loss2)/2
+    return loss
+
+def mixco(voxels, beta=0.15, s_thresh=0.5, perm=None, betas=None, select=None):
+    if perm is None:
+        perm = torch.randperm(voxels.shape[0])
+    voxels_shuffle = voxels[perm].to(voxels.device,dtype=voxels.dtype)
+    if betas is None:
+        betas = torch.distributions.Beta(beta, beta).sample([voxels.shape[0]]).to(voxels.device,dtype=voxels.dtype)
+    if select is None:
+        select = (torch.rand(voxels.shape[0]) <= s_thresh).to(voxels.device)
+    betas_shape = [-1] + [1]*(len(voxels.shape)-1)
+    voxels[select] = voxels[select] * betas[select].reshape(*betas_shape) + \
+        voxels_shuffle[select] * (1 - betas[select]).reshape(*betas_shape)
+    betas[~select] = 1
+    return voxels, perm, betas, select
+
+def mixco_clip_target(clip_target, perm, select, betas):
+    clip_target_shuffle = clip_target[perm]
+    clip_target[select] = clip_target[select] * betas[select].reshape(-1, 1) + \
+        clip_target_shuffle[select] * (1 - betas[select]).reshape(-1, 1)
+    return clip_target
+
+def mixco_nce(preds, targs, temp=0.1, perm=None, betas=None, select=None, distributed=False, 
+              accelerator=None, local_rank=None, bidirectional=True):
+    brain_clip = (preds @ targs.T)/temp
+    
+    if perm is not None and betas is not None and select is not None:
+        probs = torch.diag(betas)
+        probs[torch.arange(preds.shape[0]).to(preds.device), perm] = 1 - betas
+
+        loss = -(brain_clip.log_softmax(-1) * probs).sum(-1).mean()
+        if bidirectional:
+            loss2 = -(brain_clip.T.log_softmax(-1) * probs.T).sum(-1).mean()
+            loss = (loss + loss2)/2
+        return loss
+    else:
+        loss =  F.cross_entropy(brain_clip, torch.arange(brain_clip.shape[0]).to(brain_clip.device))
+        if bidirectional:
+            loss2 = F.cross_entropy(brain_clip.T, torch.arange(brain_clip.shape[0]).to(brain_clip.device))
+            loss = (loss + loss2)/2
+        return loss
+    
+def count_params(model):
+    total = sum(p.numel() for p in model.parameters())
+    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print('param counts:\n{:,} total\n{:,} trainable'.format(total, trainable))
+    return trainable
+
+def image_grid(imgs, rows, cols):
+    w, h = imgs[0].size
+    grid = PIL.Image.new('RGB', size=(cols*w, rows*h))
+    for i, img in enumerate(imgs):
+        grid.paste(img, box=(i%cols*w, i//cols*h))
+    return grid
+    
+def check_loss(loss):
+    if loss.isnan().any():
+        raise ValueError('NaN loss')
+
+def cosine_anneal(start, end, steps):
+    return end + (start - end)/2 * (1 + torch.cos(torch.pi*torch.arange(steps)/(steps-1)))
+
+def resize(img, img_size=128):
+    if img.ndim == 3: img = img[None]
+    return nn.functional.interpolate(img, size=(img_size, img_size), mode='nearest')
+
+import braceexpand
+def get_dataloaders(
+    batch_size,
+    image_var='images',
+    num_devices=None,
+    num_workers=None,
+    train_url=None,
+    val_url=None,
+    meta_url=None,
+    num_train=None,
+    num_val=None,
+    cache_dir="/scratch/tmp/wds-cache",
+    seed=0,
+    voxels_key="nsdgeneral.npy",
+    val_batch_size=None,
+    to_tuple=["voxels", "images", "trial"],
+    local_rank=0,
+    world_size=1,
+):
+    print("Getting dataloaders...")
+    assert image_var == 'images'
+    
+    def my_split_by_node(urls):
+        return urls
+    
+    train_url = list(braceexpand.braceexpand(train_url))
+    val_url = list(braceexpand.braceexpand(val_url))
+
+    if num_devices is None:
+        num_devices = torch.cuda.device_count()
+    
+    if num_workers is None:
+        num_workers = num_devices
+    
+    if num_train is None:
+        metadata = json.load(open(meta_url))
+        num_train = metadata['totals']['train']
+    if num_val is None:
+        metadata = json.load(open(meta_url))
+        num_val = metadata['totals']['val']
+
+    if val_batch_size is None:
+        val_batch_size = batch_size
+        
+    global_batch_size = batch_size * num_devices
+    num_batches = math.floor(num_train / global_batch_size)
+    num_worker_batches = math.floor(num_batches / num_workers)
+    if num_worker_batches == 0: num_worker_batches = 1
+    
+    print("\nnum_train",num_train)
+    print("global_batch_size",global_batch_size)
+    print("batch_size",batch_size)
+    print("num_workers",num_workers)
+    print("num_batches",num_batches)
+    print("num_worker_batches", num_worker_batches)
+    
+    # train_url = train_url[local_rank:world_size]
+    train_data = wds.WebDataset(train_url, resampled=False, cache_dir=cache_dir, nodesplitter=my_split_by_node)\
+        .shuffle(500, initial=500, rng=random.Random(42))\
+        .decode("torch")\
+        .rename(images="jpg;png", voxels=voxels_key, trial="trial.npy", coco="coco73k.npy", reps="num_uniques.npy")\
+        .to_tuple(*to_tuple)#\
+        # .batched(batch_size, partial=True)#\
+        # .with_epoch(num_worker_batches)
+    
+    # BATCH SIZE SHOULD BE NONE!!! FOR TRAIN AND VAL | resampled=True for train | .batched(val_batch_size, partial=False)
+    train_dl = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=1, shuffle=False)
+
+    # Validation 
+    print("val_batch_size",val_batch_size)
+    val_data = wds.WebDataset(val_url, resampled=False, cache_dir=cache_dir, nodesplitter=my_split_by_node)\
+        .shuffle(500, initial=500, rng=random.Random(42))\
+        .decode("torch")\
+        .rename(images="jpg;png", voxels=voxels_key, trial="trial.npy", coco="coco73k.npy", reps="num_uniques.npy")\
+        .to_tuple(*to_tuple)#\
+        # .batched(val_batch_size, partial=True)
+    val_dl = torch.utils.data.DataLoader(val_data, batch_size=val_batch_size, num_workers=1, shuffle=False, drop_last=True)
+
+    return train_dl, val_dl, num_train, num_val
+
+pixcorr_preprocess = transforms.Compose([
+    transforms.Resize(425, interpolation=transforms.InterpolationMode.BILINEAR),
+])
+def pixcorr(images,brains,nan=True):
+    all_images_flattened = pixcorr_preprocess(images).reshape(len(images), -1)
+    all_brain_recons_flattened = pixcorr_preprocess(brains).view(len(brains), -1)
+    if nan:
+        corrmean = torch.nanmean(torch.diag(batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)))
+    else:
+        corrmean = torch.mean(torch.diag(batchwise_pearson_correlation(all_images_flattened, all_brain_recons_flattened)))
+    return corrmean
+
+def select_annotations(annots, random=True):
+    """
+    There are 5 annotations per image. Select one of them for each image.
+    """
+    for i, b in enumerate(annots):
+        t = ''
+        if random:
+            # select random non-empty annotation
+            while t == '':
+                rand = torch.randint(5, (1,1))[0][0]
+                t = b[rand]
+        else:
+            # select first non-empty annotation
+            for j in range(5):
+                if b[j] != '':
+                    t = b[j]
+                    break
+        if i == 0:
+            txt = np.array(t)
+        else:
+            txt = np.vstack((txt, t))
+    txt = txt.flatten()
+    return txt
+
+def add_saturation(image, alpha=2):
+    gray_image = 0.2989 * image[:, 0, :, :] + 0.5870 * image[:, 1, :, :] + 0.1140 * image[:, 2, :, :]
+    gray_image = gray_image.unsqueeze(1).expand_as(image)
+    saturated_image = alpha * image + (1 - alpha) * gray_image
+    return torch.clamp(saturated_image, 0, 1)
+
+def find_prompt_by_image_number(image_number, data):
+    target_image_filename = f"img_t{image_number}.jpg"
+    for entry in data:
+        if 'target' in entry and entry['target'].endswith(target_image_filename):
+            return entry['prompt']
+    return -1
+
+def compute_negative_l1_losses(preds, targets):
+    batch_size = preds.size(0)
+    
+    # Expand dimensions for broadcasting
+    expanded_preds = preds.unsqueeze(1)        # Shape: [batch_size, 1, 100]
+    expanded_targets = targets.unsqueeze(0)    # Shape: [1, batch_size, 100]
+    
+    # Compute pairwise L1 differences
+    l1_diffs = torch.abs(expanded_preds - expanded_targets)  # Shape: [batch_size, batch_size, 100]
+    
+    # Mask the diagonal to exclude positive pairs
+    mask = torch.eye(batch_size).bool().to(l1_diffs.device)
+    l1_diffs[mask] = 0
+    
+    # Sum L1 differences for each sample against all negatives
+    negative_losses = l1_diffs.sum(dim=-1).mean()
+    
+    return negative_losses
+
+
+def unclip_recon(x, diffusion_engine, vector_suffix,
+                 num_samples=1, offset_noise_level=0.04):
+    from generative_models.sgm.util import append_dims
+    assert x.ndim==3
+    if x.shape[0]==1:
+        x = x[[0]]
+    with torch.no_grad(), torch.cuda.amp.autocast(dtype=torch.float16), diffusion_engine.ema_scope():
+        z = torch.randn(num_samples,4,96,96).to(device) # starting noise, can change to VAE outputs of initial image for img2img
+
+        # clip_img_tokenized = clip_img_embedder(image) 
+        # tokens = clip_img_tokenized
+        token_shape = x.shape
+        tokens = x
+        c = {"crossattn": tokens.repeat(num_samples,1,1), "vector": vector_suffix.repeat(num_samples,1)}
+
+        tokens = torch.randn_like(x)
+        uc = {"crossattn": tokens.repeat(num_samples,1,1), "vector": vector_suffix.repeat(num_samples,1)}
+
+        for k in c:
+            c[k], uc[k] = map(lambda y: y[k][:num_samples].to(device), (c, uc))
+
+        noise = torch.randn_like(z)
+        sigmas = diffusion_engine.sampler.discretization(diffusion_engine.sampler.num_steps)
+        sigma = sigmas[0].to(z.device)
+
+        if offset_noise_level > 0.0:
+            noise = noise + offset_noise_level * append_dims(
+                torch.randn(z.shape[0], device=z.device), z.ndim
+            )
+        noised_z = z + noise * append_dims(sigma, z.ndim)
+        noised_z = noised_z / torch.sqrt(
+            1.0 + sigmas[0] ** 2.0
+        )  # Note: hardcoded to DDPM-like scaling. need to generalize later.
+
+        def denoiser(x, sigma, c):
+            return diffusion_engine.denoiser(diffusion_engine.model, x, sigma, c)
+
+        samples_z = diffusion_engine.sampler(denoiser, noised_z, cond=c, uc=uc)
+        samples_x = diffusion_engine.decode_first_stage(samples_z)
+        samples = torch.clamp((samples_x*.8+.2), min=0.0, max=1.0)
+        # samples = torch.clamp((samples_x + .5) / 2.0, min=0.0, max=1.0)
+        return samples
+    
+def soft_cont_loss(student_preds, teacher_preds, teacher_aug_preds, temp=0.125):
+    teacher_teacher_aug = (teacher_preds @ teacher_aug_preds.T)/temp
+    teacher_teacher_aug_t = (teacher_aug_preds @ teacher_preds.T)/temp
+    student_teacher_aug = (student_preds @ teacher_aug_preds.T)/temp
+    student_teacher_aug_t = (teacher_aug_preds @ student_preds.T)/temp
+
+    loss1 = -(student_teacher_aug.log_softmax(-1) * teacher_teacher_aug.softmax(-1)).sum(-1).mean()
+    loss2 = -(student_teacher_aug_t.log_softmax(-1) * teacher_teacher_aug_t.softmax(-1)).sum(-1).mean()
+    
+    loss = (loss1 + loss2)/2
+    return loss
+
+def iterate_range(start, length, batchsize):
+    batch_count = int(length // batchsize )
+    residual = int(length % batchsize)
+    for i in range(batch_count):
+        yield range(start+i*batchsize, start+(i+1)*batchsize),batchsize
+    if(residual>0):
+        yield range(start+batch_count*batchsize,start+length),residual 
+        
+        
+# Torch fwRF
+def get_value(_x):
+    return np.copy(_x.data.cpu().numpy())
+
+
+#subject: nsd subject index between 1-8
+#mode: vision, imagery
+#stimtype: all, simple, complex, concepts
+#average: whether to average across trials, will produce x that is (stimuli, 1, voxels)
+#nest: whether to nest the data according to stimuli, will produce x that is (stimuli, trials, voxels)
+import pickle
+def condition_average(x, y, cond, nest=False):
+    idx, idx_count = np.unique(cond, return_counts=True)
+    idx_list = [np.array(cond)==i for i in np.sort(idx)]
+    if nest:
+        avg_x = torch.zeros((len(idx), idx_count.max(), x.shape[1]), dtype=torch.float32)
+    else:
+        avg_x = torch.zeros((len(idx), 1, x.shape[1]), dtype=torch.float32)
+    for i, m in enumerate(idx_list):
+        if nest:
+            avg_x[i] = x[m]
+        else:
+            avg_x[i] = torch.mean(x[m], axis=0)
+        
+    return avg_x, y, len(idx_count)
+def load_nsd_mental_imagery(subject, mode, stimtype="all", average=False, nest=False):
+    # This file has a bunch of information about the stimuli and cue associations that will make loading it easier
+    img_stim_file = "imagery/nsd_imagery/data/nsddata_stimuli/stimuli/nsdimagery_stimuli.pkl3"
+    ex_file = open(img_stim_file, 'rb')
+    imagery_dict = pickle.load(ex_file)
+    ex_file.close()
+    # Indicates what experiments trials belong to
+    exps = imagery_dict['exps']
+    # Indicates the cues for different stimuli
+    cues = imagery_dict['cues']
+    # Maps the cues to the stimulus image information
+    image_map  = imagery_dict['image_map']
+    # Organize the indices of the trials according to the modality and the type of stimuli
+    cond_idx = {
+    'visionsimple': np.arange(len(exps))[exps=='visA'],
+    'visioncomplex': np.arange(len(exps))[exps=='visB'],
+    'visionconcepts': np.arange(len(exps))[exps=='visC'],
+    'visionall': np.arange(len(exps))[np.logical_or(np.logical_or(exps=='visA', exps=='visB'), exps=='visC')],
+    'imagerysimple': np.arange(len(exps))[np.logical_or(exps=='imgA_1', exps=='imgA_2')],
+    'imagerycomplex': np.arange(len(exps))[np.logical_or(exps=='imgB_1', exps=='imgB_2')],
+    'imageryconcepts': np.arange(len(exps))[np.logical_or(exps=='imgC_1', exps=='imgC_2')],
+    'imageryall': np.arange(len(exps))[np.logical_or(
+                                        np.logical_or(
+                                            np.logical_or(exps=='imgA_1', exps=='imgA_2'), 
+                                            np.logical_or(exps=='imgB_1', exps=='imgB_2')), 
+                                        np.logical_or(exps=='imgC_1', exps=='imgC_2'))]}
+    # Load normalized betas
+    x = torch.load("imagery/nsd_imagery/data/preprocessed_data/subject{}/nsd_imagery.pt".format(subject)).requires_grad_(False).to("cpu")
+    # Find the trial indices conditioned on the type of trials we want to load
+    cond_im_idx = {n: [image_map[c] for c in cues[idx]] for n,idx in cond_idx.items()}
+    conditionals = cond_im_idx[mode+stimtype]
+    # Stimuli file is of shape (18,3,425,425), these can be converted back into PIL images using transforms.ToPILImage()
+    y = torch.load("imagery/nsd_imagery/data/nsddata_stimuli/stimuli/imagery_stimuli_18.pt").requires_grad_(False).to("cpu")
+    # Prune the beta file down to specific experimental mode/stimuli type
+    x = x[cond_idx[mode+stimtype]]
+    # If stimtype is not all, then prune the image data down to the specific stimuli type
+    if stimtype == "simple":
+        y = y[:6]
+    elif stimtype == "complex":
+        y = y[6:12]
+    elif stimtype == "concepts":
+        y = y[12:]
+    
+    # Average or nest the betas across trials
+    if average or nest:
+        x, y, sample_count = condition_average(x, y, conditionals, nest=nest)
+    else:
+        x = x.reshape((x.shape[0], 1, x.shape[1]))
+    
+    # print(x.shape)
+    return x, y
+    
+def bb_soft_clip_loss(preds, targs, temp=0.125):
+    temp = np.exp(temp)
+    clip_clip = (targs @ targs.T)/temp
+    brain_brain = (preds @ preds.T)/temp
+    
+#     loss1 = -(brain_brain.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean()
+#     loss2 = -(brain_brain.T.log_softmax(-1) * clip_clip.softmax(-1)).sum(-1).mean()
+#     loss = (loss1 + loss2)/2
+    
+    loss = nn.functional.kl_div(brain_brain.log_softmax(-1), clip_clip.softmax(-1), reduction='batchmean')
+    return loss #* 1e5
+
+def bb_cossim_loss(preds, targs, temp=None):
+    clip_clip = (targs @ targs.T)
+    brain_brain = (preds @ preds.T)
+    loss = 1 - nn.functional.cosine_similarity(brain_brain, clip_clip).mean()
+    return loss 
+
+def load_images_to_numpy(folder_path):
+    file_names = [f for f in os.listdir(folder_path) if (f.endswith('.png') or f.endswith('.jpg') or f.endswith('.jpeg'))]
+    image_data = []
+    image_names = []
+    for file_name in file_names:
+        image_path = os.path.join(folder_path, file_name)
+        image_names.append(file_name)
+        with Image.open(image_path) as img:
+            img_array = np.array(img)
+            if img_array.shape[1] != 224:
+                img = img.resize((224,224))
+                img_array = np.array(img)
+            image_data.append(img_array)
+    images_np = np.stack(image_data, axis=0)
+    return images_np, image_names
+
+
+import hashlib
+def hash_image(image_tensor):
+    # Convert tensor to bytes
+    image_bytes = image_tensor.detach().cpu().numpy().tobytes()
+    # Hash the bytes using SHA-256
+    hash_object = hashlib.sha256(image_bytes)
+    hex_dig = hash_object.hexdigest()
+    return hex_dig
+
+
+def find_paired_indices(x):
+    unique_elements, counts = torch.unique(x, return_counts=True)
+    repeated_elements = unique_elements[counts > 1]
+    paired_indices = []
+    
+    for element in repeated_elements:
+        indices = (x == element).nonzero(as_tuple=True)[0]
+        # Instead of creating pairs, just collect the entire set of indices once
+        paired_indices.append(indices[:len(indices)].tolist())
+    
+    return paired_indices
+
+
+def zscore(data,train_mean=None,train_std=None):
+    # assuming that first dim is num_samples and second dim is num_voxels
+    if train_mean is None:
+        train_mean = np.mean(data,axis=0)
+    if train_std is None:
+        train_std = np.std(data,axis=0)
+    zscored_data = (data - train_mean) / (train_std + 1e-6)
+    return zscored_data
+
+
+def log_io(func):  # the first argument must be input; output must be a kwarg for this to work properly
+    def wrapper(*args, **kwargs):
+        inp = args[0]
+        output = kwargs['output']
+        print(f'\n*** Loading data from {inp} ***\n')
+        result = func(*args, **kwargs)
+        print(f'\n*** Saved resampled data to {output} ***\n')
+        return result
+    return wrapper
+
+@log_io  
+def resample(inp, ref, target_size, omat, output=None):  
+    os.system(f"flirt -in {inp} \
+                    -ref {ref} \
+                    -applyisoxfm {target_size} -nosearch \
+                    -omat {omat} \
+                    -out {output}")
+
+@log_io
+def applyxfm(inp, ref, init, interp, output=None):
+    os.system(f"flirt -in {inp} \
+                -ref {ref} \
+                -out {output} \
+                -applyxfm -init {init} \
+                -interp {interp}")
+
+@log_io
+def apply_thresh(inp, thresh, output=None):
+    os.system(f"fslmaths {inp} -thr {thresh} -bin {output}")
+
+def resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat):
+    # convert vox to nifti object and save
+    orig_mask = nib.load(f"{orig_glmsingle_path}/{sub}_{session}{task_name}_brain.nii.gz")
+
+    # apply mask and save original betas
+    print("original:", vox.shape)
+    vox_nii = unmask(vox, orig_mask)
+    glm_save_path = f"{glmsingle_path}/vox.nii.gz"
+    nib.save(vox_nii, glm_save_path)
+    print(f"saved original glmsingle betas to {glm_save_path}")
+
+    # resample and save betas
+    applyxfm(glm_save_path, ref_name, omat, resample_method, output=glm_save_path_resampled)
+    vox = nib.load(glm_save_path_resampled)
+    print("vox after resampling", vox.shape)
+
+    return vox
+
+
+def load_preprocess_betas(glmsingle_path, session, ses_list,
+                              remove_close_to_MST, image_names, 
+                              remove_random_n, vox_idx):
+    glmsingle = np.load(f"{glmsingle_path}/TYPED_FITHRF_GLMDENOISE_RR.npz", allow_pickle=True)
+    vox = glmsingle['betasmd'].T
+
+    print("vox", vox.shape)
+
+    # Preprocess betas
+    if vox.ndim == 4:
+        vox = vox[:, 0, 0]
+        print("vox", vox.shape)
+
+    if remove_close_to_MST:
+        x = [x for x in image_names if x != 'blank.jpg' and str(x) != 'nan']
+        close_to_MST_idx = [y for y, z in enumerate(x) if 'closest_pairs' in z]
+        close_to_MST_mask = np.ones(len(vox), dtype=bool)
+        close_to_MST_mask[close_to_MST_idx] = False
+        vox = vox[close_to_MST_mask]
+        print("vox after removing close_to_MST", vox.shape)
+
+    elif remove_random_n:
+        random_n_mask = np.ones(len(vox), dtype=bool)
+        random_n_mask[vox_idx] = False
+        vox = vox[random_n_mask]
+        print(f"vox after removing {n_to_remove}", vox.shape)
+
+    return vox
+
+
+def prepare_model_and_training(
+    num_voxels_list, 
+    n_blocks,
+    hidden_dim, 
+    clip_emb_dim, 
+    clip_seq_dim, 
+    clip_scale,
+    use_prior=False, 
+):
+    """
+    Prepare MindEye model, optimizer, and learning rate scheduler.
+    
+    Args:
+        num_voxels_list (list): List of number of voxels for each subject
+        hidden_dim (int): Hidden dimension for model layers
+        clip_emb_dim (int): CLIP embedding dimension
+        clip_seq_dim (int): CLIP sequence dimension
+        use_prior (bool): Whether to include diffusion prior network
+    
+    Returns:
+        model
+    """
+    import torch
+    import torch.nn as nn
+    import numpy as np
+    from models import VersatileDiffusionPriorNetwork, BrainDiffusionPrior
+    from MindEye2 import MindEyeModule, RidgeRegression, BrainNetwork
+    import utils
+
+    model = MindEyeModule()
+    print(model)
+
+    model.ridge = RidgeRegression(num_voxels_list, out_features=hidden_dim)
+    utils.count_params(model.ridge)
+    utils.count_params(model)
+
+    model.backbone = BrainNetwork(h=hidden_dim, in_dim=hidden_dim, out_dim=clip_emb_dim*clip_seq_dim, seq_len=1, n_blocks=n_blocks,
+                              clip_size=clip_emb_dim)
+    utils.count_params(model.backbone)
+    utils.count_params(model)
+
+    if use_prior:
+        # setup diffusion prior network
+        out_dim = clip_emb_dim
+        depth = 6
+        dim_head = 52
+        heads = clip_emb_dim//52 # heads * dim_head = clip_emb_dim
+        timesteps = 100
+        prior_network = VersatileDiffusionPriorNetwork(
+                dim=out_dim,
+                depth=depth,
+                dim_head=dim_head,
+                heads=heads,
+                causal=False,
+                num_tokens = clip_seq_dim,
+                learned_query_mode="pos_emb"
+            )
+        model.diffusion_prior = BrainDiffusionPrior(
+            net=prior_network,
+            image_embed_dim=out_dim,
+            condition_on_text_encodings=False,
+            timesteps=timesteps,
+            cond_drop_prob=0.2,
+            image_embed_scale=None,
+        )
+
+        utils.count_params(model.diffusion_prior)
+        utils.count_params(model)
+
+    return model
+
+
+def get_slurm_seed(default=0):
+    """Returns SLURM array seed or a default seed if not running in SLURM."""
+    try:
+        seed = int(os.environ["SLURM_ARRAY_TASK_ID"])
+        print(f"Using SLURM job array seed: {seed}")
+    except KeyError:
+        print(f"SLURM seed not found, using default: {default}")
+        seed = default
+    return seed
+
+
+def get_slurm_job():
+    """Returns ID of current SLURM job"""
+    return int(os.environ["SLURM_ARRAY_JOB_ID"])
+
+
+def filter_and_average_mst(vox, vox_image_dict):
+    """
+    Filters and averages repeated MST images while retaining unique images.
+    
+    Args:
+        vox (np.ndarray): Original array of shape (num_images, num_features).
+        vox_image_dict (dict): Maps image indices to file paths.
+    Returns:
+        tuple: Filtered array and corresponding kept indices.
+    """
+    from copy import deepcopy
+    
+    # Identify repeated MST paths
+    repeats = {}
+    for idx, path in vox_image_dict.items():
+        if "MST_pairs" in path:
+            repeats.setdefault(path, []).append(idx)
+    
+    # Create mask to track kept entries
+    keep_mask = np.ones(vox.shape[0], dtype=bool)
+    output_vox = deepcopy(vox).astype(np.float32)
+    
+    # Average repeated MST images
+    for indices in repeats.values():
+        if len(indices) > 1:
+            avg_values = np.mean(vox[indices], axis=0)
+            output_vox[indices[0]] = avg_values
+            keep_mask[indices[1:]] = False
+    
+    return output_vox[keep_mask], np.where(keep_mask)[0]
+
+
+def verify_image_patterns(image_to_indices):
+    failures = []
+    for image_name, sessions in image_to_indices.items():
+        session1, session2 = sessions
+        total_count = len(session1) + len(session2)
+
+        if "special515" in image_name:
+            if not (
+                (len(session1) == 3 and len(session2) == 0) or
+                (len(session1) == 0 and len(session2) == 3) or
+                (len(session1) == 1 and len(session2) == 0) or
+                (len(session1) == 0 and len(session2) == 1)
+            ):
+                failures.append(f"{image_name} does not appear 3x in only 1 session.")
+        elif "MST_pairs" in image_name:
+            if not (len(session1) == 2 and len(session2) == 2):
+                failures.append(f"{image_name} does not appear 2x in both sessions.")
+        else:
+            if not (
+                (total_count == 1) and
+                (len(session1) == 1 and len(session2) == 0 or len(session1) == 0 and len(session2) == 1)
+            ):
+                failures.append(f"{image_name} does not appear 1x in only 1 session.")
+
+    return failures
+
+def compute_avg_repeat_corrs(vox_repeats: np.ndarray) -> np.ndarray:
+    """
+    Given an array of shape (n_repeats, n_voxels), compute the average correlation
+    across all unique repeat combinations for each voxel.
+    Returns:
+        rels: (n_voxels,) array of averaged correlations
+    """
+    import itertools
+    n_repeats, n_vox = vox_repeats.shape
+    combos = list(itertools.combinations(range(n_repeats), 2))
+    
+    rels = np.full(n_vox, np.nan)
+    
+    # For each voxel
+    for v in range(n_vox):
+        corrs = []
+        # Calculate correlation for each pair of repeats
+        for i, j in combos:
+            r = np.corrcoef(vox_repeats[i, v], vox_repeats[j, v])[0, 1]
+            corrs.append(r)
+        # Average across all pairwise correlations
+        rels[v] = np.mean(corrs)
+    
+    return rels
+
+
+def get_pairs(data, repeat_indices=(0, 1)):
+    """
+    Extract pairs based on specified repeat indices, falling back to available repeats.
+    
+    Parameters:
+    - data: List of items, where each item may have different number of repeats
+    - repeat_indices: Tuple of indices (i, j) to extract if available
+    
+    Returns:
+    - Array of pairs
+    """
+    result = []
+    
+    for item in data:
+        # Determine what repeats are actually available
+        num_repeats = len(item)
+        
+        # Handle the requested indices
+        i, j = repeat_indices
+        
+        # Adjust indices if they're out of bounds
+        if i >= num_repeats:
+            i = min(num_repeats - 1, 0)
+        if j >= num_repeats:
+            j = min(num_repeats - 1, 1 if num_repeats > 1 else 0)
+            
+        # Create the pair
+        result.append([item[i], item[j]])
+    
+    return np.array(result)
+
+
+def compute_vox_rels(vox, pairs, sub, session, rdm=False, repeat_indices=(0,1)):
+    from tqdm import tqdm
+    pairs = get_pairs(pairs, repeat_indices=repeat_indices)
+    # print(pairs)
+    # _tmp = [(i[0],i[-1]) for i in pairs]
+    # breakpoint()
+    # vox_pairs = zscore(vox[_tmp])  # zscoring based on first and last repeat only
+    # rels = compute_avg_repeat_corrs(vox_pairs)
+
+    # _tmp = [(i[0],i[1]) for i in pairs]
+    # vox_pairs = zscore(vox[_tmp])
+    
+    vox_pairs = zscore(vox[pairs])
+    rels = np.full(vox.shape[-1], np.nan)
+    for v in tqdm(range(vox.shape[-1])):
+        rels[v] = np.corrcoef(vox_pairs[:, 0, v], vox_pairs[:, 1, v])[1, 0]
+    
+    print("rels", rels.shape)
+    assert np.sum(np.all(np.isnan(rels))) == 0
+    
+    if rdm:  # generate a Representational Dissimilarity Matrix to visualize how similar the voxel patterns are across images
+        # average voxel patterns across repeats
+        vox0 = np.zeros((len(pairs), vox.shape[-1], 2))
+        for ipair, pair in enumerate(tqdm(pairs)):
+            i, j = pair[:2]  # Using the first two repeats
+            vox0[ipair, :, :] = vox[pair].T
+        vox_avg = vox0.mean(-1)
+
+        # plot the RDM at various thresholds
+        r_thresholds = np.array([.0, .1, .2, .3])
+        rdm = np.zeros((len(r_thresholds), len(pairs), len(pairs))) 
+
+        for ir_thresh, r_thresh in enumerate(r_thresholds):
+            print(f"reliability threshold = {r_thresh}")
+            for i in tqdm(range(len(pairs))):
+                for j in range(len(pairs)):
+                    rdm[ir_thresh, i, j] = np.corrcoef(vox_avg[i, rels > r_thresh], 
+                                                       vox_avg[j, rels > r_thresh])[0, 1]
+        n_thresh = len(r_thresholds)
+        fig, axs = plt.subplots(1, n_thresh, figsize=(4 * n_thresh, 4), squeeze=False)
+
+        for i, r_thresh in enumerate(r_thresholds):
+            ax = axs[0, i]
+            im = ax.imshow(rdm[i], clim=(-1, 1))
+            ax.set_title(f"r > {r_thresh:.1f}")
+            ax.set_xlabel("Image")
+            ax.set_ylabel("Image")
+            fig.colorbar(im, ax=ax, shrink=0.8)
+
+        # Optional: add a supertitle with subject/session/repeat info
+        fig.suptitle(f"{sub}_{session}\nrepeat combo {r}", fontsize=14)
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])  # Leave space for suptitle
+        plt.show()
+
+            # thresh = .2
+            # plt.figure(figsize=(4, 4))
+            # plt.imshow(rdm[np.where(r_thresholds == thresh)[0].item()], clim=(-1, 1))
+            # plt.colorbar(shrink=0.8)
+            # plt.title(f"{sub}_{session}\nreliability threshold={thresh}; repeats {r}")
+            # plt.show()
+
+        for thresh in range(rdm.shape[0]):
+            for img in range(rdm.shape[1]):
+                assert np.isclose(rdm[thresh, img, img], 1)
+    
+    return rels
+
+
+def load_masks(img_list):
+    from nilearn.masking import intersect_masks
+    import nilearn
+
+    masks = [nilearn.image.load_img(mask) for mask in img_list]
+    assert all(np.allclose(masks[0].affine, m.affine) for m in masks)
+    return masks, intersect_masks(masks, threshold=0.5, connected=True)
+
+
+def get_mask(ses_list, sub, func_task_name):
+    assert isinstance(ses_list, list), "ses_list is not a list"
+    mask_imgs = []
+    nsd_imgs = []
+    for ses in ses_list:
+        prefix = f"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_{sub}_{ses}_task-{func_task_name}/{sub}_{ses}_task-{func_task_name}"
+        mask_path = prefix + "_brain.nii.gz"
+        nsd_path = prefix + "_nsdgeneral.nii.gz"
+        print(mask_path)
+        print(nsd_path)
+        assert os.path.exists(mask_path)
+        assert os.path.exists(nsd_path)
+        mask_imgs.append(mask_path)
+        nsd_imgs.append(nsd_path)
+
+    func_masks, avg_mask = load_masks(mask_imgs)
+    print(f'intersected brain masks from {ses_list}')
+    
+    nsd_masks, roi = load_masks(nsd_imgs)
+    print(f'intersected nsdgeneral roi masks from {ses_list}')
+
+    return func_masks, avg_mask, nsd_masks, roi
+
+
+
+def process_images(image_names, unique_images, remove_close_to_MST=False, remove_random_n=False, imgs_to_remove=None, sub=None, session=None):
+    image_idx = np.array([])
+    vox_image_names = np.array([])
+    all_MST_images = {}
+    
+    for i, im in enumerate(image_names):
+        if im == "blank.jpg" or str(im) == "nan":
+            continue
+                
+        if remove_close_to_MST and "closest_pairs" in im:
+            continue
+        
+        if remove_random_n and im in imgs_to_remove:
+            continue
+            
+        vox_image_names = np.append(vox_image_names, im)
+        image_idx_ = np.where(im == unique_images)[0].item()
+        image_idx = np.append(image_idx, image_idx_)
+        
+        if sub == 'ses-01' and session in ('ses-01', 'ses-04'):
+            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)):
+                all_MST_images[i] = im
+        elif 'MST' in im:
+            all_MST_images[i] = im
+    
+    image_idx = torch.Tensor(image_idx).long()
+    unique_MST_images = np.unique(list(all_MST_images.values()))
+    
+    MST_ID = np.array([], dtype=int)
+    if remove_close_to_MST:
+        close_to_MST_idx = np.array([], dtype=int)
+    if remove_random_n:
+        random_n_idx = np.array([], dtype=int)
+    
+    vox_idx = np.array([], dtype=int)
+    j = 0  # Counter for indexing vox based on removed images
+    
+    for i, im in enumerate(image_names):
+        if im == "blank.jpg" or str(im) == "nan":
+            continue
+        
+        if remove_close_to_MST and "closest_pairs" in im:
+            close_to_MST_idx = np.append(close_to_MST_idx, i)
+            continue
+        
+        if remove_random_n and im in imgs_to_remove:
+            vox_idx = np.append(vox_idx, j)
+            j += 1
+            continue
+        
+        j += 1
+        curr = np.where(im == unique_MST_images)
+        
+        if curr[0].size == 0:
+            MST_ID = np.append(MST_ID, len(unique_MST_images))  # Out of range index for filtering later
+        else:
+            MST_ID = np.append(MST_ID, curr)
+    
+    assert len(MST_ID) == len(image_idx)
+    
+    pairs = find_paired_indices(image_idx)
+    pairs = sorted(pairs, key=lambda x: x[0])
+    
+    return image_idx, vox_image_names, pairs
+
+def find_all_indices(list_, element):
+    return [index for index, value in enumerate(list_) if value == element]
+
+
+# ENIGMA borrowed code
+
+from tqdm import tqdm
+import open_clip
+
+class CLIPEncoder:
+    def __init__(
+        self,
+        model_name="ViT-H-14",
+        pretrained="laion2b_s32b_b79k",
+        precision="fp32",
+        batch_size: int = 20,
+        device="cuda",
+        **kwargs,
+    ):
+        self.batch_size = batch_size
+        self.model, self.preprocess, _ = open_clip.create_model_and_transforms(
+            model_name, pretrained, precision, device=device, **kwargs
+        )
+        self.tokenizer = open_clip.get_tokenizer(model_name)
+        self.device = device
+
+    def encode_text(self, text, normalize=False):
+        features = []
+        for i in tqdm(
+            range(0, len(text), self.batch_size), desc="CLIP Encoding text..."
+        ):
+            batch_text = text[i : min(i + self.batch_size, len(text))]
+            inputs = self.tokenizer(batch_text).to(self.device)
+            with torch.no_grad():
+                batch_features = self.model.encode_text(inputs)
+                if normalize:
+                    batch_features = F.normalize(batch_features, dim=-1)
+            features.append(batch_features)
+        features = torch.cat(features, dim=0)
+        return features.detach().cpu()
+
+    def encode_image(self, image, verbose = False):
+        if isinstance(image, Image.Image):
+            image = [image]
+        elif isinstance(image, torch.Tensor):
+            if image.ndim == 3:
+                image = [image]
+            elif image.ndim != 4:
+                raise ValueError("Invalid tensor shape for image encoding.")
+
+        elif isinstance(image, list) and all(
+            isinstance(img, Image.Image) for img in image
+        ):
+            image = [self.preprocess(img.convert("RGB")) for img in image]
+        elif isinstance(image, list) and all(
+            isinstance(img, torch.Tensor) for img in image
+        ):
+            image = [
+                img.unsqueeze(0) if img.ndim == 3 else img for img in image
+            ]
+        elif isinstance(image, list) and all(
+            isinstance(img, str) for img in image
+        ):
+            print("Preprocessing images...")
+            preprocessed_image = []
+            for i in tqdm(
+                range(0, len(image)),
+                desc="CLIP Preprocessing images...",
+            ):
+                preprocessed_image.append(
+                    self.preprocess(Image.open(image[i]).convert("RGB"))
+                )
+            image = preprocessed_image
+        else:
+            raise ValueError("Unsupported image type for encoding.")
+
+        features = []
+        if verbose:
+            iterator = tqdm(
+                range(0, len(image), self.batch_size),
+                desc="CLIP Encoding images...",
+            )
+        else:
+            iterator = range(0, len(image), self.batch_size)
+            
+        for i in iterator:
+            batch_images = image[i : min(i + self.batch_size, len(image))]
+            if isinstance(batch_images, list):
+                batch_images = torch.stack(batch_images)
+            with torch.no_grad():
+                batch_features = self.model.encode_image(
+                    batch_images.to(self.device)
+                )
+            features.append(batch_features)
+
+        features = torch.cat(features, dim=0)
+        return features.detach()
+
+    def __call__(self, image):
+        return self.encode_image(image).unsqueeze(1) # patch to make it compatible with old ME2 embedder