def test_param_mask_deprecation_SecondLevelModel():
""" Tests whether use of deprecated keyword parameter `mask`
raises the correct warning & transfers its value to
replacement parameter `mask_img` correctly.
"""
deprecation_msg = (
'The parameter "mask" will be removed in next release of Nistats. '
'Please use the parameter "mask_img" instead.')
mask_filepath = '~/masks/mask_01.nii.gz'
with warnings.catch_warnings(record=True) as raised_warnings:
slm1 = SecondLevelModel(mask=mask_filepath)
slm2 = SecondLevelModel(mask_img=mask_filepath)
slm3 = SecondLevelModel(mask_filepath)
assert slm1.mask_img == mask_filepath
assert slm2.mask_img == mask_filepath
assert slm3.mask_img == mask_filepath
with assert_raises(AttributeError):
slm1.mask == mask_filepath
with assert_raises(AttributeError):
slm2.mask == mask_filepath
with assert_raises(AttributeError):
slm3.mask == mask_filepath
raised_param_deprecation_warnings = [
raised_warning_ for raised_warning_ in raised_warnings
if str(raised_warning_.message).startswith('The parameter')
]
assert len(raised_param_deprecation_warnings) == 1
for param_warning_ in raised_param_deprecation_warnings:
assert str(param_warning_.message) == deprecation_msg
assert param_warning_.category is DeprecationWarning
def oneSample_ttest(map_list, timeseries, coord):
print("hOLII")
template = ld.load_timserie_mask()
print("alooooo")
design_matrix = pd.DataFrame([1] * len(map_list), columns=['intercept'])
print("Hasta aqui si")
nifti_masker = NiftiMasker(standardize=True,
mask_strategy='epi',
memory="nilearn_cache",
memory_level=2,
smoothing_fwhm=8)
print("me iamgino que hasta aqui llega.")
ts = ants.matrix_to_timeseries(template, timeseries[0])
print("Esto es nuevo")
nifti_masker.fit(ts)
print("No estoy seguro de donde ha reventado")
zf = np.asmatrix(map_list[0].transpose())
imgUsar = nifti_masker.inverse_transform(zf)
print("No estoy seguro de donde ha reventado 2")
second_level_model = SecondLevelModel().fit(pd.DataFrame(zf),
design_matrix=design_matrix)
print("Creo que peta aqui")
z_map = second_level_model.compute_contrast(output_type='z_score')
return z_map
def report_slm_oasis(): # pragma: no cover
n_subjects = 5 # more subjects requires more memory
oasis_dataset = nilearn.datasets.fetch_oasis_vbm(n_subjects=n_subjects)
# Resample the images, since this mask has a different resolution
mask_img = resample_to_img(
nilearn.datasets.fetch_icbm152_brain_gm_mask(),
oasis_dataset.gray_matter_maps[0],
interpolation='nearest',
)
design_matrix = _make_design_matrix_slm_oasis(oasis_dataset, n_subjects)
second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img)
second_level_model.fit(oasis_dataset.gray_matter_maps,
design_matrix=design_matrix)
contrast = [[1, 0, 0], [0, 1, 0]]
report = make_glm_report(
model=second_level_model,
contrasts=contrast,
bg_img=nilearn.datasets.fetch_icbm152_2009()['t1'],
height_control=None,
)
output_filename = 'generated_report_slm_oasis.html'
output_filepath = os.path.join(REPORTS_DIR, output_filename)
report.save_as_html(output_filepath)
report.get_iframe()
def create_one_sample_t_test(name, maps, output_dir, smoothing_fwhm=6.0):
if not op.isdir(output_dir):
op.mkdir(output_dir)
model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm)
design_matrix = pd.DataFrame([1] * len(maps), columns=['intercept'])
model = model.fit(maps, design_matrix=design_matrix)
z_map = model.compute_contrast(output_type='z_score')
nib.save(z_map, op.join(output_dir, "{}_group_zmap.nii.gz".format(name)))
def compute_group_z_map(second_level_input, n_sub, output_pathway):
# Model the effect of conditions (sample 1 vs sample 2).
condition_effect = np.hstack(([1] * n_sub, [- 1] * n_sub))
# Model the subject effect:
# each subject is observed in sample 1 and sample 2.
subject_effect = np.vstack((np.eye(n_sub), np.eye(n_sub)))
subjects = ['S%02d' % i for i in range(1, n_sub + 1)]
# We then assemble those in a design matrix and...
design_matrix = pd.DataFrame(
np.hstack((condition_effect[:, np.newaxis], subject_effect)),
columns=['Story vs. Math'] + subjects)
# ... plot the design_matrix.
plot_design_matrix(design_matrix, output_file=
os.path.join(output_pathway,
'design_matrix_story_math.png'))
# Specify the analysis model and fit it
second_level_model = SecondLevelModel().fit(second_level_input,
design_matrix=design_matrix)
# Estimate the contrast
z_map = second_level_model.compute_contrast('Story vs. Math',
output_type='z_score')
# Report of the GLM
report = make_glm_report(second_level_model,
contrasts='Story vs. Math',
title='Group-Level HCP900 Story vs.Math Report',
cluster_threshold=5,
height_control='fdr',
min_distance=8.,
plot_type='glass',
)
report.save_as_html(os.path.join(output_pathway, 'report.html'))
# Save contrast nifti-file
z_map.to_filename(os.path.join(output_pathway,
'group_hcplang900_story_math.nii.gz'))
# Plot contrast
threshold = 3.1 # correponds to p < .001, uncorrected
display = plotting.plot_glass_brain(z_map, threshold=threshold,
colorbar=True,
plot_abs=False,
title='Story vs. Math (unc p<0.001)',
output_file=os.path.join(
output_pathway,
'group_hcplang900_story_math'))
return z_map
def fit_second_level(models1, contrasts, atlas, dim, split, write_dir):
mem = Memory(location=expanduser('cache'))
model = SecondLevelModel(n_jobs=1, memory=mem, memory_level=1)
model.fit(models1)
for contrast in contrasts:
for output_type in ['z_score', 'effect_size']:
img = model.compute_contrast(first_level_contrast=contrast,
output_type=output_type)
img.to_filename(
join(
write_dir, f'{contrast}_{output_type}_{atlas}'
f'_{dim}_{split}.nii.gz'))
def test_second_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# ols case
model = SecondLevelModel(mask=mask)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4)
model = model.fit(Y, design_matrix=X)
labels1 = model.labels_
results1 = model.results_
labels2, results2 = run_glm(model.masker_.transform(Y), X, 'ols')
assert_almost_equal(labels1, labels2, decimal=1)
assert_equal(len(results1), len(results2))
def one_sample_ttest(filenames, name):
design_matrix = pd.DataFrame([1] * len(filenames), columns=['intercept'])
second_level_model = SecondLevelModel().fit(filenames,
design_matrix=design_matrix)
z_map = second_level_model.compute_contrast(output_type='z_score')
nib.save(zmap, name + '.nii')
thmap, threshold1 = map_threshold(z_map,
level=.001,
height_control='fpr',
cluster_threshold=10)
display = plot_glass_brain(thmap,
display_mode='lzry',
threshold=0,
colorbar=True)
display.savefig(name + '.png')
display.close()
def test_slm_reporting():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
model = SecondLevelModel()
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
c1 = np.eye(len(model.design_matrix_.columns))[0]
report_slm = glmr.make_glm_report(model, c1)
# catches & raises UnicodeEncodeError in HTMLDocument.get_iframe()
report_iframe = report_slm.get_iframe()
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del Y, FUNCFILE, func_img, model
def do_contrast(con, ROOTDIR, MODEL):
""" Input: con is the name of the contrast """
confile = f'{con}_con.nii.gz'
spmfile = f'{con}_zmap.nii.gz'
cmaps = glob.glob(op.join(ROOTDIR, 'sub*', MODEL, confile))
smaps = glob.glob(op.join(ROOTDIR, 'sub*', MODEL, spmfile))
cmaps.sort()
smaps.sort()
fig, axes = plt.subplots(nrows=5, ncols=4)
for cidx, tmap in enumerate(smaps):
plotting.plot_glass_brain(tmap,
colorbar=True,
threshold=3.1,
title=f'{cidx:02d}',
axes=axes[int(cidx / 4),
int(cidx % 4)],
plot_abs=False,
display_mode='z')
fig.suptitle(f'contrast {con}')
#pdf.savefig(fig)
second_level_input = cmaps
design_matrix = pd.DataFrame([1] * len(second_level_input),
columns=['intercept'])
second_level_model = SecondLevelModel(smoothing_fwhm=8.0)
second_level_model = second_level_model.fit(second_level_input,
design_matrix=design_matrix)
z_map = second_level_model.compute_contrast(output_type='z_score')
nib.save(z_map, f'group_{con}.nii.gz')
p_val = 0.001
p001_unc = norm.isf(p_val)
display = plotting.plot_glass_brain(
z_map,
threshold=p001_unc,
colorbar=True,
display_mode='lzry',
plot_abs=False,
title=f'group contrasts {con} (unc p<0.001)')
display.savefig(f'group_{con}.png')
#pdf.savefig()
display.close()
def create_one_sample_t_test(name, maps, output_dir, smoothing_fwhm=8.0):
if not op.isdir(output_dir):
op.mkdir(output_dir)
model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm)
design_matrix = pd.DataFrame([1] * len(maps), columns=['intercept'])
model = model.fit(maps, design_matrix=design_matrix)
z_map = model.compute_contrast(output_type='z_score')
nibabel.save(z_map, op.join(output_dir,
"{}_group_zmap.nii.gz".format(name)))
p_val = 0.001
z_th = norm.isf(p_val)
z_th = 3.1
display = plotting.plot_glass_brain(z_map,
threshold=z_th,
colorbar=True,
plot_abs=False,
display_mode='lzry',
title=name)
display.savefig(op.join(output_dir, "{}_group_zmap".format(name)))
def test_high_level_glm_with_paths():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, [])
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
c1 = np.eye(len(model.design_matrix_.columns))[0]
z_image = model.compute_contrast(c1, output_type='z_score')
assert_true(isinstance(z_image, Nifti1Image))
assert_array_equal(z_image.affine, load(mask).affine)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del Y, FUNCFILE, func_img, model
def test_high_level_glm_with_paths():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, [])
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
c1 = np.eye(len(model.design_matrix_.columns))[0]
z_image = model.compute_contrast(c1, output_type='z_score')
assert_true(isinstance(z_image, Nifti1Image))
assert_array_equal(z_image.affine, load(mask).affine)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del Y, FUNCFILE, func_img, model
def test_make_headings_with_contrasts_title_none():
model = SecondLevelModel()
test_input = ({
'contrast_0': [0, 0, 1],
'contrast_1': [0, 1, 1],
}, None, model)
expected_output = (
'Report: Second Level Model for contrast_0, contrast_1',
'Statistical Report for contrast_0, contrast_1',
'Second Level Model',
)
actual_output = glmr._make_headings(*test_input)
assert actual_output == expected_output
def test_second_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
model.compute_contrast()
labels1 = model.labels_
results1 = model.results_
labels2, results2 = run_glm(
model.masker_.transform(Y), X.values, 'ols')
assert_almost_equal(labels1, labels2, decimal=1)
assert_equal(len(results1), len(results2))
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model, X, Y
def test_second_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
model.compute_contrast()
labels1 = model.labels_
results1 = model.results_
labels2, results2 = run_glm(model.masker_.transform(Y), X.values,
'ols')
assert_almost_equal(labels1, labels2, decimal=1)
assert_equal(len(results1), len(results2))
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model, X, Y
def create_one_sample_t_test(name,
maps,
output_dir,
smoothing_fwhm=None,
vmax=None,
design_matrix=None,
p_val=0.001,
fdr=0.01,
loc=0,
scale=1,
fwhm=6):
""" Do a one sample t-test over the maps.
"""
print('##### ', name, ' #####')
model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm, n_jobs=-1)
design_matrix = design_matrix if (
design_matrix is not None) else pd.DataFrame([1] * len(maps),
columns=['intercept'])
model = model.fit(maps, design_matrix=design_matrix)
z_map = model.compute_contrast(output_type='z_score')
p_val = p_val
z_th = norm.isf(p_val, loc=loc, scale=scale) # 3.09
# apply fdr to zmap
thresholded_zmap, th = map_threshold(stat_img=z_map,
alpha=fdr,
height_control='fdr',
cluster_threshold=0,
two_sided=False)
print(z_th, th)
# effect size-map
eff_map = model.compute_contrast(output_type='effect_size')
thr = np.abs(thresholded_zmap.get_data())
return z_map, eff_map, new_img_like(eff_map, (thr > z_th)), (thr > z_th)
def compute_second_level(model1, model2, FWHM=None):
"""
Compute the group-level significance of the paired difference between two
models
"""
# # compute and save the difference of two models
compute_model_difference(model1, model2,
FWHM) # compute with the FirstLevelAnalysis code
# redefine the mask, without smoothing
masker = compute_global_masker(rootdir)
# use those different files as input for group-level analysis
second_level_input = get_fmri_files(
os.path.join(rootdir, first_dir, "diff"), f'{model1}-{model2}')
# prepare second level analysis (one sample t-test)
design_matrix = pd.DataFrame([1] * len(second_level_input),
columns=['intercept'])
second_level_model = SecondLevelModel(masker)
second_level_model = second_level_model.fit(second_level_input,
design_matrix=design_matrix)
# estimation the contrast
z_map = second_level_model.compute_contrast(output_type='z_score')
# save to disk
nib.save(
z_map,
os.path.join(rootdir, second_dir, f"GroupLevel_{model1}-{model2}"))
# Get the map of positive values only
z_val = masker.transform(z_map)
z_val_pos = [val if val > 0 else 0 for val in z_val[0]]
z_map_pos = masker.inverse_transform(z_val_pos)
return z_map, z_map_pos
def test_make_headings_with_contrasts_title_custom():
model = SecondLevelModel()
test_input = (
{
'contrast_0': [0, 0, 1],
'contrast_1': [0, 1, 1],
},
'Custom Title for report',
model,
)
expected_output = (
'Custom Title for report',
'Custom Title for report',
'Second Level Model',
)
actual_output = glmr._make_headings(*test_input)
assert actual_output == expected_output
def test_second_level_model_contrast_computation_with_memory_caching():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask=mask, memory='nilearn_cache')
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
ncol = len(model.design_matrix_.columns)
c1 = np.eye(ncol)[0, :]
# test memory caching for compute_contrast
model.compute_contrast(c1, output_type='z_score')
# or simply pass nothing
model.compute_contrast()
def test_create_second_level_design():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
first_level_input = _first_level_dataframe()
first_level_input['effects_map_path'] = [FUNCFILE] * 4
confounds = [['01', 0.1], ['02', 0.75]]
confounds = pd.DataFrame(confounds, columns=['subject_id', 'f1'])
design = create_second_level_design(first_level_input, confounds)
expected_design = np.array([[1, 0, 1, 0, 0.1], [0, 1, 1, 0, 0.1],
[1, 0, 0, 1, 0.75], [0, 1, 0, 1, 0.75]])
assert_array_equal(design, expected_design)
assert_true(len(design.columns) == 2 + 2 + 1)
assert_true(len(design) == 2 + 2)
model = SecondLevelModel(mask=mask).fit(first_level_input,
confounds=confounds)
design = model.design_matrix_
assert_array_equal(design, expected_design)
assert_true(len(design.columns) == 2 + 2 + 1)
assert_true(len(design) == 2 + 2)
def test_second_level_model_contrast_computation_with_memory_caching():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask, memory='nilearn_cache')
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
ncol = len(model.design_matrix_.columns)
c1 = np.eye(ncol)[0, :]
# test memory caching for compute_contrast
model.compute_contrast(c1, output_type='z_score')
# or simply pass nothing
model.compute_contrast()
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model, X, Y
def anova(db, masker):
"""perform a big ANOVA of brain activation with three factors:
acquisition, subject, contrast"""
df = db[(db.acquisition == 'ap') | (db.acquisition == 'pa')]
# make the design matrix
subject_dmtx, subject_ = design(df.subject)
contrast_dmtx, contrast_ = design(df.contrast)
acq_dmtx, acq_ = design(df.acquisition)
dmtx = np.hstack(
(subject_dmtx[:, :-1], contrast_dmtx[:, :-1], acq_dmtx[:, :-1],
np.ones((len(df), 1))))
labels = np.hstack(
(subject_[:-1], contrast_[:-1], acq_[:-1], ['intercept']))
design_matrix = pd.DataFrame(dmtx, columns=labels)
_, singular, _ = np.linalg.svd(design_matrix.values, 0)
dof_subject = len(subject_) - 1
dof_contrast = len(contrast_) - 1
dof_acq = len(acq_) - 1
# fit the model
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel(mask=masker.mask_img_)
second_level_model = second_level_model.fit(list(df.path.values),
design_matrix=design_matrix)
subject_map = second_level_model.compute_contrast(np.eye(
len(labels))[:dof_subject],
output_type='z_score')
contrast_map = second_level_model.compute_contrast(np.eye(
len(labels))[dof_subject:dof_subject + dof_contrast],
output_type='z_score')
acq_map = second_level_model.compute_contrast(np.eye(
len(labels))[-1 - dof_acq:-1],
output_type='z_score')
subject_map = math_img('img * (img > -8.2095)', img=subject_map)
contrast_map = math_img('img * (img > -8.2095)', img=contrast_map)
acq_map = math_img('img * (img > -8.2095)', img=acq_map)
return design_matrix, subject_map, contrast_map, acq_map
def test_second_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, 'intercept')
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
ncol = len(model.design_matrix_.columns)
c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol)
# smoke test for different contrasts in fixed effects
model.compute_contrast(c1)
model.compute_contrast(c1, output_type='z_score')
model.compute_contrast(c1, output_type='stat')
model.compute_contrast(c1, output_type='p_value')
model.compute_contrast(c1, output_type='effect_size')
model.compute_contrast(c1, output_type='effect_variance')
# formula should work (passing variable name directly)
model.compute_contrast('intercept')
# or simply pass nothing
model.compute_contrast()
# passing null contrast should give back a value error
assert_raises(ValueError, model.compute_contrast, cnull)
# passing wrong parameters
assert_raises(ValueError, model.compute_contrast, [])
assert_raises(ValueError, model.compute_contrast, c1, None, '')
assert_raises(ValueError, model.compute_contrast, c1, None, [])
assert_raises(ValueError, model.compute_contrast, c1, None, None, '')
# check that passing no explicit contrast when the dsign
# matrix has morr than one columns raises an error
X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2'])
model = model.fit(Y, design_matrix=X)
assert_raises(ValueError, model.compute_contrast, None)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model, X, Y
def main(sourcedata, derivatives, subject, session, tmp_dir):
sourcedata_layout = BIDSLayout(sourcedata)
sourcedata_df = sourcedata_layout.as_data_frame()
events = sourcedata_df[(sourcedata_df['type'] == 'events')
& (sourcedata_df['subject'] == subject) &
(sourcedata_df['session'] == session)]
derivatives_layout = BIDSLayout(
os.path.join(derivatives, 'spynoza_mc_mutualinfo'))
derivatives_df = derivatives_layout.as_data_frame()
bold = derivatives_df[(derivatives_df['type'] == 'preproc')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
confounds = derivatives_df[(derivatives_df['type'] == 'confounds')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
print(derivatives_df.type.unique())
mask = derivatives_layout.get(subject=subject,
session=session,
type='mask',
return_type='file')[0]
df = events.merge(bold,
on=['subject', 'session', 'run'],
suffixes=('_events', '_bold'))
confounds = confounds.rename(columns={'path': 'confounds'})
df = df.merge(confounds[['subject', 'session', 'run', 'confounds']])
models = []
for ix, row in df.iterrows():
results_dir = os.path.join(derivatives, 'modelfitting', 'glm4',
'sub-{}'.format(row['subject']))
if 'session' in row:
results_dir = os.path.join(results_dir,
'ses-{}'.format(row['session']))
os.makedirs(results_dir, exist_ok=True)
confounds = pd.read_table(row.confounds).fillna(method='bfill')
print('Fitting {}'.format(row['path_bold']))
model = FirstLevelModel(t_r=4, mask=mask)
paradigm = pd.read_table(row['path_events'])
model.fit(row['path_bold'], paradigm, confounds=confounds)
left_right = model.compute_contrast('eye_L - eye_R',
output_type='z_score')
left_right.to_filename(
os.path.join(
results_dir,
'sub-{}_ses-{}_run-{}_left_over_right_zmap.nii.gz'.format(
row['subject'], row['session'], row['run'])))
left_right = model.compute_contrast('eye_L - eye_R',
output_type='effect_size')
left_right.to_filename(
os.path.join(
results_dir,
'sub-{}_ses-{}_run-{}_left_over_right_psc.nii.gz'.format(
row['subject'], row['session'], row['run'])))
models.append(model)
second_level_model = SecondLevelModel(mask=mask)
second_level_model.fit(models)
left_right_group = second_level_model.compute_contrast(
first_level_contrast='eye_L - eye_R', output_type='z_score')
left_right_group.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format(
row['subject'], row['session'])))
left_right_group = second_level_model.compute_contrast(
first_level_contrast='eye_L - eye_R', output_type='effect_size')
left_right_group.to_filename(
os.path.join(
results_dir,
'sub-{}_ses-{}_left_over_right_effect_size.nii.gz'.format(
row['subject'], row['session'])))
left_right_group = second_level_model.compute_contrast(
first_level_contrast='eye_L - eye_R', output_type='z_score')
left_right_group.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format(
row['subject'], row['session'])))
def main(sourcedata, derivatives, subject, session, tmp_dir):
sourcedata_layout = BIDSLayout(sourcedata)
sourcedata_df = sourcedata_layout.as_data_frame()
events = sourcedata_df[(sourcedata_df['suffix'] == 'events')
& (sourcedata_df['subject'] == subject) &
(sourcedata_df['session'] == session)]
derivatives_layout = BIDSLayout(os.path.join(derivatives), validate=False)
derivatives_df = derivatives_layout.as_data_frame()
bold = derivatives_df[(derivatives_df['suffix'] == 'preproc')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
confounds = derivatives_df[(derivatives_df['suffix'] == 'confounds')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
compcor = derivatives_df[(derivatives_df['suffix'] == 'compcor')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
mask = derivatives_layout.get(subject=subject,
session=session,
suffix='mask',
return_type='file')[0]
df = events.merge(bold,
on=['subject', 'session', 'run'],
suffixes=('_events', '_bold'))
confounds = confounds.rename(columns={'path': 'confounds'})
df = df.merge(confounds[['subject', 'session', 'run', 'confounds']])
compcor = compcor.rename(columns={'path': 'compcor'})
df = df.merge(compcor[['subject', 'session', 'run', 'compcor']])
df.sort_values('run', inplace=True)
print(df.iloc[0])
models = []
for ix, row in df.iterrows():
results_dir = os.path.join(derivatives, 'modelfitting', 'glm8',
'sub-{}'.format(row['subject']))
if 'session' in row:
results_dir = os.path.join(results_dir,
'ses-{}'.format(row['session']))
results_dir = op.join(results_dir, 'func')
os.makedirs(results_dir, exist_ok=True)
confounds = pd.read_table(row.confounds).fillna(method='bfill')
compcor = pd.read_table(row.compcor).fillna(method='bfill')
confounds = pd.concat((confounds, compcor), 1)
confounds -= confounds.mean()
confounds /= confounds.std()
pca = decomposition.PCA(n_components=6)
confounds_trans = pd.DataFrame(
pca.fit_transform(confounds),
columns=['pca_{}'.format(i) for i in range(6)])
print('Fitting {}'.format(row['path_bold']))
model = FirstLevelModel(t_r=4,
signal_scaling=False,
subject_label=int(row['run']),
mask_img=mask)
paradigm = pd.read_table(row['path_events'])
paradigm_ = paradigm.copy()
paradigm['trial_type'] = 'stimulation'
paradigm['modulation'] = 1
paradigm_['modulation'] = paradigm_.trial_type.map({
'eye_L': 1,
'eye_R': -1
})
paradigm_['trial_type'] = 'eye'
paradigm = pd.concat((paradigm, paradigm_), ignore_index=True)
model.fit(row['path_bold'], paradigm, confounds=confounds_trans)
row['run'] = int(row['run'])
row = dict(row)
left_right = model.compute_contrast('eye', output_type='z_score')
left_right.to_filename(
os.path.join(
results_dir,
'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_left_over_right_zmap.nii.gz'
.format(**row)))
left_right = model.compute_contrast('eye', output_type='effect_size')
left_right.to_filename(
os.path.join(
results_dir,
'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_left_over_right_psc.nii.gz'
.format(**row)))
stimulation = model.compute_contrast('stimulation',
output_type='effect_size')
stimulation.to_filename(
os.path.join(
results_dir,
'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_stimulation_psc.nii.gz'
.format(**row)))
stimulation = model.compute_contrast('stimulation',
output_type='z_score')
stimulation.to_filename(
os.path.join(
results_dir,
'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_stimulation_zmap.nii.gz'
.format(**row)))
models.append(model)
second_level_model = SecondLevelModel(mask_img=mask)
second_level_model.fit(models)
left_right_group = second_level_model.compute_contrast(
first_level_contrast='eye', output_type='z_score')
left_right_group.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format(
row['subject'], row['session'])))
left_right_group = second_level_model.compute_contrast(
first_level_contrast='eye', output_type='effect_size')
left_right_group.to_filename(
os.path.join(
results_dir,
'sub-{}_ses-{}_left_over_right_effect_size.nii.gz'.format(
row['subject'], row['session'])))
stimulation_group = second_level_model.compute_contrast(
first_level_contrast='stimulation', output_type='z_score')
left_right_group.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_stimulation_zmap.nii.gz'.format(
row['subject'], row['session'])))
stimulation_group = second_level_model.compute_contrast(
first_level_contrast='stimulation', output_type='effect_size')
left_right_group.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_stimulation_effect_size.nii.gz'.format(
row['subject'], row['session'])))
#########################################################################
# Get the set of individual statstical maps (contrast estimates)
cmap_filenames = localizer_dataset.cmaps
#########################################################################
# Perform the second level analysis
# ----------------------------------
#
# First define a design matrix for the model. As the model is trivial (one-sample test), the design matrix is just one column with ones.
import pandas as pd
design_matrix = pd.DataFrame([1] * n_samples, columns=['intercept'])
#########################################################################
# Specify and estimate the model
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel().fit(
cmap_filenames, design_matrix=design_matrix)
#########################################################################
# Compute the only possible contrast: the one-sample test. Since there
# is only one possible contrast, we don't need to specify it in detail
z_map = second_level_model.compute_contrast(output_type='z_score')
#########################################################################
# Threshold the resulting map:
# false positive rate < .001, cluster size > 10 voxels
from nistats.thresholding import map_threshold
thresholded_map1, threshold1 = map_threshold(
z_map, alpha=.001, height_control='fpr', cluster_threshold=10)
#########################################################################
# Now use FDR <.05, (False Discovery Rate) no cluster-level threshold
design_matrix = pd.DataFrame(np.vstack((age, sex, intercept)).T,
columns=['age', 'sex', 'intercept'])
#############################################################################
# Plot the design matrix
from nistats.reporting import plot_design_matrix
ax = plot_design_matrix(design_matrix)
ax.set_title('Second level design matrix', fontsize=12)
ax.set_ylabel('maps')
##########################################################################
# Specify and fit the second-level model when loading the data, we
# smooth a little bit to improve statistical behavior
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img)
second_level_model.fit(gray_matter_map_filenames,
design_matrix=design_matrix)
##########################################################################
# Estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast(second_level_contrast=[1, 0, 0],
output_type='z_score')
###########################################################################
# We threshold the second level contrast at uncorrected p < 0.001 and plot it.
# First compute the threshold.
from nistats.thresholding import map_threshold
_, threshold = map_threshold(
z_map, level=.05, height_control='fdr')
fig.suptitle('subjects z_map language network (unc p<0.001)')
plotting.show()
#########################################################################
# Second level model estimation
# -----------------------------
# We just have to provide the list of fitted FirstLevelModel objects
# to the SecondLevelModel object for estimation. We can do this because
# all subjects share a similar design matrix (same variables reflected in
# column names)
from nistats.second_level_model import SecondLevelModel
second_level_input = models
#########################################################################
# Note that we apply a smoothing of 8mm.
second_level_model = SecondLevelModel(smoothing_fwhm=8.0)
second_level_model = second_level_model.fit(second_level_input)
#########################################################################
# Computing contrasts at the second level is as simple as at the first level
# Since we are not providing confounders we are performing an one-sample test
# at the second level with the images determined by the specified first level
# contrast.
zmap = second_level_model.compute_contrast(
first_level_contrast='language-string')
#########################################################################
# The group level contrast reveals a left lateralized fronto-temporal
# language network
plotting.plot_glass_brain(zmap, colorbar=True, threshold=p001_unc,
title='Group language network (unc p<0.001)',
def run_sig_tests(data_fnames, mask=None):
cmap = "Wistia"
second_level_model = SecondLevelModel(smoothing_fwhm=5.0, mask=mask)
if isinstance(data_fnames, dict):
test_type = 'z'
data_fnames_num = sorted(data_fnames['number'])
data_fnames_fri = sorted(data_fnames['friend'])
fname_atts = get_all_bids_atts(data_fnames_num[0])
fname_atts['task'] = 'diff'
fname_atts['test'] = 'pairedt'
# create paired t-test design matrix
pair_mat = np.zeros(
(2 * len(data_fnames_num), len(data_fnames_num) + 1), dtype=int)
labs = []
for i in range(len(data_fnames_num)):
l = 's' + str(i)
labs = labs + [l]
a = [0] * len(data_fnames_num)
a[i] = 1
pair_mat[:, i] = a + a
pair_mat[:, len(data_fnames_num)] = [1] * len(
data_fnames_num) + [-1] * len(data_fnames_fri)
design_matrix = pd.DataFrame(pair_mat, columns=labs + ['diff'])
if fname_atts['pred'] == 'deg':
data_fnames = data_fnames_num + data_fnames_fri
cmap = "winter"
elif fname_atts['pred'] == 'dist':
data_fnames = data_fnames_fri + data_fnames_num
cmap = "cool"
print(data_fnames)
con_name = 'diff'
else:
fname_atts = get_all_bids_atts(data_fnames[0])
# if fname_atts['val'] == 'R2':
# test_type = 'ks'
# fname_atts['test'] = 'ksfit'
# else:
test_type = 'z'
fname_atts['test'] = 'singlesamplet'
design_matrix = pd.DataFrame([1] * len(data_fnames),
columns=['intercept'])
con_name = 'intercept'
# setup file names
del fname_atts['sub']
fname_atts['correction'] = "none"
# show data files and design matrix
print("Running significance testing on: ")
print(data_fnames)
if test_type == 'z':
print("Using design matrix: ")
print(design_matrix)
out_stat = "z"
# save z map
second_level_model = second_level_model.fit(
data_fnames, design_matrix=design_matrix)
z_map = second_level_model.compute_contrast(con_name,
output_type='z_score')
out_map = z_map
# save p map
p_val = second_level_model.compute_contrast(con_name,
output_type='p_value')
refnii = p_val
elif test_type == 'ks':
out_stat = "D"
d_map, p_map, all_data = run_R2_sig_tests(data_fnames, mask_nii=mask)
refnii = nib.load(data_fnames[0])
out_map = nib.Nifti1Image(d_map, refnii.affine, refnii.header)
p_val = nib.Nifti1Image(p_map, refnii.affine, refnii.header)
# save R2 mean
if fname_atts['val'] == 'R2':
all_data = load_all(data_fnames)
mean_data = np.mean(all_data, axis=3)
fname_atts['val2'] = 'mean'
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
save_nii(mean_data, refnii, out_fname)
# save stat map
fname_atts['val2'] = out_stat
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
nib.save(out_map, out_fname)
print(out_fname + ' saved.')
# save p map
fname_atts['val2'] = "p"
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
nib.save(p_val, out_fname)
print(out_fname + ' saved.')
# FDR correction
if mask is None:
test_indices = np.argwhere(np.ones(
refnii.get_data().flatten().shape)).flatten()
else:
test_indices = np.argwhere(mask.get_data().flatten()).flatten()
p_arr = p_val.get_data().flatten()
p_arr2 = np.take(p_arr, test_indices)
sigs2, fdr_val2, a2, b2 = multipletests(p_arr2,
alpha=.05,
method='fdr_bh',
is_sorted=False,
returnsorted=False)
pfdr2 = deepcopy(1 - fdr_val2)
pfdr_arr = np.zeros(p_arr.shape)
np.put(pfdr_arr, test_indices, pfdr2)
pfdr_3d2 = pfdr_arr.reshape(p_val.shape)
pfdr_map = nib.Nifti1Image(pfdr_3d2, refnii.affine, refnii.header)
fname_atts['val2'] = "p"
fname_atts['correction'] = "fdr"
fname_atts['dir'] = "rev"
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
nib.save(pfdr_map, out_fname)
print(out_fname + ' saved.')
# plot maps
thresholded_map2, threshold2 = map_threshold(
out_map, level=.05, height_control='fdr') #, two_sided=False)
display = plot_stat_map(out_map, title='raw stat')
print('The FDR=.05 threshold is %.3g' % threshold2)
if not math.isinf(threshold2):
# thresholded_map2, threshold2 = map_threshold(
# out_map, level=.001, height_control=None)#, two_sided=False)
# fname_atts['val2'] = out_stat
# fname_atts['thresh'] = "p01"
# fname_atts['plot'] = "statmap"
# fname_atts['correction'] = "none"
# out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
# display = plot_stat_map(thresholded_map2, title='z map, p < 0.001', threshold = threshold2)
# display.savefig(out_fname)
# else:
fname_atts['val2'] = out_stat
fname_atts['thresh'] = "p05"
fname_atts['plot'] = "statmap"
fname_atts['correction'] = "fdr"
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
display = plot_stat_map(thresholded_map2,
cut_coords=display.cut_coords,
title='Thresholded ' + out_stat +
' map, expected fdr = .05, ' + out_stat +
' = ' + str(threshold2),
threshold=threshold2)
display.savefig(out_fname)
fname_atts['plot'] = "glassbrain"
out_fname = os.path.join(out_dir, make_bids_str(fname_atts))
display = plot_glass_brain(thresholded_map2,
cut_coords=display.cut_coords,
title='Thresholded ' + out_stat +
' map, expected fdr = .05, z = ' +
str(threshold2),
threshold=threshold2)
display.savefig(out_fname)
def test_second_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# ols case
model = SecondLevelModel(mask=mask)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, 'intercept')
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
ncol = len(model.design_matrix_.columns)
c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol)
# smoke test for different contrasts in fixed effects
model.compute_contrast(c1)
model.compute_contrast(c1, output_type='z_score')
model.compute_contrast(c1, output_type='stat')
model.compute_contrast(c1, output_type='p_value')
model.compute_contrast(c1, output_type='effect_size')
model.compute_contrast(c1, output_type='effect_variance')
# formula should work (passing variable name directly)
model.compute_contrast('intercept')
# or simply pass nothing
model.compute_contrast()
# passing null contrast should give back a value error
assert_raises(ValueError, model.compute_contrast, cnull)
# passing wrong parameters
assert_raises(ValueError, model.compute_contrast, [])
assert_raises(ValueError, model.compute_contrast, c1, None, '')
assert_raises(ValueError, model.compute_contrast, c1, None, [])
assert_raises(ValueError, model.compute_contrast, c1, None, None, '')
plt.show()
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
import pandas as pd
second_level_input = data['cmaps']
design_matrix = pd.DataFrame([1] * len(second_level_input),
columns=['intercept'])
############################################################################
# Model specification and fit
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel(smoothing_fwhm=8.0)
second_level_model = second_level_model.fit(second_level_input,
design_matrix=design_matrix)
##########################################################################
# To estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast(output_type='z_score')
###########################################################################
# We threshold the second level contrast at uncorrected p < 0.001 and plot
from scipy.stats import norm
p_val = 0.001
p001_unc = norm.isf(p_val)
display = plotting.plot_glass_brain(
z_map, threshold=p001_unc, colorbar=True, display_mode='z', plot_abs=False,
print("Actual number of subjects after quality check: %d" % n_samples)
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
import pandas as pd
design_matrix = pd.DataFrame(
np.hstack((tested_var, np.ones_like(tested_var))),
columns=['fluency', 'intercept'])
###########################################################################
# Fit of the second-level model
from nistats.second_level_model import SecondLevelModel
model = SecondLevelModel(smoothing_fwhm=5.0)
model.fit(contrast_map_filenames, design_matrix=design_matrix)
##########################################################################
# To estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = model.compute_contrast('fluency', output_type='z_score')
###########################################################################
# We compute the fdr-corrected p = 0.05 threshold for these data
from nistats.thresholding import map_threshold
_, threshold = map_threshold(z_map, alpha=.05, height_control='fdr')
###########################################################################
# Let us plot the second level contrast at the computed thresholds
from nilearn import plotting
tested_var = tested_var[mask_quality_check].astype(float).reshape((-1, 1))
print("Actual number of subjects after quality check: %d" % n_samples)
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
import pandas as pd
design_matrix = pd.DataFrame(np.hstack((tested_var, np.ones_like(tested_var))),
columns=['fluency', 'intercept'])
###########################################################################
# Fit of the second-level model
from nistats.second_level_model import SecondLevelModel
model = SecondLevelModel(smoothing_fwhm=5.0)
model.fit(contrast_map_filenames, design_matrix=design_matrix)
##########################################################################
# To estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = model.compute_contrast('fluency', output_type='z_score')
###########################################################################
# We compute the fdr-corrected p = 0.05 threshold for these data
from nistats.thresholding import map_threshold
_, threshold = map_threshold(z_map, alpha=.05, height_control='fdr')
###########################################################################
# Let us plot the second level contrast at the computed thresholds
from nilearn import plotting
# Assemble those in a design matrix
design_matrix = pd.DataFrame(np.hstack(
(condition_effect[:, np.newaxis], subject_effect)),
columns=['vertical vs horizontal'] + subjects)
############################################################################
# plot the design_matrix
from nistats.reporting import plot_design_matrix
plot_design_matrix(design_matrix)
############################################################################
# formally specify the analysis model and fit it
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel().fit(second_level_input,
design_matrix=design_matrix)
##########################################################################
# Estimating the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast('vertical vs horizontal',
output_type='z_score')
###########################################################################
# We threshold the second level contrast and plot it
threshold = 3.1 # correponds to p < .001, uncorrected
display = plotting.plot_glass_brain(
z_map,
threshold=threshold,
colorbar=True,
plot_abs=False,
############################################################################
# Assemble those in a design matrix
design_matrix = pd.DataFrame(
np.hstack((condition_effect[:, np.newaxis], subject_effect)),
columns=['vertical vs horizontal'] + subjects)
############################################################################
# plot the design_matrix
from nistats.reporting import plot_design_matrix
plot_design_matrix(design_matrix)
############################################################################
# formally specify the analysis model and fit it
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel().fit(
second_level_input, design_matrix=design_matrix)
##########################################################################
# Estimating the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast('vertical vs horizontal',
output_type='z_score')
###########################################################################
# We threshold the second level contrast and plot it
threshold = 3.1 # correponds to p < .001, uncorrected
display = plotting.plot_glass_brain(
z_map, threshold=threshold, colorbar=True, plot_abs=False,
title='vertical vs horizontal checkerboard (unc p<0.001')
###########################################################################
def test_second_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# Ordinary Least Squares case
model = SecondLevelModel(mask_img=mask)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, 'intercept')
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
model = model.fit(Y, design_matrix=X)
ncol = len(model.design_matrix_.columns)
c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol)
# smoke test for different contrasts in fixed effects
model.compute_contrast(c1)
model.compute_contrast(c1, output_type='z_score')
model.compute_contrast(c1, output_type='stat')
model.compute_contrast(c1, output_type='p_value')
model.compute_contrast(c1, output_type='effect_size')
model.compute_contrast(c1, output_type='effect_variance')
# formula should work (passing variable name directly)
model.compute_contrast('intercept')
# or simply pass nothing
model.compute_contrast()
# passing null contrast should give back a value error
assert_raises(ValueError, model.compute_contrast, cnull)
# passing wrong parameters
assert_raises(ValueError, model.compute_contrast, [])
assert_raises(ValueError, model.compute_contrast, c1, None, '')
assert_raises(ValueError, model.compute_contrast, c1, None, [])
assert_raises(ValueError, model.compute_contrast, c1, None, None, '')
# check that passing no explicit contrast when the dsign
# matrix has morr than one columns raises an error
X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2'])
model = model.fit(Y, design_matrix=X)
assert_raises(ValueError, model.compute_contrast, None)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model, X, Y
design_matrix = pd.DataFrame(np.vstack((age, sex, intercept)).T,
columns=['age', 'sex', 'intercept'])
#############################################################################
# Plot the design matrix
from nistats.reporting import plot_design_matrix
ax = plot_design_matrix(design_matrix)
ax.set_title('Second level design matrix', fontsize=12)
ax.set_ylabel('maps')
##########################################################################
# Specify and fit the second-level model when loading the data, we
# smooth a little bit to improve statistical behavior
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img)
second_level_model.fit(gray_matter_map_filenames, design_matrix=design_matrix)
##########################################################################
# Estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast(second_level_contrast=[1, 0, 0],
output_type='z_score')
###########################################################################
# We threshold the second level contrast at uncorrected p < 0.001 and plot it.
# First compute the threshold.
from nistats.thresholding import map_threshold
_, threshold = map_threshold(z_map, level=.05, height_control='fdr')
print('The FDR=.05-corrected threshold is: %.3g' % threshold)
def test_fmri_inputs():
# Test processing of FMRI inputs
with InTemporaryDirectory():
# prepare fake data
p, q = 80, 10
X = np.random.randn(p, q)
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
T = func_img.shape[-1]
des = pd.DataFrame(np.ones((T, 1)), columns=['a'])
des_fname = 'design.csv'
des.to_csv(des_fname)
# prepare correct input first level models
flm = FirstLevelModel(subject_label='01').fit(FUNCFILE,
design_matrices=des)
flms = [flm, flm, flm]
# prepare correct input dataframe and lists
shapes = ((7, 8, 9, 1), )
_, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
dfcols = ['subject_label', 'map_name', 'effects_map_path']
dfrows = [['01', 'a', FUNCFILE], ['02', 'a', FUNCFILE],
['03', 'a', FUNCFILE]]
niidf = pd.DataFrame(dfrows, columns=dfcols)
niimgs = [FUNCFILE, FUNCFILE, FUNCFILE]
niimg_4d = concat_imgs(niimgs)
confounds = pd.DataFrame([['01', 1], ['02', 2], ['03', 3]],
columns=['subject_label', 'conf1'])
sdes = pd.DataFrame(X[:3, :3], columns=['intercept', 'b', 'c'])
# smoke tests with correct input
# First level models as input
SecondLevelModel(mask_img=mask).fit(flms)
SecondLevelModel().fit(flms)
# Note : the following one creates a singular design matrix
SecondLevelModel().fit(flms, confounds)
SecondLevelModel().fit(flms, None, sdes)
# dataframes as input
SecondLevelModel().fit(niidf)
SecondLevelModel().fit(niidf, confounds)
SecondLevelModel().fit(niidf, confounds, sdes)
SecondLevelModel().fit(niidf, None, sdes)
# niimgs as input
SecondLevelModel().fit(niimgs, None, sdes)
# 4d niimg as input
SecondLevelModel().fit(niimg_4d, None, sdes)
# test wrong input errors
# test first level model requirements
assert_raises(ValueError, SecondLevelModel().fit, flm)
assert_raises(ValueError, SecondLevelModel().fit, [flm])
# test dataframe requirements
assert_raises(ValueError,
SecondLevelModel().fit, niidf['subject_label'])
# test niimgs requirements
assert_raises(ValueError, SecondLevelModel().fit, niimgs)
assert_raises(ValueError,
SecondLevelModel().fit, niimgs + [[]], confounds)
# test first_level_conditions, confounds, and design
assert_raises(ValueError, SecondLevelModel().fit, flms, ['', []])
assert_raises(ValueError, SecondLevelModel().fit, flms, [])
assert_raises(ValueError,
SecondLevelModel().fit, flms, confounds['conf1'])
assert_raises(ValueError, SecondLevelModel().fit, flms, None, [])
import matplotlib.pyplot as plt
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
import pandas as pd
second_level_input = data['cmaps']
design_matrix = pd.DataFrame([1] * len(second_level_input),
columns=['intercept'])
############################################################################
# Model specification and fit
from nistats.second_level_model import SecondLevelModel
second_level_model = SecondLevelModel(smoothing_fwhm=8.0)
second_level_model = second_level_model.fit(second_level_input,
design_matrix=design_matrix)
##########################################################################
# To estimate the contrast is very simple. We can just provide the column
# name of the design matrix.
z_map = second_level_model.compute_contrast(output_type='z_score')
###########################################################################
# We threshold the second level contrast at uncorrected p < 0.001 and plot
from scipy.stats import norm
p_val = 0.001
p001_uncorrected = norm.isf(p_val)
from nistats.thresholding import cluster_level_inference
