def run(self, args): mask_name = os.path.splitext( os.path.basename(os.path.realpath(args.mask)))[0] mask_name = mask_name.replace('.nii', '') output_folder = args.output_folder or os.path.join( os.path.dirname(args.dwi), 'output', mask_name) tmp_results_dir = args.tmp_results_dir for match, to_set in [('true', True), ('false', False), ('none', None)]: if tmp_results_dir.lower() == match: tmp_results_dir = to_set break noise_std = args.noise_std if noise_std is not None: if not os.path.isfile(os.path.realpath(noise_std)): noise_std = float(noise_std) mdt.fit_model(args.model, mdt.load_problem_data( os.path.realpath(args.dwi), os.path.realpath(args.protocol), os.path.realpath(args.mask), gradient_deviations=args.gradient_deviations, noise_std=noise_std), output_folder, recalculate=args.recalculate, only_recalculate_last=args.only_recalculate_last, cl_device_ind=args.cl_device_ind, double_precision=args.double_precision, cascade_subdir=args.cascade_subdir, tmp_results_dir=tmp_results_dir, save_user_script_info=None)
def fit_model(): input_data = mdt.load_input_data( os.path.realpath(args.dwi), os.path.realpath(args.protocol), os.path.realpath(args.mask), gradient_deviations=args.gradient_deviations, noise_std=noise_std, extra_protocol=get_extra_protocol(args.extra_protocol, os.path.realpath(''))) optimizer_options = {} if args.patience is not None: optimizer_options['patience'] = args.patience mdt.fit_model(args.model, input_data, output_folder, method=args.method, optimizer_options=optimizer_options, recalculate=args.recalculate, only_recalculate_last=args.only_recalculate_last, cl_device_ind=args.cl_device_ind, double_precision=args.double_precision, tmp_results_dir=tmp_results_dir, use_cascaded_inits=args.use_cascaded_inits)
def _run_b1k_b2k_analysis(cls): pjoin = mdt.make_path_joiner( os.path.join(cls._tmp_dir, cls._tmp_dir_subdir, 'b1k_b2k')) input_data = mdt.load_input_data( pjoin('b1k_b2k_example_slices_24_38'), pjoin('b1k_b2k.prtcl'), pjoin('b1k_b2k_example_slices_24_38_mask')) for model_name in ['BallStick_r1', 'Tensor', 'NODDI']: mdt.fit_model(model_name, input_data, pjoin('output', 'b1k_b2k_example_slices_24_38_mask'))
def __call__(self, subject_info): from mdt import fit_model logger.info( 'Going to process subject {}, ({} of {}, we are at {:.2%})'. format(subject_info.subject_id, self._index_counter + 1, total_nmr_subjects, self._index_counter / total_nmr_subjects)) self._index_counter += 1 output_dir = os.path.join(output_folder, subject_info.subject_id) if all( model_output_exists(model, output_dir) for model in models_to_fit) and not recalculate: logger.info('Skipping subject {0}, output exists'.format( subject_info.subject_id)) return logger.info( 'Loading the data (DWI, mask and protocol) of subject {0}'. format(subject_info.subject_id)) input_data = subject_info.get_input_data(use_gradient_deviations) with timer(subject_info.subject_id): for model in models_to_fit: if isinstance(model, str): model_name = model else: model_name = model.name logger.info('Going to fit model {0} on subject {1}'.format( model_name, subject_info.subject_id)) try: fit_model(model, input_data, output_dir, recalculate=recalculate, cl_device_ind=cl_device_ind, double_precision=double_precision, tmp_results_dir=tmp_results_dir, use_cascaded_inits=True) except InsufficientProtocolError as ex: logger.info('Could not fit model {0} on subject {1} ' 'due to protocol problems. {2}'.format( model_name, subject_info.subject_id, ex)) else: logger.info( 'Done fitting model {0} on subject {1}'.format( model_name, subject_info.subject_id))
def _run_b6k_analysis(cls): pjoin = mdt.make_path_joiner( os.path.join(cls._tmp_dir, cls._tmp_dir_subdir, 'multishell_b6k_max')) input_data = mdt.load_input_data( pjoin('multishell_b6k_max_example_slices_24_38'), pjoin('multishell_b6k_max.prtcl'), pjoin('multishell_b6k_max_example_slices_24_38_mask')) for model_name in ['CHARMED_r1', 'CHARMED_r2', 'CHARMED_r3']: mdt.fit_model( model_name, input_data, pjoin('output', 'multishell_b6k_max_example_slices_24_38_mask'))
def fit_model(): mdt.fit_model(args.model, mdt.load_input_data( os.path.realpath(args.dwi), os.path.realpath(args.protocol), os.path.realpath(args.mask), gradient_deviations=args.gradient_deviations, noise_std=noise_std, extra_protocol=get_extra_protocol( args.extra_protocol, os.path.realpath(''))), output_folder, recalculate=args.recalculate, only_recalculate_last=args.only_recalculate_last, cl_device_ind=args.cl_device_ind, double_precision=args.double_precision, tmp_results_dir=tmp_results_dir)
def func(subject_info, output_path): subject_id = subject_info.subject_id for model_name in model_names: print(subject_id, model_name) starting_point = mdt.fit_model(model_name, subject_info.get_input_data(), output_path + '/' + subject_id) with mdt.config_context(''' processing_strategies: sampling: max_nmr_voxels: 5000 '''): mdt.sample_model(model_name, subject_info.get_input_data(), output_path + '/' + subject_info.subject_id, nmr_samples=nmr_samples[model_name], initialization_data={'inits': starting_point}, store_samples=False) wm_mask = generate_simple_wm_mask(os.path.join(output_path, subject_id, 'Tensor', 'Tensor.FA.nii.gz'), subject_info.get_input_data().mask, threshold=0.3, median_radius=3, nmr_filter_passes=4) mdt.write_nifti(wm_mask, os.path.join(output_path, subject_id, 'wm_mask'))
def fit_model(): mdt.fit_model(args.model, mdt.load_input_data( os.path.realpath(args.dwi), os.path.realpath(args.protocol), os.path.realpath(args.mask), gradient_deviations=args.gradient_deviations, noise_std=noise_std, protocol_maps=get_protocol_maps( args.protocol_maps, os.path.realpath(''))), output_folder, recalculate=args.recalculate, only_recalculate_last=args.only_recalculate_last, cl_device_ind=args.cl_device_ind, double_precision=args.double_precision, cascade_subdir=args.cascade_subdir, tmp_results_dir=tmp_results_dir, save_user_script_info=None)
def CHARMED(dwi, mask): import mdt import os import nibabel as nib from mdt.configuration import SetGeneralOptimizer protocol = '/media/amr/HDD/Work/October_Acquistion/MDT_multishell_protocol.prtcl' model = 'CHARMED_r2 (Cascade|fixed)' algorithm = 'Levenberg-Marquardt' patience = 100 output_folder = os.getcwd() input_data = mdt.load_input_data(dwi, protocol, mask, noise_std=5, gradient_deviations=None, extra_protocol={}) with mdt.config_context( SetGeneralOptimizer(algorithm, settings={'patience': patience})): mdt.fit_model(model, input_data, output_folder, recalculate=True, only_recalculate_last=True, double_precision=False, cl_device_ind=[0]) os.chdir('CHARMED_r2') CHARMED_FA = os.path.abspath('Tensor.FA.nii.gz') CHARMED_MD = os.path.abspath('Tensor.MD.nii.gz') CHARMED_AD = os.path.abspath('Tensor.AD.nii.gz') CHARMED_RD = os.path.abspath('Tensor.RD.nii.gz') CHARMED_FR = os.path.abspath('FR.nii.gz') #I assumed that CHARMEDRestricted0.d to be the intra-axonal diffusvity CHARMED_IAD = os.path.abspath('CHARMEDRestricted0.d.nii.gz') return CHARMED_FA, CHARMED_MD, CHARMED_AD, CHARMED_RD, CHARMED_FR, CHARMED_IAD
def get_model_fit(model_name): logger.info( 'Starting intermediate optimization for generating initialization point.' ) from mdt import fit_model results = fit_model( model_name, input_data, output_folder, recalculate=False, use_cascaded_inits=False, initialization_data={'inits': get_init_data(model_name)}) logger.info( 'Finished intermediate optimization for generating initialization point.' ) return results
def mcmc_sample(subject_info): output_folder = subject_info.data_folder[:-1] + '_output' subject_id = subject_info.subject_id for model_name in model_names: print(subject_id, model_name) starting_point = mdt.fit_model(model_name, subject_info.get_input_data(), output_folder + '/' + subject_id) with mdt.config_context(''' processing_strategies: sampling: max_nmr_voxels: 5000 '''): mdt.sample_model(model_name, subject_info.get_input_data(), output_folder + '/' + subject_id, nmr_samples=nmr_samples[model_name], initialization_data={'inits': starting_point}, store_samples=False)
def get_model_fit(model_name): logger.info( 'Starting intermediate optimization for generating initialization point.' ) inits = get_init_data(model_name) from mdt import fit_model results = fit_model(model_name, input_data, output_folder, recalculate=False, use_cascaded_inits=False, method=method, optimizer_options=optimizer_options, double_precision=double_precision, cl_device_ind=cl_device_ind, initialization_data={'inits': inits}) logger.info( 'Finished intermediate optimization for generating initialization point.' ) return results
print('Going to process', trial_ind, model_name, protocol_name, snr) noise_std = simulations_unweighted_signal_height / snr current_pjoin = pjoin.create_extended(protocol_name, model_name) input_data = mdt.load_input_data( current_pjoin('noisy_signals_{}.nii'.format(snr)), pjoin(protocol_name + '.prtcl'), current_pjoin('mask.nii'), noise_std=noise_std) fit_results = mdt.fit_model( model_name + ' (Cascade)', input_data, current_pjoin('output', str(snr), str(trial_ind))) with mdt.config_context(''' processing_strategies: sampling: max_nmr_voxels: 5000 '''): mdt.sample_model( model_name, input_data, current_pjoin('output', str(snr), str(trial_ind)), nmr_samples=nmr_samples[model_name], burnin=1000, thinning=0, initialization_data={'inits': fit_results},
def run(self): mdt.fit_model(*self._args, **self._kwargs) self.finished.emit()
if mdt_model == "NODDI_test": mask_file = "data_brain_mask.nii.gz" # generate scheme file from the bvals/bvecs protocol = mdt.create_protocol(bvecs='data.bvec', bvals='data.bval', out_file=experiment_dir + '/' + sub + '/data.prtcl') mdt_dir = opj(experiment_dir, sub, mdt_model) if not os.path.exists(mdt_dir): os.mkdir(mdt_dir) input_data = mdt.load_input_data('data.nii.gz', 'data.prtcl', 'data_brain_mask.nii.gz') test = mdt.get_optimization_inits('NODDI', input_data, 'output') mdt.fit_model('NODDI', input_data, 'output') if mdt_model == "ActiveAx": mask_file = "data_brain_mask.nii.gz" protocol = mdt.create_protocol(bvecs='data.bvec', bvals='data.bval', out_file=experiment_dir + '/' + sub + '/data.prtcl') mdt_dir = opj(experiment_dir, sub, mdt_model) if not os.path.exists(mdt_dir): os.mkdir(mdt_dir) with open("data.prtcl", 'r') as file: vals = file.readlines()