def report_flm_fiac(): # pragma: no cover
data = datasets.func.fetch_fiac_first_level()
fmri_img = [data['func1'], data['func2']]
from nilearn.image import mean_img
mean_img_ = mean_img(fmri_img[0])
design_files = [data['design_matrix1'], data['design_matrix2']]
design_matrices = [pd.DataFrame(np.load(df)['X']) for df in design_files]
fmri_glm = FirstLevelModel(mask_img=data['mask'], minimize_memory=True)
fmri_glm = fmri_glm.fit(fmri_img, design_matrices=design_matrices)
n_columns = design_matrices[0].shape[1]
contrasts = {
'SStSSp_minus_DStDSp': _pad_vector([1, 0, 0, -1], n_columns),
'DStDSp_minus_SStSSp': _pad_vector([-1, 0, 0, 1], n_columns),
'DSt_minus_SSt': _pad_vector([-1, -1, 1, 1], n_columns),
'DSp_minus_SSp': _pad_vector([-1, 1, -1, 1], n_columns),
'DSt_minus_SSt_for_DSp': _pad_vector([0, -1, 0, 1], n_columns),
'DSp_minus_SSp_for_DSt': _pad_vector([0, 0, -1, 1], n_columns),
'Deactivation': _pad_vector([-1, -1, -1, -1, 4], n_columns),
'Effects_of_interest': np.eye(n_columns)[:5]
}
report = make_glm_report(
fmri_glm,
contrasts,
bg_img=mean_img_,
height_control='fdr',
)
output_filename = 'generated_report_flm_fiac.html'
output_filepath = os.path.join(REPORTS_DIR, output_filename)
report.save_as_html(output_filepath)
report.get_iframe()
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_and_design(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_first_level_models_with_no_signal_scaling():
"""
test to ensure that the FirstLevelModel works correctly with a
signal_scaling==False. In particular, that derived theta are correct for a
constant design matrix with a single valued fmri image
"""
shapes, rk = [(3, 1, 1, 2)], 1
fmri_data = list()
design_matrices = list()
design_matrices.append(
pd.DataFrame(np.ones((shapes[0][-1], rk)),
columns=list('abcdefghijklmnopqrstuvwxyz')[:rk]))
first_level_model = FirstLevelModel(mask_img=False,
noise_model='ols',
signal_scaling=False)
fmri_data.append(Nifti1Image(np.zeros((1, 1, 1, 2)) + 6, np.eye(4)))
first_level_model.fit(fmri_data, design_matrices=design_matrices)
# trivial test of signal_scaling value
assert first_level_model.signal_scaling is False
# assert that our design matrix has one constant
assert first_level_model.design_matrices_[0].equals(
pd.DataFrame([1.0, 1.0], columns=['a']))
# assert that we only have one theta as there is only on voxel in our image
assert first_level_model.results_[0][0].theta.shape == (1, 1)
# assert that the theta is equal to the one voxel value
assert_almost_equal(first_level_model.results_[0][0].theta[0, 0], 6.0, 2)
def test_first_level_model_predictions_r_square():
shapes, rk = [(10, 10, 10, 25)], 3
mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(
shapes, rk)
for i in range(len(design_matrices)):
design_matrices[i].iloc[:, 0] = 1
model = FirstLevelModel(mask_img=mask,
signal_scaling=False,
minimize_memory=False,
noise_model='ols')
model.fit(fmri_data, design_matrices=design_matrices)
pred = model.predicted[0]
data = fmri_data[0]
r_square_3d = model.r_square[0]
y_predicted = model.masker_.transform(pred)
y_measured = model.masker_.transform(data)
assert_almost_equal(np.mean(y_predicted - y_measured), 0)
r_square_2d = model.masker_.transform(r_square_3d)
assert_array_less(0., r_square_2d)
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_and_design(
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_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_and_design(
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 test_high_level_glm_one_session():
shapes, rk = [(7, 8, 9, 15)], 3
mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(
shapes, rk)
single_session_model = FirstLevelModel(mask_img=None).fit(
fmri_data[0], design_matrices=design_matrices[0])
assert isinstance(single_session_model.masker_.mask_img_, Nifti1Image)
single_session_model = FirstLevelModel(mask_img=mask).fit(
fmri_data[0], design_matrices=design_matrices[0])
z1 = single_session_model.compute_contrast(np.eye(rk)[:1])
assert isinstance(z1, Nifti1Image)
def test_first_level_model_residuals():
shapes, rk = [(10, 10, 10, 100)], 3
mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(
shapes, rk)
for i in range(len(design_matrices)):
design_matrices[i].iloc[:, 0] = 1
model = FirstLevelModel(mask_img=mask,
minimize_memory=False,
noise_model='ols')
model.fit(fmri_data, design_matrices=design_matrices)
residuals = model.residuals[0]
mean_residuals = model.masker_.transform(residuals).mean(0)
assert_array_almost_equal(mean_residuals, 0)
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_and_design(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, fmri_data
def report_flm_adhd_dmn(): # pragma: no cover
t_r = 2.
slice_time_ref = 0.
n_scans = 176
pcc_coords = (0, -53, 26)
adhd_dataset = nilearn.datasets.fetch_adhd(n_subjects=1)
seed_masker = NiftiSpheresMasker([pcc_coords],
radius=10,
detrend=True,
standardize=True,
low_pass=0.1,
high_pass=0.01,
t_r=2.,
memory='nilearn_cache',
memory_level=1,
verbose=0)
seed_time_series = seed_masker.fit_transform(adhd_dataset.func[0])
frametimes = np.linspace(0, (n_scans - 1) * t_r, n_scans)
design_matrix = make_first_level_design_matrix(frametimes,
hrf_model='spm',
add_regs=seed_time_series,
add_reg_names=["pcc_seed"])
dmn_contrast = np.array([1] + [0] * (design_matrix.shape[1] - 1))
contrasts = {'seed_based_glm': dmn_contrast}
first_level_model = FirstLevelModel(t_r=t_r, slice_time_ref=slice_time_ref)
first_level_model = first_level_model.fit(run_imgs=adhd_dataset.func[0],
design_matrices=design_matrix)
report = make_glm_report(
first_level_model,
contrasts=contrasts,
title='ADHD DMN Report',
cluster_threshold=15,
height_control='bonferroni',
min_distance=8.,
plot_type='glass',
report_dims=(1200, 'a'),
)
output_filename = 'generated_report_flm_adhd_dmn.html'
output_filepath = os.path.join(REPORTS_DIR, output_filename)
report.save_as_html(output_filepath)
report.get_iframe()
def test_make_headings_with_contrasts_none_title_custom():
model = FirstLevelModel()
test_input = (None,
'Custom Title for report',
model,
)
expected_output = ('Custom Title for report',
'Custom Title for report',
'First Level Model',
)
actual_output = glmr._make_headings(*test_input)
assert actual_output == expected_output
def test_first_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = write_fake_fmri_data_and_design(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_high_level_glm_different_design_matrices():
# test that one can estimate a contrast when design matrices are different
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 19)), 3
mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(
shapes, rk)
# add a column to the second design matrix
design_matrices[1]['new'] = np.ones((19, 1))
# Fit a glm with two sessions and design matrices
multi_session_model = FirstLevelModel(mask_img=mask).fit(
fmri_data, design_matrices=design_matrices)
z_joint = multi_session_model.compute_contrast(
[np.eye(rk)[:1], np.eye(rk + 1)[:1]], output_type='effect_size')
assert z_joint.shape == (7, 8, 7)
# compare the estimated effects to seprarately-fitted models
model1 = FirstLevelModel(mask_img=mask).fit(
fmri_data[0], design_matrices=design_matrices[0])
z1 = model1.compute_contrast(np.eye(rk)[:1], output_type='effect_size')
model2 = FirstLevelModel(mask_img=mask).fit(
fmri_data[1], design_matrices=design_matrices[1])
z2 = model2.compute_contrast(np.eye(rk + 1)[:1], output_type='effect_size')
assert_almost_equal(z1.get_data() + z2.get_data(), 2 * z_joint.get_data())
def test_high_level_glm_null_contrasts():
# test that contrast computation is resilient to 0 values.
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 19)), 3
mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(
shapes, rk)
multi_session_model = FirstLevelModel(mask_img=None).fit(
fmri_data, design_matrices=design_matrices)
single_session_model = FirstLevelModel(mask_img=None).fit(
fmri_data[0], design_matrices=design_matrices[0])
z1 = multi_session_model.compute_contrast(
[np.eye(rk)[:1], np.zeros((1, rk))], output_type='stat')
z2 = single_session_model.compute_contrast(np.eye(rk)[:1],
output_type='stat')
np.testing.assert_almost_equal(get_data(z1), get_data(z2))
mean_img_ = mean_img(fmri_img[0])
#########################################################################
# The design matrices were pre-computed, we simply put them in a list of DataFrames.
design_files = [data['design_matrix1'], data['design_matrix2']]
import pandas as pd
import numpy as np
design_matrices = [pd.DataFrame(np.load(df)['X']) for df in design_files]
#########################################################################
# GLM estimation
# ----------------------------------
# GLM specification. Note that the mask was provided in the dataset. So we use it.
from nilearn.stats.first_level_model import FirstLevelModel
fmri_glm = FirstLevelModel(mask_img=data['mask'], minimize_memory=True)
#########################################################################
# Let's fit the GLM.
fmri_glm = fmri_glm.fit(fmri_img, design_matrices=design_matrices)
#########################################################################
# Compute fixed effects of the two runs and compute related images.
# For this, we first define the contrasts as we would do for a single session.
n_columns = design_matrices[0].shape[1]
def pad_vector(contrast_, n_columns):
"""A small routine to append zeros in contrast vectors"""
return np.hstack((contrast_, np.zeros(n_columns - len(contrast_))))
memory_level=1,
verbose=0)
seed_time_series = seed_masker.fit_transform(adhd_dataset.func[0])
frametimes = np.linspace(0, (n_scans - 1) * t_r, n_scans)
design_matrix = make_first_level_design_matrix(frametimes,
hrf_model='spm',
add_regs=seed_time_series,
add_reg_names=["pcc_seed"])
dmn_contrast = np.array([1] + [0] * (design_matrix.shape[1] - 1))
contrasts = {'seed_based_glm': dmn_contrast}
#########################################################################
# Perform first level analysis
# ----------------------------
# Setup and fit GLM.
first_level_model = FirstLevelModel(t_r=t_r, slice_time_ref=slice_time_ref)
first_level_model = first_level_model.fit(run_imgs=adhd_dataset.func[0],
design_matrices=design_matrix)
#########################################################################
# Estimate the contrast.
print('Contrast seed_based_glm computed.')
z_map = first_level_model.compute_contrast(contrasts['seed_based_glm'],
output_type='z_score')
# Saving snapshots of the contrasts
filename = 'dmn_z_map.png'
display = plotting.plot_stat_map(z_map,
threshold=3.0,
title='Seed based GLM',
cut_coords=pcc_coords)
# load events
events = pd.read_table(subject_data['events'])
#########################################################################
# Fit model
# ---------
# Note that `minimize_memory` is set to `False` so that `FirstLevelModel`
# stores the residuals.
# `signal_scaling` is set to False, so we keep the same scaling as the
# original data in `fmri_img`.
from nilearn.stats.first_level_model import FirstLevelModel
fmri_glm = FirstLevelModel(t_r=7,
drift_model='cosine',
signal_scaling=False,
mask_img=mask,
minimize_memory=False)
fmri_glm = fmri_glm.fit(fmri_img, events)
#########################################################################
# Calculate and plot contrast
# ---------------------------
from nilearn import plotting
z_map = fmri_glm.compute_contrast('active - rest')
plotting.plot_stat_map(z_map, bg_img=mean_img, threshold=3.1)
#########################################################################
def test_first_level_model_contrast_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = write_fake_fmri_data_and_design(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
#########################################################################
# The design matrices were pre-computed, we simply put them in a list of DataFrames
design_files = [data['design_matrix1'], data['design_matrix2']]
import pandas as pd
import numpy as np
design_matrices = [pd.DataFrame(np.load(df)['X']) for df in design_files]
#########################################################################
# GLM estimation
# ----------------------------------
# GLM specification. Note that the mask was provided in the dataset. So we use it.
from nilearn.stats.first_level_model import FirstLevelModel
fmri_glm = FirstLevelModel(mask_img=data['mask'],
smoothing_fwhm=5,
minimize_memory=True)
#########################################################################
# Compute fixed effects of the two runs and compute related images
# For this, we first define the contrasts as we would do for a single session
n_columns = design_matrices[0].shape[1]
contrast_val = np.hstack(([-1, -1, 1, 1], np.zeros(n_columns - 4)))
#########################################################################
# Statistics for the first session
from nilearn import plotting
cut_coords = [-129, -126, 49]
contrast_id = 'DSt_minus_SSt'
fmri_glm = fmri_glm.fit(fmri_img[0], design_matrices=design_matrices[0])
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_and_design(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_and_design(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
with pytest.raises(ValueError):
non_parametric_inference(niimgs, None, sdes)
with pytest.raises(ValueError):
non_parametric_inference(niimgs, confounds, sdes)
# 4d niimg as input
with pytest.raises(ValueError):
non_parametric_inference(niimg_4d, None, sdes)
# test wrong input errors
# test first level model
with pytest.raises(ValueError):
non_parametric_inference(flm)
# test list of less than two niimgs
with pytest.raises(ValueError):
non_parametric_inference([FUNCFILE])
# test dataframe
with pytest.raises(ValueError):
non_parametric_inference(niidf)
# test niimgs requirements
with pytest.raises(ValueError):
non_parametric_inference(niimgs)
with pytest.raises(ValueError):
non_parametric_inference(niimgs + [[]], confounds)
with pytest.raises(ValueError):
non_parametric_inference([FUNCFILE])
# test other objects
with pytest.raises(ValueError):
non_parametric_inference('random string object')
del X, FUNCFILE, func_img
# spanning the two conditions.
contrasts = {
'faces-scrambled':
basic_contrasts['faces'] - basic_contrasts['scrambled'],
'scrambled-faces':
-basic_contrasts['faces'] + basic_contrasts['scrambled'],
'effects_of_interest':
np.vstack((basic_contrasts['faces'], basic_contrasts['scrambled']))
}
#########################################################################
# Fit the GLM for the 2 sessions by speficying a FirstLevelModel and then fitting it.
from nilearn.stats.first_level_model import FirstLevelModel
print('Fitting a GLM')
fmri_glm = FirstLevelModel()
fmri_glm = fmri_glm.fit(fmri_img, design_matrices=design_matrices)
#########################################################################
# Now we can compute contrast-related statistical maps (in z-scale), and plot them.
print('Computing contrasts')
from nilearn import plotting
# Iterate on contrasts
for contrast_id, contrast_val in contrasts.items():
print("\tcontrast id: %s" % contrast_id)
# compute the contrasts
z_map = fmri_glm.compute_contrast(contrast_val, output_type='z_score')
# plot the contrasts as soon as they're generated
# the display is overlayed on the mean fMRI image
# a threshold of 3.0 is used, more sophisticated choices are possible
def test_high_level_glm_with_data():
with InTemporaryDirectory():
shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3
mask, fmri_data, design_matrices = write_fake_fmri_data_and_design(
shapes, rk)
multi_session_model = FirstLevelModel(mask_img=None).fit(
fmri_data, design_matrices=design_matrices)
n_voxels = get_data(multi_session_model.masker_.mask_img_).sum()
z_image = multi_session_model.compute_contrast(np.eye(rk)[1])
assert np.sum(get_data(z_image) != 0) == n_voxels
assert get_data(z_image).std() < 3.
# with mask
multi_session_model = FirstLevelModel(mask_img=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(get_data(z_image) == 0., get_data(load(mask)) == 0.)
assert (get_data(variance_image)[get_data(load(mask)) > 0] >
.001).all()
all_images = multi_session_model.compute_contrast(np.eye(rk)[:2],
output_type='all')
assert_array_equal(get_data(all_images['z_score']), get_data(z_image))
assert_array_equal(get_data(all_images['p_value']), get_data(p_value))
assert_array_equal(get_data(all_images['stat']), get_data(stat_image))
assert_array_equal(get_data(all_images['effect_size']),
get_data(effect_image))
assert_array_equal(get_data(all_images['effect_variance']),
get_data(variance_image))
# 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)
#########################################################################
# Next solution is to try Finite Impulse Reponse (FIR) models: we just
# say that the hrf is an arbitrary function that lags behind the
# stimulus onset. In the present case, given that the numbers of
# conditions is high, we should use a simple FIR model.
#
# Concretely, we set `hrf_model` to 'fir' and `fir_delays` to [1, 2,
# 3] (scans) corresponding to a 3-step functions on the [1 * t_r, 4 *
# t_r] seconds interval.
#
from nilearn.stats.first_level_model import FirstLevelModel
from nilearn.reporting import plot_design_matrix, plot_contrast_matrix
first_level_model = FirstLevelModel(t_r, hrf_model='fir', fir_delays=[1, 2, 3])
first_level_model = first_level_model.fit(fmri_img, events=events)
design_matrix = first_level_model.design_matrices_[0]
plot_design_matrix(design_matrix)
#########################################################################
# We have to adapt contrast specification. We characterize the BOLD
# response by the sum across the three time lags. It's a bit hairy,
# sorry, but this is the price to pay for flexibility...
import numpy as np
contrast_matrix = np.eye(design_matrix.shape[1])
contrasts = dict([(column, contrast_matrix[i])
for i, column in enumerate(design_matrix.columns)])
conditions = events.trial_type.unique()
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_and_design(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_and_design(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
with pytest.raises(ValueError):
SecondLevelModel().fit(flm)
with pytest.raises(ValueError):
SecondLevelModel().fit([flm])
# test dataframe requirements
with pytest.raises(ValueError):
SecondLevelModel().fit(niidf['subject_label'])
# test niimgs requirements
with pytest.raises(ValueError):
SecondLevelModel().fit(niimgs)
with pytest.raises(ValueError):
SecondLevelModel().fit(niimgs + [[]],
confounds)
# test first_level_conditions, confounds, and design
with pytest.raises(ValueError):
SecondLevelModel().fit(flms, ['', []])
with pytest.raises(ValueError):
SecondLevelModel().fit(flms, [])
with pytest.raises(ValueError):
SecondLevelModel().fit(flms, confounds['conf1'])
with pytest.raises(ValueError):
SecondLevelModel().fit(flms, None, [])
##############################################################################
# Instantiate and run FirstLevelModel
# -----------------------------------
from nilearn.image import index_img
from nilearn.stats.first_level_model import FirstLevelModel
# we are going to generate a list of z-maps together with their session and condition index
z_maps = []
condition_idx = []
session_idx = []
# Instantiate the glm
glm = FirstLevelModel(t_r=TR,
mask_img=haxby_dataset.mask,
high_pass=.008,
smoothing_fwhm=4,
memory='nilearn_cache')
##############################################################################
# Run the glm on data from each session
# -------------------------------------
for session in unique_sessions:
# grab the fmri data for that particular session
fmri_session = index_img(func_filename, sessions == session)
# fit the glm
glm.fit(fmri_session, events=events[session])
# set up contrasts: one per condition
conditions = events[session].trial_type.unique()
def test_fmri_inputs():
# Test processing of FMRI inputs
with InTemporaryDirectory():
shapes = ((7, 8, 9, 10), )
mask, FUNCFILE, _ = write_fake_fmri_data_and_design(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))
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None).fit([fi, fi], d)
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None).fit(fi, [d, d])
# At least paradigms or design have to be given
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None).fit(fi)
# If paradigms are given then both tr and slice time ref were
# required
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None).fit(fi, d)
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None, t_r=1.0).fit(fi, d)
with pytest.raises(ValueError):
FirstLevelModel(mask_img=None,
slice_time_ref=0.).fit(fi, d)
# confounds rows do not match n_scans
with pytest.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, _
# It is now time to create and estimate a ``FirstLevelModel`` object, that will generate the *design matrix* using the information provided by the ``events`` object.
from nilearn.stats.first_level_model import FirstLevelModel
###############################################################################
# Parameters of the first-level model
#
# * t_r=7(s) is the time of repetition of acquisitions
# * noise_model='ar1' specifies the noise covariance model: a lag-1 dependence
# * standardize=False means that we do not want to rescale the time series to mean 0, variance 1
# * hrf_model='spm' means that we rely on the SPM "canonical hrf" model (without time or dispersion derivatives)
# * drift_model='cosine' means that we model the signal drifts as slow oscillating time functions
# * high_pass=0.01(Hz) defines the cutoff frequency (inverse of the time period).
fmri_glm = FirstLevelModel(t_r=7,
noise_model='ar1',
standardize=False,
hrf_model='spm',
drift_model='cosine',
high_pass=.01)
###############################################################################
# Now that we have specified the model, we can run it on the fMRI image
fmri_glm = fmri_glm.fit(fmri_img, events)
###############################################################################
# One can inspect the design matrix (rows represent time, and
# columns contain the predictors).
design_matrix = fmri_glm.design_matrices_[0]
###############################################################################
# Formally, we have taken the first design matrix, because the model is
# implictily meant to for multiple runs.
# t_r = 2.4 events_file = data['events'] import pandas as pd events = pd.read_table(events_file) ############################################################################### # Running a basic model # --------------------- # # First we specify a linear model. # The .fit() functionality of FirstLevelModel function creates the design matrix and the beta maps. # from nilearn.stats.first_level_model import FirstLevelModel first_level_model = FirstLevelModel(t_r) first_level_model = first_level_model.fit(fmri_img, events=events) design_matrix = first_level_model.design_matrices_[0] ######################################################################### # Let us take a look at the design matrix: it has 10 main columns corresponding to 10 experimental conditions, followed by 3 columns describing low-frequency signals (drifts) and a constant regressor. from nilearn.reporting import plot_design_matrix plot_design_matrix(design_matrix) import matplotlib.pyplot as plt plt.show() ######################################################################### # Specification of the contrasts. # # For this, let's create a function that, given the design matrix, # generates the corresponding contrasts. This will be useful to