def make_design_mtx(spm_mvt_file, hfcut=128, skip_TR=SKIPTR, normalize=True, to_add=None):
"""
create the design matrix
"""
mvt_arr = np.loadtxt(spm_mvt_file)
mvt_arr = mvt_arr[skip_TR:,:]
mvt_lab = ['tx','ty','tz','rx', 'ry', 'rz']
assert mvt_arr.shape == (SK4RUNLENGH,6)
if to_add is not None:
assert to_add.shape[0] == SK4RUNLENGH
addlab = [ 'a'+str(idx) for idx in range(to_add.shape[1])]
mvt_arr = np.hstack((mvt_arr, to_add))
mvt_lab = mvt_lab + addlab
nbframes = mvt_arr.shape[0]
frametimes = np.linspace(0.0, (nbframes-1)*2.0, num=nbframes)
X, labels = dsgn_mtrx.dmtx_light(frametimes, paradigm=None, hrf_model='canonical',
drift_model='cosine', hfcut=hfcut,
drift_order=1,
fir_delays=[0], add_regs=mvt_arr, add_reg_names=mvt_lab)
if normalize:
X -= X.mean(axis=0)
Xstd = X.std(axis=0)
non_zero_col = Xstd > np.finfo(float).eps
zero_col = np.logical_not(non_zero_col)
X = np.hstack((X[:,non_zero_col]/Xstd[non_zero_col], X[:, zero_col]))
return X, labels
def _run_interface(self, runtime):
assert len(self.inputs.onsets) == len(self.inputs.events)
self.inputs.onsets, self.inputs.events = [
list(e) for e in zip(*sorted(zip(self.inputs.onsets, self.inputs.events)))
]
if self.inputs.n_blocks == 0:
self.inputs.n_blocks = int(np.sqrt(len(self.inputs.onsets)))
image = nb.load(self.inputs.data)
data = image.get_data()
self.data_shape = image.shape
length_block = self.data_shape[-1] / self.inputs.n_blocks
paradigm = EventRelatedParadigm(self.inputs.events, self.inputs.onsets)
frametimes = np.arange(0, self.data_shape[-1] * self.inputs.TR, self.inputs.TR)
X, names = dm.dmtx_light(frametimes, paradigm, drift_model="polynomial", hfcut=128, hrf_model="canonical")
for i in np.arange(0, self.data_shape[-1] + 1, length_block)[:-1]:
save(X[i : i + length_block, :], os.path.abspath("./design_matrices_%s.hdf5" % (i / length_block)))
# nb.save(nb.Nifti1Image(data[:, :, :, i:i+length_block], image.get_affine(), image.get_header()), os.path.abspath('data_%s.nii.gz' % (i/length_block)))
nb.save(
nb.Nifti1Image(data[..., i : i + length_block], image.get_affine(), image.get_header()),
os.path.abspath("data_%s.nii.gz" % (i / length_block)),
)
return runtime
def _run_interface(self, runtime):
session_info = self.inputs.session_info
TR = self.inputs.TR
data = nb.load(session_info['scans'])
if not isdefined(self.inputs.q):
self.inputs.q = int(np.sqrt(data.shape[-1]))
q = self.inputs.q
events = [[d['name']] * len(d['onset']) for d in session_info['cond']]
onsets = [d['onset'] for d in session_info['cond']]
import itertools
events = list(itertools.chain(*events))
onsets = list(itertools.chain(*onsets))
paradigm = EventRelatedParadigm(events, onsets)
frametimes = np.arange(0, data.shape[-1] * TR, TR)
X, names = dm.dmtx_light(frametimes, paradigm, drift_model='polynomial',
hfcut=128, hrf_model='canonical')
np.save(os.path.abspath('X.npy'), X)
cut_size = data.shape[-1] / (q)
cuts = np.arange(0, data.shape[-1]+1, cut_size)
data_cut = np.array([data.get_data()[..., cuts[i]:cuts[i+1]] for i in np.arange(q)])
X_cut = np.array([X[cuts[i]:cuts[i+1], :] for i in np.arange(q)])
for i, (d, fn) in enumerate(zip(data_cut, self._gen_fnames('cutted_data'))):
nb.save(nb.Nifti1Image(d, data.get_affine()), fn)
for i, (x, fn) in enumerate(zip(X_cut, self._gen_fnames('design_matrices'))):
np.save(fn, x)
return runtime
def _run_interface(self, runtime):
session_info = self.inputs.session_info
functional_runs = self.inputs.session_info[0]['scans']
if isinstance(functional_runs, str):
functional_runs = [functional_runs]
nii = nb.load(functional_runs[0])
data = nii.get_data()
if isdefined(self.inputs.mask):
mask = nb.load(self.inputs.mask).get_data() > 0
else:
mask = np.ones(nii.shape[:3]) == 1
timeseries = data.copy()[mask,:]
del data
for functional_run in functional_runs[1:]:
nii = nb.load(functional_run)
data = nii.get_data()
npdata = data.copy()
del data
timeseries = np.concatenate((timeseries,npdata[mask,:]), axis=1)
del npdata
nscans = timeseries.shape[1]
if 'hpf' in session_info[0].keys():
hpf = session_info[0]['hpf']
drift_model=self.inputs.drift_model
else:
hpf=0
drift_model = "Blank"
reg_names = []
for reg in session_info[0]['regress']:
reg_names.append(reg['name'])
reg_vals = np.zeros((nscans,len(reg_names)))
for i in range(len(reg_names)):
reg_vals[:,i] = np.array(session_info[0]['regress'][i]['val']).reshape(1,-1)
frametimes= np.linspace(0, (nscans-1)*self.inputs.TR, nscans)
conditions = []
onsets = []
duration = []
for i,cond in enumerate(session_info[0]['cond']):
onsets += cond['onset']
conditions += [cond['name']]*len(cond['onset'])
if len(cond['duration']) == 1:
duration += cond['duration']*len(cond['onset'])
else:
duration += cond['duration']
if conditions:
paradigm = BlockParadigm(con_id=conditions, onset=onsets, duration=duration)
else:
paradigm = None
design_matrix, self._reg_names = dm.dmtx_light(frametimes, paradigm, drift_model=drift_model, hfcut=hpf,
hrf_model=self.inputs.hrf_model,
add_regs=reg_vals,
add_reg_names=reg_names
)
if self.inputs.normalize_design_matrix:
for i in range(len(self._reg_names)-1):
design_matrix[:,i] = (design_matrix[:,i]-design_matrix[:,i].mean())/design_matrix[:,i].std()
if self.inputs.plot_design_matrix:
if pylab_available:
pylab.pcolor(design_matrix)
pylab.savefig("design_matrix.pdf")
pylab.close()
pylab.clf()
else:
Exception('Pylab not available for saving design matrix image')
glm = GLM.glm()
glm.fit(timeseries.T, design_matrix, method=self.inputs.method, model=self.inputs.model)
self._beta_file = os.path.abspath("beta.nii")
beta = np.zeros(mask.shape + (glm.beta.shape[0],))
beta[mask,:] = glm.beta.T
nb.save(nb.Nifti1Image(beta, nii.get_affine()), self._beta_file)
self._s2_file = os.path.abspath("s2.nii")
s2 = np.zeros(mask.shape)
s2[mask] = glm.s2
nb.save(nb.Nifti1Image(s2, nii.get_affine()), self._s2_file)
if self.inputs.save_residuals:
explained = np.dot(design_matrix,glm.beta)
residuals = np.zeros(mask.shape + (nscans,))
residuals[mask,:] = timeseries - explained.T
self._residuals_file = os.path.abspath("residuals.nii")
nb.save(nb.Nifti1Image(residuals, nii.get_affine()), self._residuals_file)
self._nvbeta = glm.nvbeta
self._dof = glm.dof
self._constants = glm._constants
self._axis = glm._axis
if self.inputs.model == "ar1":
self._a_file = os.path.abspath("a.nii")
a = np.zeros(mask.shape)
a[mask] = glm.a.squeeze()
nb.save(nb.Nifti1Image(a, nii.get_affine()), self._a_file)
self._model = glm.model
self._method = glm.method
return runtime
# write directory
write_dir = path.join(getcwd(), 'results')
if not path.exists(write_dir):
mkdir(write_dir)
########################################
# Design matrix
########################################
paradigm = np.vstack(([conditions, onsets])).T
paradigm = EventRelatedParadigm(conditions, onsets)
X, names = dmtx_light(frametimes,
paradigm,
drift_model='cosine',
hfcut=128,
hrf_model=hrf_model,
add_regs=motion,
add_reg_names=add_reg_names)
########################################
# Create ROIs
########################################
positions = np.array([[60, -30, 5], [50, 27, 5]])
# in mm (here in the MNI space)
radii = np.array([8, 6])
domain = grid_domain_from_image(mask)
my_roi = mroi.subdomain_from_balls(domain, positions, radii)
def _run_interface(self, runtime):
import nibabel as nb
import numpy as np
import nipy.modalities.fmri.glm as GLM
import nipy.modalities.fmri.design_matrix as dm
try:
BlockParadigm = dm.BlockParadigm
except AttributeError:
from nipy.modalities.fmri.experimental_paradigm import BlockParadigm
session_info = self.inputs.session_info
functional_runs = self.inputs.session_info[0]["scans"]
if isinstance(functional_runs, (str, bytes)):
functional_runs = [functional_runs]
nii = nb.load(functional_runs[0])
data = nii.get_data()
if isdefined(self.inputs.mask):
mask = nb.load(self.inputs.mask).get_data() > 0
else:
mask = np.ones(nii.shape[:3]) == 1
timeseries = data.copy()[mask, :]
del data
for functional_run in functional_runs[1:]:
nii = nb.load(functional_run, mmap=NUMPY_MMAP)
data = nii.get_data()
npdata = data.copy()
del data
timeseries = np.concatenate((timeseries, npdata[mask, :]), axis=1)
del npdata
nscans = timeseries.shape[1]
if "hpf" in list(session_info[0].keys()):
hpf = session_info[0]["hpf"]
drift_model = self.inputs.drift_model
else:
hpf = 0
drift_model = "Blank"
reg_names = []
for reg in session_info[0]["regress"]:
reg_names.append(reg["name"])
reg_vals = np.zeros((nscans, len(reg_names)))
for i in range(len(reg_names)):
reg_vals[:, i] = np.array(
session_info[0]["regress"][i]["val"]).reshape(1, -1)
frametimes = np.linspace(0, (nscans - 1) * self.inputs.TR, nscans)
conditions = []
onsets = []
duration = []
for i, cond in enumerate(session_info[0]["cond"]):
onsets += cond["onset"]
conditions += [cond["name"]] * len(cond["onset"])
if len(cond["duration"]) == 1:
duration += cond["duration"] * len(cond["onset"])
else:
duration += cond["duration"]
if conditions:
paradigm = BlockParadigm(con_id=conditions,
onset=onsets,
duration=duration)
else:
paradigm = None
design_matrix, self._reg_names = dm.dmtx_light(
frametimes,
paradigm,
drift_model=drift_model,
hfcut=hpf,
hrf_model=self.inputs.hrf_model,
add_regs=reg_vals,
add_reg_names=reg_names,
)
if self.inputs.normalize_design_matrix:
for i in range(len(self._reg_names) - 1):
design_matrix[:, i] = (
design_matrix[:, i] -
design_matrix[:, i].mean()) / design_matrix[:, i].std()
if self.inputs.plot_design_matrix:
import pylab
pylab.pcolor(design_matrix)
pylab.savefig("design_matrix.pdf")
pylab.close()
pylab.clf()
glm = GLM.GeneralLinearModel()
glm.fit(
timeseries.T,
design_matrix,
method=self.inputs.method,
model=self.inputs.model,
)
self._beta_file = os.path.abspath("beta.nii")
beta = np.zeros(mask.shape + (glm.beta.shape[0], ))
beta[mask, :] = glm.beta.T
nb.save(nb.Nifti1Image(beta, nii.affine), self._beta_file)
self._s2_file = os.path.abspath("s2.nii")
s2 = np.zeros(mask.shape)
s2[mask] = glm.s2
nb.save(nb.Nifti1Image(s2, nii.affine), self._s2_file)
if self.inputs.save_residuals:
explained = np.dot(design_matrix, glm.beta)
residuals = np.zeros(mask.shape + (nscans, ))
residuals[mask, :] = timeseries - explained.T
self._residuals_file = os.path.abspath("residuals.nii")
nb.save(nb.Nifti1Image(residuals, nii.affine),
self._residuals_file)
self._nvbeta = glm.nvbeta
self._dof = glm.dof
self._constants = glm._constants
self._axis = glm._axis
if self.inputs.model == "ar1":
self._a_file = os.path.abspath("a.nii")
a = np.zeros(mask.shape)
a[mask] = glm.a.squeeze()
nb.save(nb.Nifti1Image(a, nii.affine), self._a_file)
self._model = glm.model
self._method = glm.method
return runtime
onsets = np.linspace(5, (n_scans - 1) * tr - 10, 20) # in seconds
hrf_model = 'canonical'
motion = np.cumsum(np.random.randn(n_scans, 6), 0)
add_reg_names = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz']
# write directory
write_dir = os.getcwd()
########################################
# Design matrix
########################################
paradigm = np.vstack(([conditions, onsets])).T
paradigm = EventRelatedParadigm(conditions, onsets)
X, names = dmtx_light(frametimes, paradigm, drift_model='cosine', hfcut=128,
hrf_model=hrf_model, 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]
# 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
# 'canonical with derivative' or 'fir'
hrf_model = 'canonical'
# fake motion parameters to be included in the model
motion = np.cumsum(np.random.randn(n_scans, 6), 0)
add_reg_names = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz']
########################################
# Design matrix
########################################
paradigm = EventRelatedParadigm(conditions, onsets)
X, names = dm.dmtx_light(frametimes,
paradigm,
drift_model='cosine',
hfcut=128,
hrf_model=hrf_model,
add_regs=motion,
add_reg_names=add_reg_names)
#######################################
# 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)
########################################
conditions = np.arange(20) % 2
onsets = np.linspace(5, (n_scans - 1) * tr - 10, 20) # in seconds
hrf_model = 'Canonical'
motion = np.cumsum(np.random.randn(n_scans, 6), 0)
add_reg_names = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz']
# write directory
swd = tempfile.mkdtemp()
########################################
# Design matrix
########################################
paradigm = EventRelatedParadigm(conditions, onsets)
X, names = dm.dmtx_light(frametimes, paradigm, drift_model='Cosine', hfcut=128,
hrf_model=hrf_model, add_regs=motion,
add_reg_names=add_reg_names)
#######################################
# 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 = op.join(swd, 'fmri_data.nii')
save(fmri_data, data_file)
########################################
# Perform a GLM analysis
def _run_interface(self, runtime):
session_info = self.inputs.session_info
functional_runs = self.inputs.session_info[0]['scans']
if isinstance(functional_runs, str):
functional_runs = [functional_runs]
nii = nb.load(functional_runs[0])
data = nii.get_data()
if isdefined(self.inputs.mask):
mask = nb.load(self.inputs.mask).get_data() > 0
else:
mask = np.ones(nii.shape[:3]) == 1
timeseries = data.copy()[mask, :]
del data
for functional_run in functional_runs[1:]:
nii = nb.load(functional_run)
data = nii.get_data()
npdata = data.copy()
del data
timeseries = np.concatenate((timeseries, npdata[mask, :]), axis=1)
del npdata
nscans = timeseries.shape[1]
if 'hpf' in session_info[0].keys():
hpf = session_info[0]['hpf']
drift_model = self.inputs.drift_model
else:
hpf = 0
drift_model = "Blank"
reg_names = []
for reg in session_info[0]['regress']:
reg_names.append(reg['name'])
reg_vals = np.zeros((nscans, len(reg_names)))
for i in range(len(reg_names)):
reg_vals[:, i] = np.array(
session_info[0]['regress'][i]['val']).reshape(1, -1)
frametimes = np.linspace(0, (nscans - 1) * self.inputs.TR, nscans)
conditions = []
onsets = []
duration = []
for i, cond in enumerate(session_info[0]['cond']):
onsets += cond['onset']
conditions += [cond['name']] * len(cond['onset'])
if len(cond['duration']) == 1:
duration += cond['duration'] * len(cond['onset'])
else:
duration += cond['duration']
if conditions:
paradigm = BlockParadigm(con_id=conditions,
onset=onsets,
duration=duration)
else:
paradigm = None
design_matrix, self._reg_names = dm.dmtx_light(
frametimes,
paradigm,
drift_model=drift_model,
hfcut=hpf,
hrf_model=self.inputs.hrf_model,
add_regs=reg_vals,
add_reg_names=reg_names)
if self.inputs.normalize_design_matrix:
for i in range(len(self._reg_names) - 1):
design_matrix[:, i] = (
design_matrix[:, i] -
design_matrix[:, i].mean()) / design_matrix[:, i].std()
if self.inputs.plot_design_matrix:
import pylab
pylab.pcolor(design_matrix)
pylab.savefig("design_matrix.pdf")
pylab.close()
pylab.clf()
glm = GLM.glm()
glm.fit(timeseries.T,
design_matrix,
method=self.inputs.method,
model=self.inputs.model)
self._beta_file = os.path.abspath("beta.nii")
beta = np.zeros(mask.shape + (glm.beta.shape[0], ))
beta[mask, :] = glm.beta.T
nb.save(nb.Nifti1Image(beta, nii.get_affine()), self._beta_file)
self._s2_file = os.path.abspath("s2.nii")
s2 = np.zeros(mask.shape)
s2[mask] = glm.s2
nb.save(nb.Nifti1Image(s2, nii.get_affine()), self._s2_file)
if self.inputs.save_residuals:
explained = np.dot(design_matrix, glm.beta)
residuals = np.zeros(mask.shape + (nscans, ))
residuals[mask, :] = timeseries - explained.T
self._residuals_file = os.path.abspath("residuals.nii")
nb.save(nb.Nifti1Image(residuals, nii.get_affine()),
self._residuals_file)
self._nvbeta = glm.nvbeta
self._dof = glm.dof
self._constants = glm._constants
self._axis = glm._axis
if self.inputs.model == "ar1":
self._a_file = os.path.abspath("a.nii")
a = np.zeros(mask.shape)
a[mask] = glm.a.squeeze()
nb.save(nb.Nifti1Image(a, nii.get_affine()), self._a_file)
self._model = glm.model
self._method = glm.method
return runtime
def _run_interface(self, runtime):
data_list = [nb.load(fn).get_data() for fn in self.inputs.data_files]
onsets = self.inputs.onsets
paradigm = EventRelatedParadigm(["a"] * len(onsets), onsets)
frametimes = np.arange(0, data_list[0].shape[-1] * self.inputs.TR, self.inputs.TR)
X, names = dm.dmtx_light(frametimes, paradigm, drift_model="polynomial", hfcut=128, hrf_model="canonical")
self.X = X
X_T_inv = np.linalg.pinv(np.dot(X.T, X))
calc_beta = np.dot(X_T_inv, X.T)
# Do OLS
mean_data = np.mean(data_list, 0)
self.ols_beta = np.dot(calc_beta, mean_data.reshape(np.prod(mean_data.shape[:-1]), mean_data.shape[-1]).T)
predicted = np.dot(X, self.ols_beta).T.reshape(mean_data.shape)
resid = mean_data - predicted
ss = bottleneck.ss(resid, -1)
self.ols_var = np.outer(X_T_inv, ss)
# Create individual residuals for sandwhich:
self.sss = np.zeros(ss.shape)
self.residuals = []
for data in data_list:
beta = np.dot(calc_beta, data.reshape(np.prod(data.shape[:-1]), mean_data.shape[-1]).T)
self.predicted = np.dot(X, self.ols_beta).T.reshape(mean_data.shape)
resid = mean_data - self.predicted
self.residuals.append(resid)
self.sss += bottleneck.ss(resid, -1)
if len(data_list) > 5:
self.sss = self.sss / (len(data_list) - 1)
else:
self.sss = self.sss / len(data_list)
self.sandwich_var = np.outer(np.dot(calc_beta, calc_beta.T), self.sss) / len(data_list)
self.contrasts = np.array(self.inputs.contrasts)
self.residuals = np.array(self.residuals).swapaxes(0, -1)
self.sandwich_var = self.sandwich_var.T.reshape(mean_data.shape[:-1] + (-1,))
self.ols_beta = self.ols_beta.T.reshape(mean_data.shape[:-1] + (-1,))
self.ols_var = self.ols_var.T.reshape(mean_data.shape[:-1] + (-1,))
if self.inputs.variance_to_use == "ols":
self.z = (self.ols_beta[:, :, 0] / (np.sqrt(self.ols_var[:, :, 0]) / np.sqrt(len(data_list)))).squeeze()
else:
self.z = (
self.ols_beta[:, :, 0] / (np.sqrt(self.sandwich_var[:, :, 0]) / np.sqrt(len(data_list)))
).squeeze()
self.z = self.z.T.reshape(mean_data.shape[:-1] + (-1,))
nb.save(nb.Nifti1Image(self.ols_beta, np.identity(4)), "ols_beta.nii.gz")
nb.save(nb.Nifti1Image(self.ols_var, np.identity(4)), "ols_var.nii.gz")
nb.save(nb.Nifti1Image(self.sandwich_var, np.identity(4)), "sandwich_var.nii.gz")
nb.save(nb.Nifti1Image(self.z, np.identity(4)), "z_%s.nii.gz" % self.inputs.variance_to_use)
nb.save(nb.Nifti1Image(self.residuals, np.identity(4)), "residuals.nii.gz")
save(self.X, "design_matrix.hdf5")
return runtime
