diff --git "a/recon_inference-multisession_union_mask.ipynb" "b/recon_inference-multisession_union_mask.ipynb" new file mode 100644--- /dev/null +++ "b/recon_inference-multisession_union_mask.ipynb" @@ -0,0 +1,2077 @@ +{ + "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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ubuntu/rt_sdxlturbo/lib/python3.11/site-packages/timm/models/layers/__init__.py:48: FutureWarning: Importing from timm.models.layers is deprecated, please import via timm.layers\n", + " warnings.warn(f\"Importing from {__name__} is deprecated, please import via timm.layers\", FutureWarning)\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/ubuntu/mindeye_preproc/analysis/utils.py\" # \"/home/ri4541/mindeye_preproc/analysis/utils.py\" \n", + "spec = importlib.util.spec_from_file_location(\"utils\", parent_utils_path)\n", + "preproc = importlib.util.module_from_spec(spec)\n", + "parent_dir = os.path.dirname(parent_utils_path)\n", + "if parent_dir not in sys.path:\n", + " sys.path.append(parent_dir)\n", + "spec.loader.exec_module(preproc)\n", + "\n", + "if utils.is_interactive():\n", + " from IPython.display import clear_output # function to clear print outputs in cell\n", + " %load_ext autoreload \n", + " # this allows you to change functions in models.py or utils.py and have this notebook automatically update with your revisions\n", + " %autoreload 2 " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "33a4a539-7c94-4447-b3a4-9208c6af7920", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "no module 'xformers'. Processing without...\n", + "no module 'xformers'. Processing without...\n" + ] + }, + { + "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 = \"all\"\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-01-02\n" + ] + } + ], + "source": [ + "session_label = preproc.get_session_label(ses_list)\n", + "print('session label:', session_label)\n", + "n_runs, _ = preproc.get_runs_per_session(sub, session, ses_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e52985b1-95ff-487b-8b2d-cc1ad1c190b8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_name: testing_MST_ViT-H_lh_120\n", + "glmsingle_path: /home/ubuntu/glmsingle/glmsingle_sub-005_ses-01-02_task-C\n", + "glmsingle path exists!\n", + "--data_path=/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2 --glmsingle_path=/home/ubuntu/glmsingle/glmsingle_sub-005_ses-01-02_task-C --model_name=testing_MST_ViT-H_lh_120 --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 = \"testing_MST_ViT-H_lh_120\"\n", + " print(\"model_name:\", model_name)\n", + " glmsingle_path = f\"/home/ubuntu/glmsingle/glmsingle_{sub}_{session_label}_task-{task}\" # 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": 6, + "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": 7, + "id": "34c1e0c6-0641-4239-8201-f2c676532302", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "csv/sub-005_ses-01.csv\n", + "(790, 122)\n", + "csv/sub-005_ses-02.csv\n", + "(1575, 122)\n", + "len_unique_images 1001\n", + "n_runs 22\n", + "['all_stimuli/special515/special_15939.jpg'\n", + " 'all_stimuli/special515/special_23241.jpg'\n", + " 'all_stimuli/special515/special_32232.jpg'\n", + " 'all_stimuli/special515/special_34238.jpg']\n", + "[190.2773371 194.2907918 198.3011098 202.3095724]\n", + "[0. 0. 0. 0.]\n", + "(1386,)\n" + ] + } + ], + "source": [ + "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": 8, + "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": 9, + "id": "59bc3b21-e29d-4d2b-8223-cd704e3f058a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/1386 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from nilearn.plotting import plot_roi\n", + "assert sub == 'sub-005' and session_label == 'ses-01-02'\n", + "print('loading brain mask')\n", + "avg_mask = nib.load(\"/home/ubuntu/3t_data/data/sub-005_final_brain.nii.gz\") # '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_brain.nii.gz'\n", + "final_mask = nib.load(\"/home/ubuntu/3t_data/data/sub-005_final_mask.nii.gz\") # '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/sub-005_final_mask.nii.gz'\n", + "\n", + "# mask info\n", + "dimsize=avg_mask.header.get_zooms()\n", + "affine_mat = avg_mask.affine\n", + "brain=avg_mask.get_fdata()\n", + "xyz=brain.shape #xyz dimensionality of brain mask and epi data\n", + "\n", + "print('Mask dimensions:', dimsize)\n", + "print('')\n", + "print('Affine:')\n", + "print(affine_mat)\n", + "print('')\n", + "print(f'There are {int(np.sum(brain))} voxels in the included brain mask\\n')\n", + "\n", + "plot_roi(final_mask, bg_img=avg_mask)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "843dc2fd", + "metadata": {}, + "outputs": [], + "source": [ + "path = f'/home/ubuntu/3t_data/data/union_mask_from_{session_label}.npy' # f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_task-C/union_mask_from_{session_label}.npy'\n", + "union_mask = np.load(path)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3b36fc1d", + "metadata": {}, + "outputs": [], + "source": [ + "ses_mask = []\n", + "ses_mask.append(nib.load(f'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-01_task-C/sub-005_ses-01_task-C_brain.nii.gz')) # f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-01_task-C/sub-005_ses-01_task-C_brain.nii.gz'\n", + "ses_mask.append(nib.load(f'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-02_task-C/sub-005_ses-02_task-C_brain.nii.gz')) # f'/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-02_task-C/sub-005_ses-02_task-C_brain.nii.gz'\n", + "for m in ses_mask:\n", + " assert np.all(m.affine == final_mask.affine)\n", + " assert np.all(m.shape == final_mask.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e1f7cd2a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vox (693, 1, 1, 182242)\n", + "vox (693, 182242)\n", + "vox (693, 1, 1, 183159)\n", + "vox (693, 183159)\n", + "applied final brain mask\n", + "(1386, 19174)\n", + "applied union roi mask\n", + "(1386, 8627)\n" + ] + } + ], + "source": [ + "ses_vox = []\n", + "vox = None\n", + "needs_postprocessing = False\n", + "params = (session, ses_list, remove_close_to_MST, image_names, remove_random_n, vox_idx)\n", + "\n", + "if resample_post_glmsingle == True:\n", + " glm_save_path_resampled = f\"{glmsingle_path}/vox_resampled.nii.gz\"\n", + " if load_from_resampled_file == True:\n", + " # resampling was done in this notebook so we can load from file\n", + " vox = nib.load(glm_save_path_resampled)\n", + " else:\n", + " # do resampling here\n", + " assert os.path.exists(ref_name) and os.path.exists(omat_name), \"need to generate the boldref and omat separately since we don't have access to the functional data here; either do so using flirt on the command line or copy over the glmsingle resampled outputs\"\n", + " vox = load_preprocess_betas(orig_glmsingle_path, *params)\n", + " vox = resample_betas(orig_glmsingle_path, sub, session, task_name, vox, glmsingle_path, glm_save_path_resampled, ref_name, omat_name)\n", + " needs_postprocessing = True\n", + "\n", + "if vox is None:\n", + " # either resampling was done in glmsingle or we aren't resampling \n", + " ses_vox.append(load_preprocess_betas(f'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-01_task-C', *params)) # '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-01_task-C'\n", + " ses_vox.append(load_preprocess_betas(f'/home/ubuntu/glmsingle/glmsingle_sub-005_ses-02_task-C', *params)) # '/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/glmsingle_sub-005_ses-02_task-C'\n", + " for i, v in enumerate(ses_vox):\n", + " v = nilearn.masking.unmask(v, ses_mask[i])\n", + " ses_vox[i] = nilearn.masking.apply_mask(v, final_mask)\n", + " vox = np.concatenate(ses_vox)\n", + " print(\"applied final brain mask\")\n", + " print(vox.shape)\n", + " vox = vox[:, union_mask]\n", + " print(\"applied union roi mask\")\n", + " print(vox.shape)\n", + " \n", + " \n", + "if needs_postprocessing == True:\n", + " vox = apply_mask(vox, avg_mask)\n", + " vox = vox.reshape(-1, vox.shape[-1]) # flatten the 3D image into np array with shape (voxels, images)\n", + " print(vox.shape)\n", + "\n", + "assert len(vox) == len(image_idx)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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": 20, + "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": 21, + "id": "a292cfad-83f4-4bf8-994e-da2c871c0a6c", + "metadata": {}, + "outputs": [], + "source": [ + "# test_image_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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": 23, + "id": "5528d877-b662-41f7-8982-3f31051871f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voxels have been zscored\n", + "-0.08859582 0.99191713\n", + "vox (1386, 8627)\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": 24, + "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": 25, + "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": 26, + "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": 27, + "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": 37, + "id": "de0400d4-cbd6-4941-a0b2-1a4bc2ae97da", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FrozenOpenCLIPImageEmbedder(\n", + " (model): CLIP(\n", + " (visual): VisionTransformer(\n", + " (conv1): Conv2d(3, 1280, kernel_size=(14, 14), stride=(14, 14), bias=False)\n", + " (patch_dropout): Identity()\n", + " (ln_pre): LayerNorm((1280,), eps=1e-05, elementwise_affine=True)\n", + " (transformer): Transformer(\n", + " (resblocks): ModuleList(\n", + " (0-31): 32 x ResidualAttentionBlock(\n", + " (ln_1): LayerNorm((1280,), eps=1e-05, elementwise_affine=True)\n", + " (attn): MultiheadAttention(\n", + " (out_proj): NonDynamicallyQuantizableLinear(in_features=1280, out_features=1280, bias=True)\n", + " )\n", + " (ls_1): Identity()\n", + " (ln_2): LayerNorm((1280,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): Sequential(\n", + " (c_fc): Linear(in_features=1280, out_features=5120, bias=True)\n", + " (gelu): GELU(approximate='none')\n", + " (c_proj): Linear(in_features=5120, out_features=1280, bias=True)\n", + " )\n", + " (ls_2): Identity()\n", + " )\n", + " )\n", + " )\n", + " (ln_post): LayerNorm((1280,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + " (token_embedding): Embedding(49408, 1024)\n", + " (ln_final): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n", + " )\n", + ")\n" + ] + } + ], + "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-H-14\",\n", + " version=\"laion2b_s32b_b79k\",\n", + " output_tokens=True,\n", + " only_tokens=True,\n", + " )\n", + " clip_img_embedder.to(device)\n", + "clip_seq_dim = 256\n", + "clip_emb_dim = 1280" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "56b606a4-7302-4ac5-b89d-bbe4fcb00d11", + "metadata": {}, + "outputs": [], + "source": [ + "import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "e452b5b2-47d9-4271-b9fc-ea331fbac1bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MindEyeModule()\n", + "param counts:\n", + "8,835,072 total\n", + "8,835,072 trainable\n", + "param counts:\n", + "8,835,072 total\n", + "8,835,072 trainable\n", + "param counts:\n", + "349,203,736 total\n", + "349,203,736 trainable\n", + "param counts:\n", + "358,038,808 total\n", + "358,038,808 trainable\n", + "param counts:\n", + "153,693,568 total\n", + "153,693,552 trainable\n", + "param counts:\n", + "511,732,376 total\n", + "511,732,360 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": 41, + "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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\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:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n", + "WARNING:sgm.modules.attention:Attention mode 'softmax-xformers' is not available. Falling back to native attention. This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version 2.4.1+cu121.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False\n", + "Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False\n", + "Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_75080/493861108.py:29: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " ckpt = torch.load(ckpt_path, map_location='cpu')\n", + "/home/ubuntu/real_time_mindEye2/generative_models/sgm/util.py:54: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", + " with torch.cuda.amp.autocast(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "vector_suffix torch.Size([1, 1024])\n" + ] + } + ], + "source": [ + "# prep unCLIP\n", + "config = OmegaConf.load(\"/home/ubuntu/real_time_mindEye2/generative_models/configs/unclip6.yaml\") # /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 = '/home/ubuntu/rt_mindEye/unclip6_epoch0_step110000.ckpt' # '/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": 42, + "id": "68abd440-7e6b-4023-9dc8-05b1b5c0baa9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using a slow image processor as `use_fast` is unset and a slow processor was saved with this model. `use_fast=True` will be the default behavior in v4.52, even if the model was saved with a slow processor. This will result in minor differences in outputs. You'll still be able to use a slow processor with `use_fast=False`.\n", + "GitForCausalLMClipEmb has generative capabilities, as `prepare_inputs_for_generation` is explicitly defined. However, it doesn't directly inherit from `GenerationMixin`. From 👉v4.50👈 onwards, `PreTrainedModel` will NOT inherit from `GenerationMixin`, and this model will lose the ability to call `generate` and other related functions.\n", + " - If you're using `trust_remote_code=True`, you can get rid of this warning by loading the model with an auto class. See https://huggingface.co/docs/transformers/en/model_doc/auto#auto-classes\n", + " - If you are the owner of the model architecture code, please modify your model class such that it inherits from `GenerationMixin` (after `PreTrainedModel`, otherwise you'll get an exception).\n", + " - If you are not the owner of the model architecture class, please contact the model code owner to update it.\n", + "GitForCausalLMClipEmb has generative capabilities, as `prepare_inputs_for_generation` is explicitly defined. However, it doesn't directly inherit from `GenerationMixin`. From 👉v4.50👈 onwards, `PreTrainedModel` will NOT inherit from `GenerationMixin`, and this model will lose the ability to call `generate` and other related functions.\n", + " - If you're using `trust_remote_code=True`, you can get rid of this warning by loading the model with an auto class. See https://huggingface.co/docs/transformers/en/model_doc/auto#auto-classes\n", + " - If you are the owner of the model architecture code, please modify your model class such that it inherits from `GenerationMixin` (after `PreTrainedModel`, otherwise you'll get an exception).\n", + " - If you are not the owner of the model architecture class, please contact the model code owner to update it.\n", + "GitForCausalLMClipEmb has generative capabilities, as `prepare_inputs_for_generation` is explicitly defined. However, it doesn't directly inherit from `GenerationMixin`. From 👉v4.50👈 onwards, `PreTrainedModel` will NOT inherit from `GenerationMixin`, and this model will lose the ability to call `generate` and other related functions.\n", + " - If you're using `trust_remote_code=True`, you can get rid of this warning by loading the model with an auto class. See https://huggingface.co/docs/transformers/en/model_doc/auto#auto-classes\n", + " - If you are the owner of the model architecture code, please modify your model class such that it inherits from `GenerationMixin` (after `PreTrainedModel`, otherwise you'll get an exception).\n", + " - If you are not the owner of the model architecture class, please contact the model code owner to update it.\n", + "/tmp/ipykernel_75080/440297174.py:26: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " state_dict = torch.load(\"/home/ubuntu/rt_mindEye/bigG_to_L_epoch8.pth\", map_location='cpu')['model_state_dict'] # \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/bigG_to_L_epoch8.pth\"\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Error(s) in loading state_dict for CLIPConverter:\n\tsize mismatch for linear2.weight: copying a param with shape torch.Size([1024, 1664]) from checkpoint, the shape in current model is torch.Size([1024, 1280]).", + "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[42]\u001b[39m\u001b[32m, line 27\u001b[39m\n\u001b[32m 25\u001b[39m clip_convert = CLIPConverter()\n\u001b[32m 26\u001b[39m state_dict = torch.load(\u001b[33m\"\u001b[39m\u001b[33m/home/ubuntu/rt_mindEye/bigG_to_L_epoch8.pth\u001b[39m\u001b[33m\"\u001b[39m, map_location=\u001b[33m'\u001b[39m\u001b[33mcpu\u001b[39m\u001b[33m'\u001b[39m)[\u001b[33m'\u001b[39m\u001b[33mmodel_state_dict\u001b[39m\u001b[33m'\u001b[39m] \u001b[38;5;66;03m# \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/bigG_to_L_epoch8.pth\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m27\u001b[39m \u001b[43mclip_convert\u001b[49m\u001b[43m.\u001b[49m\u001b[43mload_state_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate_dict\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrict\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 28\u001b[39m clip_convert.to(device) \u001b[38;5;66;03m# if you get OOM running this script, you can switch this to cpu and lower minibatch_size to 4\u001b[39;00m\n\u001b[32m 29\u001b[39m \u001b[38;5;28;01mdel\u001b[39;00m state_dict\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/rt_sdxlturbo/lib/python3.11/site-packages/torch/nn/modules/module.py:2215\u001b[39m, in \u001b[36mModule.load_state_dict\u001b[39m\u001b[34m(self, state_dict, strict, assign)\u001b[39m\n\u001b[32m 2210\u001b[39m error_msgs.insert(\n\u001b[32m 2211\u001b[39m \u001b[32m0\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mMissing key(s) in state_dict: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m. \u001b[39m\u001b[33m'\u001b[39m.format(\n\u001b[32m 2212\u001b[39m \u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m.join(\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\u001b[33m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m missing_keys)))\n\u001b[32m 2214\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(error_msgs) > \u001b[32m0\u001b[39m:\n\u001b[32m-> \u001b[39m\u001b[32m2215\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33m'\u001b[39m\u001b[33mError(s) in loading state_dict for \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m'\u001b[39m.format(\n\u001b[32m 2216\u001b[39m \u001b[38;5;28mself\u001b[39m.\u001b[34m__class__\u001b[39m.\u001b[34m__name__\u001b[39m, \u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[33m\"\u001b[39m.join(error_msgs)))\n\u001b[32m 2217\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m _IncompatibleKeys(missing_keys, unexpected_keys)\n", + "\u001b[31mRuntimeError\u001b[39m: Error(s) in loading state_dict for CLIPConverter:\n\tsize mismatch for linear2.weight: copying a param with shape torch.Size([1024, 1664]) from checkpoint, the shape in current model is torch.Size([1024, 1280])." + ] + } + ], + "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(\"microsoft/git-large-coco\") # \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2\"\n", + "clip_text_model = GitForCausalLMClipEmb.from_pretrained(\"microsoft/git-large-coco\") # \"/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(\"/home/ubuntu/rt_mindEye/bigG_to_L_epoch8.pth\", map_location='cpu')['model_state_dict'] # \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/bigG_to_L_epoch8.pth\"\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": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "---loading /home/ubuntu/real_time_mindEye2/train_logs/testing_MST_ViT-H_lh_120/last.pth ckpt---\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_75080/184505764.py:5: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " checkpoint = torch.load(outdir+f'/{tag}.pth', map_location='cpu')\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Error(s) in loading state_dict for MindEyeModule:\n\tsize mismatch for backbone.backbone_linear.weight: copying a param with shape torch.Size([327680, 1024]) from checkpoint, the shape in current model is torch.Size([425984, 1024]).\n\tsize mismatch for backbone.backbone_linear.bias: copying a param with shape torch.Size([327680]) from checkpoint, the shape in current model is torch.Size([425984]).\n\tsize mismatch for backbone.clip_proj.0.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.0.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.2.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.2.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.3.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.3.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.5.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.5.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.6.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.6.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.8.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.8.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.learned_query: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.null_brain_embeds: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.null_image_embed: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.0.0.weight: copying a param with shape torch.Size([2560, 1280]) from checkpoint, the shape in current model is torch.Size([3328, 1664]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.0.0.bias: copying a param with shape torch.Size([2560]) from checkpoint, the shape in current model is torch.Size([3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.1.0.weight: copying a param with shape torch.Size([2560, 2560]) from checkpoint, the shape in current model is torch.Size([3328, 3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.1.0.bias: copying a param with shape torch.Size([2560]) from checkpoint, the shape in current model is torch.Size([3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.2.weight: copying a param with shape torch.Size([1280, 2560]) from checkpoint, the shape in current model is torch.Size([1664, 3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.2.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.rel_pos_bias.relative_attention_bias.weight: copying a param with shape torch.Size([32, 24]) from checkpoint, the shape in current model is torch.Size([32, 32]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.project_out.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).", + "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[31]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 5\u001b[39m checkpoint = torch.load(outdir+\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtag\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m.pth\u001b[39m\u001b[33m'\u001b[39m, map_location=\u001b[33m'\u001b[39m\u001b[33mcpu\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 6\u001b[39m state_dict = checkpoint[\u001b[33m'\u001b[39m\u001b[33mmodel_state_dict\u001b[39m\u001b[33m'\u001b[39m]\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mload_state_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate_dict\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrict\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[38;5;28;01mdel\u001b[39;00m checkpoint\n\u001b[32m 9\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mckpt loaded!\u001b[39m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/rt_sdxlturbo/lib/python3.11/site-packages/torch/nn/modules/module.py:2215\u001b[39m, in \u001b[36mModule.load_state_dict\u001b[39m\u001b[34m(self, state_dict, strict, assign)\u001b[39m\n\u001b[32m 2210\u001b[39m error_msgs.insert(\n\u001b[32m 2211\u001b[39m \u001b[32m0\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mMissing key(s) in state_dict: \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m. \u001b[39m\u001b[33m'\u001b[39m.format(\n\u001b[32m 2212\u001b[39m \u001b[33m'\u001b[39m\u001b[33m, \u001b[39m\u001b[33m'\u001b[39m.join(\u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\u001b[33m'\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m missing_keys)))\n\u001b[32m 2214\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(error_msgs) > \u001b[32m0\u001b[39m:\n\u001b[32m-> \u001b[39m\u001b[32m2215\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33m'\u001b[39m\u001b[33mError(s) in loading state_dict for \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[33m'\u001b[39m.format(\n\u001b[32m 2216\u001b[39m \u001b[38;5;28mself\u001b[39m.\u001b[34m__class__\u001b[39m.\u001b[34m__name__\u001b[39m, \u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\t\u001b[39;00m\u001b[33m\"\u001b[39m.join(error_msgs)))\n\u001b[32m 2217\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m _IncompatibleKeys(missing_keys, unexpected_keys)\n", + "\u001b[31mRuntimeError\u001b[39m: Error(s) in loading state_dict for MindEyeModule:\n\tsize mismatch for backbone.backbone_linear.weight: copying a param with shape torch.Size([327680, 1024]) from checkpoint, the shape in current model is torch.Size([425984, 1024]).\n\tsize mismatch for backbone.backbone_linear.bias: copying a param with shape torch.Size([327680]) from checkpoint, the shape in current model is torch.Size([425984]).\n\tsize mismatch for backbone.clip_proj.0.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.0.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.2.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.2.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.3.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.3.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.5.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.5.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.6.weight: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.6.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for backbone.clip_proj.8.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for backbone.clip_proj.8.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.learned_query: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.null_brain_embeds: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.null_image_embed: copying a param with shape torch.Size([256, 1280]) from checkpoint, the shape in current model is torch.Size([256, 1664]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.0.0.weight: copying a param with shape torch.Size([2560, 1280]) from checkpoint, the shape in current model is torch.Size([3328, 1664]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.0.0.bias: copying a param with shape torch.Size([2560]) from checkpoint, the shape in current model is torch.Size([3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.1.0.weight: copying a param with shape torch.Size([2560, 2560]) from checkpoint, the shape in current model is torch.Size([3328, 3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.1.0.bias: copying a param with shape torch.Size([2560]) from checkpoint, the shape in current model is torch.Size([3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.2.weight: copying a param with shape torch.Size([1280, 2560]) from checkpoint, the shape in current model is torch.Size([1664, 3328]).\n\tsize mismatch for diffusion_prior.net.to_time_embeds.0.1.net.2.bias: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.rel_pos_bias.relative_attention_bias.weight: copying a param with shape torch.Size([32, 24]) from checkpoint, the shape in current model is torch.Size([32, 32]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.0.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.1.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.2.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.3.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.4.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_q.weight: copying a param with shape torch.Size([1248, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_kv.weight: copying a param with shape torch.Size([104, 1280]) from checkpoint, the shape in current model is torch.Size([104, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_out.0.weight: copying a param with shape torch.Size([1280, 1248]) from checkpoint, the shape in current model is torch.Size([1664, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.0.to_out.1.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.0.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.1.weight: copying a param with shape torch.Size([10240, 1280]) from checkpoint, the shape in current model is torch.Size([13312, 1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.layers.5.1.5.weight: copying a param with shape torch.Size([1280, 5120]) from checkpoint, the shape in current model is torch.Size([1664, 6656]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.norm.g: copying a param with shape torch.Size([1280]) from checkpoint, the shape in current model is torch.Size([1664]).\n\tsize mismatch for diffusion_prior.net.causal_transformer.project_out.weight: copying a param with shape torch.Size([1280, 1280]) from checkpoint, the shape in current model is torch.Size([1664, 1664])." + ] + } + ], + "source": [ + "# Load pretrained model ckpt\n", + "tag='last'\n", + "outdir = os.path.abspath(f'/home/ubuntu/real_time_mindEye2/train_logs/{model_name}') # 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": null, + "id": "8062afe3", + "metadata": {}, + "outputs": [], + "source": [ + "eval_dir = \"/scratch/gpfs/ri4541/MindEyeV2/src/mindeyev2/evals\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6a706a3-d151-4643-bb34-7d08aa7361c8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r\n", + " 0%| | 0/8 [00:00 92\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(\u001b[43meval_dir\u001b[49m):\n\u001b[1;32m 93\u001b[0m os\u001b[38;5;241m.\u001b[39mmkdir(eval_dir)\n\u001b[1;32m 95\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMST\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m model_name:\n", + "\u001b[0;31mNameError\u001b[0m: name 'eval_dir' is not defined" + ] + } + ], + "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 = False\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, len(voxel)+2, figsize=(20, 8))\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": "5bcd5050", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved sub-005_all_task-C_bs24_MST_rishab_MSTsplit_union_mask_finetune_0 outputs!\n" + ] + } + ], + "source": [ + "# 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": [ + { + "data": { + "text/plain": [ + "torch.Size([248, 3, 256, 256])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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_sdxlturbo", + "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 +}