def anatomical_preprocessing(): ''' Inputs: MP2RAGE Skull stripped image using Spectre-2010 Workflow: 1. reorient to RPI 2. create a brain mask Returns: brain brain_mask ''' # define workflow flow = Workflow('anat_preprocess') inputnode = Node(util.IdentityInterface( fields=['anat', 'anat_gm', 'anat_wm', 'anat_csf', 'anat_first']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=[ 'brain', 'brain_gm', 'brain_wm', 'brain_csf', 'brain_first', 'brain_mask', ]), name='outputnode') reorient = Node(interface=preprocess.Resample(), name='anat_reorient') reorient.inputs.orientation = 'RPI' reorient.inputs.outputtype = 'NIFTI' erode = Node(interface=fsl.ErodeImage(), name='anat_preproc') reorient_gm = reorient.clone('anat_preproc_gm') reorient_wm = reorient.clone('anat_preproc_wm') reorient_cm = reorient.clone('anat_preproc_csf') reorient_first = reorient.clone('anat_preproc_first') make_mask = Node(interface=fsl.UnaryMaths(), name='anat_preproc_mask') make_mask.inputs.operation = 'bin' # connect workflow nodes flow.connect(inputnode, 'anat', reorient, 'in_file') flow.connect(inputnode, 'anat_gm', reorient_gm, 'in_file') flow.connect(inputnode, 'anat_wm', reorient_wm, 'in_file') flow.connect(inputnode, 'anat_csf', reorient_cm, 'in_file') flow.connect(inputnode, 'anat_first', reorient_first, 'in_file') flow.connect(reorient, 'out_file', erode, 'in_file') flow.connect(erode, 'out_file', make_mask, 'in_file') flow.connect(make_mask, 'out_file', outputnode, 'brain_mask') flow.connect(erode, 'out_file', outputnode, 'brain') flow.connect(reorient_gm, 'out_file', outputnode, 'brain_gm') flow.connect(reorient_wm, 'out_file', outputnode, 'brain_wm') flow.connect(reorient_cm, 'out_file', outputnode, 'brain_csf') flow.connect(reorient_first, 'out_file', outputnode, 'brain_first') return flow
def anatomical_preprocessing(): ''' Inputs: MP2RAGE Skull stripped image using Spectre-2010 Workflow: 1. reorient to RPI 2. create a brain mask Returns: brain brain_mask ''' # define workflow flow = Workflow('anat_preprocess') inputnode = Node(util.IdentityInterface(fields=['anat', 'anat_gm', 'anat_wm', 'anat_csf', 'anat_first']), name = 'inputnode') outputnode = Node(util.IdentityInterface(fields=['brain','brain_gm', 'brain_wm', 'brain_csf', 'brain_first', 'brain_mask',]), name = 'outputnode') reorient = Node(interface=preprocess.Resample(), name = 'anat_reorient') reorient.inputs.orientation = 'RPI' reorient.inputs.outputtype = 'NIFTI' erode = Node(interface=fsl.ErodeImage(), name = 'anat_preproc') reorient_gm = reorient.clone('anat_preproc_gm') reorient_wm = reorient.clone('anat_preproc_wm') reorient_cm = reorient.clone('anat_preproc_csf') reorient_first = reorient.clone('anat_preproc_first') make_mask = Node(interface=fsl.UnaryMaths(), name = 'anat_preproc_mask') make_mask.inputs.operation = 'bin' # connect workflow nodes flow.connect(inputnode, 'anat' , reorient, 'in_file' ) flow.connect(inputnode, 'anat_gm' , reorient_gm, 'in_file' ) flow.connect(inputnode, 'anat_wm' , reorient_wm, 'in_file' ) flow.connect(inputnode, 'anat_csf' , reorient_cm, 'in_file' ) flow.connect(inputnode, 'anat_first' , reorient_first,'in_file' ) flow.connect(reorient, 'out_file' , erode, 'in_file' ) flow.connect(erode, 'out_file' , make_mask, 'in_file' ) flow.connect(make_mask, 'out_file' , outputnode, 'brain_mask' ) flow.connect(erode, 'out_file' , outputnode, 'brain' ) flow.connect(reorient_gm, 'out_file' , outputnode, 'brain_gm' ) flow.connect(reorient_wm, 'out_file' , outputnode, 'brain_wm' ) flow.connect(reorient_cm, 'out_file' , outputnode, 'brain_csf' ) flow.connect(reorient_first, 'out_file' , outputnode, 'brain_first' ) return flow
def make_w_masking(): n_in = Node(IdentityInterface(fields=[ 'func', 'fmap', # mean ]), name='input') n_out = Node(IdentityInterface(fields=[ 'func', 'fmap', # mean ]), name='output') n_mask_func = Node(interface=Automask(), name='mask_func') n_mask_func.inputs.clfrac = 0.4 n_mask_func.inputs.dilate = 4 n_mask_func.inputs.args = '-nbhrs 15' n_mask_func.inputs.outputtype = 'NIFTI' n_mask_fmap = n_mask_func.clone('mask_fmap') n_mul = Node(interface=BinaryMaths(), name='mul') n_mul.inputs.operation = 'mul' n_masking = Node(interface=BinaryMaths(), name='masking') n_masking.inputs.operation = 'mul' n_masking_fmap = Node(interface=BinaryMaths(), name='masking_fmap') n_masking_fmap.inputs.operation = 'mul' w = Workflow('masking') w.connect(n_in, 'func', n_mask_func, 'in_file') w.connect(n_in, 'fmap', n_mask_fmap, 'in_file') w.connect(n_mask_fmap, 'out_file', n_mul, 'in_file') w.connect(n_mask_func, 'out_file', n_mul, 'operand_file') w.connect(n_in, 'func', n_masking, 'in_file') w.connect(n_mul, 'out_file', n_masking, 'operand_file') w.connect(n_masking, 'out_file', n_out, 'func') w.connect(n_in, 'fmap', n_masking_fmap, 'in_file') w.connect(n_mul, 'out_file', n_masking_fmap, 'operand_file') w.connect(n_masking_fmap, 'out_file', n_out, 'fmap') return w
FA_to_WAX_Temp.inputs.write_composite_transform = True FA_to_WAX_Temp.inputs.verbose = True FA_to_WAX_Temp.inputs.output_warped_image = True FA_to_WAX_Temp.inputs.float = True #>>>>>>>>>>>>>>>>>>>>>>>>>MD antsApplyMD_WAX = Node(ants.ApplyTransforms(), name='antsApplyMD_WAX') antsApplyMD_WAX.inputs.dimension = 3 antsApplyMD_WAX.inputs.input_image_type = 3 antsApplyMD_WAX.inputs.num_threads = 1 antsApplyMD_WAX.inputs.float = True antsApplyMD_WAX.inputs.output_image = 'MD_{subject_id}.nii' antsApplyMD_WAX.inputs.reference_image = Wax_FA_Template #>>>>>>>>>>>>>>>>>>>>>>>>>AD antsApplyAD_WAX = antsApplyMD_WAX.clone(name='antsApplyAD_WAX') antsApplyAD_WAX.inputs.output_image = 'AD_{subject_id}.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>RD antsApplyRD_WAX = antsApplyMD_WAX.clone(name='antsApplyRD_WAX') antsApplyRD_WAX.inputs.output_image = 'RD_{subject_id}.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>KA antsApplyKA_WAX = antsApplyMD_WAX.clone(name='antsApplyKA_WAX') antsApplyKA_WAX.inputs.output_image = 'KA_{subject_id}.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>AK antsApplyAK_WAX = antsApplyMD_WAX.clone(name='antsApplyAK_WAX') antsApplyAK_WAX.inputs.output_image = 'AK_{subject_id}.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>MK
FA_to_Study_Temp.inputs.write_composite_transform = True FA_to_Study_Temp.inputs.verbose = True FA_to_Study_Temp.inputs.output_warped_image = True FA_to_Study_Temp.inputs.float = True #>>>>>>>>>>>>>>>>>>>>>>>>>>>AK antsApply_AK_Study = Node(ants.ApplyTransforms(), name='antsApply_AK_Study') antsApply_AK_Study.inputs.dimension = 3 antsApply_AK_Study.inputs.input_image_type = 3 antsApply_AK_Study.inputs.num_threads = 1 antsApply_AK_Study.inputs.float = True antsApply_AK_Study.inputs.output_image = 'DKI_ExploreDTI_AK.nii' antsApply_AK_Study.inputs.reference_image = Study_Template #>>>>>>>>>>>>>>>>>>>>>>>>>AWF antsApply_AWF_Study = antsApply_AK_Study.clone(name='antsApply_AWF_Study') antsApply_AWF_Study.inputs.output_image = 'DKI_ExploreDTI_AWF.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>KA antsApply_KA_Study = antsApply_AK_Study.clone(name='antsApply_KA_Study') antsApply_KA_Study.inputs.output_image = 'DKI_ExploreDTI_KA.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>AD antsApply_AD_Study = antsApply_AK_Study.clone(name='antsApply_AD_Study') antsApply_AD_Study.inputs.output_image = 'DKI_ExploreDTI_AD.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>MD antsApply_MD_Study = antsApply_AK_Study.clone(name='antsApply_MD_Study') antsApply_MD_Study.inputs.output_image = 'DKI_ExploreDTI_MD.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>MK
def learning_predict_data_2samp_wf(working_dir, ds_dir, in_data_name_list, subjects_selection_crit_dict, subjects_selection_crit_names_list, aggregated_subjects_dir, target_list, use_n_procs, plugin_name, confound_regression=[False, True], run_cv=False, n_jobs_cv=1, run_tuning=False, run_2sample_training=False, aggregated_subjects_dir_nki=None, subjects_selection_crit_dict_nki=None, subjects_selection_crit_name_nki=None, reverse_split=False, random_state_nki=666, run_learning_curve=False, life_test_size=0.5): import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from itertools import chain from learning_utils import aggregate_multimodal_metrics_fct, run_prediction_split_fct, \ backproject_and_split_weights_fct, select_subjects_fct, select_multimodal_X_fct, learning_curve_plot import pandas as pd ############################################################################################################### # GENERAL SETTINGS wf = Workflow(name='learning_predict_data_2samp_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={ 'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120 }) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join( working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ############################################################################################################### # ensure in_data_name_list is list of lists in_data_name_list = [ i if type(i) == list else [i] for i in in_data_name_list ] in_data_name_list_unique = list(set( chain.from_iterable(in_data_name_list))) ############################################################################################################### # SET ITERATORS in_data_name_infosource = Node( util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) multimodal_in_data_name_infosource = Node( util.IdentityInterface(fields=['multimodal_in_data_name']), name='multimodal_in_data_name_infosource') multimodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) subject_selection_infosource = Node( util.IdentityInterface(fields=['selection_criterium']), name='subject_selection_infosource') subject_selection_infosource.iterables = ( 'selection_criterium', subjects_selection_crit_names_list) target_infosource = Node(util.IdentityInterface(fields=['target_name']), name='target_infosource') target_infosource.iterables = ('target_name', target_list) ############################################################################################################### # COMPILE LIFE DATA ############################################################################################################### ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file = os.path.join( aggregated_subjects_dir, 'df_all_subjects_pickle_file/df_all.pkl') df = pd.read_pickle(df_all_subjects_pickle_file) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict = {} for k in in_data_name_list_unique: unimodal_lookup_dict[k] = { 'X_file': os.path.join(aggregated_subjects_dir, X_file_template.format(in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir, info_file_template.format(in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics = Node(util.Function( input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=[ 'X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name' ], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics, 'multimodal_list') aggregate_multimodal_metrics.inputs.unimodal_lookup_dict = unimodal_lookup_dict ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects = Node(util.Function(input_names=[ 'df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium' ], output_names=[ 'df_use_file', 'df_use_pickle_file', 'subjects_selection_index' ], function=select_subjects_fct), name='select_subjects') select_subjects.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file select_subjects.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict wf.connect(subject_selection_infosource, 'selection_criterium', select_subjects, 'selection_criterium') ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X = Node(util.Function( input_names=[ 'X_multimodal_file', 'subjects_selection_index', 'selection_criterium' ], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X') wf.connect(aggregate_multimodal_metrics, 'X_multimodal_file', select_multimodal_X, 'X_multimodal_file') wf.connect(select_subjects, 'subjects_selection_index', select_multimodal_X, 'subjects_selection_index') ############################################################################################################### # COMPILE NKI DATA ############################################################################################################### if run_2sample_training: ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file_nki = os.path.join( aggregated_subjects_dir_nki, 'df_all_subjects_pickle_file/df_all.pkl') df_nki = pd.read_pickle(df_all_subjects_pickle_file_nki) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict_nki = {} for k in in_data_name_list_unique: unimodal_lookup_dict_nki[k] = { 'X_file': os.path.join(aggregated_subjects_dir_nki, X_file_template.format(in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir_nki, info_file_template.format(in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics_nki = Node( util.Function( input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=[ 'X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name' ], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics_nki') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics_nki, 'multimodal_list') aggregate_multimodal_metrics_nki.inputs.unimodal_lookup_dict = unimodal_lookup_dict_nki ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects_nki = Node(util.Function(input_names=[ 'df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium' ], output_names=[ 'df_use_file', 'df_use_pickle_file', 'subjects_selection_index' ], function=select_subjects_fct), name='select_subjects_nki') select_subjects_nki.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file_nki select_subjects_nki.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict_nki select_subjects_nki.inputs.selection_criterium = subjects_selection_crit_name_nki ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X_nki = Node(util.Function( input_names=[ 'X_multimodal_file', 'subjects_selection_index', 'selection_criterium' ], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X_nki') wf.connect(aggregate_multimodal_metrics_nki, 'X_multimodal_file', select_multimodal_X_nki, 'X_multimodal_file') wf.connect(select_subjects_nki, 'subjects_selection_index', select_multimodal_X_nki, 'subjects_selection_index') ############################################################################################################### # RUN PREDICTION # prediction_node_dict = {} backprojection_node_dict = {} prediction_split = Node(util.Function( input_names=[ 'X_file', 'target_name', 'selection_criterium', 'df_file', 'data_str', 'regress_confounds', 'run_cv', 'n_jobs_cv', 'run_tuning', 'X_file_nki', 'df_file_nki', 'reverse_split', 'random_state_nki', 'run_learning_curve', 'life_test_size' ], output_names=[ 'scatter_file', 'brain_age_scatter_file', 'df_life_out_file', 'df_nki_out_file', 'df_big_out_file', 'model_out_file', 'df_res_out_file', 'tuning_curve_file', 'scatter_file_cv', 'learning_curve_plot_file', 'learning_curve_df_file' ], function=run_prediction_split_fct), name='prediction_split') backproject_and_split_weights = Node(util.Function( input_names=[ 'trained_model_file', 'multimodal_backprojection_info', 'data_str', 'target_name' ], output_names=['out_file_list', 'out_file_render_list'], function=backproject_and_split_weights_fct), name='backproject_and_split_weights') i = 0 for reg in confound_regression: the_out_node_str = 'single_source_model_reg_%s_' % (reg) prediction_node_dict[i] = prediction_split.clone(the_out_node_str) the_in_node = prediction_node_dict[i] the_in_node.inputs.regress_confounds = reg the_in_node.inputs.run_cv = run_cv the_in_node.inputs.n_jobs_cv = n_jobs_cv the_in_node.inputs.run_tuning = run_tuning the_in_node.inputs.reverse_split = reverse_split the_in_node.inputs.random_state_nki = random_state_nki the_in_node.inputs.run_learning_curve = run_learning_curve the_in_node.inputs.life_test_size = life_test_size wf.connect(select_multimodal_X, 'X_multimodal_selected_file', the_in_node, 'X_file') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(subject_selection_infosource, 'selection_criterium', the_in_node, 'selection_criterium') wf.connect(select_subjects, 'df_use_pickle_file', the_in_node, 'df_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(the_in_node, 'model_out_file', ds, the_out_node_str + 'trained_model') wf.connect(the_in_node, 'scatter_file', ds_pdf, the_out_node_str + 'scatter') wf.connect(the_in_node, 'brain_age_scatter_file', ds_pdf, the_out_node_str + 'brain_age_scatter') wf.connect(the_in_node, 'df_life_out_file', ds_pdf, the_out_node_str + 'predicted_life') wf.connect(the_in_node, 'df_nki_out_file', ds_pdf, the_out_node_str + 'predicted_nki') wf.connect(the_in_node, 'df_big_out_file', ds_pdf, the_out_node_str + 'predicted') wf.connect(the_in_node, 'df_res_out_file', ds_pdf, the_out_node_str + 'results_error') wf.connect(the_in_node, 'tuning_curve_file', ds_pdf, the_out_node_str + 'tuning_curve') wf.connect(the_in_node, 'scatter_file_cv', ds_pdf, the_out_node_str + 'scatter_cv') wf.connect(the_in_node, 'learning_curve_plot_file', ds_pdf, the_out_node_str + 'learning_curve_plot_file.@plot') wf.connect(the_in_node, 'learning_curve_df_file', ds_pdf, the_out_node_str + 'learning_curve_df_file.@df') # NKI if run_2sample_training: wf.connect(select_multimodal_X_nki, 'X_multimodal_selected_file', the_in_node, 'X_file_nki') wf.connect(select_subjects_nki, 'df_use_pickle_file', the_in_node, 'df_file_nki') else: the_in_node.inputs.df_file_nki = None the_in_node.inputs.X_file_nki = None # BACKPROJECT PREDICTION WEIGHTS # map weights back to single modality original format (e.g., nifti or matrix) the_out_node_str = 'backprojection_single_source_model_reg_%s_' % (reg) backprojection_node_dict[i] = backproject_and_split_weights.clone( the_out_node_str) the_from_node = prediction_node_dict[i] the_in_node = backprojection_node_dict[i] wf.connect(the_from_node, 'model_out_file', the_in_node, 'trained_model_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_backprojection_info', the_in_node, 'multimodal_backprojection_info') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(the_in_node, 'out_file_list', ds_pdf, the_out_node_str + '.@weights') wf.connect(the_in_node, 'out_file_render_list', ds_pdf, the_out_node_str + 'renders.@renders') i += 1 ############################################################################################################### # # RUN WF wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical') wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf') wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf') if plugin_name == 'CondorDAGMan': wf.run(plugin=plugin_name) if plugin_name == 'MultiProc': wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
morph_closing = Node(fs.Binarize(min=0.5, dilate=10, erode=10), name='morph_close') medwall.connect([(addmasks, morph_closing, [('out_file', 'in_file')])]) '''alternative with thickness''' wallmask_rh = Node(fs.Binarize(max=0.2, out_type = 'nii.gz'), name='wallmask_rh') wallmask_lh = wallmask_rh.clone('wallmask_lh') medwall.connect([(selectfiles, wallmask_rh, [('thickness_rh', 'in_file')]), (selectfiles, wallmask_lh, [('thickness_lh', 'in_file')]) ]) addmasks2= Node(fsl.BinaryMaths(operation='add'), name='addmasks2') medwall.connect([(wallmask_rh, addmasks2, [('binary_file', 'in_file')]), (wallmask_lh, addmasks2, [('binary_file', 'operand_file')])]) ''' followed by 3dclust -savemask $out 0 20 $in '''
def func2anat_linear(): import nipype.interfaces.fsl as fsl bbr_shedule = '/usr/share/fsl/5.0/etc/flirtsch/bbr.sch' #define workflow linear = Workflow('func2anat_linear') inputnode = Node(util.IdentityInterface(fields=['func_image', 'func_mask', 'reference_image', 'anat_wm', 'anat_csf', 'anat_gm', 'anat_first',]), name = 'inputnode') outputnode = Node(util.IdentityInterface(fields=['func2anat', 'func2anat_xfm', 'anat_downsample', 'anat2func_xfm', 'anat2func', 'func_gm', 'func_wm', 'func_csf', 'func_first']), name= 'outputnode') anatdownsample = Node(interface= fsl.FLIRT(), name = 'downsample_anat') anatdownsample.inputs.apply_isoxfm = 2.3 anatdownsample.inputs.datatype = 'float' # run flirt with mutual info mutual_info = Node(interface= fsl.FLIRT(), name = 'func2anat_flirt0_mutualinfo') mutual_info.inputs.cost = 'mutualinfo' mutual_info.inputs.dof = 6 mutual_info.inputs.no_resample = True # run flirt boundary based registration on a func_moco_disco using # (a) white matter segment as a boundary and (b) the mutualinfo xfm for initialization bbr = Node(interface= fsl.FLIRT(), name = 'func2anat_flirt1_bbr') bbr.inputs.cost = 'bbr' bbr.inputs.dof = 6 bbr.inputs.schedule = bbr_shedule bbr.inputs.no_resample = True convert_xfm = Node(interface= fsl.ConvertXFM(), name ='anat2func_xfm') convert_xfm.inputs.invert_xfm = True #connect nodes linear.connect(inputnode , 'reference_image' , anatdownsample , 'in_file' ) linear.connect(inputnode , 'reference_image' , anatdownsample , 'reference' ) linear.connect(inputnode , 'func_image' , mutual_info , 'in_file' ) linear.connect(anatdownsample , 'out_file' , mutual_info , 'reference' ) linear.connect(inputnode , 'func_image' , bbr , 'in_file' ) linear.connect(anatdownsample , 'out_file' , bbr , 'reference' ) linear.connect(inputnode , 'anat_wm' , bbr , 'wm_seg' ) linear.connect(mutual_info , 'out_matrix_file' , bbr , 'in_matrix_file' ) linear.connect(bbr , 'out_matrix_file' , convert_xfm , 'in_file' ) linear.connect(bbr , 'out_file' , outputnode , 'func2anat' ) linear.connect(bbr , 'out_matrix_file' , outputnode , 'func2anat_xfm' ) linear.connect(convert_xfm , 'out_file' , outputnode , 'anat2func_xfm' ) linear.connect(anatdownsample , 'out_file' , outputnode , 'anat_downsample' ) anat_invxfm = Node(interface= fsl.ApplyXfm(), name ='apply_invxfm_anat') anat_invxfm.inputs.apply_xfm = True linear.connect(anatdownsample , 'out_file' , anat_invxfm, 'in_file') linear.connect(inputnode , 'func_image' , anat_invxfm, 'reference') linear.connect(convert_xfm , 'out_file' , anat_invxfm, 'in_matrix_file') linear.connect(anat_invxfm , 'out_file' , outputnode, 'anat2func') # flirt tissue masks back to func space gm_invxfm = Node(interface= fsl.ApplyXfm(), name ='apply_invxfm_gm') gm_invxfm.inputs.apply_xfm = True bin_gm = Node(interface= fsl.Threshold(), name ='apply_invxfm_gm_bin') bin_gm.inputs.thresh = 0.5 bin_gm.inputs.args = '-bin' mask_gm = Node(interface=fsl.BinaryMaths(), name='func_gm') mask_gm.inputs.operation = 'mul' linear.connect(inputnode , 'anat_gm' , gm_invxfm, 'in_file') linear.connect(inputnode , 'func_image' , gm_invxfm, 'reference') linear.connect(convert_xfm , 'out_file' , gm_invxfm, 'in_matrix_file') linear.connect(gm_invxfm , 'out_file' , bin_gm, 'in_file') linear.connect(bin_gm , 'out_file' , mask_gm, 'in_file') linear.connect(inputnode , 'func_mask' , mask_gm, 'operand_file') linear.connect(mask_gm , 'out_file' , outputnode,'func_gm') wm_invxfm = gm_invxfm.clone('apply_invxfm_wm') bin_wm = bin_gm.clone('apply_invxfm_wm_bin') mask_wm = mask_gm.clone('func_wm') linear.connect(inputnode , 'anat_wm' , wm_invxfm, 'in_file') linear.connect(inputnode , 'func_image' , wm_invxfm, 'reference') linear.connect(convert_xfm , 'out_file' , wm_invxfm, 'in_matrix_file') linear.connect(wm_invxfm , 'out_file' , bin_wm, 'in_file') linear.connect(bin_wm , 'out_file' , mask_wm, 'in_file') linear.connect(inputnode , 'func_mask' , mask_wm, 'operand_file') linear.connect(mask_wm , 'out_file' , outputnode,'func_wm') cm_invxfm = gm_invxfm.clone('apply_invxfm_csf') bin_cm = bin_gm.clone('apply_invxfm_csf_bin') mask_cm = mask_gm.clone('func_csf') linear.connect(inputnode , 'anat_csf' , cm_invxfm, 'in_file') linear.connect(inputnode , 'func_image' , cm_invxfm, 'reference') linear.connect(convert_xfm , 'out_file' , cm_invxfm, 'in_matrix_file') linear.connect(cm_invxfm , 'out_file' , bin_cm, 'in_file') linear.connect(bin_cm , 'out_file' , mask_cm, 'in_file') linear.connect(inputnode , 'func_mask' , mask_cm, 'operand_file') linear.connect(mask_cm , 'out_file' , outputnode,'func_csf') first_invxfm = gm_invxfm.clone('apply_invxfm_first') bin_first = Node(interface= fsl.Threshold(), name ='apply_invxfm_first_bin') bin_first.inputs.thresh = 12 bin_first.inputs.args = '-bin' mask_first = mask_gm.clone('func_first') linear.connect(inputnode , 'anat_first' , first_invxfm, 'in_file') linear.connect(inputnode , 'func_image' , first_invxfm, 'reference') linear.connect(convert_xfm , 'out_file' , first_invxfm, 'in_matrix_file') linear.connect(first_invxfm , 'out_file' , bin_first, 'in_file') linear.connect(bin_first , 'out_file' , mask_first, 'in_file') linear.connect(inputnode , 'func_mask' , mask_first, 'operand_file') linear.connect(mask_first , 'out_file' , outputnode, 'func_first') return linear
def run_tbss_wf(subject_id, working_dir, ds_dir, use_n_procs, plugin_name, dMRI_templates, in_path): import os from nipype import config from nipype.pipeline.engine import Node, Workflow, MapNode, JoinNode import nipype.interfaces.utility as util import nipype.interfaces.io as nio from nipype.interfaces import fsl, dipy from LeiCA.dMRI.nipype_11_workflows_dmri_fsl_snapshot.artifacts import hmc_pipeline, ecc_pipeline from LeiCA.dMRI.nipype_11_workflows_dmri_fsl_snapshot.utils import b0_average, extract_bval from LeiCA.dMRI.nipype_11_workflows_dmri_fsl_snapshot.tbss import create_tbss_all from nipype.workflows.dmri.dipy.denoise import nlmeans_pipeline from diffusion_utils import apply_hmc_and_ecc ##################################### # GENERAL SETTINGS ##################################### wf = Workflow(name='tbss_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': True, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 15}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash') ds = Node(nio.DataSink(base_directory=ds_dir), name='ds') ds.inputs.regexp_substitutions = [ ('_subject_id_[A0-9]*/', ''), ] # GET SUBJECT SPECIFIC FUNCTIONAL DATA selectfiles = Node(nio.SelectFiles(dMRI_templates, base_directory=in_path), name="selectfiles") selectfiles.inputs.subject_id = subject_id ##################################### # WF ##################################### def _bvals_with_nodiff_0_fct(in_bval, lowbval): ''' returns bval file with 0 in place of lowbvals ''' import os import numpy as np bvals = np.loadtxt(in_bval) bvals[bvals <= lowbval] = 0 bval_file_zero = os.path.abspath('bval_0.bval') np.savetxt(bval_file_zero, bvals) return bval_file_zero # CREATE BVALS FILES WITH 0 IN LOWBVAL SLICES. FOR ECC ONLY bvals_with_nodiff_0 = Node(util.Function(input_names=['in_bval', 'lowbval'], output_names=['bval_file_zero'], function=_bvals_with_nodiff_0_fct), name='bvals_with_nodiff_0') wf.connect(selectfiles, 'bval_file', bvals_with_nodiff_0, 'in_bval') bvals_with_nodiff_0.inputs.lowbval = 5 ## # GET B0 MASK b0_4d_init_0 = Node(util.Function(input_names=['in_dwi', 'in_bval', 'b'], output_names=['out_file'], function=extract_bval), name='b0_4d_init_0') wf.connect(selectfiles, 'dMRI_data', b0_4d_init_0, 'in_dwi') #wf.connect(selectfiles, 'bval_file', b0_4d_init_0, 'in_bval') wf.connect(bvals_with_nodiff_0, 'bval_file_zero', b0_4d_init_0, 'in_bval') b0_4d_init_0.inputs.b = 'nodiff' first_b0 = Node(fsl.ExtractROI(t_min=0, t_size=1), name='first_b0') wf.connect(b0_4d_init_0, 'out_file', first_b0, 'in_file') flirt = Node(fsl.FLIRT(dof=6, out_file='b0_moco.nii.gz'), name='flirt') wf.connect(b0_4d_init_0, 'out_file', flirt, 'in_file') wf.connect(first_b0, 'roi_file', flirt, 'reference') mean_b0_moco_init_0 = Node(fsl.MeanImage(), name='mean_b0_moco_init_0') wf.connect(flirt, 'out_file', mean_b0_moco_init_0, 'in_file') b0_mask_init_0 = Node(fsl.BET(frac=0.3, mask=True, robust=True), name='b0_mask_init_0') wf.connect(mean_b0_moco_init_0, 'out_file', b0_mask_init_0, 'in_file') # HEAD MOTION CORRECTION PIPELINE hmc = hmc_pipeline() wf.connect(selectfiles, 'dMRI_data', hmc, 'inputnode.in_file') #wf.connect(selectfiles, 'bval_file', hmc, 'inputnode.in_bval') wf.connect(bvals_with_nodiff_0, 'bval_file_zero', hmc, 'inputnode.in_bval') wf.connect(selectfiles, 'bvec_file', hmc, 'inputnode.in_bvec') wf.connect(b0_mask_init_0, 'mask_file', hmc, 'inputnode.in_mask') hmc.inputs.inputnode.ref_num = 0 wf.connect(hmc, 'outputnode.out_file', ds, 'moco') # GET UPDATED MEAN B0 AND MASK b0_4d_init_1 = b0_4d_init_0.clone('b0_4d_init_1') wf.connect(hmc, 'outputnode.out_file', b0_4d_init_1, 'in_dwi') #wf.connect(selectfiles, 'bval_file', b0_4d_init_1, 'in_bval') wf.connect(bvals_with_nodiff_0, 'bval_file_zero', b0_4d_init_1, 'in_bval') mean_b0_moco_init_1 = mean_b0_moco_init_0.clone('mean_b0_moco_init_1') wf.connect(b0_4d_init_1, 'out_file', mean_b0_moco_init_1, 'in_file') b0_mask_init_1 = b0_mask_init_0.clone('b0_mask_init_1') wf.connect(mean_b0_moco_init_1, 'out_file', b0_mask_init_1, 'in_file') # EDDY ecc = ecc_pipeline() wf.connect(selectfiles, 'dMRI_data', ecc, 'inputnode.in_file') #wf.connect(selectfiles, 'bval_file', ecc, 'inputnode.in_bval') wf.connect(bvals_with_nodiff_0, 'bval_file_zero', ecc, 'inputnode.in_bval') wf.connect(b0_mask_init_1, 'mask_file', ecc, 'inputnode.in_mask') wf.connect(hmc, 'outputnode.out_xfms', ecc, 'inputnode.in_xfms') wf.connect(ecc, 'outputnode.out_file', ds, 'ecc') combine_corrections = apply_hmc_and_ecc(name='combine_corrections') wf.connect(hmc, 'outputnode.out_xfms', combine_corrections, 'inputnode.in_hmc') wf.connect(ecc, 'outputnode.out_xfms', combine_corrections, 'inputnode.in_ecc') wf.connect(selectfiles, 'dMRI_data', combine_corrections, 'inputnode.in_dwi') wf.connect(combine_corrections, 'outputnode.out_file', ds, 'preprocessed') # GET UPDATED MEAN B0 AND MASK b0_4d = b0_4d_init_0.clone('b0_4d') wf.connect(combine_corrections, 'outputnode.out_file', b0_4d, 'in_dwi') #wf.connect(selectfiles, 'bval_file', b0_4d, 'in_bval') wf.connect(bvals_with_nodiff_0, 'bval_file_zero', b0_4d, 'in_bval') mean_b0_moco = mean_b0_moco_init_0.clone('mean_b0_moco') wf.connect(b0_4d, 'out_file', mean_b0_moco, 'in_file') b0_mask = b0_mask_init_0.clone('b0_mask') wf.connect(mean_b0_moco, 'out_file', b0_mask, 'in_file') # denoise = Node(dipy.Denoise(), name='denoise') # wf.connect(combine_corrections, 'outputnode.out_file', denoise, 'in_file') # wf.connect(b0_mask, 'mask_file', denoise, 'in_mask') # wf.connect(denoise, 'out_file', ds, 'denoised') # check if ok fixme denoise = nlmeans_pipeline() wf.connect(combine_corrections, 'outputnode.out_file', denoise, 'inputnode.in_file') wf.connect(b0_mask, 'mask_file', denoise, 'inputnode.in_mask') wf.connect(denoise, 'outputnode.out_file', ds, 'denoised') # DTIFIT dtifit = Node(interface=fsl.DTIFit(), name='dtifit') wf.connect(combine_corrections, 'outputnode.out_file', dtifit, 'dwi') wf.connect(b0_mask, 'mask_file', dtifit, 'mask') wf.connect(hmc, 'outputnode.out_bvec', dtifit, 'bvecs') wf.connect(selectfiles, 'bval_file', dtifit, 'bvals') wf.connect(dtifit, 'FA', ds, 'dtifit.@FA') wf.connect(dtifit, 'L1', ds, 'dtifit.@L1') wf.connect(dtifit, 'L2', ds, 'dtifit.@L2') wf.connect(dtifit, 'L3', ds, 'dtifit.@L3') wf.connect(dtifit, 'MD', ds, 'dtifit.@MD') wf.connect(dtifit, 'MO', ds, 'dtifit.@MO') wf.connect(dtifit, 'S0', ds, 'dtifit.@S0') wf.connect(dtifit, 'V1', ds, 'dtifit.@V1') wf.connect(dtifit, 'V2', ds, 'dtifit.@V2') wf.connect(dtifit, 'V3', ds, 'dtifit.@V3') wf.connect(dtifit, 'tensor', ds, 'dtifit.@tensor') RD_sum = Node(fsl.ImageMaths(op_string='-add '), name='RD_sum') wf.connect(dtifit, 'L2', RD_sum, 'in_file') wf.connect(dtifit, 'L3', RD_sum, 'in_file2') RD = Node(fsl.ImageMaths(op_string='-div 2', out_file='RD.nii.gz'), name='RD') wf.connect(RD_sum, 'out_file', RD, 'in_file') wf.connect(RD, 'out_file', ds, 'dtifit.@RD') simple_ecc = Node(fsl.EddyCorrect(), name='simple_ecc') wf.connect(selectfiles, 'dMRI_data', simple_ecc, 'in_file') wf.connect(simple_ecc, 'eddy_corrected', ds, 'simple_ecc') # DTIFIT DENOISED dtifit_denoised = Node(interface=fsl.DTIFit(), name='dtifit_denoised') wf.connect(denoise, 'outputnode.out_file', dtifit_denoised, 'dwi') wf.connect(b0_mask, 'mask_file', dtifit_denoised, 'mask') wf.connect(hmc, 'outputnode.out_bvec', dtifit_denoised, 'bvecs') wf.connect(selectfiles, 'bval_file', dtifit_denoised, 'bvals') wf.connect(dtifit_denoised, 'FA', ds, 'dtifit_denoised.@FA') wf.connect(dtifit_denoised, 'L1', ds, 'dtifit_denoised.@L1') wf.connect(dtifit_denoised, 'L2', ds, 'dtifit_denoised.@L2') wf.connect(dtifit_denoised, 'L3', ds, 'dtifit_denoised.@L3') wf.connect(dtifit_denoised, 'MD', ds, 'dtifit_denoised.@MD') wf.connect(dtifit_denoised, 'MO', ds, 'dtifit_denoised.@MO') wf.connect(dtifit_denoised, 'S0', ds, 'dtifit_denoised.@S0') wf.connect(dtifit_denoised, 'V1', ds, 'dtifit_denoised.@V1') wf.connect(dtifit_denoised, 'V2', ds, 'dtifit_denoised.@V2') wf.connect(dtifit_denoised, 'V3', ds, 'dtifit_denoised.@V3') # def _file_to_list(in_file): if type(in_file) is not list: return [in_file] else: return in_file in_file_to_list = Node(util.Function(input_names=['in_file'], output_names=['out_file'], function=_file_to_list), name='in_file_to_list') wf.connect(dtifit, 'FA', in_file_to_list, 'in_file') # TBSS tbss = create_tbss_all(estimate_skeleton=False) tbss.inputs.inputnode.skeleton_thresh = 0.2 wf.connect(in_file_to_list, 'out_file', tbss, 'inputnode.fa_list') wf.connect(tbss, 'outputall_node.mergefa_file3', ds, 'tbss.@mergefa') wf.connect(tbss, 'outputnode.projectedfa_file', ds, 'tbss.@projectedfa_file') wf.connect(tbss, 'outputnode.skeleton_file4', ds, 'tbss.@skeleton_file') wf.connect(tbss, 'outputnode.skeleton_mask', ds, 'tbss.@skeleton_mask') # outputnode.meanfa_file # outputnode.projectedfa_file # outputnode.skeleton_file # outputnode.skeleton_mask ##################################### # RUN WF ##################################### wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical') wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf') wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf') if plugin_name == 'CondorDAGMan': wf.run(plugin=plugin_name) if plugin_name == 'MultiProc': wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def learning_predict_data_2samp_wf(working_dir, ds_dir, in_data_name_list, subjects_selection_crit_dict, subjects_selection_crit_names_list, aggregated_subjects_dir, target_list, use_n_procs, plugin_name, confound_regression=[False, True], run_cv=False, n_jobs_cv=1, run_tuning=False, run_2sample_training=False, aggregated_subjects_dir_nki=None, subjects_selection_crit_dict_nki=None, subjects_selection_crit_name_nki=None, reverse_split=False, random_state_nki=666, run_learning_curve=False, life_test_size=0.5): import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from itertools import chain from learning_utils import aggregate_multimodal_metrics_fct, run_prediction_split_fct, \ backproject_and_split_weights_fct, select_subjects_fct, select_multimodal_X_fct, learning_curve_plot import pandas as pd ############################################################################################################### # GENERAL SETTINGS wf = Workflow(name='learning_predict_data_2samp_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ############################################################################################################### # ensure in_data_name_list is list of lists in_data_name_list = [i if type(i) == list else [i] for i in in_data_name_list] in_data_name_list_unique = list(set(chain.from_iterable(in_data_name_list))) ############################################################################################################### # SET ITERATORS in_data_name_infosource = Node(util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) multimodal_in_data_name_infosource = Node(util.IdentityInterface(fields=['multimodal_in_data_name']), name='multimodal_in_data_name_infosource') multimodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) subject_selection_infosource = Node(util.IdentityInterface(fields=['selection_criterium']), name='subject_selection_infosource') subject_selection_infosource.iterables = ('selection_criterium', subjects_selection_crit_names_list) target_infosource = Node(util.IdentityInterface(fields=['target_name']), name='target_infosource') target_infosource.iterables = ('target_name', target_list) ############################################################################################################### # COMPILE LIFE DATA ############################################################################################################### ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file = os.path.join(aggregated_subjects_dir, 'df_all_subjects_pickle_file/df_all.pkl') df = pd.read_pickle(df_all_subjects_pickle_file) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict = {} for k in in_data_name_list_unique: unimodal_lookup_dict[k] = {'X_file': os.path.join(aggregated_subjects_dir, X_file_template.format( in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir, info_file_template.format( in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics = Node(util.Function(input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=['X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name'], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics, 'multimodal_list') aggregate_multimodal_metrics.inputs.unimodal_lookup_dict = unimodal_lookup_dict ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects = Node(util.Function(input_names=['df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium'], output_names=['df_use_file', 'df_use_pickle_file', 'subjects_selection_index'], function=select_subjects_fct), name='select_subjects') select_subjects.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file select_subjects.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict wf.connect(subject_selection_infosource, 'selection_criterium', select_subjects, 'selection_criterium') ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X = Node(util.Function(input_names=['X_multimodal_file', 'subjects_selection_index', 'selection_criterium'], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X') wf.connect(aggregate_multimodal_metrics, 'X_multimodal_file', select_multimodal_X, 'X_multimodal_file') wf.connect(select_subjects, 'subjects_selection_index', select_multimodal_X, 'subjects_selection_index') ############################################################################################################### # COMPILE NKI DATA ############################################################################################################### if run_2sample_training: ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file_nki = os.path.join(aggregated_subjects_dir_nki, 'df_all_subjects_pickle_file/df_all.pkl') df_nki = pd.read_pickle(df_all_subjects_pickle_file_nki) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict_nki = {} for k in in_data_name_list_unique: unimodal_lookup_dict_nki[k] = {'X_file': os.path.join(aggregated_subjects_dir_nki, X_file_template.format( in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join( aggregated_subjects_dir_nki, info_file_template.format( in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics_nki = Node(util.Function(input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=['X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name'], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics_nki') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics_nki, 'multimodal_list') aggregate_multimodal_metrics_nki.inputs.unimodal_lookup_dict = unimodal_lookup_dict_nki ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects_nki = Node(util.Function(input_names=['df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium'], output_names=['df_use_file', 'df_use_pickle_file', 'subjects_selection_index'], function=select_subjects_fct), name='select_subjects_nki') select_subjects_nki.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file_nki select_subjects_nki.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict_nki select_subjects_nki.inputs.selection_criterium = subjects_selection_crit_name_nki ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X_nki = Node(util.Function(input_names=['X_multimodal_file', 'subjects_selection_index', 'selection_criterium'], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X_nki') wf.connect(aggregate_multimodal_metrics_nki, 'X_multimodal_file', select_multimodal_X_nki, 'X_multimodal_file') wf.connect(select_subjects_nki, 'subjects_selection_index', select_multimodal_X_nki, 'subjects_selection_index') ############################################################################################################### # RUN PREDICTION # prediction_node_dict = {} backprojection_node_dict = {} prediction_split = Node(util.Function(input_names=['X_file', 'target_name', 'selection_criterium', 'df_file', 'data_str', 'regress_confounds', 'run_cv', 'n_jobs_cv', 'run_tuning', 'X_file_nki', 'df_file_nki', 'reverse_split', 'random_state_nki', 'run_learning_curve', 'life_test_size'], output_names=['scatter_file', 'brain_age_scatter_file', 'df_life_out_file', 'df_nki_out_file', 'df_big_out_file', 'model_out_file', 'df_res_out_file', 'tuning_curve_file', 'scatter_file_cv', 'learning_curve_plot_file', 'learning_curve_df_file'], function=run_prediction_split_fct), name='prediction_split') backproject_and_split_weights = Node(util.Function(input_names=['trained_model_file', 'multimodal_backprojection_info', 'data_str', 'target_name'], output_names=['out_file_list', 'out_file_render_list'], function=backproject_and_split_weights_fct), name='backproject_and_split_weights') i = 0 for reg in confound_regression: the_out_node_str = 'single_source_model_reg_%s_' % (reg) prediction_node_dict[i] = prediction_split.clone(the_out_node_str) the_in_node = prediction_node_dict[i] the_in_node.inputs.regress_confounds = reg the_in_node.inputs.run_cv = run_cv the_in_node.inputs.n_jobs_cv = n_jobs_cv the_in_node.inputs.run_tuning = run_tuning the_in_node.inputs.reverse_split = reverse_split the_in_node.inputs.random_state_nki = random_state_nki the_in_node.inputs.run_learning_curve = run_learning_curve the_in_node.inputs.life_test_size = life_test_size wf.connect(select_multimodal_X, 'X_multimodal_selected_file', the_in_node, 'X_file') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(subject_selection_infosource, 'selection_criterium', the_in_node, 'selection_criterium') wf.connect(select_subjects, 'df_use_pickle_file', the_in_node, 'df_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(the_in_node, 'model_out_file', ds, the_out_node_str + 'trained_model') wf.connect(the_in_node, 'scatter_file', ds_pdf, the_out_node_str + 'scatter') wf.connect(the_in_node, 'brain_age_scatter_file', ds_pdf, the_out_node_str + 'brain_age_scatter') wf.connect(the_in_node, 'df_life_out_file', ds_pdf, the_out_node_str + 'predicted_life') wf.connect(the_in_node, 'df_nki_out_file', ds_pdf, the_out_node_str + 'predicted_nki') wf.connect(the_in_node, 'df_big_out_file', ds_pdf, the_out_node_str + 'predicted') wf.connect(the_in_node, 'df_res_out_file', ds_pdf, the_out_node_str + 'results_error') wf.connect(the_in_node, 'tuning_curve_file', ds_pdf, the_out_node_str + 'tuning_curve') wf.connect(the_in_node, 'scatter_file_cv', ds_pdf, the_out_node_str + 'scatter_cv') wf.connect(the_in_node, 'learning_curve_plot_file', ds_pdf, the_out_node_str + 'learning_curve_plot_file.@plot') wf.connect(the_in_node, 'learning_curve_df_file', ds_pdf, the_out_node_str + 'learning_curve_df_file.@df') # NKI if run_2sample_training: wf.connect(select_multimodal_X_nki, 'X_multimodal_selected_file', the_in_node, 'X_file_nki') wf.connect(select_subjects_nki, 'df_use_pickle_file', the_in_node, 'df_file_nki') else: the_in_node.inputs.df_file_nki = None the_in_node.inputs.X_file_nki = None # BACKPROJECT PREDICTION WEIGHTS # map weights back to single modality original format (e.g., nifti or matrix) the_out_node_str = 'backprojection_single_source_model_reg_%s_' % (reg) backprojection_node_dict[i] = backproject_and_split_weights.clone(the_out_node_str) the_from_node = prediction_node_dict[i] the_in_node = backprojection_node_dict[i] wf.connect(the_from_node, 'model_out_file', the_in_node, 'trained_model_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_backprojection_info', the_in_node, 'multimodal_backprojection_info') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(the_in_node, 'out_file_list', ds_pdf, the_out_node_str + '.@weights') wf.connect(the_in_node, 'out_file_render_list', ds_pdf, the_out_node_str + 'renders.@renders') i += 1 ############################################################################################################### # # RUN WF wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical') wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf') wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf') if plugin_name == 'CondorDAGMan': wf.run(plugin=plugin_name) if plugin_name == 'MultiProc': wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def learning_predict_data_wf(working_dir, ds_dir, trained_model_dir, in_data_name_list, subjects_selection_crit_dict, subjects_selection_crit_names_list, aggregated_subjects_dir, target_list, trained_model_template, use_n_procs, plugin_name, confound_regression=[False, True]): # trained_model_template = { # 'trained_model': 'learning_out/group_learning_prepare_data/{ana_stream}trained_model/' + # '_multimodal_in_data_name_{multimodal_in_data_name}/_selection_criterium_bothSexes_neuH/' + # '_target_name_{target_name}/trained_model.pkl'} import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from itertools import chain from learning_utils import aggregate_multimodal_metrics_fct, run_prediction_from_trained_model_fct, \ select_subjects_fct, select_multimodal_X_fct import pandas as pd ############################################################################################################### # GENERAL SETTINGS wf = Workflow(name='learning_predict_data_from_trained_model_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ############################################################################################################### # ensure in_data_name_list is list of lists in_data_name_list = [i if type(i) == list else [i] for i in in_data_name_list] in_data_name_list_unique = list(set(chain.from_iterable(in_data_name_list))) ############################################################################################################### # SET ITERATORS in_data_name_infosource = Node(util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) multimodal_in_data_name_infosource = Node(util.IdentityInterface(fields=['multimodal_in_data_name']), name='multimodal_in_data_name_infosource') multimodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) subject_selection_infosource = Node(util.IdentityInterface(fields=['selection_criterium']), name='subject_selection_infosource') subject_selection_infosource.iterables = ('selection_criterium', subjects_selection_crit_names_list) target_infosource = Node(util.IdentityInterface(fields=['target_name']), name='target_infosource') target_infosource.iterables = ('target_name', target_list) ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file = os.path.join(aggregated_subjects_dir, 'df_all_subjects_pickle_file/df_all.pkl') df = pd.read_pickle(df_all_subjects_pickle_file) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict = {} for k in in_data_name_list_unique: unimodal_lookup_dict[k] = {'X_file': os.path.join(aggregated_subjects_dir, X_file_template.format( in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir, info_file_template.format( in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics = Node(util.Function(input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=['X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name'], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics, 'multimodal_list') aggregate_multimodal_metrics.inputs.unimodal_lookup_dict = unimodal_lookup_dict ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects = Node(util.Function(input_names=['df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium'], output_names=['df_use_file', 'df_use_pickle_file', 'subjects_selection_index'], function=select_subjects_fct), name='select_subjects') select_subjects.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file select_subjects.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict wf.connect(subject_selection_infosource, 'selection_criterium', select_subjects, 'selection_criterium') ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X = Node(util.Function(input_names=['X_multimodal_file', 'subjects_selection_index', 'selection_criterium'], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X') wf.connect(aggregate_multimodal_metrics, 'X_multimodal_file', select_multimodal_X, 'X_multimodal_file') wf.connect(select_subjects, 'subjects_selection_index', select_multimodal_X, 'subjects_selection_index') ############################################################################################################### # RUN PREDICTION # prediction_node_dict = {} select_trained_model_node_dict = {} prediction = Node(util.Function(input_names=['trained_model_file', 'X_file', 'target_name', 'selection_criterium', 'df_file', 'data_str', 'regress_confounds'], output_names=['scatter_file', 'brain_age_scatter_file', 'df_use_file', 'df_res_out_file'], function=run_prediction_from_trained_model_fct), name='prediction') def rep(s): return s.replace('__', '.') select_trained_model = Node(nio.SelectFiles(trained_model_template), 'select_trained_model') i = 0 for reg in confound_regression: the_out_node_str = 'single_source_model_reg_%s_' % reg select_trained_model_node_dict[i] = select_trained_model.clone( the_out_node_str + 'select_trained_model') select_trained_model_node_dict[i].inputs.base_directory = trained_model_dir select_trained_model_node_dict[i].inputs.ana_stream = the_out_node_str wf.connect(target_infosource, 'target_name', select_trained_model_node_dict[i], 'target_name') wf.connect(aggregate_multimodal_metrics, ('multimodal_name', rep), select_trained_model_node_dict[i], 'multimodal_in_data_name') prediction_node_dict[i] = prediction.clone(the_out_node_str) the_in_node = prediction_node_dict[i] the_in_node.inputs.regress_confounds = reg wf.connect(select_trained_model_node_dict[i], 'trained_model', the_in_node, 'trained_model_file') wf.connect(select_multimodal_X, 'X_multimodal_selected_file', the_in_node, 'X_file') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(subject_selection_infosource, 'selection_criterium', the_in_node, 'selection_criterium') wf.connect(select_subjects, 'df_use_pickle_file', the_in_node, 'df_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(the_in_node, 'scatter_file', ds_pdf, the_out_node_str + 'scatter') wf.connect(the_in_node, 'brain_age_scatter_file', ds_pdf, the_out_node_str + 'brain_age_scatter') wf.connect(the_in_node, 'df_use_file', ds_pdf, the_out_node_str + 'predicted') wf.connect(the_in_node, 'df_res_out_file', ds_pdf, the_out_node_str + 'results_error') i += 1 ############################################################################################################### # RUN WF wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical') wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf') wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf') if plugin_name == 'CondorDAGMan': wf.run(plugin=plugin_name) if plugin_name == 'MultiProc': wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
img_out.to_filename(out_file) out_files.append(out_file) return out_files #Function node to filter both smooth and unsmooth bandpass = Node(Function(input_names=['in_files','lp','hp','TR'], output_names= 'out_files', function = bpfilter,imports=imports),name='bandpass') bandpass.inputs.lp = 0.01 bandpass.inputs.hp = 0.1 bandpass.inputs.TR = TR bandpass_unsmooth = bandpass.clone('bandpass_unsmooth') #create the preprocessing workflow preproc = Workflow(name='preproc3') preproc.base_dir = os.path.join(experiment_dir,working_dir) preproc.connect([(infosource,selectfiles,[('subject_id','subject_id')]), #(infosource,selectfiles_segment, [('subject_id','subject_id')]), (selectfiles,merge,[('func','in_files')]), (realign,meanfunc,[('modified_in_files','in_file')]), (selectfiles,segment,[('anat','channel_files')]), (meanfunc,bet_func,[('out_file','in_file')]), (selectfiles,bet_struct,[('anat','in_file')]), (bet_func,coregister,[('out_file','target')]), (bet_struct,coregister,[('out_file','source')]), (coregister,normalize_struct,[('coregistered_source','apply_to_files')]),
('pvc_labels.roi4DMaskFile', 'pvc.mask_file'), ('add.out_file', 'ROImeans.labelImgFile'), ('add.out_file', 'ROI_Q3.labelImgFile'), ]) ]) # 7. MNI SPACE # Quick registration to MNI template mri_to_mni = Node(interface=fsl.FLIRT(dof=12, reference=template), name="mri_to_mni") mergexfm = Node(interface=fsl.ConvertXFM(concat_xfm=True), name="mergexfm") transform_pet = Node(interface=fsl.ApplyXFM(apply_xfm=True, reference=template), name='transform_pet') transform_suvr = transform_pet.clone(name='transform_suvr') smooth_suvr = Node(interface=fsl.Smooth(fwhm=args.smooth_fwhm), name="smooth_suvr") mask_suvr = Node(interface=fsl.ImageMaths(op_string=' -mul ', suffix='_mul', in_file2=template_brainmask), name='mask_suvr') suvr_qc = Node(interface=triplanar_snapshots(alpha=.5, x=81, y=93, z=77, vmin=0.0, vmax=2.5),
def make_func_subcortical_masks(name='func_subcortical'): # Define Workflow flow = Workflow(name=name) inputnode = Node(util.IdentityInterface(fields=['func_first']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=[ 'left_nacc', 'left_amygdala', 'left_caudate', 'left_hipoocampus', 'left_pallidum', 'left_putamen', 'left_thalamus', 'right_nacc', 'right_amygdala', 'right_caudate', 'right_hipoocampus', 'right_pallidum', 'right_putamen', 'right_thalamus', 'midbrain', 'right_striatum', 'left_striatum' ]), name='outputnode') left_nacc = Node(interface=fsl.ExtractROI(), name='left_nacc') left_nacc.inputs.t_min = 0 left_nacc.inputs.t_size = 1 left_nacc.inputs.roi_file = 'left_nacc.nii.gz' left_amygdala = Node(interface=fsl.ExtractROI(), name='left_amygdala') left_amygdala.inputs.t_min = 1 left_amygdala.inputs.t_size = 1 left_amygdala.inputs.roi_file = 'left_amygdala.nii.gz' left_caudate = Node(interface=fsl.ExtractROI(), name='left_caudate') left_caudate.inputs.t_min = 2 left_caudate.inputs.t_size = 1 left_caudate.inputs.roi_file = 'left_caudate.nii.gz' left_hipoocampus = Node(interface=fsl.ExtractROI(), name='left_hipoocampus') left_hipoocampus.inputs.t_min = 3 left_hipoocampus.inputs.t_size = 1 left_hipoocampus.inputs.roi_file = 'left_hipoocampus.nii.gz' left_pallidum = Node(interface=fsl.ExtractROI(), name='left_pallidum') left_pallidum.inputs.t_min = 4 left_pallidum.inputs.t_size = 1 left_pallidum.inputs.roi_file = 'left_pallidum.nii.gz' left_putamen = Node(interface=fsl.ExtractROI(), name='left_putamen') left_putamen.inputs.t_min = 5 left_putamen.inputs.t_size = 1 left_putamen.inputs.roi_file = 'left_putamen.nii.gz' left_thalamus = Node(interface=fsl.ExtractROI(), name='left_thalamus') left_thalamus.inputs.t_min = 6 left_thalamus.inputs.t_size = 1 left_thalamus.inputs.roi_file = 'left_thalamus.nii.gz' ############### right_nacc = Node(interface=fsl.ExtractROI(), name='right_nacc') right_nacc.inputs.t_min = 7 right_nacc.inputs.t_size = 1 right_nacc.inputs.roi_file = 'right_nacc.nii.gz' right_amygdala = Node(interface=fsl.ExtractROI(), name='right_amygdala') right_amygdala.inputs.t_min = 8 right_amygdala.inputs.t_size = 1 right_amygdala.inputs.roi_file = 'right_amygdala.nii.gz' right_caudate = Node(interface=fsl.ExtractROI(), name='right_caudate') right_caudate.inputs.t_min = 9 right_caudate.inputs.t_size = 1 right_caudate.inputs.roi_file = 'right_caudate.nii.gz' right_hipoocampus = Node(interface=fsl.ExtractROI(), name='right_hipoocampus') right_hipoocampus.inputs.t_min = 10 right_hipoocampus.inputs.t_size = 1 right_hipoocampus.inputs.roi_file = 'right_hipoocampus.nii.gz' right_pallidum = Node(interface=fsl.ExtractROI(), name='right_pallidum') right_pallidum.inputs.t_min = 11 right_pallidum.inputs.t_size = 1 right_pallidum.inputs.roi_file = 'right_pallidum.nii.gz' right_putamen = Node(interface=fsl.ExtractROI(), name='right_putamen') right_putamen.inputs.t_min = 12 right_putamen.inputs.t_size = 1 right_putamen.inputs.roi_file = 'right_putamen.nii.gz' right_thalamus = Node(interface=fsl.ExtractROI(), name='right_thalamus') right_thalamus.inputs.t_min = 13 right_thalamus.inputs.t_size = 1 right_thalamus.inputs.roi_file = 'right_thalamus.nii.gz' midbrain = Node(interface=fsl.ExtractROI(), name='midbrain') midbrain.inputs.t_min = 14 midbrain.inputs.t_size = 1 midbrain.inputs.roi_file = 'midbrain.nii.gz' flow.connect(inputnode, 'func_first', left_nacc, 'in_file') flow.connect(inputnode, 'func_first', left_amygdala, 'in_file') flow.connect(inputnode, 'func_first', left_caudate, 'in_file') flow.connect(inputnode, 'func_first', left_hipoocampus, 'in_file') flow.connect(inputnode, 'func_first', left_pallidum, 'in_file') flow.connect(inputnode, 'func_first', left_putamen, 'in_file') flow.connect(inputnode, 'func_first', left_thalamus, 'in_file') flow.connect(inputnode, 'func_first', right_nacc, 'in_file') flow.connect(inputnode, 'func_first', right_amygdala, 'in_file') flow.connect(inputnode, 'func_first', right_caudate, 'in_file') flow.connect(inputnode, 'func_first', right_hipoocampus, 'in_file') flow.connect(inputnode, 'func_first', right_pallidum, 'in_file') flow.connect(inputnode, 'func_first', right_putamen, 'in_file') flow.connect(inputnode, 'func_first', right_thalamus, 'in_file') flow.connect(inputnode, 'func_first', midbrain, 'in_file') flow.connect(left_nacc, 'roi_file', outputnode, 'left_nacc') flow.connect(left_amygdala, 'roi_file', outputnode, 'left_amygdala') flow.connect(left_caudate, 'roi_file', outputnode, 'left_caudate') flow.connect(left_hipoocampus, 'roi_file', outputnode, 'left_hipoocampus') flow.connect(left_pallidum, 'roi_file', outputnode, 'left_pallidum') flow.connect(left_putamen, 'roi_file', outputnode, 'left_putamen') flow.connect(left_thalamus, 'roi_file', outputnode, 'left_thalamus') flow.connect(right_nacc, 'roi_file', outputnode, 'right_nacc') flow.connect(right_amygdala, 'roi_file', outputnode, 'right_amygdala') flow.connect(right_caudate, 'roi_file', outputnode, 'right_caudate') flow.connect(right_hipoocampus, 'roi_file', outputnode, 'right_hipoocampus') flow.connect(right_pallidum, 'roi_file', outputnode, 'right_pallidum') flow.connect(right_putamen, 'roi_file', outputnode, 'right_putamen') flow.connect(right_thalamus, 'roi_file', outputnode, 'right_thalamus') flow.connect(midbrain, 'roi_file', outputnode, 'midbrain') # add images together right_striatum = Node(interface=fsl.MultiImageMaths(), name='right_striatum') right_striatum.inputs.op_string = '-add %s -add %s -bin' right_striatum.out_file = 'right_striatum.nii.gz' list_R_str = Node(util.Function(input_names=['file_1', 'file_2'], output_names=['list'], function=return_list), name='list_str_r') flow.connect(right_pallidum, 'roi_file', list_R_str, 'file_1') flow.connect(right_putamen, 'roi_file', list_R_str, 'file_2') flow.connect(right_caudate, 'roi_file', right_striatum, 'in_file') flow.connect(list_R_str, 'list', right_striatum, 'operand_files') flow.connect(right_striatum, 'out_file', outputnode, 'right_striatum') left_striatum = Node(interface=fsl.MultiImageMaths(), name='left_striatum') left_striatum.inputs.op_string = '-add %s -add %s' left_striatum.out_file = 'left_striatum.nii.gz' list_L_str = list_R_str.clone('list_str_l') flow.connect(left_pallidum, 'roi_file', list_L_str, 'file_1') flow.connect(left_putamen, 'roi_file', list_L_str, 'file_2') flow.connect(left_caudate, 'roi_file', left_striatum, 'in_file') flow.connect(list_L_str, 'list', left_striatum, 'operand_files') flow.connect(left_striatum, 'out_file', outputnode, 'left_striatum') return flow
# robust min max of fields def makelist(file1, file2): filelist=[file1,file2] return filelist make_list=Node(util.Function(input_names=['file1', 'file2'], output_names=['filelist'], function=makelist), name='make_list') min_max = MapNode(fsl.ImageStats(op_string='-r'), iterfield=['in_file'], name='min_max') min_max_txt = corr_fields_txt.clone(name='min_max_txt') min_max_txt.inputs.filename='min_max_fields.txt' simulated.connect([(simulation, make_list, [('outputnode.nonlin_field_masked', 'file1'), ('outputnode.fmap_field_masked', 'file2')]), (make_list, min_max, [('filelist', 'in_file')]), (min_max, min_max_txt, [('out_stat', 'stats')])]) # correlation of different corrections to groundtruth def makelist2(file1, file2, file3): filelist=[file1,file2,file3] return filelist make_list2=Node(util.Function(input_names=['file1', 'file2', 'file3'],
#======================================================================================================== # In[14]: # apply the trasnfromation to all the EPI volumes fa_2_atlas = Node(ants.ApplyTransforms(), name = 'fa_2_atlas') fa_2_atlas.inputs.dimension = 3 fa_2_atlas.inputs.input_image_type = 3 fa_2_atlas.inputs.num_threads = 1 fa_2_atlas.inputs.float = True fa_2_atlas.inputs.reference_image = '/home/in/aeed/fsl/fsl/data/atlases/JHU/JHU-ICBM-FA-2mm.nii.gz' #======================================================================================================== md_2_atlas = fa_2_atlas.clone(name = 'md_2_atlas') rd_2_atlas = fa_2_atlas.clone(name = 'rd_2_atlas') ad_2_atlas = fa_2_atlas.clone(name = 'ad_2_atlas') ball_stick_ICVF_2_atlas = fa_2_atlas.clone(name = 'ball_stick_ICVF_2_atlas') ball_stick_ECVF_2_atlas = fa_2_atlas.clone(name = 'ball_stick_ECVF_2_atlas') noddi_mu_2_atlas = fa_2_atlas.clone(name = 'noddi_mu_2_atlas') noddi_odi_2_atlas = fa_2_atlas.clone(name = 'noddi_odi_2_atlas') noddi_ICVF_2_atlas = fa_2_atlas.clone(name = 'noddi_ICVF_2_atlas') noddi_ECVF_2_atlas = fa_2_atlas.clone(name = 'noddi_ECVF_2_atlas') noddi_ISOVF_2_atlas = fa_2_atlas.clone(name = 'noddi_ISOVF_2_atlas') mcmdi_lambda_2_atlas = fa_2_atlas.clone(name = 'mcmdi_lambda_2_atlas')
def make_func_subcortical_masks(name = 'func_subcortical'): # Define Workflow flow = Workflow(name=name) inputnode = Node(util.IdentityInterface(fields=['func_first']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=['left_nacc', 'left_amygdala', 'left_caudate', 'left_hipoocampus', 'left_pallidum', 'left_putamen', 'left_thalamus', 'right_nacc','right_amygdala', 'right_caudate', 'right_hipoocampus', 'right_pallidum', 'right_putamen','right_thalamus', 'midbrain', 'right_striatum', 'left_striatum']), name = 'outputnode') left_nacc = Node(interface=fsl.ExtractROI(), name = 'left_nacc') left_nacc.inputs.t_min = 0 left_nacc.inputs.t_size = 1 left_nacc.inputs.roi_file = 'left_nacc.nii.gz' left_amygdala = Node(interface=fsl.ExtractROI(), name = 'left_amygdala') left_amygdala.inputs.t_min = 1 left_amygdala.inputs.t_size = 1 left_amygdala.inputs.roi_file = 'left_amygdala.nii.gz' left_caudate = Node(interface=fsl.ExtractROI(), name = 'left_caudate') left_caudate.inputs.t_min = 2 left_caudate.inputs.t_size = 1 left_caudate.inputs.roi_file = 'left_caudate.nii.gz' left_hipoocampus = Node(interface=fsl.ExtractROI(), name = 'left_hipoocampus') left_hipoocampus.inputs.t_min = 3 left_hipoocampus.inputs.t_size = 1 left_hipoocampus.inputs.roi_file = 'left_hipoocampus.nii.gz' left_pallidum = Node(interface=fsl.ExtractROI(), name = 'left_pallidum') left_pallidum.inputs.t_min = 4 left_pallidum.inputs.t_size = 1 left_pallidum.inputs.roi_file = 'left_pallidum.nii.gz' left_putamen = Node(interface=fsl.ExtractROI(), name = 'left_putamen') left_putamen.inputs.t_min = 5 left_putamen.inputs.t_size = 1 left_putamen.inputs.roi_file = 'left_putamen.nii.gz' left_thalamus = Node(interface=fsl.ExtractROI(), name = 'left_thalamus') left_thalamus.inputs.t_min = 6 left_thalamus.inputs.t_size = 1 left_thalamus.inputs.roi_file = 'left_thalamus.nii.gz' ############### right_nacc = Node(interface=fsl.ExtractROI(), name = 'right_nacc') right_nacc.inputs.t_min = 7 right_nacc.inputs.t_size = 1 right_nacc.inputs.roi_file = 'right_nacc.nii.gz' right_amygdala = Node(interface=fsl.ExtractROI(), name = 'right_amygdala') right_amygdala.inputs.t_min = 8 right_amygdala.inputs.t_size = 1 right_amygdala.inputs.roi_file = 'right_amygdala.nii.gz' right_caudate = Node(interface=fsl.ExtractROI(), name = 'right_caudate') right_caudate.inputs.t_min = 9 right_caudate.inputs.t_size = 1 right_caudate.inputs.roi_file = 'right_caudate.nii.gz' right_hipoocampus = Node(interface=fsl.ExtractROI(), name = 'right_hipoocampus') right_hipoocampus.inputs.t_min = 10 right_hipoocampus.inputs.t_size = 1 right_hipoocampus.inputs.roi_file = 'right_hipoocampus.nii.gz' right_pallidum = Node(interface=fsl.ExtractROI(), name = 'right_pallidum') right_pallidum.inputs.t_min = 11 right_pallidum.inputs.t_size = 1 right_pallidum.inputs.roi_file = 'right_pallidum.nii.gz' right_putamen = Node(interface=fsl.ExtractROI(), name = 'right_putamen') right_putamen.inputs.t_min = 12 right_putamen.inputs.t_size = 1 right_putamen.inputs.roi_file = 'right_putamen.nii.gz' right_thalamus = Node(interface=fsl.ExtractROI(), name = 'right_thalamus') right_thalamus.inputs.t_min = 13 right_thalamus.inputs.t_size = 1 right_thalamus.inputs.roi_file = 'right_thalamus.nii.gz' midbrain = Node(interface=fsl.ExtractROI(), name = 'midbrain') midbrain.inputs.t_min = 14 midbrain.inputs.t_size = 1 midbrain.inputs.roi_file = 'midbrain.nii.gz' flow.connect( inputnode , 'func_first' , left_nacc, 'in_file' ) flow.connect( inputnode , 'func_first' , left_amygdala, 'in_file' ) flow.connect( inputnode , 'func_first' , left_caudate, 'in_file' ) flow.connect( inputnode , 'func_first' , left_hipoocampus,'in_file' ) flow.connect( inputnode , 'func_first' , left_pallidum, 'in_file' ) flow.connect( inputnode , 'func_first' , left_putamen, 'in_file' ) flow.connect( inputnode , 'func_first' , left_thalamus, 'in_file' ) flow.connect( inputnode , 'func_first' , right_nacc, 'in_file' ) flow.connect( inputnode , 'func_first' , right_amygdala, 'in_file' ) flow.connect( inputnode , 'func_first' , right_caudate, 'in_file' ) flow.connect( inputnode , 'func_first' , right_hipoocampus,'in_file' ) flow.connect( inputnode , 'func_first' , right_pallidum, 'in_file' ) flow.connect( inputnode , 'func_first' , right_putamen, 'in_file' ) flow.connect( inputnode , 'func_first' , right_thalamus, 'in_file' ) flow.connect( inputnode , 'func_first' , midbrain, 'in_file' ) flow.connect( left_nacc , 'roi_file' ,outputnode , 'left_nacc' ) flow.connect( left_amygdala , 'roi_file' ,outputnode , 'left_amygdala' ) flow.connect( left_caudate , 'roi_file' ,outputnode , 'left_caudate' ) flow.connect( left_hipoocampus , 'roi_file' ,outputnode , 'left_hipoocampus') flow.connect( left_pallidum , 'roi_file' ,outputnode , 'left_pallidum') flow.connect( left_putamen , 'roi_file' ,outputnode , 'left_putamen' ) flow.connect( left_thalamus , 'roi_file' ,outputnode , 'left_thalamus' ) flow.connect( right_nacc , 'roi_file' ,outputnode , 'right_nacc' ) flow.connect( right_amygdala , 'roi_file' ,outputnode , 'right_amygdala' ) flow.connect( right_caudate , 'roi_file' ,outputnode , 'right_caudate' ) flow.connect( right_hipoocampus, 'roi_file' ,outputnode , 'right_hipoocampus') flow.connect( right_pallidum , 'roi_file' ,outputnode , 'right_pallidum') flow.connect( right_putamen , 'roi_file' ,outputnode , 'right_putamen' ) flow.connect( right_thalamus , 'roi_file' ,outputnode , 'right_thalamus' ) flow.connect( midbrain , 'roi_file' ,outputnode , 'midbrain' ) # add images together right_striatum = Node(interface=fsl.MultiImageMaths(), name = 'right_striatum') right_striatum.inputs.op_string = '-add %s -add %s -bin' right_striatum.out_file = 'right_striatum.nii.gz' list_R_str = Node(util.Function(input_names = ['file_1', 'file_2'], output_names= ['list'], function = return_list), name = 'list_str_r') flow.connect( right_pallidum , 'roi_file' ,list_R_str , 'file_1' ) flow.connect( right_putamen , 'roi_file' ,list_R_str , 'file_2' ) flow.connect( right_caudate , 'roi_file' ,right_striatum , 'in_file' ) flow.connect( list_R_str , 'list' ,right_striatum , 'operand_files' ) flow.connect( right_striatum , 'out_file' ,outputnode , 'right_striatum' ) left_striatum = Node(interface=fsl.MultiImageMaths(), name = 'left_striatum') left_striatum.inputs.op_string = '-add %s -add %s' left_striatum.out_file = 'left_striatum.nii.gz' list_L_str = list_R_str.clone('list_str_l') flow.connect( left_pallidum , 'roi_file' ,list_L_str , 'file_1' ) flow.connect( left_putamen , 'roi_file' ,list_L_str , 'file_2' ) flow.connect( left_caudate , 'roi_file' ,left_striatum , 'in_file' ) flow.connect( list_L_str , 'list' ,left_striatum , 'operand_files' ) flow.connect( left_striatum , 'out_file' ,outputnode , 'left_striatum' ) return flow
interface=Function( input_names=['zstat', 'volume', 'dlh'], output_names=['threshold_file', 'masked_zstat'], function=cluster_zstats)) #========================================================================================================================================================== #Move the images to MNI space with precalculated transformations unthresh_2_MNI = Node(ants.ApplyTransforms(), name='unthresh_2_MNI') unthresh_2_MNI.inputs.reference_image = MNI_1mm unthresh_2_MNI.inputs.transforms = '/Volumes/Amr_1TB/NARPS/narps_to_MNI_1mm_Composite.h5' unthresh_2_MNI.inputs.dimension = 3 unthresh_2_MNI.inputs.output_image = 'unthreshold_file_MNI.nii.gz' #========================================================================================================================================================== #threshold the maps to 3.1 to make it ready for submission thresh_2_MNI = unthresh_2_MNI.clone(name='thresh_2_MNI') #========================================================================================================================================================== #overlay thresh_zstat1 overlay_zstat = Node(fsl.Overlay(), name='overlay') overlay_zstat.inputs.auto_thresh_bg = True overlay_zstat.inputs.stat_thresh = (3.1, 10) #threshold positive and negative overlay_zstat.inputs.transparency = True overlay_zstat.inputs.out_file = 'rendered_thresh_zstat.nii.gz' overlay_zstat.inputs.show_negative_stats = True overlay_zstat.inputs.background_image = MNI_1mm #========================================================================================================================================================== #generate pics thresh_zstat1
def learning_predict_data_wf(working_dir, ds_dir, trained_model_dir, in_data_name_list, subjects_selection_crit_dict, subjects_selection_crit_names_list, aggregated_subjects_dir, target_list, trained_model_template, use_n_procs, plugin_name, confound_regression=[False, True]): # trained_model_template = { # 'trained_model': 'learning_out/group_learning_prepare_data/{ana_stream}trained_model/' + # '_multimodal_in_data_name_{multimodal_in_data_name}/_selection_criterium_bothSexes_neuH/' + # '_target_name_{target_name}/trained_model.pkl'} import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from itertools import chain from learning_utils import aggregate_multimodal_metrics_fct, run_prediction_from_trained_model_fct, \ select_subjects_fct, select_multimodal_X_fct import pandas as pd ############################################################################################################### # GENERAL SETTINGS wf = Workflow(name='learning_predict_data_from_trained_model_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={ 'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120 }) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join( working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ############################################################################################################### # ensure in_data_name_list is list of lists in_data_name_list = [ i if type(i) == list else [i] for i in in_data_name_list ] in_data_name_list_unique = list(set( chain.from_iterable(in_data_name_list))) ############################################################################################################### # SET ITERATORS in_data_name_infosource = Node( util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) multimodal_in_data_name_infosource = Node( util.IdentityInterface(fields=['multimodal_in_data_name']), name='multimodal_in_data_name_infosource') multimodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) subject_selection_infosource = Node( util.IdentityInterface(fields=['selection_criterium']), name='subject_selection_infosource') subject_selection_infosource.iterables = ( 'selection_criterium', subjects_selection_crit_names_list) target_infosource = Node(util.IdentityInterface(fields=['target_name']), name='target_infosource') target_infosource.iterables = ('target_name', target_list) ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file = os.path.join( aggregated_subjects_dir, 'df_all_subjects_pickle_file/df_all.pkl') df = pd.read_pickle(df_all_subjects_pickle_file) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict = {} for k in in_data_name_list_unique: unimodal_lookup_dict[k] = { 'X_file': os.path.join(aggregated_subjects_dir, X_file_template.format(in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir, info_file_template.format(in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics = Node(util.Function( input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=[ 'X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name' ], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics, 'multimodal_list') aggregate_multimodal_metrics.inputs.unimodal_lookup_dict = unimodal_lookup_dict ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects = Node(util.Function(input_names=[ 'df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium' ], output_names=[ 'df_use_file', 'df_use_pickle_file', 'subjects_selection_index' ], function=select_subjects_fct), name='select_subjects') select_subjects.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file select_subjects.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict wf.connect(subject_selection_infosource, 'selection_criterium', select_subjects, 'selection_criterium') ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X = Node(util.Function( input_names=[ 'X_multimodal_file', 'subjects_selection_index', 'selection_criterium' ], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X') wf.connect(aggregate_multimodal_metrics, 'X_multimodal_file', select_multimodal_X, 'X_multimodal_file') wf.connect(select_subjects, 'subjects_selection_index', select_multimodal_X, 'subjects_selection_index') ############################################################################################################### # RUN PREDICTION # prediction_node_dict = {} select_trained_model_node_dict = {} prediction = Node(util.Function( input_names=[ 'trained_model_file', 'X_file', 'target_name', 'selection_criterium', 'df_file', 'data_str', 'regress_confounds' ], output_names=[ 'scatter_file', 'brain_age_scatter_file', 'df_use_file', 'df_res_out_file' ], function=run_prediction_from_trained_model_fct), name='prediction') def rep(s): return s.replace('__', '.') select_trained_model = Node(nio.SelectFiles(trained_model_template), 'select_trained_model') i = 0 for reg in confound_regression: the_out_node_str = 'single_source_model_reg_%s_' % reg select_trained_model_node_dict[i] = select_trained_model.clone( the_out_node_str + 'select_trained_model') select_trained_model_node_dict[ i].inputs.base_directory = trained_model_dir select_trained_model_node_dict[i].inputs.ana_stream = the_out_node_str wf.connect(target_infosource, 'target_name', select_trained_model_node_dict[i], 'target_name') wf.connect(aggregate_multimodal_metrics, ('multimodal_name', rep), select_trained_model_node_dict[i], 'multimodal_in_data_name') prediction_node_dict[i] = prediction.clone(the_out_node_str) the_in_node = prediction_node_dict[i] the_in_node.inputs.regress_confounds = reg wf.connect(select_trained_model_node_dict[i], 'trained_model', the_in_node, 'trained_model_file') wf.connect(select_multimodal_X, 'X_multimodal_selected_file', the_in_node, 'X_file') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(subject_selection_infosource, 'selection_criterium', the_in_node, 'selection_criterium') wf.connect(select_subjects, 'df_use_pickle_file', the_in_node, 'df_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(the_in_node, 'scatter_file', ds_pdf, the_out_node_str + 'scatter') wf.connect(the_in_node, 'brain_age_scatter_file', ds_pdf, the_out_node_str + 'brain_age_scatter') wf.connect(the_in_node, 'df_use_file', ds_pdf, the_out_node_str + 'predicted') wf.connect(the_in_node, 'df_res_out_file', ds_pdf, the_out_node_str + 'results_error') i += 1 ############################################################################################################### # RUN WF wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical') wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf') wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf') if plugin_name == 'CondorDAGMan': wf.run(plugin=plugin_name) if plugin_name == 'MultiProc': wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def create_similarity_pipeline(name): similarity=Workflow(name=name) # inputnode inputnode=Node(util.IdentityInterface(fields=['anat_brain', 'mask', 'lin_mean', 'nonlin_mean', 'fmap_mean', 'topup_mean', 'filename' ]), name='inputnode') # outputnode outputnode=Node(util.IdentityInterface(fields=['textfile']), name='outputnode') # resample all means to make sure they have the same resolution as reference anatomy resamp_mask = Node(afni.Resample(outputtype='NIFTI_GZ'), name='resample_mask') resamp_lin = resamp_mask.clone(name = 'resample_lin') resamp_nonlin = resamp_mask.clone(name='resample_nonlin') resamp_fmap = resamp_mask.clone(name='resample_fmap') resamp_topup = resamp_mask.clone(name='resample_topup') similarity.connect([(inputnode, resamp_mask, [('mask', 'in_file'), ('anat_brain', 'master')]), (inputnode, resamp_lin, [('lin_mean', 'in_file'), ('anat_brain', 'master')]), (inputnode, resamp_nonlin, [('nonlin_mean', 'in_file'), ('anat_brain', 'master')]), (inputnode, resamp_fmap, [('fmap_mean', 'in_file'), ('anat_brain', 'master')]), (inputnode, resamp_topup, [('topup_mean', 'in_file'), ('anat_brain', 'master')]), ]) # calculate similarity (all possible metrics) for each methods to mni lin_sim = MapNode(interface = nutil.Similarity(), name = 'similarity_lin', iterfield=['metric']) lin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1'] nonlin_sim = lin_sim.clone(name='similarity_nonlin') nonlin_sim.inputs.metric = ['mi','nmi','cc','cr','crl1'] fmap_sim = lin_sim.clone(name='similarity_fmap') fmap_sim.inputs.metric = ['mi','nmi','cc','cr','crl1'] topup_sim = lin_sim.clone(name='similarity_topup') topup_sim.inputs.metric = ['mi','nmi','cc','cr','crl1'] similarity.connect([(inputnode, lin_sim, [('anat_brain', 'volume1')]), (resamp_lin, lin_sim, [('out_file', 'volume2')]), (resamp_mask, lin_sim, [('out_file', 'mask1'), ('out_file', 'mask2')]), (inputnode, nonlin_sim, [('anat_brain', 'volume1')]), (resamp_nonlin, nonlin_sim, [('out_file', 'volume2')]), (resamp_mask, nonlin_sim, [('out_file', 'mask1'), ('out_file', 'mask2')]), (inputnode, fmap_sim, [('anat_brain', 'volume1')]), (resamp_fmap, fmap_sim, [('out_file', 'volume2')]), (resamp_mask, fmap_sim, [('out_file', 'mask1'), ('out_file', 'mask2')]), (inputnode, topup_sim, [('anat_brain', 'volume1')]), (resamp_topup, topup_sim, [('out_file', 'volume2')]), (resamp_mask, topup_sim, [('out_file', 'mask1'), ('out_file', 'mask2')]) ]) # write values to one text file per subject def write_text(lin_metrics, nonlin_metrics, fmap_metrics, topup_metrics, filename): import numpy as np import os lin_array = np.array(lin_metrics) lin_array=lin_array.reshape(np.size(lin_array),1) nonlin_array = np.array(nonlin_metrics) nonlin_array=nonlin_array.reshape(np.size(nonlin_array),1) fmap_array = np.array(fmap_metrics) fmap_array=fmap_array.reshape(np.size(fmap_array),1) topup_array = np.array(topup_metrics) topup_array=topup_array.reshape(np.size(topup_array),1) metrics=np.concatenate((lin_array, nonlin_array, fmap_array, topup_array),axis=1) metrics_file = filename np.savetxt(metrics_file, metrics, delimiter=' ', fmt='%f') return os.path.abspath(filename) write_txt = Node(interface=Function(input_names=['lin_metrics', 'nonlin_metrics', 'fmap_metrics', 'topup_metrics', 'filename'], output_names=['txtfile'], function=write_text), name='write_file') similarity.connect([(inputnode, write_txt, [('filename', 'filename')]), (lin_sim, write_txt, [('similarity', 'lin_metrics')]), (nonlin_sim, write_txt, [('similarity', 'nonlin_metrics')]), (fmap_sim, write_txt, [('similarity', 'fmap_metrics')]), (topup_sim, write_txt, [('similarity', 'topup_metrics')]), (write_txt, outputnode, [('txtfile', 'textfile')]) ]) return similarity
FA_to_WAX_Temp.inputs.output_warped_image=True FA_to_WAX_Temp.inputs.float=True #>>>>>>>>>>>>>>>>>>>>>>>>>>>MD antsApplyMD_WAX = Node(ants.ApplyTransforms(), name = 'antsApplyMD_WAX') antsApplyMD_WAX.inputs.dimension = 3 antsApplyMD_WAX.inputs.input_image_type = 3 antsApplyMD_WAX.inputs.num_threads = 1 antsApplyMD_WAX.inputs.float = True antsApplyMD_WAX.inputs.output_image = 'MD_{subject_id}.nii' antsApplyMD_WAX.inputs.reference_image = Wax_FA_Template #>>>>>>>>>>>>>>>>>>>>>>>>>>>AD antsApplyAD_WAX = antsApplyMD_WAX.clone(name = 'antsApplyAD_WAX') antsApplyAD_WAX.inputs.output_image = 'AD_{subject_id}.nii' #>>>>>>>>>>>>>>>>>>>>>>>>>>>RD antsApplyRD_WAX = antsApplyMD_WAX.clone(name = 'antsApplyRD_WAX') antsApplyRD_WAX.inputs.output_image = 'RD_{subject_id}.nii' #---------------------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------------------- #---------------------------------------------------------------------------------------------------- # Register to Study template second, just to have both for purposes of comparison #>>>>>>>>>>>>>>>>>>>>>>>>>>>FA FA_to_Study_Temp = Node(ants.Registration(), name = 'FA_To_Study_Template')
(demean, zstandardize, [('out_file', 'in_file')]), (standev, zstandardize, [('out_stat', 'operand_value')]), ]) ### MVPA volume and surface pipeline # Concatenate Volume node - concatenates all session files into one file concatVol = Node(Concatenate(), name='concatVol') # Create volume pipeline volume_flow = Workflow(name='volume_flow') ## create the surface workflow ## # Copy the concatenate node from the volume pipeline concatSurfLH = concatVol.clone('concatSurfLH') concatSurfRH = concatVol.clone('concatSurfRH') # Convert NIfTI into mgz mriconvertSurfLH = Node(MRIConvert(out_type = 'mgz'),name='mriconvertSurfLH') mriconvertSurfRH = Node(MRIConvert(out_type = 'mgz'),name='mriconvertSurfRH') # Sample Left node - samples the volume data onto the surface representation samplerLH = Node(SampleToSurface(hemi='lh', interp_method = 'trilinear', sampling_method = 'average', sampling_range = (0.1, 0.9, 0.1), sampling_units = 'frac'), name='samplerLH') # Sample Right node - does the same as the node above,