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