def test_calc_beta_map(sub_metadata, preproc_file, sub_events, confounds_file, brainmask_file, hrf_model, return_tstat): model = first_level_model.FirstLevelModel( t_r=2, slice_time_ref=0, hrf_model=hrf_model, mask=str(brainmask_file), smoothing_fwhm=0, signal_scaling=False, high_pass=0.008, drift_model='cosine', verbose=1, minimize_memory=False, ) lsa_df = _lsa_events_converter(str(sub_events)) model.fit(str(preproc_file), events=lsa_df) i_trial = lsa_df.index[0] t_name = lsa_df.loc[i_trial, 'trial_type'] beta_map = _calc_beta_map(model, t_name, hrf_model, return_tstat) assert beta_map.shape == nib.load(str(brainmask_file)).shape
def _run_interface(self, runtime): from nistats import first_level_model import nibabel as nib import pandas as pd import numpy as np # get t_r from bold_metadata t_r = self.inputs.bold_metadata['RepetitionTime'] # get the confounds: if self.inputs.confounds_file and self.inputs.selected_confounds: confounds = _select_confounds(self.inputs.confounds_file, self.inputs.selected_confounds) else: confounds = None # high_pass, switch from Hz to Period high_pass_period = int(1 / self.inputs.high_pass) # setup the model model = first_level_model.FirstLevelModel( t_r=t_r, slice_time_ref=0, hrf_model=self.inputs.hrf_model, mask=self.inputs.mask_file, smoothing_fwhm=self.inputs.smoothing_kernel, standardize=False, signal_scaling=0, period_cut=high_pass_period, drift_model='cosine', verbose=1, ) events_df = pd.read_csv(self.inputs.events_file, sep="\t") trial_types = events_df['trial_types'].unique() model.fit(self.inputs.bold_file, events=events_df, confounds=confounds) design_matrix = model.design_matrices_[0] bold_img = nib.load(self.inputs.bold_file) predicted_out = np.zeros(bold_img.shape) for trial_type in trial_types: beta_map = model.compute_contrast(trial_type, output_type='effect_size') beta_map_ex = np.expand_dims(beta_map, axis=3) design_series = design_matrix[trial_type] brain_map = np.tile(design_series, bold_img.shape) predicted_out += beta_map_ex * brain_map fname = "predicted_task_bold.nii.gz" bold_img.__class__(predicted_out, bold_img.affine, bold_img.header).to_filename(fname) self._results['predicted_bold'] = fname return runtime
def _run_interface(self, runtime): import nibabel as nb from nistats import first_level_model as level1 mat = pd.read_csv(self.inputs.design_matrix, delimiter='\t', index_col=0) img = nb.load(self.inputs.bold_file) mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None smoothing_fwhm = self.inputs.smoothing_fwhm if not isdefined(smoothing_fwhm): smoothing_fwhm = None flm = level1.FirstLevelModel(mask_img=mask_file, smoothing_fwhm=smoothing_fwhm) flm.fit(img, design_matrices=mat) effect_maps = [] variance_maps = [] stat_maps = [] zscore_maps = [] pvalue_maps = [] contrast_metadata = [] out_ents = self.inputs.contrast_info[0]['entities'] fname_fmt = os.path.join(runtime.cwd, '{}_{}.nii.gz').format for name, weights, contrast_type in prepare_contrasts( self.inputs.contrast_info, mat.columns.tolist()): contrast_metadata.append({ 'contrast': name, 'stat': contrast_type, **out_ents }) maps = flm.compute_contrast(weights, contrast_type, output_type='all') for map_type, map_list in (('effect_size', effect_maps), ('effect_variance', variance_maps), ('z_score', zscore_maps), ('p_value', pvalue_maps), ('stat', stat_maps)): fname = fname_fmt(name, map_type) maps[map_type].to_filename(fname) map_list.append(fname) self._results['effect_maps'] = effect_maps self._results['variance_maps'] = variance_maps self._results['stat_maps'] = stat_maps self._results['zscore_maps'] = zscore_maps self._results['pvalue_maps'] = pvalue_maps self._results['contrast_metadata'] = contrast_metadata return runtime
def _run_interface(self, runtime): info = self.inputs.session_info img = nb.load(self.inputs.bold_file) vols = img.shape[3] if info['sparse'] not in (None, 'None'): sparse = pd.read_hdf(info['sparse'], key='sparse').rename( columns={'condition': 'trial_type', 'amplitude': 'modulation'}) sparse = sparse.dropna(subset=['modulation']) # Drop NAs else: sparse = None if info['dense'] not in (None, 'None'): dense = pd.read_hdf(info['dense'], key='dense') column_names = dense.columns.tolist() drift_model = None if 'cosine_00' in column_names else 'cosine' else: dense = None column_names = None drift_model = 'cosine' mat = dm.make_first_level_design_matrix( frame_times=np.arange(vols) * info['repetition_time'], events=sparse, add_regs=dense, add_reg_names=column_names, drift_model=drift_model, ) mat.to_csv('design.tsv', sep='\t') self._results['design_matrix'] = os.path.join(runtime.cwd, 'design.tsv') mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None smoothing_fwhm = self.inputs.smoothing_fwhm if not isdefined(smoothing_fwhm): smoothing_fwhm = None flm = level1.FirstLevelModel( mask=mask_file, smoothing_fwhm=smoothing_fwhm) flm.fit(img, design_matrices=mat) contrast_maps = [] contrast_metadata = [] out_ents = self.inputs.contrast_info[0]['entities'] for name, weights, type in prepare_contrasts( self.inputs.contrast_info, mat.columns.tolist()): es = flm.compute_contrast( weights, type, output_type='effect_size') es_fname = os.path.join( runtime.cwd, '{}.nii.gz').format(name) es.to_filename(es_fname) contrast_maps.append(es_fname) contrast_metadata.append( {'contrast': name, 'suffix': 'effect', **out_ents} ) self._results['contrast_maps'] = contrast_maps self._results['contrast_metadata'] = contrast_metadata return runtime
def first_level(analysis, block, space, deriv_dir): analyses = [] for paradigm, _, ents in block.get_design_matrix(block.model['HRF_variables'], mode='sparse'): preproc_files = analysis.layout.get(type='preproc', space=space, **ents) if len(preproc_files) == 0: raise ValueError("No PREPROC files found") if len(preproc_files) != 1: print(preproc_files) raise ValueError("Too many potential PREPROC files") fname = preproc_files[0].filename img = nb.load(fname) TR = img.header.get_zooms()[3] vols = img.shape[3] # Get dense portion of design matrix once TR is known _, confounds, _ = block.get_design_matrix(mode='dense', sampling_rate=1/TR, **ents)[0] names = [col for col in confounds.columns if col.startswith('NonSteadyStateOutlier') or col in block.model['variables']] mat = dm.make_design_matrix( frame_times=np.arange(vols) * TR, paradigm=paradigm.rename(columns={'condition': 'trial_type', 'amplitude': 'modulation'}), add_regs=confounds[names].fillna(0), add_reg_names=names, drift_model=None if 'Cosine00' in names else 'cosine', ) preproc_ents = analysis.layout.parse_file_entities(fname) dm_ents = {k: v for k, v in preproc_ents.items() if k in ('subject', 'session', 'task')} dm_ents['type'] = 'design' design_fname = op.join(deriv_dir, analysis.layout.build_path(dm_ents, strict=True)) os.makedirs(op.dirname(design_fname), exist_ok=True) mat.to_csv(design_fname, sep='\t') plt.set_cmap('viridis') plot_and_save(design_fname.replace('.tsv', '.svg'), nis.reporting.plot_design_matrix, mat) corr_ents = dm_ents.copy() corr_ents['type'] = 'corr' corr_fname = op.join(deriv_dir, analysis.layout.build_path(corr_ents, strict=True)) plot_and_save(corr_fname, plot_corr_matrix, mat.drop(columns=['constant']).corr(), len(block.model['HRF_variables'])) job_desc = { 'ents': ents, 'subject_id': ents['subject'], 'dataset': analysis.layout.root, 'model_name': analysis.model['name'], 'design_matrix_svg': design_fname.replace('.tsv', '.svg'), 'correlation_matrix_svg': corr_fname, } cnames = [contrast['name'] for contrast in block.contrasts] + block.model['HRF_variables'] contrast_matrix = [] if cnames: contrasts_ents = corr_ents.copy() contrasts_ents['type'] = 'contrasts' contrasts_fname = op.join( deriv_dir, analysis.layout.build_path(contrasts_ents, strict=True)) contrast_matrix = expand_contrast_matrix( block.get_contrasts(cnames, **ents)[0][0], mat) plot_and_save(contrasts_fname, plot_contrast_matrix, contrast_matrix.drop(['constant'], 'index'), ornt='horizontal') job_desc['contrasts_svg'] = contrasts_fname brainmask = analysis.layout.get(type='brainmask', space=space, **ents)[0] fmri_glm = None for contrast in contrast_matrix: stat_ents = preproc_ents.copy() stat_ents.pop('modality', None) stat_ents.update({'contrast': snake_to_camel(contrast), 'type': 'stat'}) stat_fname = op.join(deriv_dir, analysis.layout.build_path(stat_ents, strict=True)) ortho_ents = stat_ents.copy() ortho_ents['type'] = 'ortho' ortho_fname = op.join(deriv_dir, analysis.layout.build_path(ortho_ents, strict=True)) desc = {'name': contrast, 'image_file': ortho_fname} if contrast not in block.model['HRF_variables']: job_desc.setdefault('contrasts', []).append(desc) else: job_desc.setdefault('estimates', []).append(desc) if op.exists(stat_fname): continue if fmri_glm is None: fmri_glm = level1.FirstLevelModel(mask=brainmask.filename) fmri_glm.fit(fname, design_matrices=mat) stat_types = [c['type'] for c in block.contrasts if c['name'] == contrast] stat_type = stat_types[0] if stat_types else 'T' stat = fmri_glm.compute_contrast(contrast_matrix[contrast].values, {'T': 't', 'F': 'F'}[stat_type]) stat.to_filename(stat_fname) nlp.plot_glass_brain(stat, colorbar=True, plot_abs=False, display_mode='lyrz', axes=None, output_file=ortho_fname) analyses.append(job_desc) return analyses
def _run_interface(self, runtime): import nibabel as nb from nistats import first_level_model as level1 mat = pd.read_csv(self.inputs.design_matrix, delimiter='\t', index_col=0) img = nb.load(self.inputs.bold_file) if isinstance(img, nb.dataobj_images.DataobjImage): # Ugly hack to ensure that retrieved data isn't cast to float64 unless # necessary to prevent an overflow # For NIfTI-1 files, slope and inter are 32-bit floats, so this is # "safe". For NIfTI-2 (including CIFTI-2), these fields are 64-bit, # so include a check to make sure casting doesn't lose too much. slope32 = np.float32(img.dataobj._slope) inter32 = np.float32(img.dataobj._inter) if max(np.abs(slope32 - img.dataobj._slope), np.abs(inter32 - img.dataobj._inter)) < 1e-7: img.dataobj._slope = slope32 img.dataobj._inter = inter32 mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None smoothing_fwhm = self.inputs.smoothing_fwhm if not isdefined(smoothing_fwhm): smoothing_fwhm = None flm = level1.FirstLevelModel(mask_img=mask_file, smoothing_fwhm=smoothing_fwhm) flm.fit(img, design_matrices=mat) effect_maps = [] variance_maps = [] stat_maps = [] zscore_maps = [] pvalue_maps = [] contrast_metadata = [] out_ents = self.inputs.contrast_info[0]['entities'] fname_fmt = os.path.join(runtime.cwd, '{}_{}.nii.gz').format for name, weights, contrast_type in prepare_contrasts( self.inputs.contrast_info, mat.columns.tolist()): contrast_metadata.append({ 'contrast': name, 'stat': contrast_type, **out_ents }) maps = flm.compute_contrast(weights, contrast_type, output_type='all') for map_type, map_list in (('effect_size', effect_maps), ('effect_variance', variance_maps), ('z_score', zscore_maps), ('p_value', pvalue_maps), ('stat', stat_maps)): fname = fname_fmt(name, map_type) maps[map_type].to_filename(fname) map_list.append(fname) self._results['effect_maps'] = effect_maps self._results['variance_maps'] = variance_maps self._results['stat_maps'] = stat_maps self._results['zscore_maps'] = zscore_maps self._results['pvalue_maps'] = pvalue_maps self._results['contrast_metadata'] = contrast_metadata return runtime
def _run_interface(self, runtime): import matplotlib matplotlib.use('Agg') import seaborn as sns from matplotlib import pyplot as plt sns.set_style('white') plt.rcParams['svg.fonttype'] = 'none' plt.rcParams['image.interpolation'] = 'nearest' info = self.inputs.session_info img = nb.load(self.inputs.bold_file) vols = img.shape[3] events = pd.read_hdf(info['events'], key='events') confounds = pd.read_hdf(info['confounds'], key='confounds') if isdefined(self.inputs.contrast_info): contrast_spec = pd.read_hdf(self.inputs.contrast_info, key='contrasts') else: contrast_spec = pd.DataFrame() mat = dm.make_design_matrix( frame_times=np.arange(vols) * info['repetition_time'], paradigm=events.rename(columns={ 'condition': 'trial_type', 'amplitude': 'modulation' }), add_regs=confounds, add_reg_names=confounds.columns.tolist(), drift_model=None if 'Cosine00' in confounds.columns else 'cosine', ) exp_vars = events['condition'].unique().tolist() contrast_matrix, contrast_types = build_contrast_matrix( contrast_spec, mat, exp_vars) plt.set_cmap('viridis') plot_and_save('design.svg', nis.reporting.plot_design_matrix, mat) self._results['design_matrix_plot'] = os.path.join( runtime.cwd, 'design.svg') plot_and_save('correlation.svg', plot_corr_matrix, mat.drop(columns='constant').corr(), len(exp_vars)) self._results['correlation_matrix_plot'] = os.path.join( runtime.cwd, 'correlation.svg') plot_and_save('contrast.svg', plot_contrast_matrix, contrast_matrix.drop(['constant'], 'index'), ornt='horizontal') self._results['contrast_matrix_plot'] = os.path.join( runtime.cwd, 'contrast.svg') mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None flm = level1.FirstLevelModel(mask=mask_file) flm.fit(img, design_matrices=mat) estimate_maps = [] contrast_maps = [] estimate_metadata = [] contrast_metadata = [] estimate_map_plots = [] contrast_map_plots = [] stat_fmt = os.path.join(runtime.cwd, '{}.nii.gz').format plot_fmt = os.path.join(runtime.cwd, '{}.png').format for contrast, ctype in zip(contrast_matrix, contrast_types): es = flm.compute_contrast(contrast_matrix[contrast].values, { 'T': 't', 'F': 'F' }[ctype], output_type='effect_size') es_fname = stat_fmt(contrast) es.to_filename(es_fname) plot_fname = plot_fmt(contrast) nlp.plot_glass_brain(es, colorbar=True, plot_abs=False, display_mode='lyrz', axes=None, output_file=plot_fname) if contrast in exp_vars: estimate_maps.append(es_fname) estimate_map_plots.append(plot_fname) estimate_metadata.append({ 'contrast': contrast, 'type': 'effect' }) else: contrast_maps.append(es_fname) contrast_map_plots.append(plot_fname) contrast_metadata.append({ 'contrast': contrast, 'type': 'effect' }) self._results['estimate_maps'] = estimate_maps self._results['contrast_maps'] = contrast_maps self._results['estimate_metadata'] = estimate_metadata self._results['contrast_metadata'] = contrast_metadata self._results['estimate_map_plots'] = estimate_map_plots self._results['contrast_map_plots'] = contrast_map_plots return runtime
def _run_interface(self, runtime): import nibabel as nb from nistats import first_level_model as level1 from nistats.contrasts import compute_contrast mat = pd.read_csv(self.inputs.design_matrix, delimiter='\t', index_col=0) img = nb.load(self.inputs.bold_file) is_cifti = isinstance(img, nb.Cifti2Image) if isinstance(img, nb.dataobj_images.DataobjImage): # Ugly hack to ensure that retrieved data isn't cast to float64 unless # necessary to prevent an overflow # For NIfTI-1 files, slope and inter are 32-bit floats, so this is # "safe". For NIfTI-2 (including CIFTI-2), these fields are 64-bit, # so include a check to make sure casting doesn't lose too much. slope32 = np.float32(img.dataobj._slope) inter32 = np.float32(img.dataobj._inter) if max(np.abs(slope32 - img.dataobj._slope), np.abs(inter32 - img.dataobj._inter)) < 1e-7: img.dataobj._slope = slope32 img.dataobj._inter = inter32 mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None smoothing_fwhm = self.inputs.smoothing_fwhm if not isdefined(smoothing_fwhm): smoothing_fwhm = None if is_cifti: fname_fmt = os.path.join(runtime.cwd, '{}_{}.dscalar.nii').format labels, estimates = level1.run_glm(img.get_fdata(dtype='f4'), mat.values) model_attr = { 'r_square': dscalar_from_cifti( img, _get_voxelwise_stat(labels, estimates, 'r_square'), 'r_square'), 'log_likelihood': dscalar_from_cifti( img, _get_voxelwise_stat(labels, estimates, 'logL'), 'log_likelihood') } else: fname_fmt = os.path.join(runtime.cwd, '{}_{}.nii.gz').format flm = level1.FirstLevelModel(minimize_memory=False, mask_img=mask_file, smoothing_fwhm=smoothing_fwhm) flm.fit(img, design_matrices=mat) model_attr = { 'r_square': flm.r_square[0], 'log_likelihood': flm.masker_.inverse_transform( _get_voxelwise_stat(flm.labels_[0], flm.results_[0], 'logL')) } out_ents = self.inputs.contrast_info[0]['entities'] # Save model level images model_maps = [] model_metadata = [] for attr, img in model_attr.items(): model_metadata.append({'stat': attr, **out_ents}) fname = fname_fmt('model', attr) img.to_filename(fname) model_maps.append(fname) effect_maps = [] variance_maps = [] stat_maps = [] zscore_maps = [] pvalue_maps = [] contrast_metadata = [] for name, weights, contrast_type in prepare_contrasts( self.inputs.contrast_info, mat.columns): contrast_metadata.append({ 'contrast': name, 'stat': contrast_type, **out_ents }) if is_cifti: contrast = compute_contrast(labels, estimates, weights, contrast_type=contrast_type) maps = { map_type: dscalar_from_cifti(img, getattr(contrast, map_type)(), map_type) for map_type in [ 'z_score', 'stat', 'p_value', 'effect_size', 'effect_variance' ] } else: maps = flm.compute_contrast(weights, contrast_type, output_type='all') for map_type, map_list in (('effect_size', effect_maps), ('effect_variance', variance_maps), ('z_score', zscore_maps), ('p_value', pvalue_maps), ('stat', stat_maps)): fname = fname_fmt(name, map_type) maps[map_type].to_filename(fname) map_list.append(fname) self._results['effect_maps'] = effect_maps self._results['variance_maps'] = variance_maps self._results['stat_maps'] = stat_maps self._results['zscore_maps'] = zscore_maps self._results['pvalue_maps'] = pvalue_maps self._results['contrast_metadata'] = contrast_metadata self._results['model_maps'] = model_maps self._results['model_metadata'] = model_metadata return runtime
def _run_interface(self, runtime): import nibabel as nb from nistats import design_matrix as dm from nistats import first_level_model as level1 info = self.inputs.session_info img = nb.load(self.inputs.bold_file) vols = img.shape[3] if info['sparse'] not in (None, 'None'): sparse = pd.read_hdf(info['sparse'], key='sparse').rename(columns={ 'condition': 'trial_type', 'amplitude': 'modulation' }) sparse = sparse.dropna(subset=['modulation']) # Drop NAs else: sparse = None if info['dense'] not in (None, 'None'): dense = pd.read_hdf(info['dense'], key='dense') column_names = dense.columns.tolist() drift_model = None if 'cosine_00' in column_names else 'cosine' else: dense = None column_names = None drift_model = 'cosine' mat = dm.make_first_level_design_matrix( frame_times=np.arange(vols) * info['repetition_time'], events=sparse, add_regs=dense, add_reg_names=column_names, drift_model=drift_model, ) mat.to_csv('design.tsv', sep='\t') self._results['design_matrix'] = os.path.join(runtime.cwd, 'design.tsv') mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None smoothing_fwhm = self.inputs.smoothing_fwhm if not isdefined(smoothing_fwhm): smoothing_fwhm = None flm = level1.FirstLevelModel(mask_img=mask_file, smoothing_fwhm=smoothing_fwhm) flm.fit(img, design_matrices=mat) effect_maps = [] variance_maps = [] stat_maps = [] zscore_maps = [] pvalue_maps = [] contrast_metadata = [] out_ents = self.inputs.contrast_info[0]['entities'] fname_fmt = os.path.join(runtime.cwd, '{}_{}.nii.gz').format for name, weights, contrast_type in prepare_contrasts( self.inputs.contrast_info, mat.columns.tolist()): maps = flm.compute_contrast(weights, contrast_type, output_type='all') contrast_metadata.append({ 'contrast': name, 'stat': contrast_type, **out_ents }) for map_type, map_list in (('effect_size', effect_maps), ('effect_variance', variance_maps), ('z_score', zscore_maps), ('p_value', pvalue_maps), ('stat', stat_maps)): fname = fname_fmt(name, map_type) maps[map_type].to_filename(fname) map_list.append(fname) self._results['effect_maps'] = effect_maps self._results['variance_maps'] = variance_maps self._results['stat_maps'] = stat_maps self._results['zscore_maps'] = zscore_maps self._results['pvalue_maps'] = pvalue_maps self._results['contrast_metadata'] = contrast_metadata return runtime
def _run_interface(self, runtime): info = self.inputs.session_info img = nb.load(self.inputs.bold_file) vols = img.shape[3] events = pd.read_hdf(info['events'], key='events') if info['confounds'] is not None and info['confounds'] != 'None': confounds = pd.read_hdf(info['confounds'], key='confounds') confound_names = confounds.columns.tolist() drift_model = None if 'Cosine00' in confound_names else 'cosine' else: confounds = None confound_names = None drift_model = 'cosine' if isdefined(self.inputs.contrast_info): contrast_spec = pd.read_hdf(self.inputs.contrast_info, key='contrasts') else: contrast_spec = pd.DataFrame() mat = dm.make_design_matrix( frame_times=np.arange(vols) * info['repetition_time'], paradigm=events.rename(columns={ 'condition': 'trial_type', 'amplitude': 'modulation' }), add_regs=confounds, add_reg_names=confound_names, drift_model=drift_model, ) # Assume that explanatory variables == HRF-convolved variables exp_vars = events['condition'].unique().tolist() contrast_matrix, contrast_types = build_contrast_matrix( contrast_spec, mat, exp_vars) mat.to_csv('design.tsv', sep='\t') self._results['design_matrix'] = os.path.join(runtime.cwd, 'design.tsv') contrast_matrix.to_csv('contrasts.tsv', sep='\t') self._results['contrast_matrix'] = os.path.join( runtime.cwd, 'contrasts.tsv') mask_file = self.inputs.mask_file if not isdefined(mask_file): mask_file = None flm = level1.FirstLevelModel(mask=mask_file) flm.fit(img, design_matrices=mat) contrast_maps = [] contrast_metadata = [] stat_fmt = os.path.join(runtime.cwd, '{}.nii.gz').format for contrast, ctype in zip(contrast_matrix, contrast_types): es = flm.compute_contrast(contrast_matrix[contrast].values, { 'T': 't', 'F': 'F' }[ctype], output_type='effect_size') es_fname = stat_fmt(contrast) es.to_filename(es_fname) contrast_maps.append(es_fname) contrast_metadata.append({'contrast': contrast, 'type': 'effect'}) self._results['contrast_maps'] = contrast_maps self._results['contrast_metadata'] = contrast_metadata return runtime
def _run_interface(self, runtime): from nistats import first_level_model import nibabel as nib import os # get t_r from bold_metadata t_r = self.inputs.bold_metadata['RepetitionTime'] # get the confounds: if self.inputs.confounds_file and self.inputs.selected_confounds: confounds = _select_confounds(self.inputs.confounds_file, self.inputs.selected_confounds) else: confounds = None # high_pass, switch from Hz to Period high_pass_period = int(1 / self.inputs.high_pass) # setup the model model = first_level_model.FirstLevelModel( t_r=t_r, slice_time_ref=0, hrf_model=self.inputs.hrf_model, mask=self.inputs.mask_file, smoothing_fwhm=self.inputs.smoothing_kernel, standardize=True, signal_scaling=0, period_cut=high_pass_period, drift_model='cosine', verbose=1) # initialize dictionary to contain trial estimates (betas) beta_maps = {} design_matrix_collector = {} for target_trial_df, trial_type, trial_idx in \ _lss_events_iterator(self.inputs.events_file): # fit the model for the target trial model.fit(self.inputs.bold_file, events=target_trial_df, confounds=confounds) # calculate the beta map beta_map = model.compute_contrast(trial_type, output_type='effect_size') design_matrix_collector[trial_idx] = model.design_matrices_[0] # import pdb; pdb.set_trace() # assign beta map to appropriate list if trial_type in beta_maps: beta_maps[trial_type].append(beta_map) else: beta_maps[trial_type] = [beta_map] # make a beta series from each beta map list beta_series_template = os.path.join( runtime.cwd, 'desc-{trial_type}_betaseries.nii.gz') # collector for the betaseries files beta_series_lst = [] for t_type, betas in beta_maps.items(): size_check = len(betas) if size_check < 3: logging.warning( 'At least 3 trials are needed ' 'for a beta series: {trial_type} has {num}'.format( trial_type=t_type, num=size_check)) else: beta_series = nib.funcs.concat_images(betas) nib.save(beta_series, beta_series_template.format(trial_type=t_type)) beta_series_lst.append( beta_series_template.format(trial_type=t_type)) self._results['beta_maps'] = beta_series_lst self._results['design_matrices'] = design_matrix_collector return runtime
def _run_interface(self, runtime): from nistats import first_level_model import os # get t_r from bold_metadata t_r = self.inputs.bold_metadata['RepetitionTime'] # get the confounds: if self.inputs.confounds_file and self.inputs.selected_confounds: confounds = _select_confounds(self.inputs.confounds_file, self.inputs.selected_confounds) else: confounds = None # setup the model model = first_level_model.FirstLevelModel( t_r=t_r, slice_time_ref=0, hrf_model=self.inputs.hrf_model, mask=self.inputs.mask_file, smoothing_fwhm=self.inputs.smoothing_kernel, signal_scaling=self.inputs.signal_scaling, high_pass=self.inputs.high_pass, drift_model='cosine', verbose=1, fir_delays=self.inputs.fir_delays, minimize_memory=False, ) # initialize dictionary to contain trial estimates (betas) beta_maps = {} residuals = None design_matrix_collector = {} for target_trial_df, trial_type, trial_idx in \ _lss_events_iterator(self.inputs.events_file): # fit the model for the target trial model.fit(self.inputs.bold_file, events=target_trial_df, confounds=confounds) if self.inputs.hrf_model == 'fir': # FS modeling for delay in self.inputs.fir_delays: delay_ttype = trial_type + '_delay_{}'.format(delay) new_delay_ttype = delay_ttype.replace( '_delay_{}'.format(delay), 'Delay{}Vol'.format(delay)) beta_map = _calc_beta_map(model, delay_ttype, self.inputs.hrf_model, self.inputs.return_tstat) if new_delay_ttype in beta_maps: beta_maps[new_delay_ttype].append(beta_map) else: beta_maps[new_delay_ttype] = [beta_map] else: # calculate the beta map beta_map = _calc_beta_map(model, trial_type, self.inputs.hrf_model, self.inputs.return_tstat) design_matrix_collector[trial_idx] = model.design_matrices_[0] # assign beta map to appropriate list if trial_type in beta_maps: beta_maps[trial_type].append(beta_map) else: beta_maps[trial_type] = [beta_map] # add up all the residuals (to be divided later) if residuals is None: residuals = model.residuals[0].get_fdata() else: residuals += model.residuals[0].get_fdata() # make an average residual ave_residual = residuals / (trial_idx + 1) # make residual nifti image residual_file = os.path.join(runtime.cwd, 'desc-residuals_bold.nii.gz') nib.Nifti2Image( ave_residual, model.residuals[0].affine, model.residuals[0].header, ).to_filename(residual_file) # make a beta series from each beta map list beta_series_template = os.path.join( runtime.cwd, 'desc-{trial_type}_betaseries.nii.gz') # collector for the betaseries files beta_series_lst = [] for t_type, betas in beta_maps.items(): beta_series = nib.funcs.concat_images(betas) nib.save(beta_series, beta_series_template.format(trial_type=t_type)) beta_series_lst.append( beta_series_template.format(trial_type=t_type)) self._results['beta_maps'] = beta_series_lst self._results['design_matrices'] = design_matrix_collector self._results['residual'] = residual_file return runtime
def _run_interface(self, runtime): from nistats import first_level_model import os # get t_r from bold_metadata t_r = self.inputs.bold_metadata['RepetitionTime'] # get the confounds: if self.inputs.confounds_file and self.inputs.selected_confounds: confounds = _select_confounds(self.inputs.confounds_file, self.inputs.selected_confounds) else: confounds = None # setup the model model = first_level_model.FirstLevelModel( t_r=t_r, slice_time_ref=0, hrf_model=self.inputs.hrf_model, mask=self.inputs.mask_file, smoothing_fwhm=self.inputs.smoothing_kernel, signal_scaling=self.inputs.signal_scaling, high_pass=self.inputs.high_pass, drift_model='cosine', verbose=1, minimize_memory=False, ) # initialize dictionary to contain trial estimates (betas) beta_maps = {} lsa_df = _lsa_events_converter(self.inputs.events_file) model.fit(self.inputs.bold_file, events=lsa_df, confounds=confounds) design_matrix = model.design_matrices_[0] for i_trial in lsa_df.index: t_name = lsa_df.loc[i_trial, 'trial_type'] t_type = lsa_df.loc[i_trial, 'original_trial_type'] # calculate the beta map beta_map = _calc_beta_map(model, t_name, self.inputs.hrf_model, self.inputs.return_tstat) # assign beta map to appropriate list if t_type in beta_maps: beta_maps[t_type].append(beta_map) else: beta_maps[t_type] = [beta_map] # calculate the residual residual_file = os.path.join(runtime.cwd, 'desc-residuals_bold.nii.gz') model.residuals[0].to_filename(residual_file) # make a beta series from each beta map list beta_series_template = os.path.join( runtime.cwd, 'desc-{trial_type}_betaseries.nii.gz') # collector for the betaseries files beta_series_lst = [] for t_type, betas in beta_maps.items(): beta_series = nib.funcs.concat_images(betas) nib.save(beta_series, beta_series_template.format(trial_type=t_type)) beta_series_lst.append( beta_series_template.format(trial_type=t_type)) self._results['beta_maps'] = beta_series_lst self._results['design_matrices'] = [design_matrix] self._results['residual'] = residual_file return runtime