def test_permuted_ols_sklearn_nocovar(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
# create design
target_var = rng.randn(n_samples, 1)
tested_var = rng.randn(n_samples, 1)
# scikit-learn F-score
fvals, _ = f_regression(target_var, tested_var, center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(tested_var, target_var, model_intercept=False, n_perm=0, random_state=random_state)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
# test with ravelized tested_var
_, orig_scores, _ = permuted_ols(
np.ravel(tested_var), target_var, model_intercept=False, n_perm=0, random_state=random_state
)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
### Adds intercept (should be equivalent to centering variates)
# permuted OLS
_, orig_scores_addintercept, _ = permuted_ols(
tested_var, target_var, model_intercept=True, n_perm=0, random_state=random_state
)
target_var -= target_var.mean(0)
tested_var -= tested_var.mean(0)
# scikit-learn F-score
fvals_addintercept, _ = f_regression(target_var, tested_var, center=True)
assert_array_almost_equal([fvals_addintercept], orig_scores_addintercept, decimal=6)
def test_permuted_ols_intercept_sklearn_nocovar_multivariate(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
n_targets = 10
# create design
target_vars = rng.randn(n_samples, n_targets)
tested_var = np.ones((n_samples, 1))
# scikit-learn F-scores
fvals = np.empty((n_targets, 1))
for i in range(n_targets):
fvals[i], _ = f_regression(target_vars[:, i], tested_var, center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(tested_var,
target_vars,
confounding_vars=None,
n_perm=0,
random_state=random_state)
# same thing but with model_intercept=True to check it has no effect
_, orig_scores_addintercept, _ = permuted_ols(tested_var,
target_vars,
confounding_vars=None,
model_intercept=True,
n_perm=0,
random_state=random_state)
assert_array_almost_equal(fvals, orig_scores, decimal=6)
assert_array_almost_equal(orig_scores, orig_scores_addintercept, decimal=6)
def test_permuted_ols_intercept_sklearn_nocovar(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
# create design
target_var = rng.randn(n_samples, 1)
tested_var = np.ones((n_samples, 1))
# scikit-learn F-score
fvals, _ = f_regression(target_var, tested_var, center=False)
# permuted OLS
neg_log_pvals, orig_scores, _ = permuted_ols(tested_var,
target_var,
confounding_vars=None,
n_perm=10,
random_state=random_state)
assert_array_less(neg_log_pvals, 1.) # ensure sign swap is correctly done
# same thing but with model_intercept=True to check it has no effect
_, orig_scores_addintercept, _ = permuted_ols(tested_var,
target_var,
confounding_vars=None,
model_intercept=True,
n_perm=0,
random_state=random_state)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
assert_array_almost_equal(orig_scores, orig_scores_addintercept, decimal=6)
def test_permuted_ols_sklearn_nocovar_multivariate(random_state=0):
"""Test permuted_ols with multiple tested variates and no covariate.
It is equivalent to fitting several models with only one tested variate.
"""
rng = check_random_state(random_state)
# design parameters
n_samples = 50
n_targets = 10
n_regressors = 2
# create design
target_vars = rng.randn(n_samples, n_targets)
tested_var = rng.randn(n_samples, n_regressors)
# scikit-learn F-scores
fvals = np.empty((n_targets, n_regressors))
for i in range(n_targets):
fvals[i], _ = f_regression(tested_var, target_vars[:, i], center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(tested_var,
target_vars,
model_intercept=False,
n_perm=0,
random_state=random_state)
assert_array_almost_equal(fvals, orig_scores, decimal=6)
### Adds intercept (should be equivalent to centering variates)
# permuted OLS
_, orig_scores_addintercept, _ = permuted_ols(tested_var,
target_vars,
model_intercept=True,
n_perm=0,
random_state=random_state)
target_vars -= target_vars.mean(0)
tested_var -= tested_var.mean(0)
# scikit-learn F-score
fvals_addintercept = np.empty((n_targets, n_regressors))
for i in range(n_targets):
fvals_addintercept[i], _ = f_regression(tested_var,
target_vars[:, i],
center=True)
assert_array_almost_equal(fvals_addintercept,
orig_scores_addintercept,
decimal=6)
def test_f_score_with_covars_and_normalized_design_nocovar(random_state=0):
rng = check_random_state(random_state)
### Normalized data
n_samples = 50
# generate data
var1 = np.ones((n_samples, 1)) / np.sqrt(n_samples)
var2 = rng.randn(n_samples, 1)
var2 = var2 / np.sqrt(np.sum(var2**2, 0)) # normalize
f_val_own = _f_score_with_covars_and_normalized_design(var1, var2)[0]
f_val_sklearn, _ = f_regression(var2, np.ravel(var1), center=False)
assert_array_almost_equal(f_val_own, f_val_sklearn)
def test_f_score_with_covars_and_normalized_design_nocovar(random_state=0):
rng = check_random_state(random_state)
### Normalized data
n_samples = 50
# generate data
var1 = np.ones((n_samples, 1)) / np.sqrt(n_samples)
var2 = rng.randn(n_samples, 1)
var2 = var2 / np.sqrt(np.sum(var2 ** 2, 0)) # normalize
f_val_own = _f_score_with_covars_and_normalized_design(var1, var2)[0]
f_val_sklearn, _ = f_regression(var2, np.ravel(var1), center=False)
assert_array_almost_equal(f_val_own, f_val_sklearn)
def test_permuted_ols_sklearn_nocovar(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
# create design
target_var = rng.randn(n_samples, 1)
tested_var = rng.randn(n_samples, 1)
# scikit-learn F-score
fvals, _ = f_regression(target_var, tested_var, center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(tested_var,
target_var,
model_intercept=False,
n_perm=0,
random_state=random_state)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
# test with ravelized tested_var
_, orig_scores, _ = permuted_ols(np.ravel(tested_var),
target_var,
model_intercept=False,
n_perm=0,
random_state=random_state)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
### Adds intercept (should be equivalent to centering variates)
# permuted OLS
_, orig_scores_addintercept, _ = permuted_ols(tested_var,
target_var,
model_intercept=True,
n_perm=0,
random_state=random_state)
target_var -= target_var.mean(0)
tested_var -= tested_var.mean(0)
# scikit-learn F-score
fvals_addintercept, _ = f_regression(target_var, tested_var, center=True)
assert_array_almost_equal([fvals_addintercept],
orig_scores_addintercept,
decimal=6)
def test_permuted_ols_sklearn_nocovar_multivariate(random_state=0):
"""Test permuted_ols with multiple tested variates and no covariate.
It is equivalent to fitting several models with only one tested variate.
"""
rng = check_random_state(random_state)
# design parameters
n_samples = 50
n_targets = 10
n_regressors = 2
# create design
target_vars = rng.randn(n_samples, n_targets)
tested_var = rng.randn(n_samples, n_regressors)
# scikit-learn F-scores
fvals = np.empty((n_targets, n_regressors))
for i in range(n_targets):
fvals[i], _ = f_regression(tested_var, target_vars[:, i], center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(
tested_var, target_vars, model_intercept=False, n_perm=0, random_state=random_state
)
assert_array_almost_equal(fvals, orig_scores, decimal=6)
### Adds intercept (should be equivalent to centering variates)
# permuted OLS
_, orig_scores_addintercept, _ = permuted_ols(
tested_var, target_vars, model_intercept=True, n_perm=0, random_state=random_state
)
target_vars -= target_vars.mean(0)
tested_var -= tested_var.mean(0)
# scikit-learn F-score
fvals_addintercept = np.empty((n_targets, n_regressors))
for i in range(n_targets):
fvals_addintercept[i], _ = f_regression(tested_var, target_vars[:, i], center=True)
assert_array_almost_equal(fvals_addintercept, orig_scores_addintercept, decimal=6)
def test_permuted_ols_intercept_sklearn_nocovar(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
# create design
target_var = rng.randn(n_samples, 1)
tested_var = np.ones((n_samples, 1))
# scikit-learn F-score
fvals, _ = f_regression(target_var, tested_var, center=False)
# permuted OLS
neg_log_pvals, orig_scores, _ = permuted_ols(
tested_var, target_var, confounding_vars=None, n_perm=10, random_state=random_state
)
assert_array_less(neg_log_pvals, 1.0) # ensure sign swap is correctly done
# same thing but with model_intercept=True to check it has no effect
_, orig_scores_addintercept, _ = permuted_ols(
tested_var, target_var, confounding_vars=None, model_intercept=True, n_perm=0, random_state=random_state
)
assert_array_almost_equal([fvals], orig_scores, decimal=6)
assert_array_almost_equal(orig_scores, orig_scores_addintercept, decimal=6)
def test_permuted_ols_intercept_sklearn_nocovar_multivariate(random_state=0):
rng = check_random_state(random_state)
# design parameters
n_samples = 50
n_targets = 10
# create design
target_vars = rng.randn(n_samples, n_targets)
tested_var = np.ones((n_samples, 1))
# scikit-learn F-scores
fvals = np.empty((n_targets, 1))
for i in range(n_targets):
fvals[i], _ = f_regression(target_vars[:, i], tested_var, center=False)
# permuted OLS
_, orig_scores, _ = permuted_ols(
tested_var, target_vars, confounding_vars=None, n_perm=0, random_state=random_state
)
# same thing but with model_intercept=True to check it has no effect
_, orig_scores_addintercept, _ = permuted_ols(
tested_var, target_vars, confounding_vars=None, model_intercept=True, n_perm=0, random_state=random_state
)
assert_array_almost_equal(fvals, orig_scores, decimal=6)
assert_array_almost_equal(orig_scores, orig_scores_addintercept, decimal=6)
mask_quality_check = np.where(tested_var != 'None')[0]
n_samples = mask_quality_check.size
contrast_map_filenames = [localizer_dataset.cmaps[i]
for i in mask_quality_check]
tested_var = tested_var[mask_quality_check].astype(float).reshape((-1, 1))
print("Actual number of subjects after quality check: %d" % n_samples)
### Mask data #################################################################
nifti_masker = NiftiMasker(
smoothing_fwhm=5,
memory='nilearn_cache', memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(contrast_map_filenames)
### Anova (parametric F-scores) ###############################################
from nilearn._utils.fixes import f_regression
_, pvals_anova = f_regression(fmri_masked, tested_var, center=True)
pvals_anova *= fmri_masked.shape[1]
pvals_anova[np.isnan(pvals_anova)] = 1
pvals_anova[pvals_anova > 1] = 1
neg_log_pvals_anova = - np.log10(pvals_anova)
neg_log_pvals_anova_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_anova)
### Perform massively univariate analysis with permuted OLS ###################
neg_log_pvals_permuted_ols, _, _ = permuted_ols(
tested_var, fmri_masked,
model_intercept=True,
n_perm=5000, # 5,000 for the sake of time. Idealy, this should be 10,000
n_jobs=1) # can be changed to use more CPUs
neg_log_pvals_permuted_ols_unmasked = nifti_masker.inverse_transform(
np.ravel(neg_log_pvals_permuted_ols))
### Load Localizer contrast ###################################################
n_samples = 20
localizer_dataset = datasets.fetch_localizer_calculation_task(
n_subjects=n_samples)
tested_var = np.ones((n_samples, 1))
### Mask data #################################################################
nifti_masker = NiftiMasker(
smoothing_fwhm=5,
memory='nilearn_cache', memory_level=1) # cache options
cmap_filenames = localizer_dataset.cmaps
fmri_masked = nifti_masker.fit_transform(cmap_filenames)
### Anova (parametric F-scores) ###############################################
from nilearn._utils.fixes import f_regression
_, pvals_anova = f_regression(fmri_masked, tested_var,
center=False) # do not remove intercept
pvals_anova *= fmri_masked.shape[1]
pvals_anova[np.isnan(pvals_anova)] = 1
pvals_anova[pvals_anova > 1] = 1
neg_log_pvals_anova = - np.log10(pvals_anova)
neg_log_pvals_anova_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_anova)
### Visualization #############################################################
from nilearn.plotting import plot_stat_map
# Various plotting parameters
z_slice = 45 # plotted slice
from nilearn.image.resampling import coord_transform
affine = neg_log_pvals_anova_unmasked.get_affine()
_, _, k_slice = coord_transform(0, 0, z_slice,
### Mask data #################################################################
nifti_masker = NiftiMasker(memory='nilearn_cache',
memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(dataset_files.cmaps)
### Perform massively univariate analysis with permuted OLS ###################
tested_var = np.ones((n_samples, 1), dtype=float) # intercept
neg_log_pvals, all_scores, h0 = permuted_ols(
tested_var, fmri_masked, model_intercept=False, n_perm=10000,
n_jobs=1) # can be changed to use more CPUs
neg_log_pvals_unmasked = nifti_masker.inverse_transform(
np.ravel(neg_log_pvals))
### scikit-learn F-scores for comparison ######################################
from nilearn._utils.fixes import f_regression
_, pvals_bonferroni = f_regression(fmri_masked, tested_var, center=False)
pvals_bonferroni *= fmri_masked.shape[1]
pvals_bonferroni[np.isnan(pvals_bonferroni)] = 1
pvals_bonferroni[pvals_bonferroni > 1] = 1
neg_log_pvals_bonferroni = -np.log10(pvals_bonferroni)
neg_log_pvals_bonferroni_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_bonferroni)
### Visualization #############################################################
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
# Here, we should use a structural image as a background, when available.
# Various plotting parameters
picked_slice = 30 # plotted slice
neg_log_pvals, t_scores_original_data, _ = permuted_ols(
grouped_conditions_encoded, grouped_fmri_masked,
# + intercept as a covariate by default
n_perm=10000, two_sided_test=True,
n_jobs=1) # can be changed to use more CPUs
signed_neg_log_pvals = neg_log_pvals * np.sign(t_scores_original_data)
signed_neg_log_pvals_unmasked = nifti_masker.inverse_transform(
signed_neg_log_pvals)
##############################################################################
# scikit-learn F-scores for comparison
#
# F-test does not allow to observe the effect sign (pure two-sided test)
from nilearn._utils.fixes import f_regression
_, pvals_bonferroni = f_regression(
grouped_fmri_masked,
grouped_conditions_encoded) # f_regression implicitly adds intercept
pvals_bonferroni *= fmri_masked.shape[1]
pvals_bonferroni[np.isnan(pvals_bonferroni)] = 1
pvals_bonferroni[pvals_bonferroni > 1] = 1
neg_log_pvals_bonferroni = -np.log10(pvals_bonferroni)
neg_log_pvals_bonferroni_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_bonferroni)
##############################################################################
# Visualization
import matplotlib.pyplot as plt
from nilearn.plotting import plot_stat_map, show
# Use the fmri mean image as a surrogate of anatomical data
from nilearn import image
### Load Localizer contrast ###################################################
n_samples = 20
localizer_dataset = datasets.fetch_localizer_calculation_task(
n_subjects=n_samples)
tested_var = np.ones((n_samples, 1))
### Mask data #################################################################
nifti_masker = NiftiMasker(smoothing_fwhm=5,
memory='nilearn_cache',
memory_level=1) # cache options
cmap_filenames = localizer_dataset.cmaps
fmri_masked = nifti_masker.fit_transform(cmap_filenames)
### Anova (parametric F-scores) ###############################################
from nilearn._utils.fixes import f_regression
_, pvals_anova = f_regression(fmri_masked, tested_var,
center=False) # do not remove intercept
pvals_anova *= fmri_masked.shape[1]
pvals_anova[np.isnan(pvals_anova)] = 1
pvals_anova[pvals_anova > 1] = 1
neg_log_pvals_anova = -np.log10(pvals_anova)
neg_log_pvals_anova_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_anova)
### Visualization #############################################################
from nilearn.plotting import plot_stat_map
# Various plotting parameters
z_slice = 45 # plotted slice
from nilearn.image.resampling import coord_transform
affine = neg_log_pvals_anova_unmasked.get_affine()
_, _, k_slice = coord_transform(0, 0, z_slice, linalg.inv(affine))
condition_mask = np.logical_or(conditions == 'face', conditions == 'house')
conditions_encoded = conditions_encoded[condition_mask]
fmri_masked = fmri_masked[condition_mask]
### Perform massively univariate analysis with permuted OLS ###################
neg_log_pvals, all_scores, _ = permuted_ols(
conditions_encoded,
fmri_masked, # + intercept as a covariate by default
n_perm=10000,
n_jobs=1) # can be changed to use more CPUs
neg_log_pvals_unmasked = nifti_masker.inverse_transform(
neg_log_pvals).get_data()
### scikit-learn F-scores for comparison ######################################
from nilearn._utils.fixes import f_regression
_, pvals_bonferroni = f_regression(
fmri_masked, conditions_encoded) # f_regression implicitly adds intercept
pvals_bonferroni *= fmri_masked.shape[1]
pvals_bonferroni[np.isnan(pvals_bonferroni)] = 1
pvals_bonferroni[pvals_bonferroni > 1] = 1
neg_log_pvals_bonferroni = -np.log10(pvals_bonferroni)
neg_log_pvals_bonferroni_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_bonferroni).get_data()
### Visualization #############################################################
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
# Use the fmri mean image as a surrogate of anatomical data
mean_fmri = nibabel.load(dataset_files.func).get_data().mean(axis=-1)
# Various plotting parameters
nifti_masker = NiftiMasker(
memory='nilearn_cache', memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(dataset_files.cmaps)
### Perform massively univariate analysis with permuted OLS ###################
tested_var = np.ones((n_samples, 1), dtype=float) # intercept
neg_log_pvals, all_scores, h0 = permuted_ols(
tested_var, fmri_masked, model_intercept=False,
n_perm=10000,
n_jobs=1) # can be changed to use more CPUs
neg_log_pvals_unmasked = nifti_masker.inverse_transform(
np.ravel(neg_log_pvals))
### scikit-learn F-scores for comparison ######################################
from nilearn._utils.fixes import f_regression
_, pvals_bonferroni = f_regression(fmri_masked, tested_var, center=False)
pvals_bonferroni *= fmri_masked.shape[1]
pvals_bonferroni[np.isnan(pvals_bonferroni)] = 1
pvals_bonferroni[pvals_bonferroni > 1] = 1
neg_log_pvals_bonferroni = - np.log10(pvals_bonferroni)
neg_log_pvals_bonferroni_unmasked = nifti_masker.inverse_transform(
neg_log_pvals_bonferroni)
### Visualization #############################################################
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
# Here, we should use a structural image as a background, when available.
# Various plotting parameters
picked_slice = 30 # plotted slice
