def run_anal(mask_path: str, bold_path: str, sl_rad: float, max_blk_edge: int,
pool_size: int, nn_paths: list, part: int, save_dir: str,
rsa) -> bool:
"""
DOCS: TODO:
"""
# extract the subject string from the bold path
sub = bold_path.split("/")[-1].split(".")[0].split("_")[-1]
print("starting run {}".format(sub))
# this is to account for if we're using part 1 of the movie clip or part 2
if part == 1:
tr_start_idx = 0
tr_end_idx = 946
elif part == 2:
tr_start_idx = 946
tr_end_idx = 1976
# get the correct correlation matrices for alexnet
nncor_files = nnpart_files(part, nn_paths)
# nibabel load, this loads an object but not the numpy arrays of the data
mask_obj = nib.load(mask_path)
bold_obj = nib.load(bold_path)
# converting to numpy arrays
data = np.array(bold_obj.dataobj)[:, :, :, tr_start_idx:tr_end_idx]
mask = np.array(mask_obj.dataobj).astype(int)
sl = Searchlight(sl_rad=sl_rad, max_blk_edge=max_blk_edge)
sl.distribute([data], mask)
counter = 0
for nn_path in nncor_files:
# this is alexnet
bcvar = np.load(nn_path)
save_name = nn_path.split("/")[-1].split(".")[0]
# broadcast the NN matrix
sl.broadcast(bcvar)
# now the rsa part
sl_result = sl.run_searchlight(rsa, pool_size=pool_size)
sl_result[sl_result == None] = 0
sl_data = np.array(sl_result, dtype=float)
sl_img = nib.Nifti1Image(sl_data, affine=mask_obj.affine)
# save the result to file as a nifti image
save_path = os.path.join(save_dir, save_name + "_" + sub)
sl_img.to_filename(save_path + ".nii.gz")
counter += 1
if counter == len(nncor_files):
print("\nCOMPLETE SUCCESSFULLY\n")
return True
print("\nSOMETHING FAILED\n")
return False
def block_test(data, mask, max_blk_edge, rad):
comm = MPI.COMM_WORLD
rank = comm.rank
(dim0, dim1, dim2) = mask.shape
# Initialize dataset with known pattern
for subj in data:
if subj is not None:
for tr in range(subj.shape[3]):
for d1 in range(dim0):
for d2 in range(dim1):
for d3 in range(dim2):
subj[d1, d2, d3, tr] = np.array(
[d1, d2, d3, tr])
sl = Searchlight(sl_rad=rad, max_blk_edge=max_blk_edge)
sl.distribute(data, mask)
sl.broadcast(mask)
global_outputs = sl.run_block_function(block_test_sfn)
if rank == 0:
for d0 in range(rad, global_outputs.shape[0]-rad):
for d1 in range(rad, global_outputs.shape[1]-rad):
for d2 in range(rad, global_outputs.shape[2]-rad):
if mask[d0, d1, d2]:
assert np.array_equal(
np.array(global_outputs[d0, d1, d2]),
np.array([d0, d1, d2, 0]))
def block_test(data, mask, max_blk_edge, rad):
comm = MPI.COMM_WORLD
rank = comm.rank
size = comm.size
nsubj = len(data)
(dim0, dim1, dim2) = mask.shape
# Initialize dataset with known pattern
for subj in data:
if subj is not None:
for tr in range(subj.shape[3]):
for d1 in range(dim0):
for d2 in range(dim1):
for d3 in range(dim2):
subj[d1,d2,d3,tr] = np.array([ d1, d2, d3, tr])
def sfn(l,msk,myrad,bcast_var):
outmat = l[0][:,:,:,0]
outmat[~msk] = None
return outmat[rad:-rad,rad:-rad,rad:-rad]
sl = Searchlight(sl_rad=rad, max_blk_edge=max_blk_edge)
sl.distribute(data, mask)
sl.broadcast(mask)
global_outputs = sl.run_block_function(sfn)
if rank == 0:
for d0 in range(rad, global_outputs.shape[0]-rad):
for d1 in range(rad, global_outputs.shape[1]-rad):
for d2 in range(rad, global_outputs.shape[2]-rad):
if mask[d0, d1, d2]:
assert np.array_equal(np.array(global_outputs[d0,d1,d2]), np.array([d0,d1,d2,0]))
def block_test(data, mask, max_blk_edge, rad):
comm = MPI.COMM_WORLD
rank = comm.rank
(dim0, dim1, dim2) = mask.shape
# Initialize dataset with known pattern
for subj in data:
if subj is not None:
for tr in range(subj.shape[3]):
for d1 in range(dim0):
for d2 in range(dim1):
for d3 in range(dim2):
subj[d1, d2, d3, tr] = np.array(
[d1, d2, d3, tr])
sl = Searchlight(sl_rad=rad, max_blk_edge=max_blk_edge)
sl.distribute(data, mask)
sl.broadcast(mask)
global_outputs = sl.run_block_function(block_test_sfn)
if rank == 0:
for d0 in range(rad, global_outputs.shape[0]-rad):
for d1 in range(rad, global_outputs.shape[1]-rad):
for d2 in range(rad, global_outputs.shape[2]-rad):
if mask[d0, d1, d2]:
assert np.array_equal(
np.array(global_outputs[d0, d1, d2]),
np.array([d0, d1, d2, 0]))
def block_test(data, mask, max_blk_edge, rad):
comm = MPI.COMM_WORLD
rank = comm.rank
size = comm.size
nsubj = len(data)
(dim0, dim1, dim2) = mask.shape
# Initialize dataset with known pattern
for subj in data:
if subj is not None:
for tr in range(subj.shape[3]):
for d1 in range(dim0):
for d2 in range(dim1):
for d3 in range(dim2):
subj[d1,d2,d3,tr] = np.array([ d1, d2, d3, tr])
def sfn(l,msk,myrad,bcast_var, extra_params):
outmat = l[0][:,:,:,0]
outmat[~msk] = None
return outmat[rad:-rad,rad:-rad,rad:-rad]
sl = Searchlight(sl_rad=rad, max_blk_edge=max_blk_edge)
sl.distribute(data, mask)
sl.broadcast(mask)
global_outputs = sl.run_block_function(sfn)
if rank == 0:
for d0 in range(rad, global_outputs.shape[0]-rad):
for d1 in range(rad, global_outputs.shape[1]-rad):
for d2 in range(rad, global_outputs.shape[2]-rad):
if mask[d0, d1, d2]:
assert np.array_equal(np.array(global_outputs[d0,d1,d2]), np.array([d0,d1,d2,0]))
def voxel_test(data, mask, max_blk_edge, rad):
comm = MPI.COMM_WORLD
rank = comm.rank
size = comm.size
nsubj = len(data)
(dim0, dim1, dim2) = mask.shape
# Initialize dataset with known pattern
for subj in data:
if subj is not None:
for tr in range(subj.shape[3]):
for d1 in range(dim0):
for d2 in range(dim1):
for d3 in range(dim2):
subj[d1,d2,d3,tr] = np.array([d1, d2, d3, tr])
def sfn(l,msk,myrad,bcast_var):
# Check each point
for subj in l:
for _tr in range(subj.shape[3]):
tr = subj[:,:,:,_tr]
midpt = tr[rad,rad,rad]
for d0 in range(tr.shape[0]):
for d1 in range(tr.shape[1]):
for d2 in range(tr.shape[2]):
assert np.array_equal(tr[d0,d1,d2] - midpt, np.array([d0-rad,d1-rad,d2-rad,0]))
# Determine midpoint
midpt = l[0][rad,rad,rad,0]
midpt = (midpt[0], midpt[1], midpt[2])
for d0 in range(msk.shape[0]):
for d1 in range(msk.shape[1]):
for d2 in range(msk.shape[2]):
pt = (midpt[0] - rad + d0, midpt[1] - rad + d1, midpt[2] - rad + d2)
assert bcast_var[pt] == msk[d0,d1,d2]
# Return midpoint
return midpt
sl = Searchlight(sl_rad=rad, max_blk_edge=max_blk_edge)
sl.distribute(data, mask)
sl.broadcast(mask)
global_outputs = sl.run_searchlight(sfn)
if rank == 0:
for d0 in range(rad, global_outputs.shape[0]-rad):
for d1 in range(rad, global_outputs.shape[1]-rad):
for d2 in range(rad, global_outputs.shape[2]-rad):
if mask[d0, d1, d2]:
assert np.array_equal(np.array(global_outputs[d0,d1,d2]), np.array([d0,d1,d2]))
for i in range(len(subjs)):
# Load functional data and mask data
data1 = load_img(datadir + 'subjects/' + subjs[i] +
'/data/avg_reorder1.nii')
data2 = load_img(datadir + 'subjects/' + subjs[i] +
'/data/avg_reorder2.nii')
data1 = data1.get_data()
data2 = data2.get_data()
np.seterr(divide='ignore', invalid='ignore')
# Create and run searchlight
sl = Searchlight(sl_rad=1, max_blk_edge=5)
sl.distribute([data1, data2], mask_img)
sl.broadcast(None)
print('Running Searchlight...')
global_outputs = sl.run_searchlight(corr2_coeff)
global_outputs_all[:, :, :, i] = global_outputs
# Plot and save searchlight results
global_outputs_avg = np.mean(global_outputs_all, 3)
maxval = np.max(global_outputs_avg[np.not_equal(global_outputs_avg, None)])
minval = np.min(global_outputs_avg[np.not_equal(global_outputs_avg, None)])
global_outputs = np.array(global_outputs_avg, dtype=np.float)
global_nonans = global_outputs[np.not_equal(global_outputs, None)]
global_nonans = np.reshape(global_nonans, (91, 109, 91))
min1 = np.min(global_nonans[~np.isnan(global_nonans)])
max1 = np.max(global_nonans[~np.isnan(global_nonans)])
img = nib.Nifti1Image(global_nonans, np.eye(4))
img.header['cal_min'] = min1
print('Subject: ',subjs[i])
data_run1 = np.nan_to_num(load_img(datadir + 'subjects/' + subjs[i] + '/analysis/run1.feat/trans_filtered_func_data.nii').get_data()[:,:,:,0:628])
runs.append(data_run1)
for i in range(len(subjs)):
data_run2 = np.nan_to_num(load_img(datadir + 'subjects/' + subjs[i] + '/data/avg_reorder2.nii').get_data())
runs.append(data_run2)
print("All Subjects Loaded")
#np.seterr(divide='ignore',invalid='ignore')
# Create and run searchlight
sl = Searchlight(sl_rad=5,max_blk_edge=5)
sl.distribute(runs,mask_img)
sl.broadcast([nfeature,niter,loo_idx])
print('Running Searchlight...')
global_outputs = sl.run_searchlight(corr2_coeff)
global_outputs_all[:,:,:,i] = global_outputs
# Plot and save searchlight results
global_outputs_avg = np.mean(global_outputs_all,3)
#maxval = np.max(global_outputs_avg[np.not_equal(global_outputs_avg,None)])
#minval = np.min(global_outputs_avg[np.not_equal(global_outputs_avg,None)])
global_outputs_avg = np.array(global_outputs_avg, dtype=np.float)
#global_nonans = global_outputs_avg[np.not_equal(global_outputs_avg,None)]
#global_nonans = np.reshape(global_nonans,(91,109,91))
#img = nib.Nifti1Image(global_nonans, np.eye(4))
#img.header['cal_min'] = minval
#img.header['cal_max'] = maxval
#nib.save(img,datadir + 'prototype/link/scripts/data/searchlight_output/janice_srm_results/loo_' + subjs[loo_idx])
bcvar = [metas]
# say some things about the mask.
print('mask dimensions: {}'.format(mask.shape))
print('number of voxels in mask: {}'.format(np.sum(mask)))
sl_rad = radius
max_blk_edge = 5
pool_size = 1
# Create the searchlight object
sl = Searchlight(sl_rad=sl_rad, max_blk_edge=max_blk_edge)
# Distribute the information to the searchlights (preparing it to run)
sl.distribute(data, mask)
sl.broadcast(bcvar)
slstart = time.time()
sl_result = sl.run_searchlight(Class)
#result = Class(data, np.zeros((5,5,5)), 2, bcvar)
SL = time.time() - slstart
tot = time.time() - starttime
print('total time: {}, searchlight time: {}'.format(tot, SL))
'''
# Only save the data if this is the first core
if rank == 0:
output = ('{}/{}_r{}.npy'.format(outloc, subject, radius))
#np.save(output, sl_result)
sl_result = sl_result.astype('double')
stats.zscore(movie_data[:, :, :, :int(ntr / 2), s], axis=3,
ddof=1))
test_tmp = np.nan_to_num(
stats.zscore(movie_data[:, :, :, int(ntr / 2):, s], axis=3,
ddof=1))
all_data.append(np.concatenate((train_tmp, test_tmp), axis=3))
# Generate mask
mask = np.ones((dim1, dim2, dim3), dtype=np.bool)
# Create searchlight object
sl = Searchlight(sl_rad=sl_rad, max_blk_edge=max_blk_edge)
# Distribute data to processes
sl.distribute(all_data, mask)
sl.broadcast([n_iter, nfeature])
# time segment matching experiment
def timesegmentmatching_accuracy(data, win_size=6):
nsubjs = len(data)
(ndim, nsample) = data[0].shape
accu = np.zeros(shape=nsubjs)
nseg = nsample - win_size
# mysseg prediction prediction
trn_data = np.zeros((ndim * win_size, nseg))
# the trn data also include the tst data, but will be subtracted when
# calculating A
for m in range(nsubjs):
# compute shifted recall correlation matrix
shifted_corrmat = np.corrcoef(shifted)
# isolate off-diagonal values with video model temporal correlations > 0
# this was precomputed to save permutation runtime with:
# for k in range(1976):
# d = np.diag(np.corrcoef(video_model), k=k)
# if ~(d > 0).any():
# DIAG_LIMIT = k
# break
DIAG_LIMIT = 238
diag_mask = np.zeros_like(shifted_corrmat, dtype=bool)
for k in range(1, DIAG_LIMIT):
ix = kth_diag_indices(diag_mask, k)
diag_mask[ix] = True
recall_corrs = shifted_corrmat[diag_mask]
to_broadcast = (recall_corrs, diag_mask)
# create Searchlight object
sl = Searchlight(sl_rad=2)
# distribute data to processes
sl.distribute([scan_data], mask)
sl.broadcast(to_broadcast)
# run searchlight, save data
result = sl.run_searchlight(sfn)
np.save(result_path, result)
kernel [i,j,k] = np.exp(-np.dot(arr.T,arr))
kernel = kernel / np.sum(kernel)
for (idx, l) in enumerate(labels):
if l:
data[pt[0]:pt[0]+kernel_dim,pt[1]:pt[1]+kernel_dim,pt[2]:pt[2]+kernel_dim,idx] += kernel * weight
else:
data[pt[0]:pt[0]+kernel_dim,pt[1]:pt[1]+kernel_dim,pt[2]:pt[2]+kernel_dim,idx] -= kernel * weight
# Create searchlight object
sl = Searchlight(sl_rad=1, max_blk_edge=5, shape=Diamond,
min_active_voxels_proportion=0)
# Distribute data to processes
sl.distribute([data], mask)
sl.broadcast(labels)
# Define voxel function
def sfn(l, msk, myrad, bcast_var):
import sklearn.svm
import sklearn.model_selection
classifier = sklearn.svm.SVC()
data = l[0][msk,:].T
return np.mean(sklearn.model_selection.cross_val_score(classifier, data, bcast_var,n_jobs=1))
# Run searchlight
global_outputs = sl.run_searchlight(sfn)
# Visualize result
if rank == 0:
print(global_outputs)
)[:, :, :, 0:628])
runs.append(data_run1)
for i in range(len(subjs)):
data_run2 = np.nan_to_num(
load_img(datadir + 'subjects/' + subjs[i] +
'/data/avg_reorder2.nii').get_data())
runs.append(data_run2)
print("All Subjects Loaded")
#np.seterr(divide='ignore',invalid='ignore')
# Create and run searchlight
sl = Searchlight(sl_rad=5, max_blk_edge=5)
sl.distribute(runs, mask_img)
sl.broadcast([nfeature, niter, loo_idx, exclude_songs])
print('Running Searchlight...')
global_outputs = sl.run_searchlight(corr2_coeff, pool_size=1)
global_outputs_all[:, :, :, i] = global_outputs
# Plot and save searchlight results
global_outputs_avg = np.mean(global_outputs_all, 3)
#maxval = np.max(global_outputs_avg[np.not_equal(global_outputs_avg,None)])
#minval = np.min(global_outputs_avg[np.not_equal(global_outputs_avg,None)])
global_outputs_avg = np.array(global_outputs_avg, dtype=np.float)
#global_nonans = global_outputs_avg[np.not_equal(global_outputs_avg,None)]
#global_nonans = np.reshape(global_nonans,(91,109,91))
#img = nib.Nifti1Image(global_nonans, np.eye(4))
#img.header['cal_min'] = minval
#img.header['cal_max'] = maxval
#nib.save(img,datadir + 'prototype/link/scripts/data/searchlight_output/janice_srm_results/loo_' + subjs[loo_idx])
jazz_within = np.mean(corrAB[8:16,8:16])
classJazz_between = np.mean(corrAB[8:16,0:8])
jazzClass_between = np.mean(corrAB[0:8,8:16])
within_genre = np.mean([classical_within,jazz_within])
between_genre = np.mean([classJazz_between,jazzClass_between])
diff = within_genre - between_genre
return diff
comm.Barrier()
begin_time = time.time()
comm.Barrier()
# Create and run searchlight
sl = Searchlight(sl_rad=1,max_blk_edge=5)
sl.distribute([data1,data2],mask_img)
sl.broadcast(None)
global_outputs = sl.run_searchlight(corr2_coeff)
comm.Barrier()
end_time = time.time()
comm.Barrier()
# Plot searchlight results
if rank == 0:
print('Searchlight Done: ', end_time - begin_time)
maxval = np.max(global_outputs[np.not_equal(global_outputs,None)])
minval = np.min(global_outputs[np.not_equal(global_outputs,None)])
global_outputs = np.array(global_outputs, dtype=np.float)
print(global_outputs)
# Save searchlight images
def run_rsa_sub(sub,
model_rdms,
procedure,
corr,
tasks=TASKS,
overwrite=False,
val_label=None,
pred=None,
dist='correlation'):
"""
sub: str subject ID
model_rdms: dictionary with model names as keys and lower triangles of RDMs as elements
tasks: array of task names: friend, number, avg
"""
# check type of input arguments
# subject id
sub = convert2subid(sub)
# get labels
corr_label = 'spear' if corr == 'corr' else 'reg'
if val_label is None:
val_label = 'r' if corr == 'corr' else 'beta'
elif val_label == "R2" and corr != 'reg':
print("ERROR: cannot calculate R2 with corr label '" + corr +
"'. Must be 'reg'")
exit(1)
parc_label = SL + str(SL_RADIUS) if isSl(procedure) else PARC_LAB
# make output directories if they don't exist
if not os.path.exists(out_dir % (sub, corr_label, dist)):
os.makedirs(out_dir % (sub, corr_label, dist))
# tasks to run
if not isinstance(tasks, list):
tasks = [tasks]
# dictionary of model representational dissimilarity matrices (lower triangles)
if not isinstance(model_rdms, dict):
if isinstance(model_rdms, list):
model_rdms = {'model': model_rdms}
else:
print("ERROR: model_rdms input must be dictionary")
exit(1)
# procedure to run
if procedure not in PROCEDURES_ALL:
print("ERROR: procedure is not in PROCEDURES_ALL")
print(PROCEDURES_ALL)
exit(1)
# reference image for saving parcellation output
parcellation_template = nib.load(MNI_PARCELLATION, mmap=False)
parcellation_template.set_data_dtype(np.double)
# get model names
model_keys = [pred] if val_label == "R2" else model_rdms.keys()
print(
str(datetime.now()) + ": Using the following models to get " +
val_label + " values")
print(model_rdms.keys())
# turn model dictionary into matrix, s.t. column = model RDM lower triangle
for i, k in enumerate(model_rdms.keys()):
if i == 0:
# if first model, setup matrix
model_rdms_mat = [model_rdms[k]]
else:
# add next matrix as row
model_rdms_mat = np.vstack((model_rdms_mat, model_rdms[k]))
# transpose so that each column corresponds to each measure
model_rdms_mat = np.transpose(model_rdms_mat)
out_tasks = {}
# iterate through inputted tasks
for task in tasks:
print(str(datetime.now()) + ": Task " + task)
# read in subject's image
sub_template = nib.load(data_fnames % (sub, sub, TASKS[0], 0),
mmap=False)
sub_dims = sub_template.get_data().shape + (N_NODES, )
sub_data = np.empty(sub_dims)
for n in range(N_NODES):
print(str(datetime.now()) + ": Reading in node " + str(n))
if task == 'avg':
# average this node's data from both runs
d1 = load_nii(data_fnames % (sub, sub, TASKS[0], n))
d2 = load_nii(data_fnames % (sub, sub, TASKS[1], n))
d = (d1 + d2) / 2
else:
d = load_nii(data_fnames % (sub, sub, task, n))
# save to fourth dimension
sub_data[:, :, :, n] = d
out_data_dict = {}
if isParc(procedure):
# out csv filename
sub_csv_fname = csv_fname % (sub, corr_label, dist, sub, task,
corr_label, parc_label, val_label)
if (not overwrite) and os.path.isfile(sub_csv_fname):
read_bool = True
# read in csv if already exists
sub_csv = pd.read_csv(sub_csv_fname)
# remove row column
sub_csv = sub_csv.iloc[:, 1:]
# save all completed ROIs except for last one (since may not have been finished)
completed_rois = np.unique(sub_csv['roi'])
sub_csv = sub_csv[sub_csv['roi'].isin(completed_rois)]
sub_csv.to_csv(sub_csv_fname)
out_csv_array = sub_csv.values.tolist()
completed_preds = np.unique(sub_csv['predictor'])
else:
if os.path.isfile(sub_csv_fname):
os.remove(sub_csv_fname)
print("Deleted " + sub_csv_fname)
read_bool = False
out_csv_array = []
completed_rois = []
completed_preds = []
wtr = csv.writer(open(sub_csv_fname, 'a'),
delimiter=',',
lineterminator='\n')
# column names for csv file
colnames = ['sub', 'task', 'roi', 'predictor', val_label]
if not read_bool:
# write out to csv
wtr.writerow(colnames)
ref_img = parcellation_template
# make mask
parcellation = sub_parc % (sub, sub)
print(str(datetime.now()) + ": Using parcellation " + parcellation)
parc_data = load_nii(parcellation)
roi_list = np.unique(parc_data)
# remove 0 (i.e., the background)
roi_list = np.delete(roi_list, 0)
# check if number of parcels matches global variable
if N_PARCELS != len(roi_list):
print("WARNING: Number of parcels found (" +
str(len(roi_list)) + ") does not equal N_PARCELS (" +
str(N_PARCELS) + ")")
# Run regression on each parcellation
print(
str(datetime.now()) + ": Starting parcellation " +
str(N_PARCELS))
# get the voxels from parcellation nii
out_data = ref_img.get_data().astype(np.double)
# create a dictionary of nii's: one per predictor
for i, k in enumerate(model_keys):
out_data_dict[k] = deepcopy(out_data)
# iterate through each ROI of parcellation and run regression
for r, parc_roi in enumerate(roi_list):
roi_done = parc_roi in completed_rois and all(
mk in completed_preds for mk in model_keys)
if roi_done:
print(
str(datetime.now()) + ': ROI ' + str(parc_roi) +
' already saved.')
# read in values from dataframe for nii
res = get_roi_csv_val(sub_csv, parc_roi, val_label)
else:
perc_done = round(((r + 1) / len(roi_list)) * 100, 3)
print(
str(datetime.now()) + ': Analyzing ROI ' +
str(parc_roi) + ' -- ' + str(perc_done) + '%')
# create mask for this ROI
roi_mask = parc_data == parc_roi
roi_mask = roi_mask.astype(int)
roi_data = get_roi_data(sub_data, roi_mask)
res_dict = run_rsa_roi(roi_data,
model_rdms_mat,
corr=corr,
val_label=val_label,
dist=dist)
res = res_dict['result']
# for each model, save the result to its image in out_data_dict
for i, k in enumerate(model_keys):
# save to dataframe if not already there
if not roi_done:
val = res[i]
csv_row = [sub, task, parc_roi, k, val]
out_csv_array.append(csv_row)
# write out to csv
wtr.writerow(csv_row)
else:
val = res[i]
# update voxels
model_data = out_data_dict[k]
model_data[model_data == parc_roi] = val
out_data_dict[k] = model_data
elif isSl(procedure):
ref_img = sub_template
# mask
if use_mask:
# load all functional masks and make largest mask
t = task if task in TASKS else "*"
print(str(datetime.now()) + ": Reading in masks")
func_mask_names = glob.glob(sub_mask_fname % (sub, sub, t))
for i, m in enumerate(func_mask_names):
print(m)
m_data = load_nii(m)
if i == 0:
m_sum = deepcopy(m_data)
else:
m_sum += m_data
whole_brain_mask = np.where(m_sum > 0, 1, 0)
whole_brain_mask_dil = binary_dilation(
whole_brain_mask,
iterations=int(SL_RADIUS)).astype(whole_brain_mask.dtype)
mask = whole_brain_mask_dil
else:
mask = deepcopy(d)
mask.fill(1)
# Create the searchlight object
begin_time = time.time()
sl = Searchlight(sl_rad=sl_rad,
max_blk_edge=max_blk_edge,
shape=Ball)
print(str(datetime.now()) + ": Setup searchlight inputs")
print(
str(datetime.now()) + ": Input data shape: " +
str(sub_data.shape))
# Distribute the information to the searchlights (preparing it to run)
print(str(datetime.now()) + ": Distributing searchlight")
sl.distribute([sub_data], mask)
# Data that is needed for all searchlights is sent to all cores via
# the sl.broadcast function. In this example, we are sending the
# labels for classification to all searchlights.
print(str(datetime.now()) + ": Broadcasting bcvar")
sl.broadcast(bcvar)
print(str(datetime.now()) + ": Shape of searchlight")
print(sl.shape)
# turn model dictionary into matrix, s.t. column = model RDM lower triangle
sl_result = run_rsa_searchlight(sl,
model_rdms_mat,
corr=corr,
val_label=val_label,
dist=dist)
end_time = time.time()
# Print outputs
print(
str(datetime.now()) + ": Number of searchlights run: " +
str(len(sl_result[mask == 1])))
print(
str(datetime.now()) +
': Total searchlight duration (including start up time): %.2f min'
% ((end_time - begin_time) / 60))
# separate values
for i, k in enumerate(model_keys):
out_data_dict[k] = deepcopy(sl_result)
for x in range(sl_result.shape[0]):
for y in range(sl_result.shape[1]):
for z in range(sl_result.shape[2]):
val = sl_result[x, y, z]
if val is None:
out_val = 0.
else:
out_val = val[i]
out_data_dict[k][x, y, z] = out_val
out_data_dict[k] = out_data_dict[k].astype('double')
# unindent if saving images in parcellation (in addition to csv)
# save images
for k in out_data_dict.keys():
fname = out_fname % (sub, corr_label, dist, sub, task,
corr_label, parc_label, val_label, k)
save_nii(out_data_dict[k], ref_img, fname)
# add to output array
out_tasks[task] = out_data_dict
out_tasks['ref_img'] = ref_img
return (out_tasks)
subid = sys.argv[1]
data = load_img(
'/idata/cdl/data/fMRI/andy/sherlock/data/sherlock_movie_s%s_10000.nii.gz' %
str(subid)).get_data()
mask = data[:, :, :, 0] != 10000
model = np.load('/idata/cdl/data/fMRI/andy/sherlock/data/movie_corrmat.npy')
params = dict(sl_rad=5)
# Create searchlight object
sl = Searchlight(**params)
# Distribute data to processes
sl.distribute([data], mask)
sl.broadcast(model)
# Define voxel function
def sfn(l, msk, myrad, bcast_var):
from scipy.spatial.distance import cdist
from scipy.stats import pearsonr
b = l[0][msk, :].T
c = 1 - cdist(b, b, 'correlation').ravel()
return pearsonr(c, bcast_var.ravel())[0]
# Run searchlight
result = sl.run_searchlight(sfn)
np.save(
kernel = kernel / np.sum(kernel)
for (idx, l) in enumerate(labels):
if l:
data[pt[0]:pt[0] + kernel_dim, pt[1]:pt[1] + kernel_dim,
pt[2]:pt[2] + kernel_dim, idx] += kernel * weight
else:
data[pt[0]:pt[0] + kernel_dim, pt[1]:pt[1] + kernel_dim,
pt[2]:pt[2] + kernel_dim, idx] -= kernel * weight
# Create searchlight object
sl = Searchlight(sl_rad=1, max_blk_edge=5, shape=Diamond)
# Distribute data to processes
sl.distribute([data], mask)
sl.broadcast(labels)
# Define voxel function
def sfn(l, msk, myrad, bcast_var):
import sklearn.svm
import sklearn.model_selection
classifier = sklearn.svm.SVC()
data = l[0][msk, :].T
return np.mean(
sklearn.model_selection.cross_val_score(classifier,
data,
bcast_var,
n_jobs=1))
print ('brain data dimension is {}-by-{}-by-{}'.format(dim1,dim2,dim3))
# Generate mask: mask is a 3D binary array, with active voxels being 1. I simply set
# all voxels to be active in this example, but you should set the mask to fit your ROI
# in practice.
mask = np.ones((dim1,dim2,dim3), dtype=np.bool)
# Create searchlight object
sl = Searchlight(sl_rad=sl_rad)
# Distribute data to processes
# the first argument of "distribute" is a list of 4D arrays, and each 4D array is data
# from a single subject
sl.distribute(all_data, mask)
# broadcast something that should be shared by all ranks
sl.broadcast([niter,nfeature])
# time segment matching experiment. Define your own experiment function here
def time_segment_matching_accuracy(data, win_size=6):
nsubjs = len(data)
(ndim, nsample) = data[0].shape
accu = np.zeros(shape=nsubjs)
nseg = nsample - win_size
# mysseg prediction prediction
trn_data = np.zeros((ndim*win_size, nseg),order='f')
# the trn data also include the tst data, but will be subtracted when
# calculating A
for m in range(nsubjs):
for w in range(win_size):
trn_data[w*ndim:(w+1)*ndim,:] += data[m][:,w:(w+nseg)]
for tst_subj in range(nsubjs):