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