def glm(image_ts, regressors):
'''
image_ts should be a matrix of the form (t x v) where t is the no. of timepoints
and v is the no. of voxels
regressors should be a matrix of the form (t x n) where t is the no. of timepoints
and n is the number of regressors
------------------
beta output is a serie of beta vector of the form (n x v).
'''
Y = image_ts
if len(regressors.shape) == 1:
X = np.expand_dims(regressors, axis=1)
else:
X = regressors
glm_dist = GeneralLinearModel(X)
glm_dist.transform(Y)
beta = glm_dist.get_beta()
return beta
def glm(image_ts, regressors):
'''
image_ts should be a matrix of the form (t x v) where t is the no. of timepoints
and v is the no. of voxels
regressors should be a matrix of the form (t x n) where t is the no. of timepoints
and n is the number of regressors
------------------
beta output is a serie of beta vector of the form (n x v).
'''
Y = image_ts
if len(regressors.shape) == 1:
X = np.expand_dims(regressors, axis=1)
else:
X = regressors
glm_dist = GeneralLinearModel(X)
glm_dist.transform(Y)
beta = glm_dist.get_beta()
return beta
def _fit_glm(X, Y, glm_model, model_tol=1e10):
design_mask = ~np.all(X == 0, axis=0)
design_mask = np.ones(X.shape[1], dtype=np.bool)
sv = np.linalg.svd(X[:, design_mask])[1]
sv = sv[0] / sv[-1]
if sv < model_tol:
glm = GeneralLinearModel(X[:, design_mask])
glm.fit(Y, model=glm_model)
return glm, design_mask
else:
return None, design_mask
def resting_dmn(sub, ses, in_file=None,
lh_ctx_file=None, rh_ctx_file=None, sc_file=None,
schedule_file=None):
from pipe_hbn_ssi import wb_to_tss
import os, sys
import numpy as np
sys.path.append('/home/bpinsard/data/projects/CoRe')
import core.mvpa.dataset as cds
from nipy.modalities.fmri.glm import GeneralLinearModel
import scipy.ndimage
from mvpa2.datasets import Dataset
sched = np.loadtxt(
schedule_file,
converters = {0:int,1:int,2:str,3:int,4:str,5:str},
dtype=np.object,
skiprows=1)
idx = sched[:,1].tolist().index(ses)
#scan_no = sched[idx,2].split('-').index('Rest')
if in_file is None:
scan_no = [i for i,n in enumerate(lh_ctx_file) if 'RESTING' in n]
else:
scan_no = [i for i,n in enumerate(in_file) if 'RESTING' in n]
scan_no = scan_no[0]
if in_file is None:
inf = lh_ctx_file[scan_no]
print(inf)
ds = Dataset(wb_to_tss(lh_ctx_file[scan_no], rh_ctx_file[scan_no], sc_file[scan_no]))
else:
inf = in_file[scan_no]
print(inf)
ds = cds.ds_from_ts(in_file[scan_no])
#cds.preproc_ds(ds, detrend=True)
ds.samples -= scipy.ndimage.gaussian_filter1d(ds.samples,sigma=8,axis=0,truncate=2)
seed_roi = 9
cds.add_aparc_ba_fa(ds, sub, pproc_tpl=os.path.join(pipe_hbn_ssi.proc_dir,'moco_multiband','surface_32k','_sub_%d'))
roi_mask = np.logical_or(ds.fa.aparc==seed_roi+11100, ds.fa.aparc==seed_roi+12100)
mean_roi_ts = ds.samples[:,roi_mask].mean(1)
mean_roi_ts -= mean_roi_ts.mean()
mtx = np.asarray([mean_roi_ts, np.ones(ds.nsamples)]).T
glm = GeneralLinearModel(mtx)
glm.fit(ds.samples,model='ols')
contrast = glm.contrast([1,0], contrast_type='t')
out_file = os.path.abspath('sub%d_ses%d_connectivity_results.npz'%(sub,ses))
np.savez_compressed(out_file, contrast=contrast, mean_roi_ts=mean_roi_ts)
#return contrast
return out_file, inf
def _do_nipy_glm_for_one_voxel(self, v_x, v_y, v_z):
"""
Does a NIPY GLM analysis for one voxel with coordinate (v_x, v_y, v_z).
Args:
v_x (int): x coordinate of the voxel
v_y (int): y coordinate of the voxel
v_z (int): z coordinate of the voxel
"""
voxel_time_course = np.atleast_2d(self._ni_data[v_x, v_y,
v_z, :]).T # Y data.
model = GeneralLinearModel(self._design_matrix)
model.fit(voxel_time_course)
z_val = model.contrast(self._contrast).z_score()
return z_val
def _nipy_glm(x, y):
"""
Parameters
----------
x:
y:
Returns
-------
nipy.GeneralLinearModel
"""
myglm = GeneralLinearModel(x)
myglm.fit(y)
return myglm
def global_signal_regression(timeserie, regressor):
#Get timeseries data
Y = timeserie.data.T
X = np.expand_dims(regressor, axis=1)
glm_dist = GeneralLinearModel(X)
glm_dist.transform(Y)
beta_dist = glm_dist.get_beta()
r_signal = np.dot(X, beta_dist)
regressed_s = Y - r_signal
return regressed_s
def global_signal_regression(timeserie, regressor):
#Get timeseries data
Y = timeserie.data.T
X = np.expand_dims(regressor, axis=1)
glm_dist = GeneralLinearModel(X)
glm_dist.transform(Y)
beta_dist = glm_dist.get_beta()
r_signal = np.dot(X, beta_dist)
regressed_s = Y - r_signal
return regressed_s
pylab.savefig(os.path.join(write_dir, 'design_matrix_%s.png') %\
session)
# get the data
if side == False:
Y, _ = data_scaling(np.array([load(f).get_data()[mask_array]
for f in fmri_data]))
affine = load(fmri_data[0]).get_affine()
else:
Y, _ = data_scaling(np.array(
[load_texture(f) for f in fmri_data]))
mask_array = np.var(Y, 0) > 0
Y = Y[:, mask_array]
# fit the glm
print 'Fitting a GLM (this takes time)...'
result = GeneralLinearModel(design_matrix.matrix)
result.fit(Y, model='ar1', steps=100)
for contrast_id, contrast_val in contrasts.iteritems():
if (contrast_val[session] == 0).all():
continue
if contrast_id in contrast_obj.keys():
contrast_obj[contrast_id] = contrast_obj[contrast_id] +\
result.contrast(contrast_val[session])
else:
contrast_obj[contrast_id] =\
result.contrast(contrast_val[session])
print 'Computing contrasts...'
# In fact, this only writes the output images/textures
X = [np.load(f)['X'] for f in design_files]
# Get multi-session fMRI data
print('Loading fmri data...')
Y = [load_image(f) for f in fmri_files]
# Get mask image
print('Loading mask...')
mask = load_image(mask_file)
mask_array, affine = mask.get_data() > 0, mask.get_affine()
# GLM fitting
print('Starting fit...')
glms = []
for x, y in zip(X, Y):
glm = GeneralLinearModel(x)
data, mean = data_scaling(y.get_data()[mask_array].T)
glm.fit(data, 'ar1')
glms.append(glm)
# Compute the required contrast
print('Computing test contrast image...')
nregressors = X[0].shape[1]
## should check that all design matrices have the same
c = np.zeros(nregressors)
c[0:4] = cvect
z_vals = (glms[0].contrast(c) + glms[1].contrast(c)).z_score()
# Show Zmap image
z_map = mask_array.astype(np.float)
z_map[mask_array] = z_vals
def snr_measures(premade_output = None):
studies = {'Diffusion1':'dMRI_AP1.nii.gz','Diffusion2':'dMRI_PA1.nii.gz','Diffusion3':'dMRI_AP2.nii.gz','Diffusion4':'dMRI_PA2.nii.gz','Rest1':'fMRI_rest1_AP.nii.gz', 'Rest2':'fMRI_rest2_PA.nii.gz', 'Rest3':'fMRI_rest3_AP.nii.gz', 'Rest4':'fMRI_rest4_PA.nii.gz', 'Gambling1':'tfMRI_gambling1_AP.nii.gz', 'Gambling2':'tfMRI_gambling2_PA.nii.gz','FaceMatching1':'tfMRI_faceMatching1_AP.nii.gz', 'FaceMatching2':'tfMRI_faceMatching2_PA.nii.gz', 'Conflict1':'tfMRI_conflict1_AP.nii.gz', 'Conflict2':'tfMRI_conflict2_PA.nii.gz', 'Conflict3':'tfMRI_conflict3_AP.nii.gz', 'Conflict4':'tfMRI_conflict4_PA.nii.gz', 'T2':'T2.nii.gz','T1':'T1.nii.gz'}
scans=['Diffusion1','Diffusion2','Diffusion3','Diffusion4','Rest1','Rest2','Rest3','Rest4','Gambling1','Gambling2','FaceMatching1','FaceMatching2','Conflict1','Conflict2','Conflict3','Conflict4','T1','T2']
diffusion=[ [0,98], [98,196],[196,295],[295,394]]
if premade_output == None:
snr_output=csv.writer(open('/autofs/space/erebus_001/users/data/scores/new2/snr_avg_output_wComposites_rjj020419.csv','w+'))
snr_output.writerow(['subject','avg_snr','questionnaire','questionnaire_score'])
subjects, sex, scores = utils.loadBANDA140(outliers)
#print(subjects)
for key, score in scores.items():
f, axarr = plt.subplots(1,1,figsize=(23,14))
#f.tight_layout()
f.subplots_adjust(left=.03, bottom=.06, right=.97, top=.95, wspace=.18, hspace=.30)
axarr.set_title(str(key))
#for calculating axis ranges
ymin_value = 0
ymax_value = 0
xmin_value = 0
xmax_value = 0
x_values = []
y_values = []
#for s in subjects:
for s_index,s in enumerate(subjects):
print (s)
if premade_output ==None:
snr_accumulate = 0
for scan in scans:
roi="/space/erebus/1/users/data/preprocess/"+s+"/snr/WMROI5001_2"+studies[scan]
image="/space/erebus/1/users/data/preprocess/"+s+"/"+studies[scan]
mean2="/space/erebus/1/users/data/preprocess/"+s+"/snr/mean"+studies[scan]
std2="/space/erebus/1/users/data/preprocess/"+s+"/snr/std"+studies[scan]
snr2="/space/erebus/1/users/data/preprocess/"+s+"/snr/snr"+studies[scan]
#ROI= nib.load("/space/erebus/1/users/data/preprocess/"+s+"/snr/WMROI4010_2"+studies[scan]).get_data()
#image = nib.load("/space/erebus/1/users/data/preprocess/"+s+"/"+studies[scan]).get_data()
snr=0
if os.path.isfile(image) :
#os.popen("mri_concat --i "+image+ " --mean --o "+mean2).read()
#os.popen("mri_concat --i "+image+ " --std --o "+std2).read()
if "T1" in scan or "T2" in scan:
mean=os.popen("fslstats "+image+" -k "+roi+" -m").read()
std=os.popen("fslstats "+image+" -k "+roi+" -s").read()
snr = float(mean.split("\n")[0])/float(std.split("\n")[0])
#print( snr)
elif os.path.isfile(std2):
#os.popen("fscalc "+mean2 +" div "+std2 +" --o " +snr2).read()
res=os.popen("fslstats "+snr2+" -k "+roi+" -m").read()
snr= float(res.split("\n")[0])
snr_accumulate+= snr
avg_snr = snr_accumulate/len(scans)
x = float(score[s_index])
y = avg_snr
snr_output.writerow([s,y,key,x])
else:
snr_accumulate = 0
for scan in scans:
with open('/space/erebus/1/users/data/scores/snr_output_master.csv', 'r') as output:
output_reader = csv.DictReader(output, delimiter = ",")
for row in iter(output_reader):
skip = 0
if str(row['subject'])==s:
print (row['subject'],s,key,scan)
if str(row['questionnaire'])==key and str(row['scan'])==scan:
print (key,scan)
snr_accumulate += float(row['score'])
if scans.index(scan) == 0: x = float(row['questionnaire_score'])
break
else:
if skip > 0:skip+= 70
else: skip+=69
for i in range(skip):
next(iter(output_reader))
avg_snr = snr_accumulate/len(scans)
y = avg_snr
axarr.plot(x, y, "o",markersize=5, c='m')
x_values.append(x)
y_values.append(y)
if s_index == 0: ymin_value = y
ymin_value = min(ymin_value,y)
ymax_value = max(ymax_value,y)
if s_index == 0: xmin_value = x
xmin_value = min(xmin_value,x)
xmax_value = max(xmax_value,x)
if key == 'Anhedonia':
x_1 = [g for g in x_values if g>=3]
x_2 = [g for g in x_values if g<3]
#regression lines
(sl,b) = polyfit(x_1,y_values[-len(x_1):], 1)
yp = polyval([sl,b],x_1)
axarr.plot(x_1,yp,'-',color='g')
#regression lines
(sl,b) = polyfit(x_2,y_values[:len(x_2)], 1)
yp = polyval([sl,b],x_2)
axarr.plot(x_2,yp,'-',color='b')
else:
#regression lines
(sl,b) = polyfit(x_values,y_values, 1)
yp = polyval([sl,b],x_values)
axarr.plot(x_values,yp,'-',color='r')
#GLM
X=np.array([])
if key != 'Anhedonia':
X = np.ones(len(x_values))
X =np.stack((X, x_values), axis=-1)
cval = np.hstack((0, -1))
else:
for x in x_values:
if x>3:
X=np.append(X,[[1,0]])
else:
X=np.append(X,[[0,1]])
cval = np.hstack((1, -1))
X= np.array(X).reshape(len(y_values),2)
Y=np.array(y_values )
model = GeneralLinearModel(X)
model.fit(Y)
z_vals = model.contrast(cval).p_value() # z-transformed statistics
print(key, z_vals)
axarr.set_ylabel("Average SNR")
axarr.set_xlabel(str(key))
axarr.set_xlim(xmin_value-(np.median(x_values)*.30),xmax_value+(np.median(x_values)*.30))
axarr.set_ylim(ymin_value-(np.median(y_values)*.30),ymax_value+(np.median(y_values)*.30))
f.savefig("/autofs/space/erebus_001/users/data/scores/new2/plots/snr_avg_"+str(key),dpi=199)
# Get the FMRI data ####################################### fmri_data = surrogate_4d_dataset(mask=mask, dmtx=X, seed=1)[0] # if you want to save it as an image # data_file = op.join(write_dir,'fmri_data.nii') # save(fmri_data, data_file) ######################################## # Perform a GLM analysis ######################################## # GLM fit Y = fmri_data.get_data()[mask_array] glm = GeneralLinearModel(X) glm.fit(Y.T) # specifiy the contrast [1 -1 0 ..] contrast = np.zeros(X.shape[1]) contrast[:2] = np.array([1, -1]) # compute the constrast image related to it zvals = glm.contrast(contrast).z_score() zmap = mask_array.astype(np.float) zmap[mask_array] = zvals ######################################## # Create ROIs ########################################
Y = [load(f) for f in fmri_files]
# Get mask image
print ("Loading mask...")
mask = load(mask_file)
mask_array = mask.get_data() > 0
# GLM fitting
print ("Starting fit...")
results = []
for x, y in zip(X, Y):
# normalize the data to report effects in percent of the baseline
data = y.get_data()[mask_array].T
data, mean = data_scaling(data)
# fit the glm
model = GeneralLinearModel(x)
model.fit(data, "ar1")
results.append(model)
# make a mean volume for display
wmean = mask_array.astype(np.int16)
wmean[mask_array] = mean
def make_fiac_contrasts():
"""Specify some constrasts for the FIAC experiment"""
con = {}
# the design matrices of both runs comprise 13 columns
# the first 5 columns of the design matrices correpond to the following
# conditions: ["SSt-SSp", "SSt-DSp", "DSt-SSp", "DSt-DSp", "FirstSt"]
p = 13
for i_delay, delay in enumerate(
np.linspace(0, 30, n_models + 1)[:-1]):
paradigm = make_paradigm(
delay, duration=duration, length=length,
odd=(subject in ['sujet10', 'sujet12']))
design_matrix = make_dmtx(
frametimes, paradigm, drift_model=drift_model, hfcut=hf_cut)
# plot the design matrix
ax = design_matrix.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
# fit the glm
print 'Fitting a GLM (this takes time)...'
result = GeneralLinearModel(design_matrix.matrix)
result.fit(Y, model='ar1', steps=100)
z_values = result.contrast([contrast_val]).z_score()
best_d[z_values > best_z] = i_delay
best_z = np.maximum(z_values, best_z)
write_array = mask_array.astype(np.float)
write_array[mask_array] = best_z
best_d = best_d * 2 * np.pi / n_models
best_d[best_d > np.pi] -= 2 * np.pi
if side == False:
contrast_path = os.path.join(write_dir, '%s_z_map.nii' %
session)
save(Nifti1Image(write_array, affine), contrast_path)
write_array[mask_array] = best_d
contrast_path = os.path.join(write_dir, '%s_d_map.nii' %
def _fit_glm(X, Y, glm_model):
glm = GeneralLinearModel(X)
glm.fit(Y, model=glm_model)
return glm
# Get the FMRI data ####################################### fmri_data = surrogate_4d_dataset(shape=shape, n_scans=n_scans)[0] # if you want to save it as an image data_file = 'fmri_data.nii' save(fmri_data, data_file) ######################################## # Perform a GLM analysis ######################################## # GLM fit Y = fmri_data.get_data().reshape(np.prod(shape), n_scans) glm = GeneralLinearModel(X) glm.fit(Y.T) # specify the contrast [1 -1 0 ..] contrast = np.zeros(X.shape[1]) contrast[0] = 1 contrast[1] = - 1 # compute the constrast image related to it zvals = glm.contrast(contrast).z_score() contrast_image = Nifti1Image(np.reshape(zvals, shape), affine) # if you want to save the contrast as an image contrast_path = 'zmap.nii' save(contrast_image, contrast_path)
contrasts["video-audio"] = contrasts["video"] - contrasts["audio"]
contrasts["computation-sentences"] = contrasts["computation"] - \
contrasts["sentences"]
contrasts["reading-visual"] = contrasts["sentences"] * 2 - \
contrasts["damier_H"] - contrasts["damier_V"]
contrasts['effects_of_interest'] = np.eye(25)[:20:2]
########################################
# Perform a GLM analysis
########################################
print 'Fitting a GLM (this takes time)...'
fmri_image = load(data_path)
Y, _ = data_scaling(fmri_image.get_data()[mask_array])
X = design_matrix.matrix
results = GeneralLinearModel(X)
results.fit(Y.T, steps=100)
affine = fmri_image.get_affine()
#########################################
# Estimate the contrasts
#########################################
print 'Computing contrasts...'
for index, (contrast_id, contrast_val) in enumerate(contrasts.iteritems()):
print ' Contrast % 2i out of %i: %s' % (index + 1, len(contrasts),
contrast_id)
contrast_path = path.join(write_dir, '%s_z_map.nii' % contrast_id)
write_array = mask_array.astype(np.float)
write_array[mask_array] = results.contrast(contrast_val).z_score()
contrast_image = Nifti1Image(write_array, affine)
# Get the FMRI data
#######################################
fmri_data = surrogate_4d_dataset(mask=mask, dmtx=X)[0]
Y = fmri_data.get_data()[mask_array]
# artificially added signal in ROIs to make the example more meaningful
activation = 30 * (X.T[1] + .5 * X.T[0])
for (position, radius) in zip(positions, radii):
Y[((domain.coord - position) ** 2).sum(1) < radius ** 2 + 1] += activation
########################################
# Perform a GLM analysis
########################################
# GLM fit
glm = GeneralLinearModel(X)
glm.fit(Y.T)
# specifiy the contrast [1 -1 0 ..]
contrast = np.hstack((1, -1, np.zeros(X.shape[1] - 2)))
# compute the constrast image related to it
zvals = glm.contrast(contrast).z_score()
########################################
# ROI-based analysis
########################################
# exact the time courses with ROIs
signal_feature = [Y[my_roi.select_id(id, roi=False)] for id in my_roi.get_id()]
my_roi.set_feature('signal', signal_feature)
def _fit_model(self, ds, X, reg_names):
glm = GeneralLinearModel(X)
glm.fit(ds.samples, **self.glmfit_kwargs)
out = Dataset(glm.get_beta(),
sa={self.get_space(): reg_names})
return glm, out
X = [np.load(f)['X'] for f in design_files]
# Get multi-session fMRI data
print('Loading fmri data...')
Y = [load_image(f) for f in fmri_files]
# Get mask image
print('Loading mask...')
mask = load_image(mask_file)
mask_array, affine = mask.get_data() > 0, mask.get_affine()
# GLM fitting
print('Starting fit...')
glms = []
for x, y in zip(X, Y):
glm = GeneralLinearModel(x)
data, mean = data_scaling(y.get_data()[mask_array].T)
glm.fit(data, 'ar1')
glms.append(glm)
# Compute the required contrast
print('Computing test contrast image...')
nregressors = X[0].shape[1]
## should check that all design matrices have the same
c = np.zeros(nregressors)
c[0:4] = cvect
z_vals = (glms[0].contrast(c) + glms[1].contrast(c)).z_score()
# Show Zmap image
z_map = mask_array.astype(np.float)
z_map[mask_array] = z_vals
# y = glob.glob(study_dir + '/sub???/model/model002/z_maps/*face_vs_house*.nii.gz*')
if len(y) != 0:
target.extend([(study_id, )] * len(y))
niimgs.extend(y)
studies.append(study_id)
lb = LabelBinarizer()
masker = NiftiMasker(mask='mask.nii.gz',
standardize=True,
memory=Memory(cache_dir))
X = lb.fit_transform(target)
X[:, -1] = 0
Y = masker.fit_transform(niimgs)
glm = GeneralLinearModel(X)
glm.fit(Y, model='ols')
affine = nb.load('mask.nii.gz').get_affine()
vs_baseline = []
for i, study_id in enumerate(studies[:-1]):
con_val = np.zeros(len(studies))
con_val[i] = 1
contrast = glm.contrast(con_val, contrast_type='t')
z_map = masker.inverse_transform(contrast.z_score())
z_map.to_filename(result_dir + '/%s.nii.gz' % study_id)
# vs_baseline.append()
def _fit_model(self, ds, X, reg_names):
glm = GeneralLinearModel(X)
glm.fit(ds.samples, **self.glmfit_kwargs)
out = Dataset(glm.get_beta(), sa={self.get_space(): reg_names})
return glm, out
Y = [load(f) for f in fmri_files]
# Get mask image
print('Loading mask...')
mask = load(mask_file)
mask_array = mask.get_data() > 0
# GLM fitting
print('Starting fit...')
results = []
for x, y in zip(X, Y):
# normalize the data to report effects in percent of the baseline
data = y.get_data()[mask_array].T
data, mean = data_scaling(data)
# fit the glm
model = GeneralLinearModel(x)
model.fit(data, 'ar1')
results.append(model)
# make a mean volume for display
wmean = mask_array.astype(np.int16)
wmean[mask_array] = mean
def make_fiac_contrasts():
"""Specify some constrasts for the FIAC experiment"""
con = {}
# the design matrices of both runs comprise 13 columns
# the first 5 columns of the design matrices correpond to the following
# conditions: ["SSt-SSp", "SSt-DSp", "DSt-SSp", "DSt-DSp", "FirstSt"]
p = 13
from nipy.modalities.fmri.glm import GeneralLinearModel dimt = 100 dimx = 10 dimy = 11 dimz = 12 # axis defines the "time direction" y = np.random.randn(dimt, dimx * dimy * dimz) axis = 0 X = np.array([np.ones(dimt), range(dimt)]) X = X.T ## the design matrix X must have dimt lines mod = GeneralLinearModel(X) mod.fit(y) # Define a t contrast tcon = mod.contrast([1, 0]) # Compute the t-stat t = tcon.stat() ## t = tcon.stat(baseline=1) to test effects > 1 # Compute the p-value p = tcon.p_value() # Compute the z-score z = tcon.z_score()
# Get the FMRI data ####################################### fmri_data = surrogate_4d_dataset(shape=shape, n_scans=n_scans)[0] # if you want to save it as an image data_file = 'fmri_data.nii' save(fmri_data, data_file) ######################################## # Perform a GLM analysis ######################################## # GLM fit Y = fmri_data.get_data().reshape(np.prod(shape), n_scans) glm = GeneralLinearModel(X) glm.fit(Y.T) # specify the contrast [1 -1 0 ..] contrast = np.zeros(X.shape[1]) contrast[0] = 1 contrast[1] = -1 # compute the constrast image related to it zvals = glm.contrast(contrast).z_score() contrast_image = Nifti1Image(np.reshape(zvals, shape), affine) # if you want to save the contrast as an image contrast_path = 'zmap.nii' save(contrast_image, contrast_path)
contrasts["right-left"] = contrasts["right"] - contrasts["left"]
contrasts["audio-video"] = contrasts["audio"] - contrasts["video"]
contrasts["video-audio"] = contrasts["video"] - contrasts["audio"]
contrasts["computation-sentences"] = contrasts["computation"] - contrasts["sentences"]
contrasts["reading-visual"] = contrasts["sentences"] * 2 - contrasts["damier_H"] - contrasts["damier_V"]
contrasts["effects_of_interest"] = np.eye(25)[::2]
########################################
# Perform a GLM analysis
########################################
print "Fitting a GLM (this takes time)..."
fmri_image = load(data_path)
Y, _ = data_scaling(fmri_image.get_data()[mask_array])
X = design_matrix.matrix
results = GeneralLinearModel(X)
results.fit(Y.T, steps=100)
affine = fmri_image.get_affine()
#########################################
# Estimate the contrasts
#########################################
print "Computing contrasts..."
for index, (contrast_id, contrast_val) in enumerate(contrasts.iteritems()):
print " Contrast % 2i out of %i: %s" % (index + 1, len(contrasts), contrast_id)
contrast_path = op.join(write_dir, "%s_z_map.nii" % contrast_id)
write_array = mask_array.astype(np.float)
write_array[mask_array] = results.contrast(contrast_val).z_score()
contrast_image = Nifti1Image(write_array, affine)
save(contrast_image, contrast_path)
mp.savefig(fig1_file)
#-----------------------------------------------------------------
# Mean-scale, de-mean and multiply data by 100
#-----------------------------------------------------------------
mask = np.sum(img.get_data(), axis=-1) > 0
data, mean = data_scaling(img.get_data()[mask].T)
if np.size(data):
mean.shape = mask.shape
#-----------------------------------------------------------------
# Apply a general linear model to all pixels
#-----------------------------------------------------------------
print(' Apply general linear model...')
model = "ar1"
glm = GeneralLinearModel(design_matrix)
glm.fit(data, model=model)
#-----------------------------------------------------------------
# Create a contrast image
#
# Contrast condition 1 vs. condition 2, holding condition 3 constant
# (sleep vs. awake holding concentration of odorant constant)
#-----------------------------------------------------------------
print(' Make contrast image...')
# Specify the contrast [1 -1 0 ..]
contrast = np.zeros(design_matrix.shape[1])
if ntest < 5:
contrast[0] = 1
else:
Y = [load(f) for f in fmri_files]
# Get mask image
print('Loading mask...')
mask = load(mask_file)
mask_array = mask.get_data() > 0
# GLM fitting
print('Starting fit...')
results = []
for x, y in zip(X, Y):
# normalize the data to report effects in percent of the baseline
data = y.get_data()[mask_array].T
data, mean = data_scaling(data)
# fit the glm
model = GeneralLinearModel(x)
model.fit(data, 'ar1')
results.append(model)
# make a mean volume for display
wmean = mask_array.astype(np.int16)
wmean[mask_array] = mean
def make_fiac_contrasts():
"""Specify some contrasts for the FIAC experiment"""
con = {}
# the design matrices of both runs comprise 13 columns
# the first 5 columns of the design matrices correspond to the following
# conditions: ["SSt-SSp", "SSt-DSp", "DSt-SSp", "DSt-DSp", "FirstSt"]
p = 13
def _fit_glm(X, Y, glm_model):
glm = GeneralLinearModel(X)
glm.fit(Y, model=glm_model)
return glm
def KK_visit_Vermeer_GLM(stats_path):
stimulus_txt = np.loadtxt('/Users/davidzipser/Google_Drive/Data/stimuli/2015/6/Vermeer_1024x768/natural_stimuli_10Hz_Fri_Jun_19_21-56-59_2015.medium_letters/stimulus.txt')
n_Secs = len(stimulus_txt) # DANGER
n_TRs_all = 300
n_images = 24
stimulus_REGRESSORS = np.zeros((n_Secs, n_images))
for s in range(n_Secs):
if stimulus_txt[s] > 0:
stimulus_REGRESSORS[s,stimulus_txt[s]-1] = 1
hrf = KK_getcanonicalhrf()
hrf_1Hz = hrf[::5]
#PP[FF]=3,3
#plt.figure('hrf_1Hz')
#plt.plot(hrf_1Hz,'.-')
#mi(stimulus_REGRESSORS,'stimulus_REGRESSORS')
HRF_REG = np.zeros((n_TRs_all,n_images))
stimulus_times = np.arange(0,n_Secs)
TR_times = 0.9 * np.arange(0,n_TRs_all)
for i in range(n_images):
r = stimulus_REGRESSORS[:,i]
hp = np.convolve(r, hrf_1Hz)[:(np.shape(r)[0])]
hp_interp = np.interp(TR_times,stimulus_times,hp)
HRF_REG[:,i]=hp_interp
#PP[FF] = 5,8
#mi(HRF_REG,'HRF_REG')
nii = nib.load(opj(stats_path,'all_average.nii.gz'))
data = nii.get_data()
header = nii.get_header()
affine = nii.get_affine()
Voxels,Vox_xyzs = vol_to_voxels(data)
# - http://nipy.org/nipy/api/generated/nipy.modalities.fmri.glm.html
from nipy.modalities.fmri.glm import GeneralLinearModel
n_TRs = 294
n_voxels = np.shape(Voxels)[1]
n_images = 24
DATA = Voxels
REGRESSORS = HRF_REG.copy()[6:] # this deals with DELETE volumes
model = GeneralLinearModel(REGRESSORS)
model.fit(DATA)
#mi(DATA,1,[1,1,1],'DATA ' + str(np.shape(DATA)))
#mi(REGRESSORS,2,[1,1,1],'REGRESSORS ' + str(np.shape(REGRESSORS)))
betas = model.get_beta()
#mi(betas,3,[1,1,1],'betas ' + str(np.shape(betas)))
mse = model.get_mse()
#plt.figure('mse ' + str(np.shape(mse)))
#plt.plot(mse)
vol_betas = vox_list_to_vol(betas,Vox_xyzs,data[:,:,:,0].copy())
betas_nii = nib.Nifti1Image(vol_betas, affine, header)
nib.save(betas_nii, opj(stats_path,'betas.nipy_GLM.nii.gz'))
add_regs=motion,
add_reg_names=add_reg_names)
#######################################
# Get the FMRI data
#######################################
fmri_data = surrogate_4d_dataset(mask=mask, dmtx=X, seed=1)[0]
########################################
# Perform a GLM analysis
########################################
# GLM fit
Y = fmri_data.get_data()[mask_array]
glm = GeneralLinearModel(X)
glm.fit(Y.T)
# specifiy the contrast [1 -1 0 ..]
contrast = np.zeros(X.shape[1])
contrast[:2] = np.array([1, -1])
# compute the constrast image related to it
zvals = glm.contrast(contrast).z_score()
zmap = mask_array.astype(np.float)
zmap[mask_array] = zvals
########################################
# Create ROIs
########################################
def motionWithin_measures():
studies = {'Diffusion1': 'dMRI_topup_eddy.nii.gz.eddy_parameters','Diffusion2': 'dMRI_topup_eddy.nii.gz.eddy_parameters','Diffusion3': 'dMRI_topup_eddy.nii.gz.eddy_parameters','Diffusion4':
'dMRI_topup_eddy.nii.gz.eddy_parameters','Rest1': 'fMRI_rest1_AP_motion.nii.gz.par','Rest2': 'fMRI_rest2_PA_motion.nii.gz.par','Rest3': 'fMRI_rest3_AP_motion.nii.gz.par','Rest4':
'fMRI_rest4_PA_motion.nii.gz.par', 'Gambling1' : 'tfMRI_gambling1_AP_motion.nii.gz.par','Gambling2' : 'tfMRI_gambling2_PA_motion.nii.gz.par','FaceMatching1' :
'tfMRI_faceMatching1_AP_motion.nii.gz.par','FaceMatching2' :
'tfMRI_faceMatching2_PA_motion.nii.gz.par','Conflict1':'tfMRI_conflict1_AP_motion.nii.gz.par','Conflict2':'tfMRI_conflict2_PA_motion.nii.gz.par','Conflict3':'tfMRI_conflict3_AP_motion.nii.gz.par',
'Conflict4':'tfMRI_conflict4_PA_motion.nii.gz.par', 'T1':'motion/T1_motion.nii.gz.par','T2':'motion/T2_motion.nii.gz.par'}
scans=['T1'] #'Diffusion1','Diffusion2','Diffusion3','Diffusion4'] #,'Rest1','Rest2','Rest3','Rest4','Gambling1','Gambling2','FaceMatching1','FaceMatching2','Conflict1','Conflict2','Conflict3','Conflict4','T1','T2']
#scans.append("T1 all vnavs - no reacq")
#scans.append("T2 all vnavs - no reacq")
#scans=['T2']
diffusion=[ [0,98], [98,196],[196,295],[295,394]]
metric = [getTranslation, getRotation] #, getTranslationAbsolute, getRotationAbsolute]
metric_label=["Translation (mm/s)" , "Rotation ($\degree/s$)", "Absolute translation per second", "Absolute rotation per second"]
indexPerDiffusion = {'Diffusion1':[0,98], 'Diffusion2':[98,196], 'Diffusion3':[196,295],'Diffusion4':[295,394]}
fmri_order = {'Rest1':0,'Rest2':1,'Rest3':2,'Rest4':3,'Gambling1':4,'Gambling2':5, 'FaceMatching1':6,'FaceMatching2':7, 'Conflict1':8,'Conflict2':9,'Conflict3':10,'Conflict4':11}
subjects, sex, scores = utils.loadBANDA140(outliers)
motionWithin_output=csv.writer(open('/space/erebus/1/users/data/scores/new2/test_rjj091219.csv','w+'))
motionWithin_output.writerow(['subject','rot_trans','avg_score','questionnaire','questionnaire_score'])
for key, score in scores.items():
print (scans)
f, axarr = plt.subplots(1, 2,figsize=(23,14))
f.subplots_adjust(left=.03, bottom=.06, right=.97, top=.95, wspace=.18, hspace=.28)
trans_boxplot_data = [[],[]]
rotat_boxplot_data = [[],[]]
anhedonia = 0
anhedonia_no = 0
#box plot measures
g, (boxes1,boxes2) = plt.subplots(nrows=1,ncols=2,figsize=(15,14))
for i,met in enumerate(metric):
axarr[i].set_title(str(met)[13:18])
if str(met)[13:18]=='Trans': boxes1.set_title(str(met)[13:18])
elif str(met)[13:18]=='Rotat': boxes2.set_title(str(met)[13:18])
#for calculating axis ranges
ymin_value = 0
ymax_value = 0
xmin_value = 0
xmax_value = 0
x_values = []
y_values = []
#for s in subjects:
for s_index,s in enumerate(subjects):
print(s)
t_accumulate = 0
for name in scans:
fileN = studies[name.split()[0]]
column,acq_time = getFileData(fileN)
if "no vnavs" in name:
if "T1" in name :
index=[0,166]
else:
index=[0,111]
else:
index=[0,1000]
if "dMRI" in fileN:
index =diffusion[i]
filePath = getFilePath(fileN,s)
#print(i,j)
#print(name)
if filePath != None :
#print (name)
if "T1" == name:
ind = readVNavsScoreFiles(s, "T1")
elif "T2" == name:
ind = readVNavsScoreFiles(s, "T2")
#print(s, ind)
else:
ind = range(index[0], index[1])
t= met(filePath,column,np.sort(ind),acq_time)
t_accumulate += t
avg_t = t_accumulate/len(scans)
if s_index == 0: ymin_value = avg_t
ymin_value = min(ymin_value,avg_t)
ymax_value = max(ymax_value,avg_t)
if s_index == 0: xmin_value = float(score[s_index])
xmin_value = min(xmin_value,float(score[s_index]))
xmax_value = max(xmax_value,float(score[s_index]))
if str(str(key))=='Anhedonia':
if str(met)[13:18]=='Trans':
if float(score[s_index])<3:
trans_boxplot_data[0].append(avg_t)
anhedonia_no += 1
else:
trans_boxplot_data[1].append(avg_t)
anhedonia += 1
if str(met)[13:18]=='Rotat':
if float(score[s_index])<3: rotat_boxplot_data[0].append(avg_t)
else: rotat_boxplot_data[1].append(avg_t)
motionWithin_output.writerow([s,metric_label[metric.index(met)],avg_t,key,float(score[s_index])])
axarr[i].plot(float(score[s_index]),avg_t,"o",markersize=5, color='m')
x_values.append(float(score[s_index]))
y_values.append(avg_t)
#regression lines
(sl,b) = polyfit(x_values,y_values,1)
yp = polyval([sl,b],x_values)
axarr[i].plot(x_values,yp,'-',color='r')
#GLM
X=np.array([])
if key != 'Anhedonia':
X = np.ones(len(x_values))
X =np.stack((X, x_values), axis=-1)
cval = np.hstack((0, -1))
else:
for x in x_values:
if x>=3:
X=np.append(X,[[1,0]])
else:
X=np.append(X,[[0,1]])
cval = np.hstack((1, -1))
X= np.array(X).reshape(len(y_values),2)
Y=np.array(y_values )
model = GeneralLinearModel(X)
model.fit(Y)
z_vals = model.contrast(cval).p_value() # z-transformed statistics
print(key, z_vals)
axarr[i].set_ylabel("Average" + str(metric_label[metric.index(met)]))
axarr[i].set_xlabel(str(key))
axarr[i].set_xlim(xmin_value-(np.median(x_values)*.30),xmax_value+(np.median(x_values)*.30))
axarr[i].set_ylim(ymin_value-(np.median(y_values)*.30),ymax_value+(np.median(y_values)*.30))
if str(key)=='Anhedonia':
if i==0:
trans_box_max_list = [ max(a) for a in trans_boxplot_data]
trans_box_min_list = [ min(a) for a in trans_boxplot_data]
boxes1.set_ylabel("Average " + str(metric_label[metric.index(met)]))
boxes1.set_xlabel(str(key))
elif i==1:
rotat_box_max_list = [ max(a) for a in rotat_boxplot_data]
rotat_box_min_list = [ min(a) for a in rotat_boxplot_data]
boxes2.set_ylabel("Average " + str(metric_label[metric.index(met)]))
boxes2.set_xlabel(str(key))
#f.savefig("/space/erebus/1/users/data/comparisonPlots_1_88/plots/motion_snr/motionWithin_avg_"+str(key),dpi=199)
f.savefig("/autofs/space/erebus_001/users/data/scores/new2/plots/test_09122019_motion_Within_avg_"+str(key),dpi=199)
if str(str(key))=='Anhedonia':
boxes1.set_ylim(0,max(trans_box_max_list)+.25)
boxes2.set_ylim(0,max(rotat_box_max_list)+.25)
#print(trans_boxplot_data[0])
#print(trans_boxplot_data[1])
boxes1.boxplot(trans_boxplot_data,labels=['no anhedonia','anhedonia'])
boxes2.boxplot(rotat_boxplot_data,labels=['no anhedonia','anhedonia'])
g.savefig("/autofs/space/erebus_001/users/data/scores/new2/plots/test_09112019_motion_Within_avg_Anhedonia"+"_boxplot",dpi=199)
#g.savefig("/space/erebus/1/users/vsiless/QA_plots//motion_Within_avg_Anhedonia"+"_boxplot",dpi=199)
print(anhedonia)
print(anhedonia_no)
pylab.savefig(os.path.join(write_dir, 'design_matrix_%s.png') %\
session)
# get the data
if side == False:
Y, _ = data_scaling(load(fmri_data).get_data()[mask_array].T)
affine = load(fmri_data).get_affine()
else:
Y = np.array([x.data for x in read(fmri_data).darrays])
Y, _ = data_scaling(Y)
if sess == 0: # do not redefine the mask later !
mask_array = np.var(Y, 0) > 0
Y = Y[:, mask_array]
# fit the glm
print 'Fitting a GLM'
result = GeneralLinearModel(design_matrix.matrix)
result.fit(Y, model='ar1', steps=100)
for contrast_id, contrast_val in contrasts.iteritems():
if (contrast_val[session] == 0).all():
continue
contrast_obj[contrast_id] =\
result.contrast(contrast_val[session])
print 'Computing contrasts...'
# In fact, this only writes the output images/textures
# define the effects of interest
F_ = np.zeros(mask_array.sum())
for index, contrast_id in enumerate(contrasts):
F_ += (contrast_obj[contrast_id].stat()) ** 2
print ' Contrast % 2i out of %i: %s' % (
design_matrix = np.vstack((np.ones(len(beh_data['sub_id_database_brain'])), beh_data['memory_acc'], beh_data['perception_acc'], beh_data['age'])).T
design_matrix[1,:] = stats.zscore(design_matrix[1,:])
design_matrix[2,:] = stats.zscore(design_matrix[2,:])
design_matrix[3,:] = stats.zscore(design_matrix[3,:])
contrasts = 1#, "memory>perception": [0,1,-1,0]}
contrasts_t_mmaps = {}
contrasts_p_mmaps = {}
contrasts_z_mmaps = {}
for contrast_name in contrasts.keys():
contrasts_t_mmaps[contrast_name] = np.memmap("/scr/adenauer1/tmp/%s_t_map.float64"%contrast_name, dtype='float64', mode='w+', shape=corr_mmaps[0].shape)
contrasts_p_mmaps[contrast_name] = np.memmap("/scr/adenauer1/tmp/%s_p_map.float64"%contrast_name, dtype='float64', mode='w+', shape=corr_mmaps[0].shape)
contrasts_z_mmaps[contrast_name] = np.memmap("/scr/adenauer1/tmp/%s_z_map.float64"%contrast_name, dtype='float64', mode='w+', shape=corr_mmaps[0].shape)
glm = GeneralLinearModel(design_matrix)
chunk_size = 40000
print len(corr_mmaps[0])
counter = 0
while counter < len(corr_mmaps[0]):
data_chunk = np.vstack([(corr_mmaps[i][counter:counter+chunk_size]) for i in range(len(beh_data['sub_id_database_brain']))])
data_chunk = np.arctanh(data_chunk/10000.0)
glm.fit(data_chunk,model="ols")
for contrast_name, contrast in contrasts.iteritems():
c = glm.contrast(contrast)
contrasts_t_mmaps[contrast_name][counter:counter+chunk_size] = c.stat()
# Get the FMRI data
#######################################
fmri_data = surrogate_4d_dataset(mask=mask, dmtx=X)[0]
Y = fmri_data.get_data()[mask_array]
# artificially added signal in ROIs to make the example more meaningful
activation = 30 * (X.T[1] + .5 * X.T[0])
for (position, radius) in zip(positions, radii):
Y[((domain.coord - position)**2).sum(1) < radius**2 + 1] += activation
########################################
# Perform a GLM analysis
########################################
# GLM fit
glm = GeneralLinearModel(X)
glm.fit(Y.T)
# specifiy the contrast [1 -1 0 ..]
contrast = np.hstack((1, -1, np.zeros(X.shape[1] - 2)))
# compute the constrast image related to it
zvals = glm.contrast(contrast).z_score()
########################################
# ROI-based analysis
########################################
# exact the time courses with ROIs
signal_feature = [Y[my_roi.select_id(id, roi=False)] for id in my_roi.get_id()]
my_roi.set_feature('signal', signal_feature)
def run_glms(subject):
# necessary paths
analysis_dir = os.path.join(spm_dir, subject, 'analyses')
subject_dir = os.path.join(work_dir, subject)
if os.path.exists(subject_dir) == False:
os.mkdir(subject_dir)
fmri_dir = os.path.join(subject_dir, 'fmri')
if os.path.exists(fmri_dir) == False:
os.mkdir(fmri_dir)
result_dir = os.path.join(fmri_dir, 'results')
if os.path.exists(result_dir) == False:
os.mkdir(result_dir)
memory = Memory(cachedir=os.path.join(fmri_dir, 'cache_dir'), verbose=0)
# audiosentence protocol
# step 1: get the necessary files
spm_fmri_dir = os.path.join(spm_dir, subject, 'fMRI/audiosentence')
onset_dir = os.path.join(analysis_dir, 'audiosentence')
onset_files = glob.glob(os.path.join(onset_dir, 'onsetfile*.mat'))
motion_files = glob.glob(
os.path.join(spm_fmri_dir, 'rp*.txt'))
left_fmri_files = glob.glob(os.path.join(spm_fmri_dir, 'sraaudio*_lh.gii'))
right_fmri_files = glob.glob(os.path.join(spm_fmri_dir, 'sraaudio*_rh.gii'))
onset_files.sort()
motion_files.sort()
left_fmri_files.sort()
right_fmri_files.sort()
# get the ratings of the trials
final_data = os.path.join(behavioral_dir, subject,
'finaldata_%s.mat' %subject)
ratings = make_ratings(final_data)
# scan times
n_scans = 200
lh_effects, lh_variances, rh_effects, rh_variances = {}, {}, {}, {}
for i, (onset_file, motion_file, left_fmri_file, right_fmri_file) in\
enumerate(zip(
onset_files, motion_files, left_fmri_files, right_fmri_files)):
# Create the design matrix
dmtx = audiosentence_dmtx(final_data, motion_file, n_scans, tr, i)
ax = dmtx.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
session_contrasts = audiosentence_contrasts(dmtx.names, final_data, i)
fmri_glm = GeneralLinearModel(dmtx.matrix)
# left hemisphere
Y = np.array([darrays.data for darrays in read(left_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
print('Computing contrasts...')
for index, contrast_id in enumerate(session_contrasts):
print(' Contrast % i out of %i: %s' %
(index + 1, len(session_contrasts), contrast_id))
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
if i == 0:
lh_effects[contrast_id] = [contrast_.effect.ravel()]
lh_variances[contrast_id] = [contrast_.variance.ravel()]
else:
lh_effects[contrast_id].append(contrast_.effect.ravel())
lh_variances[contrast_id].append(contrast_.variance.ravel())
# right hemisphere
Y = np.array(
[darrays.data for darrays in read(right_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
for index, contrast_id in enumerate(session_contrasts):
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
if i == 0:
rh_effects[contrast_id] = [contrast_.effect.ravel()]
rh_variances[contrast_id] = [contrast_.variance.ravel()]
else:
rh_effects[contrast_id].append(contrast_.effect.ravel())
rh_variances[contrast_id].append(contrast_.variance.ravel())
for index, contrast_id in enumerate(session_contrasts):
# left hemisphere
_, _, z_map = fixed_effects(
lh_effects[contrast_id], lh_variances[contrast_id])
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_lh.gii' % contrast_id)
write(z_texture, z_map_path)
# right hemisphere
_, _, z_map = fixed_effects(
rh_effects[contrast_id], rh_variances[contrast_id])
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_rh.gii' % contrast_id)
write(z_texture, z_map_path)
#########################################################################
# localizer protocol
# get the necessary files
spm_fmri_dir = os.path.join(spm_dir, subject, 'fMRI/localizer')
motion_file, = glob.glob(
os.path.join(spm_dir, subject, 'fMRI/localizer/rp*.txt'))
left_fmri_file = glob.glob(
os.path.join(spm_fmri_dir, 'sralocalizer*_lh.gii'))[0]
right_fmri_file = glob.glob(
os.path.join(spm_fmri_dir, 'sralocalizer*_rh.gii'))[0]
n_scans = 205
# Create the design matrix
dmtx = localizer_dmtx(motion_file, n_scans, tr)
ax = dmtx.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
session_contrasts = localizer_contrasts(dmtx)
fmri_glm = GeneralLinearModel(dmtx.matrix)
# left hemisphere
Y = np.array([darrays.data for darrays in read(left_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
print('Computing contrasts...')
for index, contrast_id in enumerate(session_contrasts):
print(' Contrast % i out of %i: %s' %
(index + 1, len(session_contrasts), contrast_id))
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
z_map = contrast_.z_score()
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_lh.gii' % contrast_id)
write(z_texture, z_map_path)
# right hemisphere
Y = np.array([darrays.data for darrays in read(right_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
print('Computing contrasts...')
for index, contrast_id in enumerate(session_contrasts):
print(' Contrast % i out of %i: %s' %
(index + 1, len(session_contrasts), contrast_id))
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
z_map = contrast_.z_score()
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_rh.gii' % contrast_id)
write(z_texture, z_map_path)
#########################################################################
# VisualCategs protocol
# get the necessary files
spm_fmri_dir = os.path.join(spm_dir, subject, 'fMRI/visualcategs')
onset_dir = os.path.join(analysis_dir, 'visualcategs')
onset_files = glob.glob(os.path.join(onset_dir, 'onsetfile*.mat'))
motion_files = glob.glob(
os.path.join(spm_dir, subject, 'fMRI/visualcategs/rp*.txt'))
fmri_files = glob.glob(os.path.join(fmri_dir, 'crvisu*.nii.gz'))
onset_files.sort()
motion_files.sort()
fmri_files.sort()
left_fmri_files = glob.glob(
os.path.join(spm_fmri_dir, 'sravisu*_lh.gii'))
right_fmri_files = glob.glob(
os.path.join(spm_fmri_dir, 'sravisu*_rh.gii'))
n_scans = 185
lh_effects, lh_variances, rh_effects, rh_variances = {}, {}, {}, {}
for i, (onset_file, motion_file, left_fmri_file, right_fmri_file) in\
enumerate(zip(
onset_files, motion_files, left_fmri_files, right_fmri_files)):
# Create the design matrix
dmtx = visualcategs_dmtx(onset_file, motion_file, n_scans, tr)
ax = dmtx.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
session_contrasts = visualcategs_contrasts(dmtx.names)
fmri_glm = GeneralLinearModel(dmtx.matrix)
# left hemisphere
Y = np.array([darrays.data for darrays in read(left_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
print('Computing contrasts...')
for index, contrast_id in enumerate(session_contrasts):
print(' Contrast % i out of %i: %s' %
(index + 1, len(session_contrasts), contrast_id))
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
if i == 0:
lh_effects[contrast_id] = [contrast_.effect.ravel()]
lh_variances[contrast_id] = [contrast_.variance.ravel()]
else:
lh_effects[contrast_id].append(contrast_.effect.ravel())
lh_variances[contrast_id].append(contrast_.variance.ravel())
# right hemisphere
Y = np.array([
darrays.data for darrays in read(right_fmri_file).darrays])
# fit the GLM
fmri_glm.fit(Y, model='ar1')
# Estimate the contrasts
print('Computing contrasts...')
for index, contrast_id in enumerate(session_contrasts):
print(' Contrast % i out of %i: %s' %
(index + 1, len(session_contrasts), contrast_id))
# save the z_image
contrast_ = fmri_glm.contrast(session_contrasts[contrast_id])
if i == 0:
rh_effects[contrast_id] = [contrast_.effect.ravel()]
rh_variances[contrast_id] = [contrast_.variance.ravel()]
else:
rh_effects[contrast_id].append(contrast_.effect.ravel())
rh_variances[contrast_id].append(contrast_.variance.ravel())
for index, contrast_id in enumerate(session_contrasts):
# left hemisphere
_, _, z_map = fixed_effects(
lh_effects[contrast_id], lh_variances[contrast_id])
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_lh.gii' % contrast_id)
write(z_texture, z_map_path)
# right hemisphere
_, _, z_map = fixed_effects(
rh_effects[contrast_id], rh_variances[contrast_id])
z_texture = GiftiImage(
darrays=[GiftiDataArray().from_array(z_map, intent='t test')])
z_map_path = os.path.join(result_dir, '%s_z_map_rh.gii' % contrast_id)
write(z_texture, z_map_path)
