def test_first_level_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_check_first_level_contrast(): from nilearn.glm.second_level.second_level import \ _check_first_level_contrast _check_first_level_contrast(["foo"], None) # Should not do anything with pytest.raises(ValueError, match="If second_level_input was a list"): _check_first_level_contrast([FirstLevelModel()], None) _check_first_level_contrast([FirstLevelModel()], "foo")
def test_first_level_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])) # Check error with invalid signal_scaling values with pytest.raises(ValueError, match="signal_scaling must be"): FirstLevelModel(mask_img=False, noise_model='ols', signal_scaling="foo") first_level = 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.fit(fmri_data, design_matrices=design_matrices) # trivial test of signal_scaling value assert first_level.signal_scaling is False # assert that our design matrix has one constant assert first_level.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.results_[0][0].theta.shape == (1, 1) # assert that the theta is equal to the one voxel value assert_almost_equal(first_level.results_[0][0].theta[0, 0], 6.0, 2)
def test_first_level_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 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_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 # Check that voxelwise model attributes cannot be # accessed if minimize_memory is set to True model = FirstLevelModel(mask_img=mask, minimize_memory=True, noise_model='ols') model.fit(fmri_data, design_matrices=design_matrices) with pytest.raises(ValueError, match="To access voxelwise attributes"): residuals = model.residuals[0] model = FirstLevelModel(mask_img=mask, minimize_memory=False, noise_model='ols') # Check that trying to access residuals without fitting # raises an error with pytest.raises(ValueError, match="The model has not been fit yet"): residuals = model.residuals[0] model.fit(fmri_data, design_matrices=design_matrices) # For coverage with pytest.raises(ValueError, match="attribute must be one of"): model._get_voxelwise_model_attribute("foo", True) residuals = model.residuals[0] mean_residuals = model.masker_.transform(residuals).mean(0) assert_array_almost_equal(mean_residuals, 0)
def test_flm_reporting(use_method): 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] if use_method: report_flm = flm.generate_report( contrast, plot_type='glass', height_control=None, min_distance=15, alpha=0.001, threshold=2.78) else: 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 test_masking_first_level_model(): """ Checks that using NiftiMasker when instantiating FirstLevelModel doesn't raise Error when calling generate_report(). """ 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) masker = NiftiMasker(mask_img=mask) masker.fit(fmri_data) flm = FirstLevelModel(mask_img=masker).fit( fmri_data, design_matrices=design_matrices ) contrast = np.eye(3)[1] report_flm = flm.generate_report( contrast, plot_type='glass', height_control=None, min_distance=15, alpha=0.001, threshold=2.78 ) report_iframe = report_flm.get_iframe() # So flake8 doesn't complain about not using variable (F841) report_iframe del mask, flm, fmri_data, masker
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(get_data(z1) + get_data(z2), 2 * get_data(z_joint))
def run_glm(dmtx, contrasts, fmri_data, mask_img, subject_dic, subject_session_output_dir, tr, slice_time_ref, smoothing_fwhm=False): """ Run the GLM on a given session and compute contrasts Parameters ---------- dmtx : array-like the design matrix for the model contrasts : dict holding the numerical specification of contrasts fmri_data : Nifti1Image the fMRI data fir by the model mask_img : Nifti1Image the mask used for the fMRI data """ from nilearn.glm.first_level import FirstLevelModel fmri_4d = nib.load(fmri_data) # GLM analysis print('Fitting a GLM (this takes time)...') fmri_glm = FirstLevelModel(mask_img=mask_img, t_r=tr, slice_time_ref=slice_time_ref, smoothing_fwhm=smoothing_fwhm).fit( fmri_4d, design_matrices=dmtx) # compute contrasts z_maps = {} for contrast_id, contrast_val in contrasts.items(): print("\tcontrast id: %s" % contrast_id) # store stat maps to disk for map_type in ['z_score', 'stat', 'effect_size', 'effect_variance']: stat_map = fmri_glm.compute_contrast(contrast_val, output_type=map_type) map_dir = os.path.join(subject_session_output_dir, '%s_maps' % map_type) if not os.path.exists(map_dir): os.makedirs(map_dir) map_path = os.path.join(map_dir, '%s.nii.gz' % contrast_id) print("\t\tWriting %s ..." % map_path) stat_map.to_filename(map_path) # collect zmaps for contrasts we're interested in if map_type == 'z_score': z_maps[contrast_id] = map_path return z_maps, fmri_glm
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_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(get_data(fixed_fx_contrast), get_data(fixed_fx_dic['effect_size'])) assert_almost_equal(get_data(fixed_fx_variance), get_data(fixed_fx_dic['effect_variance'])) assert_almost_equal(get_data(fixed_fx_stat), get_data(fixed_fx_dic['stat'])) # test without mask variable ( fixed_fx_contrast, fixed_fx_variance, fixed_fx_stat, ) = compute_fixed_effects(contrasts, variance) assert_almost_equal(get_data(fixed_fx_contrast), get_data(fixed_fx_dic['effect_size'])) assert_almost_equal(get_data(fixed_fx_variance), get_data(fixed_fx_dic['effect_variance'])) assert_almost_equal(get_data(fixed_fx_stat), get_data(fixed_fx_dic['stat'])) # 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_glm_sample_mask(): """Ensure the sample mask is performing correctly in GLM.""" shapes, rk = [(10, 10, 10, 25)], 3 mask, fmri_data, design_matrix =\ generate_fake_fmri_data_and_design(shapes, rk) model = FirstLevelModel(t_r=2.0, mask_img=mask, minimize_memory=False) sample_mask = np.arange(25)[3:] # censor the first three volumes model.fit(fmri_data, design_matrices=design_matrix, sample_masks=sample_mask) assert model.design_matrices_[0].shape[0] == 22 assert model.predicted[0].shape[-1] == 22
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_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_get_voxelwise_attributes_should_return_as_many_as_design_matrices( shapes): mask, fmri_data, design_matrices =\ generate_fake_fmri_data_and_design(shapes) 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) # Check that length of outputs is the same as the number of design matrices assert len(model._get_voxelwise_model_attribute("resid", True)) == \ len(shapes)
def create_bmap(sub_dir: Union[str, os.PathLike], noise_model: str = 'ar1', hrf_model: str = 'spm', drift_model: str = None, fwhm: int = 8, **kwargs): sub_id = os.path.basename(sub_dir) tsk_prfx = '_ses-04_run-01_task-memory_' outfile_suffix = '_bmap-effectsize.nii.gz' confounds = pd.read_csv(pjoin(sub_dir, sub_id + tsk_prfx + 'confounds.tsv'), sep='\t') events = pd.read_csv(pjoin(sub_dir, sub_id + tsk_prfx + 'events.tsv'), sep='\t') contrast_list = [] sub_out_dir = pjoin(xpu(output_dir), 'derivatives', sub_id, 'beta_maps') out_filename = pjoin(sub_out_dir, sub_id + outfile_suffix) os.makedirs(sub_out_dir, exist_ok=True) fmri_img = nib.load(pjoin(sub_dir, sub_id + tsk_prfx + 'bold.nii.gz')) nscans, t_r = fmri_img.shape[-1], fmri_img.header.get_zooms()[-1] frame_times = frame_times = np.arange(confounds.shape[0]) * t_r for row in tqdm(list(events.iterrows())): tnum = row[1].trial_number events['trial_type'] = [ 'X_' + row[1].condition if row[1].trial_number != tnum else row[1].condition for row in events.iterrows() ] mat_params = { 'frame_times': frame_times, 'events': events[['onset', 'duration', 'trial_type']], 'add_regs': confounds, 'drift_model': drift_model, 'hrf_model': hrf_model } trial_matrix = make_first_level_design_matrix(**mat_params) trial_contrast = pd.Series( np.array([1] + list(np.repeat(0, trial_matrix.shape[1] - 1)))).values glm_params = { 't_r': t_r, 'drift_model': drift_model, 'standardize': True, 'noise_model': noise_model, 'hrf_model': hrf_model, 'smoothing_fwhm': fwhm } fit_params = {'run_imgs': fmri_img, 'design_matrices': trial_matrix} con_params = { 'contrast_def': trial_contrast, 'output_type': 'effect_size' } contrast_list.append( FirstLevelModel().fit(**fit_params).compute_contrast(**con_params)) nib.save(img=nilearn.image.concat_imgs(contrast_list), filename=out_filename)
def test_first_level_glm_computation_with_memory_caching(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 10),) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(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_img=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 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_high_level_glm_different_design_matrices_formulas(): # 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) # make column names identical design_matrices[1].columns = design_matrices[0].columns # 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) # Compute contrast with formulas cols_formula = tuple(design_matrices[0].columns[:2]) formula = "%s-%s" % cols_formula with pytest.warns(UserWarning, match='One contrast given, assuming it for all 2 runs'): z_joint_formula = multi_session_model.compute_contrast( formula, output_type='effect_size')
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_z_score_opposite_contrast(): fmri, mask = generate_fake_fmri(shape=(50, 20, 50), length=96, rand_gen=np.random.RandomState(42)) nifti_masker = NiftiMasker(mask_img=mask) data = nifti_masker.fit_transform(fmri) frametimes = np.linspace(0, (96 - 1) * 2, 96) for i in [0, 20]: design_matrix = make_first_level_design_matrix( frametimes, hrf_model='spm', add_regs=np.array(data[:, i]).reshape(-1, 1)) c1 = np.array([1] + [0] * (design_matrix.shape[1] - 1)) c2 = np.array([0] + [1] + [0] * (design_matrix.shape[1] - 2)) contrasts = {'seed1 - seed2': c1 - c2, 'seed2 - seed1': c2 - c1} fmri_glm = FirstLevelModel(t_r=2., noise_model='ar1', standardize=False, hrf_model='spm', drift_model='cosine') fmri_glm.fit(fmri, design_matrices=design_matrix) z_map_seed1_vs_seed2 = fmri_glm.compute_contrast( contrasts['seed1 - seed2'], output_type='z_score') z_map_seed2_vs_seed1 = fmri_glm.compute_contrast( contrasts['seed2 - seed1'], output_type='z_score') assert_almost_equal(z_map_seed1_vs_seed2.get_data().min(), -z_map_seed2_vs_seed1.get_data().max(), decimal=10) assert_almost_equal(z_map_seed1_vs_seed2.get_data().max(), -z_map_seed2_vs_seed1.get_data().min(), decimal=10)
def test_compute_contrast_num_contrasts(): shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 19), (7, 8, 7, 13)), 3 mask, fmri_data, design_matrices = generate_fake_fmri_data_and_design(shapes, rk) # Fit a glm with 3 sessions and design matrices multi_session_model = FirstLevelModel(mask_img=mask).fit( fmri_data, design_matrices=design_matrices) # raise when n_contrast != n_runs | 1 with pytest.raises(ValueError): multi_session_model.compute_contrast([np.eye(rk)[1]]*2) multi_session_model.compute_contrast([np.eye(rk)[1]]*3) with pytest.warns(UserWarning, match='One contrast given, assuming it for all 3 runs'): multi_session_model.compute_contrast([np.eye(rk)[1]])
def test_process_second_level_input_as_firstlevelmodels(): """Unit tests for function _process_second_level_input_as_firstlevelmodels(). """ from nilearn.glm.second_level.second_level import _process_second_level_input_as_firstlevelmodels # noqa shapes, rk = [(7, 8, 9, 15)], 3 mask, fmri_data, design_matrices = \ generate_fake_fmri_data_and_design(shapes, rk) list_of_flm = [ FirstLevelModel(mask_img=mask, subject_label=f"sub-{i}").fit( fmri_data[0], design_matrices=design_matrices[0]) for i in range(3) ] sample_map, subjects_label =\ _process_second_level_input_as_firstlevelmodels(list_of_flm) assert subjects_label == [f"sub-{i}" for i in range(3)] assert isinstance(sample_map, Nifti1Image) assert sample_map.shape == (7, 8, 9)
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))
def test_infer_effect_maps(): from nilearn.glm.second_level.second_level import _infer_effect_maps # with InTemporaryDirectory(): shapes, rk = ((7, 8, 9, 1), (7, 8, 7, 16)), 3 mask, fmri_data, design_matrices = write_fake_fmri_data_and_design( shapes, rk) func_img = load(fmri_data[0]) second_level_input = pd.DataFrame({ 'map_name': ["a", "b"], 'effects_map_path': [fmri_data[0], "bar"] }) assert _infer_effect_maps(second_level_input, "a") == [fmri_data[0]] with pytest.raises(ValueError, match="File not found: 'bar'"): _infer_effect_maps(second_level_input, "b") assert _infer_effect_maps([fmri_data[0]], None) == [fmri_data[0]] contrast = np.eye(rk)[1] second_level_input = [FirstLevelModel(mask_img=mask)] * 2 for i, model in enumerate(second_level_input): model.fit(fmri_data[i], design_matrices=design_matrices[i]) assert len(_infer_effect_maps(second_level_input, contrast)) == 2 # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del mask, fmri_data, func_img, second_level_input
def test_first_level_with_scaling(): shapes, rk = [(3, 1, 1, 2)], 1 fmri_data = list() fmri_data.append(Nifti1Image(np.zeros((1, 1, 1, 2)) + 6, np.eye(4))) design_matrices = list() design_matrices.append( pd.DataFrame(np.ones((shapes[0][-1], rk)), columns=list('abcdefghijklmnopqrstuvwxyz')[:rk])) fmri_glm = FirstLevelModel(mask_img=False, noise_model='ols', signal_scaling=0, minimize_memory=True) assert fmri_glm.signal_scaling == 0 assert not fmri_glm.standardize with pytest.warns(DeprecationWarning, match="Deprecated. `scaling_axis` will be removed"): assert fmri_glm.scaling_axis == 0 glm_parameters = fmri_glm.get_params() test_glm = FirstLevelModel(**glm_parameters) fmri_glm = fmri_glm.fit(fmri_data, design_matrices=design_matrices) test_glm = test_glm.fit(fmri_data, design_matrices=design_matrices) assert glm_parameters['signal_scaling'] == 0
def test_first_level_hrf_model(hrf_model, spaces): """ Ensure that FirstLevelModel runs without raising errors for different values of hrf_model. In particular, one checks that it runs without raising errors when given a custom response function. Also ensure that it computes contrasts without raising errors, even when event (ie condition) names have spaces. """ shapes, rk = [(10, 10, 10, 25)], 3 mask, fmri_data, _ =\ generate_fake_fmri_data_and_design(shapes, rk) events = basic_paradigm(condition_names_have_spaces=spaces) model = FirstLevelModel(t_r=2.0, mask_img=mask, hrf_model=hrf_model) model.fit(fmri_data, events) columns = model.design_matrices_[0].columns model.compute_contrast(f"{columns[0]}-{columns[1]}")
# define the effects of interest contrast, a 2-dimensional contrasts # 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 specifying a FirstLevelModel and then # fitting it. from nilearn.glm.first_level 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
######################################################################### # 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.glm.first_level 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()