def test_sub_treatment(self):
t = FMRITreatment(output_dir=self.tmp_dir)
t.enable_draft_testing()
sub_ts = t.split()
for sub_t in sub_ts:
sub_t.run()
def test_default_treatment_parallel_LAN(self):
#pyhrf.verbose.set_verbosity(1)
if cfg['parallel-LAN']['enable_unit_test'] == 1:
t = FMRITreatment(make_outputs=False, result_dump_file=None,
output_dir=self.tmp_dir)
t.enable_draft_testing()
t.run(parallel='LAN')
else:
print 'LAN testing is off '\
'([parallel-LAN][enable_unit_test] = 0 in ~/.pyhrf/config.cfg'
def test_default_jde_cmd_parallel_local(self):
t = FMRITreatment(make_outputs=False, result_dump_file=None)
t.enable_draft_testing()
t_fn = op.join(self.tmp_dir, 'treatment.pck')
fout = open(t_fn, 'w')
cPickle.dump(t, fout)
fout.close()
cmd = 'pyhrf_jde_estim -t %s -x local' %t_fn
if os.system(cmd) != 0:
raise Exception('"' + cmd + '" did not execute correctly')
def glm_analyse(fdata, contrasts, output_dir, output_prefix,
hrf_model="Canonical", fir_delays=None,
rescale_factor_file=None):
glm_analyser = GLMAnalyser(hrf_model=hrf_model, contrasts=contrasts,
outputPrefix=output_prefix, fir_delays=fir_delays,
rescale_factor_file=rescale_factor_file)
glm_analyser.set_pass_errors(False)
glm_analyser.set_gzip_outputs(True)
tt = FMRITreatment(fdata, glm_analyser, output_dir=output_dir)
tt.run()
def test_jdevemanalyser(self):
""" Test BOLD VEM sampler on small simulation with small
nb of iterations. Estimation accuracy is not tested.
"""
jde_vem_analyser = JDEVEMAnalyser(beta=.8, dt=.5, hrfDuration=25.,
nItMax=2, nItMin=2, fast=True,
computeContrast=False, PLOT=False,
constrained=True)
tjde_vem = FMRITreatment(fmri_data=self.data_simu,
analyser=jde_vem_analyser,
output_dir=None)
tjde_vem.run()
def test_jde_estim_from_treatment_pck(self):
t = FMRITreatment(make_outputs=False, result_dump_file=None)
t.enable_draft_testing()
sub_ts = t.split()
sub_t_fn = op.join(self.tmp_dir, 'treatment.pck')
fout = open(sub_t_fn, 'w')
cPickle.dump(sub_ts[0], fout)
fout.close()
cmd = 'pyhrf_jde_estim -t %s' %sub_t_fn
if os.system(cmd) != 0:
raise Exception('"' + cmd + '" did not execute correctly')
def jde_analyse(fdata, contrasts, output_dir):
from pyhrf.jde.models import BOLDGibbsSampler as BG
from pyhrf.jde.hrf import RHSampler
from pyhrf.jde.nrl.bigaussian import NRLSampler
sampler = BG(nb_iterations=250,
hrf_var=RHSampler(do_sampling=False, val_ini=np.array([0.05])),
response_levels=NRLSampler(contrasts=contrasts))
analyser = JDEMCMCAnalyser(sampler=sampler)
analyser.set_gzip_outputs(True)
tt = FMRITreatment(fdata, analyser, output_dir=output_dir)
tt.run(parallel='local')
def test_jdevemanalyser(self):
""" Test BOLD VEM sampler on small simulation with small
nb of iterations. Estimation accuracy is not tested.
"""
# pyhrf.verbose.set_verbosity(0)
pyhrf.logger.setLevel(logging.WARNING)
jde_vem_analyser = JDEVEMAnalyser(beta=.8, dt=.5, hrfDuration=25.,
nItMax=2, nItMin=2, fast=True,
PLOT=False,
constrained=True)
tjde_vem = FMRITreatment(fmri_data=self.data_simu,
analyser=jde_vem_analyser,
output_dir=None)
tjde_vem.run()
def test_jdevemanalyser(self):
""" Test BOLD VEM sampler on small simulation with small
nb of iterations. Estimation accuracy is not tested.
"""
jde_vem_analyser = JDEVEMAnalyser(beta=.8,
dt=.5,
hrfDuration=25.,
nItMax=2,
nItMin=2,
fast=True,
computeContrast=False,
PLOT=False,
constrained=True)
tjde_vem = FMRITreatment(fmri_data=self.data_simu,
analyser=jde_vem_analyser,
output_dir=None)
tjde_vem.run()
def test_default_jde_small_simulation(self):
""" Test JDE multi-sessions sampler on small
simulation with small nb of iterations.
Estimation accuracy is not tested.
"""
sampler = BMSS()
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=.5, driftParam=4, driftType='polynomial',
outputPrefix='jde_MS_mcmc_',
randomSeed=9778946)
treatment = FMRITreatment(fmri_data=self.data_simu,
analyser=analyser)
treatment.run()
def test_default_jde_small_simulation(self):
""" Test ASL sampler on small simulation with small nb of iterations.
Estimation accuracy is not tested.
"""
simu = simulate_asl(spatial_size='random_small')
fdata = FmriData.from_simulation_dict(simu)
sampler = jde_asl.ASLSampler()
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=.5, driftParam=4, driftType='polynomial',
outputPrefix='jde_mcmc_', randomSeed=None)
treatment = FMRITreatment(fmri_data=fdata, analyser=analyser,
output_dir=None)
treatment.run()
def test_TreatmentXML(self):
from pyhrf.ui.jde import JDEMCMCAnalyser
from pyhrf.jde.models import BOLDGibbsSampler
from pyhrf.ui.treatment import FMRITreatment
a = JDEMCMCAnalyser(sampler=BOLDGibbsSampler(nb_iterations=42))
t = FMRITreatment(analyser=a)
txml = xmlio.to_xml(t, pretty=True)
t2 = xmlio.from_xml(txml)
self.assertEqual(t2.analyser.sampler.nbIterations, 42)
def dummy_jde(fmri_data, dt):
print 'run dummy_jde ...'
jde_mcmc_sampler = \
physio_build_jde_mcmc_sampler(3, 'basic_regularized',
do_sampling_prf=False,
do_sampling_brf=False,
do_sampling_prls=False,
do_sampling_labels=False,
do_sampling_prf_var=False,
do_sampling_brf_var=False,
brf_var_ini=np.array([0.1]),
prf_var_ini=np.array([0.1]))
analyser = JDEMCMCAnalyser(jde_mcmc_sampler, copy_sampler=False, dt=dt)
analyser.set_pass_errors(False)
tjde_mcmc = FMRITreatment(fmri_data, analyser, output_dir=None)
outputs, fns = tjde_mcmc.run()
print 'dummy_jde done!'
return tjde_mcmc.analyser.sampler
def test_default_jde_small_simulation(self):
""" Test ASL Physio sampler on small simulation with small nb of
iterations. Estimation accuracy is not tested.
"""
pyhrf.verbose.set_verbosity(0)
sampler_params = {
'nb_iterations' : 3,
'smpl_hist_pace' : 1,
'obs_hist_pace' : 1,
'brf' : jde_asl_physio.PhysioBOLDResponseSampler(zero_constraint=False),
'brf_var' : jde_asl_physio.PhysioBOLDResponseVarianceSampler(val_ini=\
np.array([1e-3])),
'prf' : jde_asl_physio.PhysioPerfResponseSampler(zero_constraint=False),
'prf_var' : jde_asl_physio.PhysioPerfResponseVarianceSampler(val_ini=\
np.array([1e-3])),
'noise_var' : jde_asl_physio.NoiseVarianceSampler(),
'drift_var' : jde_asl_physio.DriftVarianceSampler(),
'drift' : jde_asl_physio.DriftCoeffSampler(),
'bold_response_levels' : jde_asl_physio.BOLDResponseLevelSampler(),
'perf_response_levels' : jde_asl_physio.PerfResponseLevelSampler(),
'bold_mixt_params' : jde_asl_physio.BOLDMixtureSampler(),
'perf_mixt_params' : jde_asl_physio.PerfMixtureSampler(),
'labels' : jde_asl_physio.LabelSampler(),
'perf_baseline' : jde_asl_physio.PerfBaselineSampler(),
'perf_baseline_var' : jde_asl_physio.PerfBaselineVarianceSampler(),
'check_final_value' : None,
}
sampler = jde_asl_physio.ASLPhysioSampler(**sampler_params)
simu_items = phym.simulate_asl_physio_rfs(spatial_size='random_small')
simu_fdata = FmriData.from_simulation_dict(simu_items)
dt = simu_items['dt']
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=dt, driftParam=4, driftType='polynomial',
outputPrefix='jde_mcmc_')
treatment = FMRITreatment(fmri_data=simu_fdata, analyser=analyser,
output_dir=None)
treatment.run()
def test_default_jde_small_simulation(self):
""" Test ASL Physio sampler on small simulation with small nb of
iterations. Estimation accuracy is not tested.
"""
pyhrf.verbose.set_verbosity(0)
sampler_params = {
jde_asl_physio.ASLPhysioSampler.P_NB_ITERATIONS : 100,
jde_asl_physio.ASLPhysioSampler.P_SMPL_HIST_PACE : 1,
jde_asl_physio.ASLPhysioSampler.P_OBS_HIST_PACE : 1,
'brf' : jde_asl_physio.PhysioBOLDResponseSampler(zero_constraint=False),
'brf_var' : jde_asl_physio.PhysioBOLDResponseVarianceSampler(val_ini=\
np.array([1e-3])),
'prf' : jde_asl_physio.PhysioPerfResponseSampler(zero_constraint=False),
'prf_var' : jde_asl_physio.PhysioPerfResponseVarianceSampler(val_ini=\
np.array([1e-3])),
'noise_var' : jde_asl_physio.NoiseVarianceSampler(),
'drift_var' : jde_asl_physio.DriftVarianceSampler(),
'drift_coeff' : jde_asl_physio.DriftCoeffSampler(),
'brl' : jde_asl_physio.BOLDResponseLevelSampler(),
'prl' : jde_asl_physio.PerfResponseLevelSampler(),
'bold_mixt_params' : jde_asl_physio.BOLDMixtureSampler(),
'perf_mixt_params' : jde_asl_physio.PerfMixtureSampler(),
'label' : jde_asl_physio.LabelSampler(),
'perf_baseline' : jde_asl_physio.PerfBaselineSampler(),
'perf_baseline_var' : jde_asl_physio.PerfBaselineVarianceSampler(),
'assert_final_value_close_to_true' : False,
}
sampler = jde_asl_physio.ASLPhysioSampler(sampler_params)
simu_items = phym.simulate_asl_physio_rfs(spatial_size='random_small')
simu_fdata = FmriData.from_simulation_dict(simu_items)
dt = simu_items['dt']
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=dt, driftParam=4, driftType='polynomial',
outputFile=None,outputPrefix='jde_mcmc_',
randomSeed=None)
treatment = FMRITreatment(fmri_data=simu_fdata, analyser=analyser)
treatment.run()
def test_default_jde_small_simulation(self):
""" Test ASL Physio sampler on small simulation with small nb of
iterations. Estimation accuracy is not tested.
"""
sampler_params = {
'nb_iterations': 3,
'smpl_hist_pace': 1,
'obs_hist_pace': 1,
'brf': jde_asl_physio.PhysioBOLDResponseSampler(zero_constraint=False),
'brf_var': jde_asl_physio.PhysioBOLDResponseVarianceSampler(val_ini=np.array([1e-3])),
'prf': jde_asl_physio.PhysioPerfResponseSampler(zero_constraint=False),
'prf_var': jde_asl_physio.PhysioPerfResponseVarianceSampler(val_ini=np.array([1e-3])),
'noise_var': jde_asl_physio.NoiseVarianceSampler(),
'drift_var': jde_asl_physio.DriftVarianceSampler(),
'drift': jde_asl_physio.DriftCoeffSampler(),
'bold_response_levels': jde_asl_physio.BOLDResponseLevelSampler(),
'perf_response_levels': jde_asl_physio.PerfResponseLevelSampler(),
'bold_mixt_params': jde_asl_physio.BOLDMixtureSampler(),
'perf_mixt_params': jde_asl_physio.PerfMixtureSampler(),
'labels': jde_asl_physio.LabelSampler(),
'perf_baseline': jde_asl_physio.PerfBaselineSampler(),
'perf_baseline_var': jde_asl_physio.PerfBaselineVarianceSampler(),
'check_final_value': None,
}
sampler = jde_asl_physio.ASLPhysioSampler(**sampler_params)
simu_items = phym.simulate_asl_physio_rfs(spatial_size='random_small')
simu_fdata = FmriData.from_simulation_dict(simu_items)
dt = simu_items['dt']
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=dt, driftParam=4, driftType='polynomial',
outputPrefix='jde_mcmc_')
treatment = FMRITreatment(fmri_data=simu_fdata, analyser=analyser,
output_dir=None)
treatment.run()
def _test_specific_parameters(self, parameter_name, fdata, simu,
beta=.8, dt=.5, nItMax=100, nItMin=10,
hrfDuration=25., estimateSigmaH=False,
estimateBeta=False, estimateSigmaG=False,
PLOT=False, constrained=True, fast=False,
estimateH=False, estimateG=False,
estimateA=False, estimateC=False,
estimateZ=False, estimateLA=False,
estimateNoise=False, estimateMP=True):
"""
Test specific samplers.
"""
logger.info('_test_specific_parameters %s', str(parameter_name))
output_dir = self.tmp_dir
# JDE analysis
jde_vem_analyser = JDEVEMAnalyser(beta=beta, dt=dt,
hrfDuration=hrfDuration,
estimateSigmaH=estimateSigmaH,
nItMax=nItMax, nItMin=nItMin,
estimateBeta=estimateBeta,
estimateSigmaG=estimateSigmaG,
PLOT=PLOT,
constrained=constrained, fast=fast,
fmri_data=fdata,
simulation=simu,
estimateH=estimateH,
estimateG=estimateG,
estimateA=estimateA,
estimateC=estimateC,
estimateLabels=estimateZ,
estimateLA=estimateLA,
estimateMixtParam=estimateMP,
estimateNoise=estimateNoise)
tjde_vem = FMRITreatment(fmri_data=fdata, analyser=jde_vem_analyser,
output_dir=output_dir)
outputs = tjde_vem.run()
print 'out_dir:', output_dir
return outputs
def _test_specific_parameters(self, parameter_name, fdata, simu,
beta=.8, dt=.5, nItMax=100, nItMin=10,
hrfDuration=25., estimateSigmaH=False,
estimateBeta=False, estimateSigmaG=False,
PLOT=False, constrained=True, fast=False,
estimateH=False, estimateG=False,
estimateA=False, estimateC=False,
estimateZ=False, estimateLA=False,
estimateNoise=False, estimateMP=True):
"""
Test specific samplers.
"""
logger.info('_test_specific_parameters %s', str(parameter_name))
output_dir = self.tmp_dir
# JDE analysis
jde_vem_analyser = JDEVEMAnalyser(beta=beta, dt=dt,
hrfDuration=hrfDuration,
estimateSigmaH=estimateSigmaH,
nItMax=nItMax, nItMin=nItMin,
estimateBeta=estimateBeta,
estimateSigmaG=estimateSigmaG,
PLOT=PLOT,
constrained=constrained, fast=fast,
fmri_data=fdata,
simulation=simu,
estimateH=estimateH,
estimateG=estimateG,
estimateA=estimateA,
estimateC=estimateC,
estimateLabels=estimateZ,
estimateLA=estimateLA,
estimateMixtParam=estimateMP,
estimateNoise=estimateNoise)
tjde_vem = FMRITreatment(fmri_data=fdata, analyser=jde_vem_analyser,
output_dir=output_dir)
outputs = tjde_vem.run()
print 'out_dir:', output_dir
return outputs
def rfir_analyse(fdata, output_dir):
analyser = RFIRAnalyser(RFIREstim(nb_its_max=150))
analyser.set_gzip_outputs(True)
tt = FMRITreatment(fdata, analyser, output_dir=output_dir)
tt.run()
def _test_specific_samplers(self, sampler_names, fdata,
nb_its=None, use_true_val=None,
save_history=False, check_fv=None,
normalize_brf=1., normalize_prf=1.,
normalize_mu=1., prf_prior_type='regularized',
brf_prior_type='regularized',
mu_prior_type='regularized'):
"""
Test specific samplers.
"""
if use_true_val is None:
use_true_val = dict((n, False) for n in sampler_names)
logger.info('_test_specific_samplers %s ...', str(sampler_names))
params = deepcopy(self.sampler_params_for_single_test)
# Loop over given samplers to enable them
for var_name in sampler_names:
var_class = params[var_name].__class__
use_tval = use_true_val[var_name]
# special case for HRF -> normalization and prior type
if var_class == jaslh.PhysioBOLDResponseSampler:
params[var_name] = \
jaslh.PhysioBOLDResponseSampler(do_sampling=True,
use_true_value=use_tval,
normalise=normalize_brf,
zero_constraint=False,
prior_type=brf_prior_type)
elif var_class == jaslh.PhysioPerfResponseSampler:
params[var_name] = \
jaslh.PhysioPerfResponseSampler(do_sampling=True,
use_true_value=use_tval,
normalise=normalize_brf,
zero_constraint=False,
prior_type=prf_prior_type)
elif var_class == jaslh.PhysioTrueBOLDResponseSampler:
params[var_name] = \
jaslh.PhysioTrueBOLDResponseSampler(do_sampling=True,
use_true_value=use_tval,
normalise=normalize_mu,
zero_constraint=False,
prior_type=mu_prior_type)
else:
params[var_name] = var_class(do_sampling=True,
use_true_value=use_tval)
if nb_its is not None:
params['nb_iterations'] = nb_its
if save_history:
params['smpl_hist_pace'] = 1
params['obs_hist_pace'] = 1
if check_fv is not None:
params['check_final_value'] = check_fv
sampler = jaslh.ASLPhysioSampler(**params)
output_dir = self.tmp_dir
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=fdata.simulation[0]['dt'], driftParam=4,
driftType='polynomial',
outputPrefix='jde_mcmc_',
pass_error=False)
treatment = FMRITreatment(fmri_data=fdata, analyser=analyser,
output_dir=output_dir)
outputs = treatment.run()
print 'out_dir:', output_dir
return outputs
def _test_specific_samplers(self,
sampler_names,
simu,
nb_its=None,
use_true_val=None,
save_history=False,
check_fv=None,
normalize_hrf=1.,
hrf_prior_type='singleHRF',
normalize_hrf_group=1.,
hrf_group_prior_type='singleHRF',
reg_hgroup=True):
"""
Test specific samplers.
"""
if use_true_val is None:
use_true_val = dict((n, False) for n in sampler_names)
logger.info('_test_specific_samplers %s ...', str(sampler_names))
params = deepcopy(self.sampler_params_for_single_test)
# Loop over given samplers to enable them
for var_name in sampler_names:
var_class = params[var_name].__class__
use_tval = use_true_val[var_name]
# special case for HRF -> normalization and prior type
if var_class == jms.HRF_Sampler:
params[var_name] = jms.HRF_Sampler(do_sampling=True,
use_true_value=use_tval,
normalise=normalize_hrf,
prior_type=hrf_prior_type,
zero_contraint=False)
elif var_class == jms.HRF_Group_Sampler:
ptype = hrf_group_prior_type
nhg = normalize_hrf_group
shg = jms.HRF_Group_Sampler(do_sampling=True,
use_true_value=use_tval,
normalise=nhg,
prior_type=ptype,
zero_contraint=False,
regularise=reg_hgroup)
params[var_name] = shg
else:
params[var_name] = var_class(do_sampling=True,
use_true_value=use_tval)
if nb_its is not None:
params['nb_iterations'] = nb_its
if save_history:
params['smpl_hist_pace'] = 1
params['obs_hist_pace'] = 1
if check_fv is not None:
params['check_final_value'] = check_fv
sampler = BMSS(**params)
output_dir = self.simu_dir
analyser = JDEMCMCAnalyser(sampler=sampler,
osfMax=4,
dtMin=.4,
dt=.6,
driftParam=4,
driftType='polynomial',
outputPrefix='jde_mcmc_',
randomSeed=5421087,
pass_error=False)
treatment = FMRITreatment(fmri_data=simu,
analyser=analyser,
output_dir=output_dir)
outputs = treatment.run()
return outputs
def test_pickle_treatment(self):
t = FMRITreatment(make_outputs=False, result_dump_file=None)
t.enable_draft_testing()
cPickle.loads(cPickle.dumps(t))
def _test_specific_samplers(self, sampler_names, simu,
nb_its=None, use_true_val=None,
save_history=False, check_fv=None,
normalize_hrf=1.,
hrf_prior_type='singleHRF',
normalize_hrf_group=1.,
hrf_group_prior_type='singleHRF',
reg_hgroup=True):
"""
Test specific samplers.
"""
if use_true_val is None:
use_true_val = dict( (n,False) for n in sampler_names )
pyhrf.verbose(1, '_test_specific_samplers %s ...' %str(sampler_names))
params = deepcopy(self.sampler_params_for_single_test)
# Loop over given samplers to enable them
for var_name in sampler_names:
var_class = params[var_name].__class__
use_tval = use_true_val[var_name]
# special case for HRF -> normalization and prior type
if var_class == jms.HRF_Sampler:
params[var_name] = jms.HRF_Sampler(do_sampling=True,
use_true_value=use_tval,
normalise=normalize_hrf,
prior_type=hrf_prior_type,
zero_contraint=False)
elif var_class == jms.HRF_Group_Sampler:
ptype = hrf_group_prior_type
nhg = normalize_hrf_group
shg = jms.HRF_Group_Sampler(do_sampling=True,
use_true_value=use_tval,
normalise=nhg,
prior_type=ptype,
zero_contraint=False,
regularise=reg_hgroup)
params[var_name] = shg
else:
params[var_name] = var_class(do_sampling=True,
use_true_value=use_tval)
if nb_its is not None:
params[BMSS.P_NB_ITERATIONS] = nb_its
if save_history:
params[BMSS.P_SMPL_HIST_PACE] = 1
params[BMSS.P_OBS_HIST_PACE] = 1
if check_fv is not None:
params[BMSS.P_CHECK_FINAL_VALUE] = check_fv
sampler = BMSS(params)
output_dir = self.simu_dir
analyser = JDEMCMCAnalyser(sampler=sampler, osfMax=4, dtMin=.4,
dt=.6, driftParam=4, driftType='polynomial',
outputFile=None, outputPrefix='jde_mcmc_',
randomSeed=5421087, pass_error=False)
treatment = FMRITreatment(fmri_data=simu, analyser=analyser,
output_dir=output_dir)
outputs = treatment.run()
#print 'out_dir:', output_dir
return outputs
def test_default_treatment(self):
#pyhrf.verbose.set_verbosity(4)
t = FMRITreatment(make_outputs=False, result_dump_file=None)
t.enable_draft_testing()
t.run()
def main():
"""Run when calling the script"""
start_time = time.time()
if not os.path.isdir(config["output_dir"]):
try:
os.makedirs(config["output_dir"])
except OSError as e:
print("Ouput directory could not be created.\n"
"Error was: {}".format(e.strerror))
sys.exit(1)
bold_data = FmriData.from_vol_files(
mask_file=config["parcels_file"], paradigm_csv_file=config["onsets_file"],
bold_files=config["bold_data_file"], tr=config["tr"]
)
compute_contrasts, contrasts_def = load_contrasts_definitions(config["def_contrasts_file"])
jde_vem_analyser = JDEVEMAnalyser(
hrfDuration=config["hrf_duration"], sigmaH=config["sigma_h"], fast=True,
computeContrast=compute_contrasts, nbClasses=2, PLOT=False,
nItMax=config["nb_iter_max"], nItMin=config["nb_iter_min"], scale=False,
beta=config["beta"], estimateSigmaH=True, estimateHRF=config["estimate_hrf"],
TrueHrfFlag=False, HrfFilename='hrf.nii', estimateDrifts=True,
hyper_prior_sigma_H=config["hrf_hyperprior"], dt=config["dt"], estimateBeta=True,
contrasts=contrasts_def, simulation=False, estimateLabels=True,
LabelsFilename=None, MFapprox=False, estimateMixtParam=True,
constrained=False, InitVar=0.5, InitMean=2.0, MiniVemFlag=False, NbItMiniVem=5,
zero_constraint=config["zero_constraint"], drifts_type=config["drifts_type"]
)
processing_jde_vem = FMRITreatment(
fmri_data=bold_data, analyser=jde_vem_analyser,
output_dir=config["output_dir"], make_outputs=True
)
if not config["parallel"]:
processing_jde_vem.run()
else:
processing_jde_vem.run(parallel="local")
if config["save_processing_config"]:
# Let's canonicalize all paths
config_save = dict(config)
for file_nb, bold_file in enumerate(config_save["bold_data_file"]):
config_save["bold_data_file"][file_nb] = os.path.abspath(bold_file)
config_save["parcels_file"] = os.path.abspath(config_save["parcels_file"])
config_save["onsets_file"] = os.path.abspath(config_save["onsets_file"])
if config_save["def_contrasts_file"]:
config_save["def_contrasts_file"] = os.path.abspath(config_save["def_contrasts_file"])
config_save["output_dir"] = os.path.abspath(config_save["output_dir"])
config_save_filename = "{}_processing.json".format(
datetime.datetime.today()
).replace(" ", "_")
config_save_path = os.path.join(config["output_dir"], config_save_filename)
with open(config_save_path, 'w') as json_file:
json.dump(config_save, json_file, sort_keys=True, indent=4)
print("")
print("Total computation took: {} seconds".format(format_duration(time.time() - start_time)))
def jde_analyse_2steps_v1(output_dir, fmri_data, dt, nb_iterations, brf_var=None,
do_sampling_brf_var=False, prf_var=None, do_sampling_prf_var=False):
"""
#Return:
# dict of outputs
"""
nb_iterations_m1 = nb_iterations_m2 = nb_iterations
jde_output_dir = op.join(output_dir, 'bold_only')
if not op.exists(jde_output_dir):
os.makedirs(jde_output_dir)
dummy_sampler = dummy_jde(fmri_data, dt)
prf_ini_m1 = np.zeros_like(dummy_sampler.get_variable('prf').finalValue)
prls_ini_m1 = np.zeros_like(dummy_sampler.get_variable('prl').finalValue)
#perf_bl_ini_m1 = np.zeros_like(dummy_sampler.get_variable('perf_baseline').finalValue)
jde_mcmc_sampler_m1 = \
physio_build_jde_mcmc_sampler(nb_iterations_m1, 'basic_regularized',
prf_ini=prf_ini_m1,
do_sampling_prf=False,
prls_ini=prls_ini_m1,
do_sampling_prls=False,
brf_var_ini=brf_var,
do_sampling_brf_var=do_sampling_brf_var,
prf_var_ini=brf_var,
do_sampling_prf_var=False,
flag_zc = False)
pyhrf.verbose(2, 'JDE first pass -> BOLD fit')
analyser_m1 = JDEMCMCAnalyser(jde_mcmc_sampler_m1, copy_sampler=False,
dt=dt)
analyser_m1.set_pass_errors(False)
tjde_mcmc_m1 = FMRITreatment(fmri_data, analyser_m1,
output_dir=jde_output_dir)
outputs_m1, fns_m1 = tjde_mcmc_m1.run()
jde_output_dir = op.join(output_dir, 'perf_only_from_res')
if not op.exists(jde_output_dir):
os.makedirs(jde_output_dir)
brf_m1 = jde_mcmc_sampler_m1.get_variable('brf').finalValue
omega = jde_mcmc_sampler_m1.get_variable('prf').omega_operator
print omega.shape
print np.concatenate(([0],[0],[0],brf_m1,[0],[0],[0])).shape
#prf_m2 = np.dot(omega, brf_m1)
prf_m2 = np.dot(omega, np.concatenate(([0],[0],[0],brf_m1,[0],[0],[0])))[3:-3]
if 0:
import matplotlib.pyplot as plt
plt.plot(brf_m1)
plt.plot(prf_m2)
plt.show()
if 0:
import matplotlib.pyplot as plt
f, axarr = plt.subplots(2, 2)
axarr[0, 0].matshow(omega)
axarr[0, 1].plot(prf_m2)
import copy
omega2 = copy.deepcopy(omega)
omega2[-5:,:5] = 0.
omega2[:5,-5:] = 0.
prf_m2 = np.dot(omega2, brf_m1)
axarr[1, 0].matshow(omega2)
axarr[1, 1].plot(prf_m2)
plt.show()
#print 'PRF M2 shape = ', prf_m2.shape
#force begin & end to be zero
#XXX TODO: rather fix omega to avoid this kind of thing or use zero-contrainst again
#prf_m2[0] = 0.
#prf_m2[-5:] = 0.
brls_m1 = jde_mcmc_sampler_m1.get_variable('brl').finalValue
labels_m1 = jde_mcmc_sampler_m1.get_variable('label').finalValue >= 0.5
labels_m1 = labels_m1.astype(np.int32)
drift_m1 = jde_mcmc_sampler_m1.get_variable('drift_coeff').finalValue
drift_var_m1 = jde_mcmc_sampler_m1.get_variable('drift_var').finalValue
noise_var_m1 = jde_mcmc_sampler_m1.get_variable('noise_var').finalValue
pyhrf.verbose(2, 'ASL JDE second pass -> Perfusion fit')
pyhrf.verbose(1, 'Physiological prior stochastic regularized')
jde_mcmc_sampler_m2 = \
physio_build_jde_mcmc_sampler(nb_iterations_m2, 'physio_stochastic_not_regularized',
#prf_ini=prf_m2,
do_sampling_prf=True,
flag_zc=True,
prf_var_ini = prf_var,
do_sampling_prf_var = do_sampling_prf_var,
brls_ini=brls_m1, #if prls_ini_m1, it should be the same
do_sampling_brls=False,
brf_ini=brf_m1, #if prf_ini_m1, PRF sampler 'basic_regularized'
do_sampling_brf=False,
brf_var_ini=brf_var,
do_sampling_brf_var=False,
#perf_bl_ini=perf_bl_m1,
drift_ini=drift_m1,
do_sampling_drift = False,
drift_var_ini = drift_var_m1,
do_sampling_drift_var = False,
noise_var_ini=noise_var_m1,
labels_ini=labels_m1,
do_sampling_labels=True)
""" available_priors = ['physio_stochastic_regularized',
'physio_stochastic_not_regularized',
'physio_deterministic',
'physio_deterministic_hack',
'basic_regularized'] """
analyser_m2 = JDEMCMCAnalyser(jde_mcmc_sampler_m2, dt=dt)
analyser_m2.set_pass_errors(False)
tjde_mcmc_m2 = FMRITreatment(fmri_data, analyser_m2,
output_dir=jde_output_dir)
outputs_m2, fns_m2 = tjde_mcmc_m2.run()
# combine outputs
outputs = {}
for o in ['brf_pm', 'brl_pm']:
outputs[o] = outputs_m1[o]
outputs['noise_var_pm_m1'] = outputs_m1['noise_var_pm']
for o in ['prf_pm', 'prl_pm', 'label_pm']:
outputs[o] = outputs_m2[o]
outputs['noise_var_pm_m2'] = outputs_m2['noise_var_pm']
return outputs_m1
def test_default_treatment_parallel_local(self):
t = FMRITreatment(make_outputs=False, result_dump_file=None)
t.enable_draft_testing()
t.run(parallel='local')
