def test_fmri_inputs_for_non_parametric_inference():
# 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)
# 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'])
# test missing second-level contrast
# niimgs as input
assert_raises(ValueError, non_parametric_inference, niimgs, None, sdes)
assert_raises(ValueError, non_parametric_inference, niimgs, confounds,
sdes)
# 4d niimg as input
assert_raises(ValueError, non_parametric_inference, niimg_4d, None,
sdes)
# test wrong input errors
# test first level model
assert_raises(ValueError, non_parametric_inference, flm)
# test list of less than two niimgs
assert_raises(ValueError, non_parametric_inference, [FUNCFILE])
# test dataframe
assert_raises(ValueError, non_parametric_inference, niidf)
# test niimgs requirements
assert_raises(ValueError, non_parametric_inference, niimgs)
assert_raises(ValueError, non_parametric_inference, niimgs + [[]],
confounds)
assert_raises(ValueError, non_parametric_inference, [FUNCFILE])
# test other objects
assert_raises(ValueError, non_parametric_inference,
'random string object')
del X, FUNCFILE, func_img
def test_fmri_inputs_for_non_parametric_inference():
# 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)
# 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'])
# test missing second-level contrast
# niimgs as input
assert_raises(ValueError, non_parametric_inference, niimgs, None, sdes)
assert_raises(ValueError, non_parametric_inference, niimgs, confounds,
sdes)
# 4d niimg as input
assert_raises(ValueError, non_parametric_inference, niimg_4d, None,
sdes)
# test wrong input errors
# test first level model
assert_raises(ValueError, non_parametric_inference, flm)
# test list of less than two niimgs
assert_raises(ValueError, non_parametric_inference, [FUNCFILE])
# test dataframe
assert_raises(ValueError, non_parametric_inference, niidf)
# test niimgs requirements
assert_raises(ValueError, non_parametric_inference, niimgs)
assert_raises(ValueError, non_parametric_inference, niimgs + [[]],
confounds)
assert_raises(ValueError, non_parametric_inference, [FUNCFILE])
# test other objects
assert_raises(ValueError, non_parametric_inference,
'random string object')
del X, FUNCFILE, func_img
def test_first_level_model_design_creation():
# Test processing of FMRI inputs
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
model = FirstLevelModel(t_r,
slice_time_ref,
mask_img=mask,
drift_model='polynomial',
drift_order=3)
model = model.fit(func_img, events)
frame1, X1, names1 = check_design_matrix(model.design_matrices_[0])
# check design computation is identical
n_scans = get_data(func_img).shape[3]
start_time = slice_time_ref * t_r
end_time = (n_scans - 1 + slice_time_ref) * t_r
frame_times = np.linspace(start_time, end_time, n_scans)
design = make_first_level_design_matrix(frame_times,
events,
drift_model='polynomial',
drift_order=3)
frame2, X2, names2 = check_design_matrix(design)
assert_array_equal(frame1, frame2)
assert_array_equal(X1, X2)
assert_array_equal(names1, names2)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del FUNCFILE, mask, model, func_img
def test_high_level_glm_with_data():
# New API
with InTemporaryDirectory():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = _write_fake_fmri_data(shapes, rk)
multi_session_model = FirstLevelModel(mask=None).fit(
fmri_data, design_matrices=design_matrices)
n_voxels = multi_session_model.masker_.mask_img_.get_data().sum()
z_image = multi_session_model.compute_contrast(np.eye(rk)[1])
assert_equal(np.sum(z_image.get_data() != 0), n_voxels)
assert_true(z_image.get_data().std() < 3.)
# with mask
multi_session_model = FirstLevelModel(mask=mask).fit(
fmri_data, design_matrices=design_matrices)
z_image = multi_session_model.compute_contrast(np.eye(rk)[:2],
output_type='z_score')
p_value = multi_session_model.compute_contrast(np.eye(rk)[:2],
output_type='p_value')
stat_image = multi_session_model.compute_contrast(np.eye(rk)[:2],
output_type='stat')
effect_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='effect_size')
variance_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='effect_variance')
assert_array_equal(z_image.get_data() == 0.,
load(mask).get_data() == 0.)
assert_true((variance_image.get_data()[load(mask).get_data() > 0] >
.001).all())
all_images = multi_session_model.compute_contrast(np.eye(rk)[:2],
output_type='all')
assert_array_equal(all_images['z_score'].get_data(),
z_image.get_data())
assert_array_equal(all_images['p_value'].get_data(),
p_value.get_data())
assert_array_equal(all_images['stat'].get_data(),
stat_image.get_data())
assert_array_equal(all_images['effect_size'].get_data(),
effect_image.get_data())
assert_array_equal(all_images['effect_variance'].get_data(),
variance_image.get_data())
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del (
all_images,
design_matrices,
effect_image,
fmri_data,
mask,
multi_session_model,
n_voxels,
p_value,
rk,
shapes,
stat_image,
variance_image,
z_image,
)
def test_high_level_non_parametric_inference_with_paths():
with InTemporaryDirectory():
n_perm = 100
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
c1 = np.eye(len(X.columns))[0]
neg_log_pvals_img = non_parametric_inference(Y,
design_matrix=X,
second_level_contrast=c1,
mask=mask,
n_perm=n_perm)
neg_log_pvals = neg_log_pvals_img.get_data()
assert_true(isinstance(neg_log_pvals_img, Nifti1Image))
assert_array_equal(neg_log_pvals_img.affine, load(mask).affine)
assert_true(np.all(neg_log_pvals <= -np.log10(1.0 / (n_perm + 1))))
assert_true(np.all(0 <= neg_log_pvals))
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory
del X, Y, FUNCFILE, func_img, neg_log_pvals_img
def test_first_level_model_design_creation():
# Test processing of FMRI inputs
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
model = FirstLevelModel(t_r, slice_time_ref, mask=mask,
drift_model='polynomial', drift_order=3)
model = model.fit(func_img, events)
frame1, X1, names1 = check_design_matrix(model.design_matrices_[0])
# check design computation is identical
n_scans = func_img.get_data().shape[3]
start_time = slice_time_ref * t_r
end_time = (n_scans - 1 + slice_time_ref) * t_r
frame_times = np.linspace(start_time, end_time, n_scans)
design = make_first_level_design_matrix(frame_times, events,
drift_model='polynomial', drift_order=3)
frame2, X2, names2 = check_design_matrix(design)
assert_array_equal(frame1, frame2)
assert_array_equal(X1, X2)
assert_array_equal(names1, names2)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del FUNCFILE, mask, model, func_img
def test_flm_reporting():
with InTemporaryDirectory():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = _write_fake_fmri_data(shapes, rk)
flm = FirstLevelModel(mask_img=mask).fit(
fmri_data, design_matrices=design_matrices)
contrast = np.eye(3)[1]
report_flm = glmr.make_glm_report(
flm,
contrast,
plot_type='glass',
height_control=None,
min_distance=15,
alpha=0.001,
threshold=2.78,
)
'''
catches & raises UnicodeEncodeError in HTMLDocument.get_iframe()
Python2's limited unicode support causes HTMLDocument.get_iframe() to
mishandle certain unicode characters, like the greek alpha symbol
and raises this error.
Calling HTMLDocument.get_iframe() here causes the tests
to fail on Python2, alerting us if such a situation arises
due to future modifications.
'''
report_iframe = report_flm.get_iframe()
# So flake8 doesn't complain about not using variable (F841)
report_iframe
del mask, flm
def test_first_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r,
slice_time_ref,
mask_img=mask,
drift_model='polynomial',
drift_order=3,
minimize_memory=False)
c1, c2, cnull = np.eye(7)[0], np.eye(7)[1], np.zeros(7)
# asking for contrast before model fit gives error
with pytest.raises(ValueError):
model.compute_contrast(c1)
# fit model
model = model.fit([func_img, func_img], [events, events])
# smoke test for different contrasts in fixed effects
model.compute_contrast([c1, c2])
# smoke test for same contrast in fixed effects
model.compute_contrast([c2, c2])
# smoke test for contrast that will be repeated
model.compute_contrast(c2)
model.compute_contrast(c2, 'F')
model.compute_contrast(c2, 't', 'z_score')
model.compute_contrast(c2, 't', 'stat')
model.compute_contrast(c2, 't', 'p_value')
model.compute_contrast(c2, None, 'effect_size')
model.compute_contrast(c2, None, 'effect_variance')
# formula should work (passing varible name directly)
model.compute_contrast('c0')
model.compute_contrast('c1')
model.compute_contrast('c2')
# smoke test for one null contrast in group
model.compute_contrast([c2, cnull])
# only passing null contrasts should give back a value error
with pytest.raises(ValueError):
model.compute_contrast(cnull)
with pytest.raises(ValueError):
model.compute_contrast([cnull, cnull])
# passing wrong parameters
with pytest.raises(ValueError):
model.compute_contrast([])
with pytest.raises(ValueError):
model.compute_contrast([c1, []])
with pytest.raises(ValueError):
model.compute_contrast(c1, '', '')
with pytest.raises(ValueError):
model.compute_contrast(c1, '', [])
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model
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)
z_image = model.compute_contrast(c1, output_type='z_score')
stat_image = model.compute_contrast(c1, output_type='stat')
p_image = model.compute_contrast(c1, output_type='p_value')
effect_image = model.compute_contrast(c1, output_type='effect_size')
variance_image = model.compute_contrast(c1,
output_type='effect_variance')
# Test output_type='all', and verify images are equivalent
all_images = model.compute_contrast(c1, output_type='all')
assert_array_equal(all_images['z_score'].get_data(),
z_image.get_data())
assert_array_equal(all_images['stat'].get_data(),
stat_image.get_data())
assert_array_equal(all_images['p_value'].get_data(),
p_image.get_data())
assert_array_equal(all_images['effect_size'].get_data(),
effect_image.get_data())
assert_array_equal(all_images['effect_variance'].get_data(),
variance_image.get_data())
# 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 test_explicit_fixed_effects():
""" tests the fixed effects performed manually/explicitly"""
with InTemporaryDirectory():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = _write_fake_fmri_data(shapes, rk)
contrast = np.eye(rk)[1]
# session 1
multi_session_model = FirstLevelModel(mask_img=mask).fit(
fmri_data[0], design_matrices=design_matrices[:1])
dic1 = multi_session_model.compute_contrast(contrast,
output_type='all')
# session 2
multi_session_model.fit(fmri_data[1],
design_matrices=design_matrices[1:])
dic2 = multi_session_model.compute_contrast(contrast,
output_type='all')
# fixed effects model
multi_session_model.fit(fmri_data, design_matrices=design_matrices)
fixed_fx_dic = multi_session_model.compute_contrast(contrast,
output_type='all')
# manual version
contrasts = [dic1['effect_size'], dic2['effect_size']]
variance = [dic1['effect_variance'], dic2['effect_variance']]
(
fixed_fx_contrast,
fixed_fx_variance,
fixed_fx_stat,
) = compute_fixed_effects(contrasts, variance, mask)
assert_almost_equal(fixed_fx_contrast.get_data(),
fixed_fx_dic['effect_size'].get_data())
assert_almost_equal(fixed_fx_variance.get_data(),
fixed_fx_dic['effect_variance'].get_data())
assert_almost_equal(fixed_fx_stat.get_data(),
fixed_fx_dic['stat'].get_data())
# test without mask variable
(
fixed_fx_contrast,
fixed_fx_variance,
fixed_fx_stat,
) = compute_fixed_effects(contrasts, variance)
assert_almost_equal(fixed_fx_contrast.get_data(),
fixed_fx_dic['effect_size'].get_data())
assert_almost_equal(fixed_fx_variance.get_data(),
fixed_fx_dic['effect_variance'].get_data())
assert_almost_equal(fixed_fx_stat.get_data(),
fixed_fx_dic['stat'].get_data())
# ensure that using unbalanced effects size and variance images
# raises an error
with pytest.raises(ValueError):
compute_fixed_effects(contrasts * 2, variance, mask)
del mask, multi_session_model
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)
z_image = model.compute_contrast(c1, output_type='z_score')
stat_image = model.compute_contrast(c1, output_type='stat')
p_image = model.compute_contrast(c1, output_type='p_value')
effect_image = model.compute_contrast(c1, output_type='effect_size')
variance_image = \
model.compute_contrast(c1, output_type='effect_variance')
# Test output_type='all', and verify images are equivalent
all_images = model.compute_contrast(c1, output_type='all')
assert_array_equal(all_images['z_score'].get_data(),
z_image.get_data())
assert_array_equal(all_images['stat'].get_data(),
stat_image.get_data())
assert_array_equal(all_images['p_value'].get_data(),
p_image.get_data())
assert_array_equal(all_images['effect_size'].get_data(),
effect_image.get_data())
assert_array_equal(all_images['effect_variance'].get_data(),
variance_image.get_data())
# 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 design
# matrix has more 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 test_high_level_glm_with_data():
# New API
with InTemporaryDirectory():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = _write_fake_fmri_data(shapes, rk)
multi_session_model = FirstLevelModel(mask=None).fit(
fmri_data, design_matrices=design_matrices)
n_voxels = multi_session_model.masker_.mask_img_.get_data().sum()
z_image = multi_session_model.compute_contrast(np.eye(rk)[1])
assert_equal(np.sum(z_image.get_data() != 0), n_voxels)
assert_true(z_image.get_data().std() < 3.)
# with mask
multi_session_model = FirstLevelModel(mask=mask).fit(
fmri_data, design_matrices=design_matrices)
z_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='z_score')
p_value = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='p_value')
stat_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='stat')
effect_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='effect_size')
variance_image = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='effect_variance')
assert_array_equal(z_image.get_data() == 0., load(mask).get_data() == 0.)
assert_true(
(variance_image.get_data()[load(mask).get_data() > 0] > .001).all())
all_images = multi_session_model.compute_contrast(
np.eye(rk)[:2], output_type='all')
assert_array_equal(all_images['z_score'].get_data(), z_image.get_data())
assert_array_equal(all_images['p_value'].get_data(), p_value.get_data())
assert_array_equal(all_images['stat'].get_data(), stat_image.get_data())
assert_array_equal(all_images['effect_size'].get_data(), effect_image.get_data())
assert_array_equal(all_images['effect_variance'].get_data(), variance_image.get_data())
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del (all_images,
design_matrices,
effect_image,
fmri_data,
mask,
multi_session_model,
n_voxels,
p_value,
rk,
shapes,
stat_image,
variance_image,
z_image,
)
def test_high_level_glm_with_paths():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 14)), 3
with InTemporaryDirectory():
mask_file, fmri_files, design_files = _write_fake_fmri_data(shapes, rk)
multi_session_model = FirstLevelModel(mask_img=None).fit(
fmri_files, design_matrices=design_files)
z_image = multi_session_model.compute_contrast(np.eye(rk)[1])
assert_array_equal(z_image.affine, load(mask_file).affine)
assert get_data(z_image).std() < 3.
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del z_image, fmri_files, multi_session_model
def _gen_report():
""" Generate an empty HTMLReport for testing """
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = _write_fake_fmri_data(shapes, rk)
flm = FirstLevelModel(mask_img=mask).fit(
fmri_data, design_matrices=design_matrices)
contrast = np.eye(3)[1]
report = make_glm_report(flm, contrast, plot_type='glass',
height_control=None, min_distance=15,
alpha=0.001, threshold=2.78,
)
return report
def test_high_level_glm_with_paths():
# New API
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 14)), 3
with InTemporaryDirectory():
mask_file, fmri_files, design_files = _write_fake_fmri_data(shapes, rk)
multi_session_model = FirstLevelModel(mask=None).fit(
fmri_files, design_matrices=design_files)
z_image = multi_session_model.compute_contrast(np.eye(rk)[1])
assert_array_equal(z_image.affine, load(mask_file).affine)
assert_true(z_image.get_data().std() < 3.)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del z_image, fmri_files, multi_session_model
def test_non_parametric_inference_permutation_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X,
mask=mask, n_perm=100)
assert_equal(neg_log_pvals_img.get_data().shape, shapes[0][:3])
del func_img, FUNCFILE, neg_log_pvals_img, X, Y
def test_non_parametric_inference_permutation_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X,
mask=mask, n_perm=100)
assert_equal(get_data(neg_log_pvals_img).shape, shapes[0][:3])
del func_img, FUNCFILE, neg_log_pvals_img, X, Y
def test_first_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r, slice_time_ref, mask=mask,
drift_model='polynomial', drift_order=3,
minimize_memory=False)
c1, c2, cnull = np.eye(7)[0], np.eye(7)[1], np.zeros(7)
# asking for contrast before model fit gives error
assert_raises(ValueError, model.compute_contrast, c1)
# fit model
model = model.fit([func_img, func_img], [events, events])
# smoke test for different contrasts in fixed effects
model.compute_contrast([c1, c2])
# smoke test for same contrast in fixed effects
model.compute_contrast([c2, c2])
# smoke test for contrast that will be repeated
model.compute_contrast(c2)
model.compute_contrast(c2, 'F')
model.compute_contrast(c2, 't', 'z_score')
model.compute_contrast(c2, 't', 'stat')
model.compute_contrast(c2, 't', 'p_value')
model.compute_contrast(c2, None, 'effect_size')
model.compute_contrast(c2, None, 'effect_variance')
# formula should work (passing varible name directly)
model.compute_contrast('c0')
model.compute_contrast('c1')
model.compute_contrast('c2')
# smoke test for one null contrast in group
model.compute_contrast([c2, cnull])
# only passing null contrasts should give back a value error
assert_raises(ValueError, model.compute_contrast, cnull)
assert_raises(ValueError, model.compute_contrast, [cnull, cnull])
# passing wrong parameters
assert_raises(ValueError, model.compute_contrast, [])
assert_raises(ValueError, model.compute_contrast, [c1, []])
assert_raises(ValueError, model.compute_contrast, c1, '', '')
assert_raises(ValueError, model.compute_contrast, c1, '', [])
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del func_img, FUNCFILE, model
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 test_fmri_inputs():
# Test processing of FMRI inputs
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
T = func_img.shape[-1]
conf = pd.DataFrame([0, 0])
des = pd.DataFrame(np.ones((T, 1)), columns=[''])
des_fname = 'design.csv'
des.to_csv(des_fname)
for fi in func_img, FUNCFILE:
for d in des, des_fname:
FirstLevelModel().fit(fi, design_matrices=d)
FirstLevelModel(mask_img=None).fit([fi], design_matrices=d)
FirstLevelModel(mask_img=mask).fit(fi, design_matrices=[d])
FirstLevelModel(mask_img=mask).fit([fi], design_matrices=[d])
FirstLevelModel(mask_img=mask).fit([fi, fi],
design_matrices=[d, d])
FirstLevelModel(mask_img=None).fit((fi, fi),
design_matrices=(d, d))
assert_raises(ValueError,
FirstLevelModel(mask_img=None).fit, [fi, fi], d)
assert_raises(ValueError,
FirstLevelModel(mask_img=None).fit, fi, [d, d])
# At least paradigms or design have to be given
assert_raises(ValueError,
FirstLevelModel(mask_img=None).fit, fi)
# If paradigms are given then both tr and slice time ref were
# required
assert_raises(ValueError,
FirstLevelModel(mask_img=None).fit, fi, d)
assert_raises(ValueError,
FirstLevelModel(mask_img=None, t_r=1.0).fit, fi,
d)
assert_raises(
ValueError,
FirstLevelModel(mask_img=None, slice_time_ref=0.).fit, fi,
d)
# confounds rows do not match n_scans
assert_raises(ValueError,
FirstLevelModel(mask_img=None).fit, fi, d, conf)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del fi, func_img, mask, d, des, FUNCFILE, _
def test_non_parametric_inference_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# asking for contrast before model fit gives error
with pytest.raises(ValueError):
non_parametric_inference(None, None, None, 'intercept', mask)
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
# formula should work without second-level contrast
neg_log_pvals_img = non_parametric_inference(Y,
design_matrix=X,
mask=mask,
n_perm=100)
ncol = len(X.columns)
c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol)
# formula should work with second-level contrast
neg_log_pvals_img = non_parametric_inference(Y,
design_matrix=X,
second_level_contrast=c1,
mask=mask,
n_perm=100)
# formula should work passing variable name directly
neg_log_pvals_img = \
non_parametric_inference(Y, design_matrix=X,
second_level_contrast='intercept',
mask=mask, n_perm=100)
# passing null contrast should give back a value error
with pytest.raises(ValueError):
non_parametric_inference(Y, X, cnull, 'intercept', mask)
# passing wrong parameters
with pytest.raises(ValueError):
non_parametric_inference(Y, X, [], 'intercept', mask)
# check that passing no explicit contrast when the design
# matrix has more than one columns raises an error
X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2'])
with pytest.raises(ValueError):
non_parametric_inference(Y, X, None)
del func_img, FUNCFILE, neg_log_pvals_img, X, Y
def test_first_level_glm_computation_with_memory_caching():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# initialize FirstLevelModel with memory option enabled
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r, slice_time_ref, mask=mask,
drift_model='polynomial', drift_order=3,
memory='nilearn_cache', memory_level=1,
minimize_memory=False)
model.fit(func_img, events)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del mask, func_img, FUNCFILE, model
def test_first_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r, slice_time_ref, mask_img=mask,
drift_model='polynomial', drift_order=3,
minimize_memory=False)
model = model.fit(func_img, events)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del mask, FUNCFILE, func_img, model
def test_fmri_inputs():
# Test processing of FMRI inputs
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
T = func_img.shape[-1]
conf = pd.DataFrame([0, 0])
des = pd.DataFrame(np.ones((T, 1)), columns=[''])
des_fname = 'design.csv'
des.to_csv(des_fname)
for fi in func_img, FUNCFILE:
for d in des, des_fname:
FirstLevelModel().fit(fi, design_matrices=d)
FirstLevelModel(mask=None).fit([fi], design_matrices=d)
FirstLevelModel(mask=mask).fit(fi, design_matrices=[d])
FirstLevelModel(mask=mask).fit([fi], design_matrices=[d])
FirstLevelModel(mask=mask).fit([fi, fi], design_matrices=[d, d])
FirstLevelModel(mask=None).fit((fi, fi), design_matrices=(d, d))
assert_raises(
ValueError, FirstLevelModel(mask=None).fit, [fi, fi], d)
assert_raises(
ValueError, FirstLevelModel(mask=None).fit, fi, [d, d])
# At least paradigms or design have to be given
assert_raises(
ValueError, FirstLevelModel(mask=None).fit, fi)
# If paradigms are given then both tr and slice time ref were
# required
assert_raises(
ValueError, FirstLevelModel(mask=None).fit, fi, d)
assert_raises(
ValueError, FirstLevelModel(mask=None, t_r=1.0).fit, fi, d)
assert_raises(
ValueError, FirstLevelModel(mask=None, slice_time_ref=0.).fit, fi, d)
# confounds rows do not match n_scans
assert_raises(
ValueError, FirstLevelModel(mask=None).fit, fi, d, conf)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del fi, func_img, mask, d, des, FUNCFILE, _
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_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 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 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_non_parametric_inference_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# asking for contrast before model fit gives error
assert_raises(ValueError, non_parametric_inference, None, None, None,
'intercept', mask)
# fit model
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
# formula should work without second-level contrast
neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X,
mask=mask, n_perm=100)
ncol = len(X.columns)
c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol)
# formula should work with second-level contrast
neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X,
second_level_contrast=c1,
mask=mask, n_perm=100)
# formula should work passing variable name directly
neg_log_pvals_img = \
non_parametric_inference(Y, design_matrix=X,
second_level_contrast='intercept',
mask=mask, n_perm=100)
# passing null contrast should give back a value error
assert_raises(ValueError, non_parametric_inference, Y, X, cnull,
'intercept', mask)
# passing wrong parameters
assert_raises(ValueError, non_parametric_inference, Y, X, [],
'intercept', mask)
# check that passing no explicit contrast when the design
# matrix has more than one columns raises an error
X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2'])
assert_raises(ValueError, non_parametric_inference, Y, X, None)
del func_img, FUNCFILE, neg_log_pvals_img, X, Y
def test_first_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# basic test based on basic_paradigm and glover hrf
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r,
slice_time_ref,
mask_img=mask,
drift_model='polynomial',
drift_order=3,
minimize_memory=False)
model = model.fit(func_img, events)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del mask, FUNCFILE, func_img, model
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_high_level_non_parametric_inference_with_paths():
with InTemporaryDirectory():
n_perm = 100
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
Y = [func_img] * 4
X = pd.DataFrame([[1]] * 4, columns=['intercept'])
c1 = np.eye(len(X.columns))[0]
neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X,
second_level_contrast=c1,
mask=mask, n_perm=n_perm)
neg_log_pvals = neg_log_pvals_img.get_data()
assert_true(isinstance(neg_log_pvals_img, Nifti1Image))
assert_array_equal(neg_log_pvals_img.affine, load(mask).affine)
assert_true(np.all(neg_log_pvals <= - np.log10(1.0 / (n_perm + 1))))
assert_true(np.all(0 <= neg_log_pvals))
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory
del X, Y, FUNCFILE, func_img, neg_log_pvals_img
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_first_level_glm_computation_with_memory_caching():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = _write_fake_fmri_data(shapes)
FUNCFILE = FUNCFILE[0]
func_img = load(FUNCFILE)
# initialize FirstLevelModel with memory option enabled
t_r = 10.0
slice_time_ref = 0.
events = basic_paradigm()
# Ordinary Least Squares case
model = FirstLevelModel(t_r,
slice_time_ref,
mask=mask,
drift_model='polynomial',
drift_order=3,
memory='nilearn_cache',
memory_level=1,
minimize_memory=False)
model.fit(func_img, events)
# Delete objects attached to files to avoid WindowsError when deleting
# temporary directory (in Windows)
del mask, func_img, FUNCFILE, model
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, [])
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, [])