def report_slm_oasis(): # pragma: no cover n_subjects = 5 # more subjects requires more memory oasis_dataset = nilearn.datasets.fetch_oasis_vbm(n_subjects=n_subjects) # Resample the images, since this mask has a different resolution mask_img = resample_to_img( nilearn.datasets.fetch_icbm152_brain_gm_mask(), oasis_dataset.gray_matter_maps[0], interpolation='nearest', ) design_matrix = _make_design_matrix_slm_oasis(oasis_dataset, n_subjects) second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img) second_level_model.fit(oasis_dataset.gray_matter_maps, design_matrix=design_matrix) contrast = [[1, 0, 0], [0, 1, 0]] report = make_glm_report( model=second_level_model, contrasts=contrast, bg_img=nilearn.datasets.fetch_icbm152_2009()['t1'], height_control=None, ) output_filename = 'generated_report_slm_oasis.html' output_filepath = os.path.join(REPORTS_DIR, output_filename) report.save_as_html(output_filepath) report.get_iframe()
def test_second_level_model_contrast_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, 'intercept') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol) # smoke test for different contrasts in fixed effects model.compute_contrast(c1) z_image = model.compute_contrast(c1, output_type='z_score') stat_image = model.compute_contrast(c1, output_type='stat') p_image = model.compute_contrast(c1, output_type='p_value') effect_image = model.compute_contrast(c1, output_type='effect_size') variance_image = model.compute_contrast(c1, output_type='effect_variance') # Test output_type='all', and verify images are equivalent all_images = model.compute_contrast(c1, output_type='all') assert_array_equal(all_images['z_score'].get_data(), z_image.get_data()) assert_array_equal(all_images['stat'].get_data(), stat_image.get_data()) assert_array_equal(all_images['p_value'].get_data(), p_image.get_data()) assert_array_equal(all_images['effect_size'].get_data(), effect_image.get_data()) assert_array_equal(all_images['effect_variance'].get_data(), variance_image.get_data()) # formula should work (passing variable name directly) model.compute_contrast('intercept') # or simply pass nothing model.compute_contrast() # passing null contrast should give back a value error assert_raises(ValueError, model.compute_contrast, cnull) # passing wrong parameters assert_raises(ValueError, model.compute_contrast, []) assert_raises(ValueError, model.compute_contrast, c1, None, '') assert_raises(ValueError, model.compute_contrast, c1, None, []) assert_raises(ValueError, model.compute_contrast, c1, None, None, '') # check that passing no explicit contrast when the dsign # matrix has morr than one columns raises an error X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2']) model = model.fit(Y, design_matrix=X) assert_raises(ValueError, model.compute_contrast, None) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del func_img, FUNCFILE, model, X, Y
def test_second_level_model_contrast_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, 'intercept') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol) # smoke test for different contrasts in fixed effects model.compute_contrast(c1) z_image = model.compute_contrast(c1, output_type='z_score') stat_image = model.compute_contrast(c1, output_type='stat') p_image = model.compute_contrast(c1, output_type='p_value') effect_image = model.compute_contrast(c1, output_type='effect_size') variance_image = \ model.compute_contrast(c1, output_type='effect_variance') # Test output_type='all', and verify images are equivalent all_images = model.compute_contrast(c1, output_type='all') assert_array_equal(all_images['z_score'].get_data(), z_image.get_data()) assert_array_equal(all_images['stat'].get_data(), stat_image.get_data()) assert_array_equal(all_images['p_value'].get_data(), p_image.get_data()) assert_array_equal(all_images['effect_size'].get_data(), effect_image.get_data()) assert_array_equal(all_images['effect_variance'].get_data(), variance_image.get_data()) # formula should work (passing variable name directly) model.compute_contrast('intercept') # or simply pass nothing model.compute_contrast() # passing null contrast should give back a value error assert_raises(ValueError, model.compute_contrast, cnull) # passing wrong parameters assert_raises(ValueError, model.compute_contrast, []) assert_raises(ValueError, model.compute_contrast, c1, None, '') assert_raises(ValueError, model.compute_contrast, c1, None, []) assert_raises(ValueError, model.compute_contrast, c1, None, None, '') # check that passing no explicit contrast when the design # matrix has more than one columns raises an error X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2']) model = model.fit(Y, design_matrix=X) assert_raises(ValueError, model.compute_contrast, None) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del func_img, FUNCFILE, model, X, Y
def fit_second_level(models1, contrasts, atlas, dim, split, write_dir): mem = Memory(location=expanduser('cache')) model = SecondLevelModel(n_jobs=1, memory=mem, memory_level=1) model.fit(models1) for contrast in contrasts: for output_type in ['z_score', 'effect_size']: img = model.compute_contrast(first_level_contrast=contrast, output_type=output_type) img.to_filename( join( write_dir, f'{contrast}_{output_type}_{atlas}' f'_{dim}_{split}.nii.gz'))
def test_second_level_model_contrast_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # ols case model = SecondLevelModel(mask=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, 'intercept') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol) # smoke test for different contrasts in fixed effects model.compute_contrast(c1) model.compute_contrast(c1, output_type='z_score') model.compute_contrast(c1, output_type='stat') model.compute_contrast(c1, output_type='p_value') model.compute_contrast(c1, output_type='effect_size') model.compute_contrast(c1, output_type='effect_variance') # formula should work (passing variable name directly) model.compute_contrast('intercept') # or simply pass nothing model.compute_contrast() # passing null contrast should give back a value error assert_raises(ValueError, model.compute_contrast, cnull) # passing wrong parameters assert_raises(ValueError, model.compute_contrast, []) assert_raises(ValueError, model.compute_contrast, c1, None, '') assert_raises(ValueError, model.compute_contrast, c1, None, []) assert_raises(ValueError, model.compute_contrast, c1, None, None, '')
def create_one_sample_t_test(name, maps, output_dir, smoothing_fwhm=6.0): if not op.isdir(output_dir): op.mkdir(output_dir) model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm) design_matrix = pd.DataFrame([1] * len(maps), columns=['intercept']) model = model.fit(maps, design_matrix=design_matrix) z_map = model.compute_contrast(output_type='z_score') nib.save(z_map, op.join(output_dir, "{}_group_zmap.nii.gz".format(name)))
def test_second_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # ols case model = SecondLevelModel(mask=mask) Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4) model = model.fit(Y, design_matrix=X) labels1 = model.labels_ results1 = model.results_ labels2, results2 = run_glm(model.masker_.transform(Y), X, 'ols') assert_almost_equal(labels1, labels2, decimal=1) assert_equal(len(results1), len(results2))
def test_slm_reporting(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) model = SecondLevelModel() Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] report_slm = glmr.make_glm_report(model, c1) # catches & raises UnicodeEncodeError in HTMLDocument.get_iframe() report_iframe = report_slm.get_iframe() # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def test_second_level_model_contrast_computation_with_memory_caching(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask=mask, memory='nilearn_cache') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1 = np.eye(ncol)[0, :] # test memory caching for compute_contrast model.compute_contrast(c1, output_type='z_score') # or simply pass nothing model.compute_contrast()
def do_contrast(con, ROOTDIR, MODEL): """ Input: con is the name of the contrast """ confile = f'{con}_con.nii.gz' spmfile = f'{con}_zmap.nii.gz' cmaps = glob.glob(op.join(ROOTDIR, 'sub*', MODEL, confile)) smaps = glob.glob(op.join(ROOTDIR, 'sub*', MODEL, spmfile)) cmaps.sort() smaps.sort() fig, axes = plt.subplots(nrows=5, ncols=4) for cidx, tmap in enumerate(smaps): plotting.plot_glass_brain(tmap, colorbar=True, threshold=3.1, title=f'{cidx:02d}', axes=axes[int(cidx / 4), int(cidx % 4)], plot_abs=False, display_mode='z') fig.suptitle(f'contrast {con}') #pdf.savefig(fig) second_level_input = cmaps design_matrix = pd.DataFrame([1] * len(second_level_input), columns=['intercept']) second_level_model = SecondLevelModel(smoothing_fwhm=8.0) second_level_model = second_level_model.fit(second_level_input, design_matrix=design_matrix) z_map = second_level_model.compute_contrast(output_type='z_score') nib.save(z_map, f'group_{con}.nii.gz') p_val = 0.001 p001_unc = norm.isf(p_val) display = plotting.plot_glass_brain( z_map, threshold=p001_unc, colorbar=True, display_mode='lzry', plot_abs=False, title=f'group contrasts {con} (unc p<0.001)') display.savefig(f'group_{con}.png') #pdf.savefig() display.close()
def test_second_level_model_contrast_computation_with_memory_caching(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask, memory='nilearn_cache') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1 = np.eye(ncol)[0, :] # test memory caching for compute_contrast model.compute_contrast(c1, output_type='z_score') # or simply pass nothing model.compute_contrast() # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del func_img, FUNCFILE, model, X, Y
def test_high_level_glm_with_paths(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, []) # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] z_image = model.compute_contrast(c1, output_type='z_score') assert_true(isinstance(z_image, Nifti1Image)) assert_array_equal(z_image.affine, load(mask).affine) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def test_high_level_glm_with_paths(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, []) # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] z_image = model.compute_contrast(c1, output_type='z_score') assert_true(isinstance(z_image, Nifti1Image)) assert_array_equal(z_image.affine, load(mask).affine) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def create_one_sample_t_test(name, maps, output_dir, smoothing_fwhm=8.0): if not op.isdir(output_dir): op.mkdir(output_dir) model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm) design_matrix = pd.DataFrame([1] * len(maps), columns=['intercept']) model = model.fit(maps, design_matrix=design_matrix) z_map = model.compute_contrast(output_type='z_score') nibabel.save(z_map, op.join(output_dir, "{}_group_zmap.nii.gz".format(name))) p_val = 0.001 z_th = norm.isf(p_val) z_th = 3.1 display = plotting.plot_glass_brain(z_map, threshold=z_th, colorbar=True, plot_abs=False, display_mode='lzry', title=name) display.savefig(op.join(output_dir, "{}_group_zmap".format(name)))
def anova(db, masker): """perform a big ANOVA of brain activation with three factors: acquisition, subject, contrast""" df = db[(db.acquisition == 'ap') | (db.acquisition == 'pa')] # make the design matrix subject_dmtx, subject_ = design(df.subject) contrast_dmtx, contrast_ = design(df.contrast) acq_dmtx, acq_ = design(df.acquisition) dmtx = np.hstack( (subject_dmtx[:, :-1], contrast_dmtx[:, :-1], acq_dmtx[:, :-1], np.ones((len(df), 1)))) labels = np.hstack( (subject_[:-1], contrast_[:-1], acq_[:-1], ['intercept'])) design_matrix = pd.DataFrame(dmtx, columns=labels) _, singular, _ = np.linalg.svd(design_matrix.values, 0) dof_subject = len(subject_) - 1 dof_contrast = len(contrast_) - 1 dof_acq = len(acq_) - 1 # fit the model from nistats.second_level_model import SecondLevelModel second_level_model = SecondLevelModel(mask=masker.mask_img_) second_level_model = second_level_model.fit(list(df.path.values), design_matrix=design_matrix) subject_map = second_level_model.compute_contrast(np.eye( len(labels))[:dof_subject], output_type='z_score') contrast_map = second_level_model.compute_contrast(np.eye( len(labels))[dof_subject:dof_subject + dof_contrast], output_type='z_score') acq_map = second_level_model.compute_contrast(np.eye( len(labels))[-1 - dof_acq:-1], output_type='z_score') subject_map = math_img('img * (img > -8.2095)', img=subject_map) contrast_map = math_img('img * (img > -8.2095)', img=contrast_map) acq_map = math_img('img * (img > -8.2095)', img=acq_map) return design_matrix, subject_map, contrast_map, acq_map
def test_second_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = _write_fake_fmri_data(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_equal(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_second_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(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_equal(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 create_one_sample_t_test(name, maps, output_dir, smoothing_fwhm=None, vmax=None, design_matrix=None, p_val=0.001, fdr=0.01, loc=0, scale=1, fwhm=6): """ Do a one sample t-test over the maps. """ print('##### ', name, ' #####') model = SecondLevelModel(smoothing_fwhm=smoothing_fwhm, n_jobs=-1) design_matrix = design_matrix if ( design_matrix is not None) else pd.DataFrame([1] * len(maps), columns=['intercept']) model = model.fit(maps, design_matrix=design_matrix) z_map = model.compute_contrast(output_type='z_score') p_val = p_val z_th = norm.isf(p_val, loc=loc, scale=scale) # 3.09 # apply fdr to zmap thresholded_zmap, th = map_threshold(stat_img=z_map, alpha=fdr, height_control='fdr', cluster_threshold=0, two_sided=False) print(z_th, th) # effect size-map eff_map = model.compute_contrast(output_type='effect_size') thr = np.abs(thresholded_zmap.get_data()) return z_map, eff_map, new_img_like(eff_map, (thr > z_th)), (thr > z_th)
def compute_second_level(model1, model2, FWHM=None): """ Compute the group-level significance of the paired difference between two models """ # # compute and save the difference of two models compute_model_difference(model1, model2, FWHM) # compute with the FirstLevelAnalysis code # redefine the mask, without smoothing masker = compute_global_masker(rootdir) # use those different files as input for group-level analysis second_level_input = get_fmri_files( os.path.join(rootdir, first_dir, "diff"), f'{model1}-{model2}') # prepare second level analysis (one sample t-test) design_matrix = pd.DataFrame([1] * len(second_level_input), columns=['intercept']) second_level_model = SecondLevelModel(masker) second_level_model = second_level_model.fit(second_level_input, design_matrix=design_matrix) # estimation the contrast z_map = second_level_model.compute_contrast(output_type='z_score') # save to disk nib.save( z_map, os.path.join(rootdir, second_dir, f"GroupLevel_{model1}-{model2}")) # Get the map of positive values only z_val = masker.transform(z_map) z_val_pos = [val if val > 0 else 0 for val in z_val[0]] z_map_pos = masker.inverse_transform(z_val_pos) return z_map, z_map_pos
############################################################################ # Estimate second level model # --------------------------- # We define the input maps and the design matrix for the second level model # and fit it. import pandas as pd second_level_input = data['cmaps'] design_matrix = pd.DataFrame([1] * len(second_level_input), columns=['intercept']) ############################################################################ # Model specification and fit from nistats.second_level_model import SecondLevelModel second_level_model = SecondLevelModel(smoothing_fwhm=8.0) second_level_model = second_level_model.fit(second_level_input, design_matrix=design_matrix) ########################################################################## # To estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = second_level_model.compute_contrast(output_type='z_score') ########################################################################### # We threshold the second level contrast at uncorrected p < 0.001 and plot from scipy.stats import norm p_val = 0.001 p001_unc = norm.isf(p_val) display = plotting.plot_glass_brain( z_map, threshold=p001_unc, colorbar=True, display_mode='z', plot_abs=False, title='group left-right button press (unc p<0.001')
print("Actual number of subjects after quality check: %d" % n_samples) ############################################################################ # Estimate second level model # --------------------------- # We define the input maps and the design matrix for the second level model # and fit it. import pandas as pd design_matrix = pd.DataFrame(np.hstack((tested_var, np.ones_like(tested_var))), columns=['fluency', 'intercept']) ########################################################################### # Fit of the second-level model from nistats.second_level_model import SecondLevelModel model = SecondLevelModel(smoothing_fwhm=5.0) model.fit(contrast_map_filenames, design_matrix=design_matrix) ########################################################################## # To estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = model.compute_contrast('fluency', output_type='z_score') ########################################################################### # We compute the fdr-corrected p = 0.05 threshold for these data from nistats.thresholding import map_threshold _, threshold = map_threshold(z_map, alpha=.05, height_control='fdr') ########################################################################### # Let us plot the second level contrast at the computed thresholds from nilearn import plotting plotting.plot_stat_map(
############################################################################ # Estimate second level model # --------------------------- # We define the input maps and the design matrix for the second level model # and fit it. import pandas as pd design_matrix = pd.DataFrame( np.hstack((tested_var, np.ones_like(tested_var))), columns=['fluency', 'intercept']) ########################################################################### # Fit of the second-level model from nistats.second_level_model import SecondLevelModel model = SecondLevelModel(smoothing_fwhm=5.0) model.fit(contrast_map_filenames, design_matrix=design_matrix) ########################################################################## # To estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = model.compute_contrast('fluency', output_type='z_score') ########################################################################### # We compute the fdr-corrected p = 0.05 threshold for these data from nistats.thresholding import map_threshold _, threshold = map_threshold(z_map, alpha=.05, height_control='fdr') ########################################################################### # Let us plot the second level contrast at the computed thresholds from nilearn import plotting plotting.plot_stat_map(
columns=['age', 'sex', 'intercept']) ############################################################################# # Plot the design matrix from nistats.reporting import plot_design_matrix ax = plot_design_matrix(design_matrix) ax.set_title('Second level design matrix', fontsize=12) ax.set_ylabel('maps') ########################################################################## # Specify and fit the second-level model when loading the data, we # smooth a little bit to improve statistical behavior from nistats.second_level_model import SecondLevelModel second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img) second_level_model.fit(gray_matter_map_filenames, design_matrix=design_matrix) ########################################################################## # Estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = second_level_model.compute_contrast(second_level_contrast=[1, 0, 0], output_type='z_score') ########################################################################### # We threshold the second level contrast at uncorrected p < 0.001 and plot it. # First compute the threshold. from nistats.thresholding import map_threshold _, threshold = map_threshold(z_map, level=.05, height_control='fdr') print('The FDR=.05-corrected threshold is: %.3g' % threshold) ###########################################################################
plotting.show() ######################################################################### # Second level model estimation # ----------------------------- # We just have to provide the list of fitted FirstLevelModel objects # to the SecondLevelModel object for estimation. We can do this because # all subjects share a similar design matrix (same variables reflected in # column names) from nistats.second_level_model import SecondLevelModel second_level_input = models ######################################################################### # Note that we apply a smoothing of 8mm. second_level_model = SecondLevelModel(smoothing_fwhm=8.0) second_level_model = second_level_model.fit(second_level_input) ######################################################################### # Computing contrasts at the second level is as simple as at the first level # Since we are not providing confounders we are performing an one-sample test # at the second level with the images determined by the specified first level # contrast. zmap = second_level_model.compute_contrast( first_level_contrast='language-string') ######################################################################### # The group level contrast reveals a left lateralized fronto-temporal # language network plotting.plot_glass_brain(zmap, colorbar=True, threshold=p001_unc, title='Group language network (unc p<0.001)', plot_abs=False, display_mode='x')
write_dir = '' sorted_contrasts = '' for task in sorted_contrasts.keys(): task_dir = os.path.join(write_dir, task) if not os.path.exists(task_dir): os.mkdir(task_dir) contrasts = sorted_contrasts[task] n_contrasts = len(contrasts) # First do the random effects glass brain figure for i, contrast in enumerate(contrasts): contrast_mask = (db.contrast.values == contrast) dmtx = pd.DataFrame(np.ones(np.sum(contrast_mask))) glm.fit(list(db.path[contrast_mask].values), design_matrix=dmtx) grp_stat = glm.compute_contrast([1], stat_type='t', output_type='z_score') plotting.plot_glass_brain( grp_stat, display_mode='z', title=BETTER_NAMES[contrast], threshold=3., vmax=8, plot_abs=False, black_bg=True, output_file='/tmp/rfx_%s.png' % contrast) plt.figure(figsize=(7, 2 * n_contrasts + 1), facecolor='k', edgecolor='k') delta = (4 * n_contrasts - 1.) / (4 * n_contrasts ** 2) for i, contrast in enumerate(contrasts): ax = plt.axes([0., 1 - (i + 1) * delta, 1., delta], axisbg='k') ax.imshow(mpimg.imread('/tmp/rfx_%s.png' % contrast)) plt.axis('off') ax = plt.axes([0.02, 0.0, .8, 1./ (8 * n_contrasts)], axisbg='k') _draw_colorbar(ax, vmax=8, offset=3., orientation='horizontal', fontsize=14) ax = plt.axes([0.84, .01, .15, 1./ (8 * n_contrasts)], axisbg='k')
def main(sourcedata, derivatives, subject, session, tmp_dir): sourcedata_layout = BIDSLayout(sourcedata) sourcedata_df = sourcedata_layout.as_data_frame() events = sourcedata_df[(sourcedata_df['type'] == 'events') & (sourcedata_df['subject'] == subject) & (sourcedata_df['session'] == session)] derivatives_layout = BIDSLayout( os.path.join(derivatives, 'spynoza_mc_mutualinfo')) derivatives_df = derivatives_layout.as_data_frame() bold = derivatives_df[(derivatives_df['type'] == 'preproc') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] confounds = derivatives_df[(derivatives_df['type'] == 'confounds') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] print(derivatives_df.type.unique()) mask = derivatives_layout.get(subject=subject, session=session, type='mask', return_type='file')[0] df = events.merge(bold, on=['subject', 'session', 'run'], suffixes=('_events', '_bold')) confounds = confounds.rename(columns={'path': 'confounds'}) df = df.merge(confounds[['subject', 'session', 'run', 'confounds']]) models = [] for ix, row in df.iterrows(): results_dir = os.path.join(derivatives, 'modelfitting', 'glm4', 'sub-{}'.format(row['subject'])) if 'session' in row: results_dir = os.path.join(results_dir, 'ses-{}'.format(row['session'])) os.makedirs(results_dir, exist_ok=True) confounds = pd.read_table(row.confounds).fillna(method='bfill') print('Fitting {}'.format(row['path_bold'])) model = FirstLevelModel(t_r=4, mask=mask) paradigm = pd.read_table(row['path_events']) model.fit(row['path_bold'], paradigm, confounds=confounds) left_right = model.compute_contrast('eye_L - eye_R', output_type='z_score') left_right.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session'], row['run']))) left_right = model.compute_contrast('eye_L - eye_R', output_type='effect_size') left_right.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_left_over_right_psc.nii.gz'.format( row['subject'], row['session'], row['run']))) models.append(model) second_level_model = SecondLevelModel(mask=mask) second_level_model.fit(models) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye_L - eye_R', output_type='z_score') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session']))) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye_L - eye_R', output_type='effect_size') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_effect_size.nii.gz'.format( row['subject'], row['session']))) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye_L - eye_R', output_type='z_score') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session'])))
def main(derivatives, ds): if ds == 'ds-01': subjects = ['{:02d}'.format(s) for s in range(1, 20)] elif ds == 'ds-02': subjects = ['{:02d}'.format(s) for s in range(1, 16)] subjects.pop(3) # Remove 4 models = [] for subject in subjects: print('subject {}'.format(subject)) runs = ['{:02d}'.format(i) for i in range(1, 4)] if ds == 'ds-01': if subject == '06': runs = ['{:02d}'.format(i) for i in range(1, 3)] elif ds == 'ds-02': if subject == '07': runs = ['{:02d}'.format(i) for i in range(1, 3)] include = [ u'dvars', u'framewise_displacement', u'a_comp_cor_00', u'a_comp_cor_01', u'a_comp_cor_02', u'a_comp_cor_03', u'a_comp_cor_04', u'a_comp_cor_05', u'cosine00', u'cosine01', u'cosine02', u'cosine03', u'cosine04', u'cosine05', u'cosine06', u'cosine07', u'cosine08', u'cosine09', u'cosine10', u'cosine11', u'cosine12', u'cosine13', u'cosine14', u'cosine15', u'trans_x', u'trans_y', u'trans_z', u'rot_x', u'rot_y', u'rot_z' ] images = [] confounds = [] behavior = [] masks = [] for run in runs: masks.append( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz' ).format(**locals())) images.append( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz' ).format(**locals())) confounds.append( pd.read_table( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_desc-confounds_regressors.tsv' ).format(**locals()))) behavior.append( pd.read_table( op.join( derivatives, ds, 'event_files', 'sub-{subject}_task-randomdotmotion_run-{run}_events.tsv' ).format(**locals()))) behavior[-1]['duration'] = None confounds = [c[include].fillna(method='bfill') for c in confounds] model = FirstLevelModel( t_r=3, mask=masks[0], drift_model=None, # Already done by fmriprep smoothing_fwhm=5.0, hrf_model='spm + derivative', n_jobs=10, subject_label=subject) model.fit(images, behavior, confounds) print(model.design_matrices_[0].columns) difficulty = model.compute_contrast('hard - easy', output_type='z_score') left_right_cue = model.compute_contrast('cue_left - cue_right', output_type='z_score') left_right_response = model.compute_contrast( 'response_left - response_right', output_type='z_score') error = model.compute_contrast('error', output_type='z_score') cue = model.compute_contrast('cue_left + cue_right - 2 * cue_neutral') template = op.join(derivatives, ds, 'glm', 'individual_zmaps', 'sub-{subject}_desc-{contrast}_contrast.nii.gz') difficulty.to_filename( template.format(subject=subject, contrast='difficulty')) left_right_cue.to_filename( template.format(subject=subject, contrast='left_right_cue')) left_right_response.to_filename( template.format(subject=subject, contrast='left_right_response')) error.to_filename(template.format(subject=subject, contrast='error')) cue.to_filename(template.format(subject=subject, contrast='cue')) models.append(model) mask = fsl.Info.standard_image('MNI152_T1_2mm_brain_mask.nii.gz') model2 = SecondLevelModel(mask) model2.fit(models) difficulty = model2.compute_contrast(first_level_contrast='hard - easy', output_type='z_score') left_right_cue = model2.compute_contrast( first_level_contrast='cue_left - cue_right', output_type='z_score') left_right_response = model2.compute_contrast( first_level_contrast='response_left - response_right', output_type='z_score') error = model2.compute_contrast(first_level_contrast='error', output_type='z_score') cue = model2.compute_contrast( first_level_contrast='cue_left + cue_right - 2 * cue_neutral', output_type='z_score') template = op.join(derivatives, ds, 'glm', 'sub-{subject}_desc-{contrast}_contrast.nii.gz') difficulty.to_filename( template.format(subject='group', contrast='difficulty')) left_right_cue.to_filename( template.format(subject='group', contrast='left_right_cue')) left_right_response.to_filename( template.format(subject='group', contrast='left_right_response')) error.to_filename(template.format(subject='group', contrast='error')) cue.to_filename(template.format(subject='group', contrast='cue'))
confounds = confounds.groupby('dataset').transform( lambda x: (x - x.mean()) / x.std()) confounds['subject_label'] = confounds.apply( lambda row: '{}.{}'.format(row.name[0], row.name[1]), 1) confounds['ds'] = confounds.index.get_level_values('dataset').map({ 'ds-01': 0, 'ds-02': 1 }) confounds = confounds.reset_index(drop=True) model2 = SecondLevelModel(mask) model2.fit(models, confounds=confounds) glm_dir = op.join(derivatives, 'both', 'modelfitting', 'glm_5', 'shift-{}'.format(shift)) if not op.exists(glm_dir): os.makedirs(glm_dir) keys = [ 'difficulty', 'cue', 'cue_left_right', 'error_difficulty', 'error_bias', 'left_minus_right' ] first_level_contrasts = [ 'hard - easy', 'cue_left - cue_right', 'cue_left + cue_right - 2 * cue_neutral', 'error', 'error', 'response_left - response_right'
def main(derivatives, ds): if ds == 'ds-01': subjects = ['{:02d}'.format(s) for s in range(1, 20)] elif ds == 'ds-02': subjects = ['{:02d}'.format(s) for s in range(1, 16)] subjects.pop(3) # Remove 4 models = [] for subject in subjects: print('subject {}'.format(subject)) runs = ['{:02d}'.format(i) for i in range(1, 4)] if ds == 'ds-01': if subject == '06': runs = ['{:02d}'.format(i) for i in range(1, 3)] elif ds == 'ds-02': if subject == '07': runs = ['{:02d}'.format(i) for i in range(1, 3)] include = [ u'dvars', u'framewise_displacement', u'a_comp_cor_00', u'a_comp_cor_01', u'a_comp_cor_02', u'a_comp_cor_03', u'a_comp_cor_04', u'a_comp_cor_05', u'cosine00', u'cosine01', u'cosine02', u'cosine03', u'cosine04', u'cosine05', u'cosine06', u'cosine07', u'cosine08', u'cosine09', u'cosine10', u'cosine11', u'cosine12', u'cosine13', u'cosine14', u'cosine15', u'trans_x', u'trans_y', u'trans_z', u'rot_x', u'rot_y', u'rot_z' ] images = [] confounds = [] behavior = [] masks = [] for run in runs: masks.append( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_space-MNI152NLin2009cAsym_desc-brain_mask.nii.gz' ).format(**locals())) images.append( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz' ).format(**locals())) confounds.append( pd.read_table( op.join( derivatives, ds, 'fmriprep', 'sub-{subject}', 'func', 'sub-{subject}_task-randomdotmotion_run-{run}_desc-confounds_regressors.tsv' ).format(**locals()))) behavior.append( pd.read_table( op.join( derivatives, ds, 'event_files', 'sub-{subject}_task-randomdotmotion_run-{run}_events.tsv' ).format(**locals()))) behavior[-1]['duration'] = None confounds = [c[include].fillna(method='bfill') for c in confounds] model = FirstLevelModel( t_r=3, mask=masks[0], drift_model=None, # Already done by fmriprep smoothing_fwhm=5.0, hrf_model='spm + derivative', n_jobs=10, subject_label='{}.{}'.format(ds, subject)) model.fit(images, behavior, confounds) models.append(model) mask = fsl.Info.standard_image('MNI152_T1_2mm_brain_mask.nii.gz') confounds = pd.read_pickle( op.join(derivatives, 'all_subjectwise_parameters.pkl')) confounds = confounds[['ddm difficulty_effect', 'ddm z_cue_regressor']] confounds = confounds.groupby('dataset').transform( lambda x: (x - x.mean()) / x.std()) confounds['subject_label'] = confounds.apply( lambda row: '{}.{}'.format(row.name[0], row.name[1]), 1) #confounds['ds'] = confounds.index.get_level_values('dataset').map({'ds-01':0, 'ds-02':1}) confounds = confounds.reset_index(drop=True) model2 = SecondLevelModel(mask) model2.fit(models, confounds=confounds) glm_dir = op.join(derivatives, ds, 'modelfitting', 'glm_3') if not op.exists(glm_dir): os.makedirs(glm_dir) keys = ['difficulty', 'cue', 'cue_left_right', 'error'] first_level_contrasts = [ 'hard - easy', 'cue_left - cue_right', 'cue_left + cue_right - 2 * cue_neutral', 'error' ] second_level_contrasts = [ 'ddm difficulty_effect', 'ddm z_cue_regressor', 'ddm z_cue_regressor', 'ddm difficulty_effect' ] for key, fl, sl in zip(keys, first_level_contrasts, second_level_contrasts): for sl_ in ['intercept', sl]: contrast = model2.compute_contrast(first_level_contrast=fl, second_level_contrast=sl_, output_type='z_score') contrast.to_filename( op.join(glm_dir, '{}_{}_zmap.nii.gz'.format(key, sl_)))
############################################################################ # Estimate second level model # --------------------------- # We define the input maps and the design matrix for the second level model # and fit it. import pandas as pd second_level_input = data['cmaps'] design_matrix = pd.DataFrame([1] * len(second_level_input), columns=['intercept']) ############################################################################ # Model specification and fit from nistats.second_level_model import SecondLevelModel second_level_model = SecondLevelModel(smoothing_fwhm=8.0) second_level_model = second_level_model.fit(second_level_input, design_matrix=design_matrix) ########################################################################## # To estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = second_level_model.compute_contrast(output_type='z_score') ########################################################################### # We threshold the second level contrast at uncorrected p < 0.001 and plot from scipy.stats import norm p_val = 0.001 p001_uncorrected = norm.isf(p_val) from nistats.thresholding import cluster_level_inference proportion_true_discoveries_img = cluster_level_inference(z_map, threshold=[3, 4, 5],
img = resample_to_img(filelist[i], template) else: img = load_img(filelist[i]) imgs.append(math_img('img * np.sqrt(%d)' % nvol, img=img)) # Create mask (containing only voxels with values in at least half of the images) img_concat = concat_imgs(imgs) mask = np.sum(img_concat.get_data()!=0, axis=-1)>=(img_concat.shape[-1] * 0.8) mask = binary_fill_holes( binary_dilation(binary_erosion(mask, iterations=2), iterations=2)) group_mask = new_img_like(img_concat, mask.astype('int'), copy_header=True) # Create 2nd-level model design_matrix = design_matrix = pd.get_dummies(method_id) second_level_model = SecondLevelModel(n_jobs=-1, mask=group_mask) second_level_model = second_level_model.fit(imgs, design_matrix=design_matrix) # Compute contrasts, save nifti and plot glass brain weights = [ [1, 0, 0, 0, 0], [1,-1, 0, 0, 0], [1, 0,-1, 0, 0], [1, 0, 0,-1, 0], [1, 0, 0, 0,-1], [-1, 1, 0, 0, 0], [0, 1, 0, 0, 0], [0, 1,-1, 0, 0], [0, 1, 0,-1, 0], [0, 1, 0, 0,-1], [-1, 0, 1, 0, 0], [0,-1, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1,-1, 0], [0, 0, 1, 0,-1], [-1, 0, 0, 1, 0], [0,-1, 0, 1, 0], [0, 0,-1, 1, 0], [0, 0, 0, 1, 0], [0, 0, 0, 1,-1], [-1, 0, 0, 0, 1], [0,-1, 0, 0, 1], [0, 0,-1, 0, 1], [0, 0, 0,-1, 1], [0, 0, 0, 0, 1]] for i, w in enumerate(weights): # Estimate contrast z_map = second_level_model.compute_contrast( second_level_contrast=w, second_level_stat_type='t', output_type='z_score') #z_map.to_filename(res_path + '/tsnr/tsnr_%04d.nii.gz' % (i + 1))
columns=['age', 'sex', 'intercept']) ############################################################################# # Plot the design matrix from nistats.reporting import plot_design_matrix ax = plot_design_matrix(design_matrix) ax.set_title('Second level design matrix', fontsize=12) ax.set_ylabel('maps') ########################################################################## # Specify and fit the second-level model when loading the data, we # smooth a little bit to improve statistical behavior from nistats.second_level_model import SecondLevelModel second_level_model = SecondLevelModel(smoothing_fwhm=2.0, mask=mask_img) second_level_model.fit(gray_matter_map_filenames, design_matrix=design_matrix) ########################################################################## # Estimate the contrast is very simple. We can just provide the column # name of the design matrix. z_map = second_level_model.compute_contrast(second_level_contrast=[1, 0, 0], output_type='z_score') ########################################################################### # We threshold the second level contrast at uncorrected p < 0.001 and plot it. # First compute the threshold. from nistats.thresholding import map_threshold _, threshold = map_threshold( z_map, level=.05, height_control='fdr') print('The FDR=.05-corrected threshold is: %.3g' % threshold)
def main(sourcedata, derivatives, subject, session, tmp_dir): sourcedata_layout = BIDSLayout(sourcedata) sourcedata_df = sourcedata_layout.as_data_frame() events = sourcedata_df[(sourcedata_df['type'] == 'events') & (sourcedata_df['subject'] == subject) & (sourcedata_df['session'] == session)] derivatives_layout = BIDSLayout(os.path.join(derivatives, 'spynoza')) derivatives_df = derivatives_layout.as_data_frame() bold = derivatives_df[(derivatives_df['type'] == 'preproc') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] mask = derivatives_layout.get(subject=subject, session=session, type='mask', return_type='file')[0] mask = image.math_img('(im > .5).astype(int)', im=mask) print(mask) df = events.merge(bold, on=['subject', 'session', 'run'], suffixes=('_events', '_bold')) models = [] for ix, row in df.iterrows(): results_dir = os.path.join(derivatives, 'modelfitting', 'sub-{}'.format(row['subject'])) if 'session' in row: results_dir = os.path.join(results_dir, 'ses-{}'.format(row['session'])) os.makedirs(results_dir, exist_ok=True) print('Fitting {}'.format(row['path_bold'])) model = FirstLevelModel(t_r=4, mask=mask) paradigm = pd.read_table(row['path_events']) paradigm_short = paradigm.copy() paradigm_short['duration'] = 1 paradigm_short['trial_type'] = paradigm_short['trial_type'].map( lambda x: '{}_instant'.format(x)) paradigm = pd.concat((paradigm, paradigm_short)) model.fit(row['path_bold'], paradigm) left_right = model.compute_contrast('eye_L - eye_R', output_type='z_score') left_right.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session'], row['run']))) left_right = model.compute_contrast('eye_L - eye_R', output_type='effect_size') left_right.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_left_over_right_psc.nii.gz'.format( row['subject'], row['session'], row['run']))) eye_l_instant = model.compute_contrast('eye_L_instant', output_type='z_score') eye_l_instant.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_eye_l_instant_zmap.nii.gz'.format( row['subject'], row['session'], row['run']))) eye_l_instant = model.compute_contrast('eye_L_instant', output_type='effect_size') eye_l_instant.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_eye_l_instant_effect_size.nii.gz'.format( row['subject'], row['session'], row['run']))) eye_r_instant = model.compute_contrast('eye_R_instant', output_type='z_score') eye_r_instant.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_eye_r_instant_zmap.nii.gz'.format( row['subject'], row['session'], row['run']))) eye_r_instant = model.compute_contrast('eye_R_instant', output_type='effect_size') eye_r_instant.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_run-{}_eye_R_instant_effect_size.nii.gz'.format( row['subject'], row['session'], row['run']))) models.append(model) second_level_model = SecondLevelModel(mask=mask) second_level_model.fit(models) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye_L - eye_R', output_type='z_score') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session']))) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye_L - eye_R', output_type='effect_size') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_effect_size.nii.gz'.format( row['subject'], row['session'])))
def main(sourcedata, derivatives, subject, session, tmp_dir): sourcedata_layout = BIDSLayout(sourcedata) sourcedata_df = sourcedata_layout.as_data_frame() events = sourcedata_df[(sourcedata_df['suffix'] == 'events') & (sourcedata_df['subject'] == subject) & (sourcedata_df['session'] == session)] derivatives_layout = BIDSLayout(os.path.join(derivatives), validate=False) derivatives_df = derivatives_layout.as_data_frame() bold = derivatives_df[(derivatives_df['suffix'] == 'preproc') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] confounds = derivatives_df[(derivatives_df['suffix'] == 'confounds') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] compcor = derivatives_df[(derivatives_df['suffix'] == 'compcor') & (derivatives_df['subject'] == subject) & (derivatives_df['session'] == session)] mask = derivatives_layout.get(subject=subject, session=session, suffix='mask', return_type='file')[0] df = events.merge(bold, on=['subject', 'session', 'run'], suffixes=('_events', '_bold')) confounds = confounds.rename(columns={'path': 'confounds'}) df = df.merge(confounds[['subject', 'session', 'run', 'confounds']]) compcor = compcor.rename(columns={'path': 'compcor'}) df = df.merge(compcor[['subject', 'session', 'run', 'compcor']]) df.sort_values('run', inplace=True) print(df.iloc[0]) models = [] for ix, row in df.iterrows(): results_dir = os.path.join(derivatives, 'modelfitting', 'glm8', 'sub-{}'.format(row['subject'])) if 'session' in row: results_dir = os.path.join(results_dir, 'ses-{}'.format(row['session'])) results_dir = op.join(results_dir, 'func') os.makedirs(results_dir, exist_ok=True) confounds = pd.read_table(row.confounds).fillna(method='bfill') compcor = pd.read_table(row.compcor).fillna(method='bfill') confounds = pd.concat((confounds, compcor), 1) confounds -= confounds.mean() confounds /= confounds.std() pca = decomposition.PCA(n_components=6) confounds_trans = pd.DataFrame( pca.fit_transform(confounds), columns=['pca_{}'.format(i) for i in range(6)]) print('Fitting {}'.format(row['path_bold'])) model = FirstLevelModel(t_r=4, signal_scaling=False, subject_label=int(row['run']), mask_img=mask) paradigm = pd.read_table(row['path_events']) paradigm_ = paradigm.copy() paradigm['trial_type'] = 'stimulation' paradigm['modulation'] = 1 paradigm_['modulation'] = paradigm_.trial_type.map({ 'eye_L': 1, 'eye_R': -1 }) paradigm_['trial_type'] = 'eye' paradigm = pd.concat((paradigm, paradigm_), ignore_index=True) model.fit(row['path_bold'], paradigm, confounds=confounds_trans) row['run'] = int(row['run']) row = dict(row) left_right = model.compute_contrast('eye', output_type='z_score') left_right.to_filename( os.path.join( results_dir, 'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_left_over_right_zmap.nii.gz' .format(**row))) left_right = model.compute_contrast('eye', output_type='effect_size') left_right.to_filename( os.path.join( results_dir, 'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_left_over_right_psc.nii.gz' .format(**row))) stimulation = model.compute_contrast('stimulation', output_type='effect_size') stimulation.to_filename( os.path.join( results_dir, 'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_stimulation_psc.nii.gz' .format(**row))) stimulation = model.compute_contrast('stimulation', output_type='z_score') stimulation.to_filename( os.path.join( results_dir, 'sub-{subject}_ses-{session}_task-{task_events}_run-{run:02d}_stimulation_zmap.nii.gz' .format(**row))) models.append(model) second_level_model = SecondLevelModel(mask_img=mask) second_level_model.fit(models) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye', output_type='z_score') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format( row['subject'], row['session']))) left_right_group = second_level_model.compute_contrast( first_level_contrast='eye', output_type='effect_size') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_left_over_right_effect_size.nii.gz'.format( row['subject'], row['session']))) stimulation_group = second_level_model.compute_contrast( first_level_contrast='stimulation', output_type='z_score') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_stimulation_zmap.nii.gz'.format( row['subject'], row['session']))) stimulation_group = second_level_model.compute_contrast( first_level_contrast='stimulation', output_type='effect_size') left_right_group.to_filename( os.path.join( results_dir, 'sub-{}_ses-{}_stimulation_effect_size.nii.gz'.format( row['subject'], row['session'])))
axes=axes[int(midx / 5), int(midx % 5)], plot_abs=False, display_mode='x') fig.suptitle('subjects z_map language network (unc p<0.001)') plt.show() ######################################################################### # Second level model estimation # ----------------------------- # We just have to provide the list of fitted FirstLevelModel objects # to the SecondLevelModel object for estimation. We can do this since # all subjects share the same design matrix. second_level_input = models second_level_model = SecondLevelModel(smoothing_fwhm=8.0) second_level_model = second_level_model.fit(second_level_input) ######################################################################### # Computing contrasts at the second level is as simple as at the first level # Since we are not providing confounders we are performing an one-sample test # at the second level with the images determined by the specified first level # contrast. zmap = second_level_model.compute_contrast( first_level_contrast='language-string') ######################################################################### # The group level contrast of the language network is mostly left # lateralized as expected plotting.plot_glass_brain(zmap, colorbar=True, threshold=norm.isf(0.001),
verbose=100, n_jobs=1, minimize_memory=True) for con in ['left_hand-right_hand' ]: #['incongruent-congruent', 'incorrect-correct']: if con == 'incorrect-correct': models = [] for model in fl_models: if 'incorrect' in model.design_matrices_[0]: models.append(model) else: models = fl_models slm.fit(models) print("Computing %s contrast ..." % con) zmap = slm.compute_contrast(second_level_contrast=None, first_level_contrast=con, second_level_stat_type='t', output_type='z_score') zmap_thr = map_threshold(stat_img=zmap, mask_img=None, level=0.05, height_control='fdr', cluster_threshold=0)[0] zmap.to_filename(op.join(sl_dir, 'zmap_%s.nii.gz' % con)) zmap_thr.to_filename(op.join(sl_dir, 'zmap_thr_%s.nii.gz' % con))
del fname_atts['sub'] del fname_atts['task'] fname_atts['con'] = "face" fname_atts['val2'] = "z" fname_atts['correction'] = "none" if 'extra' in fname_atts.keys(): fname_atts.move_to_end('extra') # setup model model = SecondLevelModel(mask=mni_mask_dil_img, smoothing_fwhm=5.0) design_matrix = pd.DataFrame([1] * len(data_fnames), columns=['intercept']) con_name = 'intercept' print("Using design matrix: ") print(design_matrix) # save z map model = model.fit(data_fnames, design_matrix=design_matrix) z_map = model.compute_contrast(con_name, output_type='z_score') out_fname = os.path.join(out_dir, make_bids_str(fname_atts)) nib.save(z_map, out_fname) print(out_fname + ' saved.') threshold = 3.1 #3.1 # correponds to p < .001, uncorrected display = plotting.plot_glass_brain(z_map, threshold=threshold, colorbar=True, plot_abs=False, output_file=out_fname, title='z map') # save p map p_val = model.compute_contrast(con_name, output_type='p_value') fname_atts['val2'] = "p" out_fname = os.path.join(out_dir, make_bids_str(fname_atts))