def test_Tcontrast():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
labels, results = run_glm(Y, X, 'ar1')
con_val = np.eye(q)[0]
z_vals = compute_contrast(labels, results, con_val).z_score()
assert_almost_equal(z_vals.mean(), 0, 0)
assert_almost_equal(z_vals.std(), 1, 0)
def test_fixed_effect_contrast():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
lab, res = run_glm(Y, X, 'ols')
c1, c2 = np.eye(q)[0], np.eye(q)[1]
con = _compute_fixed_effect_contrast([lab, lab], [res, res], [c1, c2])
z_vals = con.z_score()
assert_almost_equal(z_vals.mean(), 0, 0)
assert_almost_equal(z_vals.std(), 1, 0)
def test_t_contrast_add():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
lab, res = run_glm(Y, X, 'ols')
c1, c2 = np.eye(q)[0], np.eye(q)[1]
con = compute_contrast(lab, res, c1) + compute_contrast(lab, res, c2)
z_vals = con.z_score()
assert_almost_equal(z_vals.mean(), 0, 0)
assert_almost_equal(z_vals.std(), 1, 0)
def test_contrast_mul():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
lab, res = run_glm(Y, X, 'ar1')
for c1 in [np.eye(q)[0], np.eye(q)[:3]]:
con1 = compute_contrast(lab, res, c1)
con2 = con1 * 2
assert_almost_equal(con1.effect * 2, con2.effect)
assert_almost_equal(con1.z_score(), con2.z_score())
def test_Fcontrast():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
for model in ['ols', 'ar1']:
labels, results = run_glm(Y, X, model)
for con_val in [np.eye(q)[0], np.eye(q)[:3]]:
z_vals = compute_contrast(labels,
results,
con_val,
contrast_type='F').z_score()
assert_almost_equal(z_vals.mean(), 0, 0)
assert_almost_equal(z_vals.std(), 1, 0)
def run_GLM(raw,
design_matrix,
noise_model='ar1',
bins=100,
n_jobs=1,
verbose=0):
"""
Run GLM on data using supplied design matrix.
This is a wrapper function for nilearn.stats.first_level_model.run_glm.
Parameters
----------
raw : instance of Raw
The haemoglobin data.
design_matrix : as specified in Nilearn
The design matrix.
noise_model : {'ar1', 'ols'}, optional
The temporal variance model. Defaults to 'ar1'.
bins : : int, optional
Maximum number of discrete bins for the AR(1) coef histogram.
n_jobs : int, optional
The number of CPUs to use to do the computation. -1 means
'all CPUs'.
verbose : int, optional
The verbosity level. Defaut is 0
Returns
-------
glm_estimates : dict
Keys correspond to the different labels values values are
RegressionResults instances corresponding to the voxels.
"""
from nilearn.stats.first_level_model import run_glm
picks = _picks_to_idx(raw.info, 'fnirs', exclude=[], allow_empty=True)
ch_names = raw.ch_names
results = dict()
for pick in picks:
labels, glm_estimates = run_glm(raw.get_data(pick).T,
design_matrix.values,
noise_model=noise_model,
bins=bins,
n_jobs=n_jobs,
verbose=verbose)
results[ch_names[pick]] = glm_estimates[labels[0]]
return results
def test_F_contrast_add():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
lab, res = run_glm(Y, X, 'ar1')
c1, c2 = np.eye(q)[:2], np.eye(q)[2:4]
con = compute_contrast(lab, res, c1) + compute_contrast(lab, res, c2)
z_vals = con.z_score()
assert_almost_equal(z_vals.mean(), 0, 0)
assert_almost_equal(z_vals.std(), 1, 0)
# first test with dependent contrast
con1 = compute_contrast(lab, res, c1)
con2 = compute_contrast(lab, res, c1) + compute_contrast(lab, res, c1)
assert_almost_equal(con1.effect * 2, con2.effect)
assert_almost_equal(con1.variance * 2, con2.variance)
assert_almost_equal(con1.stat() * 2, con2.stat())
def test_contrast_values():
# but this test is circular and should be removed
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
lab, res = run_glm(Y, X, 'ar1', bins=1)
# t test
cval = np.eye(q)[0]
con = compute_contrast(lab, res, cval)
t_ref = list(res.values())[0].Tcontrast(cval).t
assert_almost_equal(np.ravel(con.stat()), t_ref)
# F test
cval = np.eye(q)[:3]
con = compute_contrast(lab, res, cval)
F_ref = list(res.values())[0].Fcontrast(cval).F
# Note that the values are not strictly equal,
# this seems to be related to a bug in Mahalanobis
assert_almost_equal(np.ravel(con.stat()), F_ref, 3)
def test_fixed_effect_contrast_nonzero_effect():
X, y = make_regression(n_features=5, n_samples=20, random_state=0)
y = y[:, None]
labels, results = run_glm(y, X, 'ols')
coef = LinearRegression(fit_intercept=False).fit(X, y).coef_
for i in range(X.shape[1]):
contrast = np.zeros(X.shape[1])
contrast[i] = 1.
fixed_effect = _compute_fixed_effect_contrast(
[labels],
[results],
[contrast],
)
assert_almost_equal(fixed_effect.effect_size(), coef.ravel()[i])
fixed_effect = _compute_fixed_effect_contrast([labels] * 3,
[results] * 3,
[contrast] * 3)
assert_almost_equal(fixed_effect.effect_size(), coef.ravel()[i])
def test_second_level_model_glm_computation():
with InTemporaryDirectory():
shapes = ((7, 8, 9, 1),)
mask, FUNCFILE, _ = write_fake_fmri_data_and_design(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 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_run_glm():
n, p, q = 100, 80, 10
X, Y = np.random.randn(p, q), np.random.randn(p, n)
# Ordinary Least Squares case
labels, results = run_glm(Y, X, 'ols')
assert_array_equal(labels, np.zeros(n))
assert list(results.keys()) == [0.0]
assert results[0.0].theta.shape == (q, n)
assert_almost_equal(results[0.0].theta.mean(), 0, 1)
assert_almost_equal(results[0.0].theta.var(), 1. / p, 1)
# ar(1) case
labels, results = run_glm(Y, X, 'ar1')
assert len(labels) == n
assert len(results.keys()) > 1
tmp = sum([val.theta.shape[1] for val in results.values()])
assert tmp == n
# non-existant case
with pytest.raises(ValueError):
run_glm(Y, X, 'ar2')
with pytest.raises(ValueError):
run_glm(Y, X.T)
# The drift model is implicitly a cosine basis with a period cutoff at 128s.
from nilearn.stats.first_level_model import make_first_level_design_matrix
design_matrix = make_first_level_design_matrix(frame_times,
events=events,
hrf_model='glover + derivative')
#########################################################################
# Setup and fit GLM.
#
# Note that the output consists in 2 variables: `labels` and `fit`.
# `labels` tags voxels according to noise autocorrelation.
# `estimates` contains the parameter estimates.
# We keep them for later contrast computation.
from nilearn.stats.first_level_model import run_glm
labels, estimates = run_glm(texture.T, design_matrix.values)
#########################################################################
# Estimate contrasts
# ------------------
# Specify the contrasts.
#
# For practical purpose, we first generate an identity matrix whose size is
# the number of columns of the design matrix.
contrast_matrix = np.eye(design_matrix.shape[1])
#########################################################################
# At first, we create basic contrasts.
basic_contrasts = dict([(column, contrast_matrix[i])
for i, column in enumerate(design_matrix.columns)])
