def _yield_data(self):
""" Yield signals for unittests.
"""
# caution random_state should be fixed but it could also systematically
# lead to failing signal generation, so this arg is carefully set
random_state_s = [99]
snr_s = [1.0, 10.0, 20.0]
tr_s = [0.1, 2.0]
dur_orig_s = [3, 5, 10] # minutes
delta_s = [0.5, 1.0]
listparams = [random_state_s, snr_s, tr_s, dur_orig_s,
delta_s]
for params in itertools.product(*listparams):
random_state, snr, tr, dur_orig, delta = params
nb_events = int(dur_orig/2)
hrf, _ = spm_hrf(delta=delta, t_r=tr)
params = {'dur': dur_orig,
'tr': tr,
'hrf': hrf,
# if nb_events should be adapted to
# the length of the signal
'nb_events': nb_events,
'avg_dur': 1,
'std_dur': 5,
'overlapping': False,
'snr': snr,
'random_state': random_state,
}
res = gen_rnd_bloc_bold(**params)
yield res, snr, nb_events
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from pybold.data import gen_rnd_bloc_bold
from pybold.hrf_model import spm_hrf
from pybold.utils import fwhm, tp
###############################################################################
# generate the signal
tr = 1.0
snr = 1.0
dur = 4 # minutes
hrf_dur = 30.0
hrf, t_hrf = spm_hrf(1.0, t_r=tr, dur=hrf_dur)
hrf_fwhm = fwhm(t_hrf, hrf)
hrf_tp = tp(t_hrf, hrf)
params = {
'dur': dur,
'tr': tr,
'hrf': hrf,
'nb_events': 4,
'avg_dur': 1,
'std_dur': 4,
'overlapping': False,
'snr': snr,
'random_state': 0,
}
res = gen_rnd_bloc_bold(**params)
if not os.path.exists(dirname):
os.makedirs(dirname)
print("archiving '{0}' under '{1}'".format(__file__, dirname))
shutil.copyfile(__file__, os.path.join(dirname, __file__))
###############################################################################
# generate data
hrf_dur = 30.
dur = 10 # minutes
TR = 1.0
snr = 1.0
# True HRF
true_hrf_delta = 1.5
orig_hrf, t_hrf = spm_hrf(t_r=TR, delta=true_hrf_delta, dur=hrf_dur)
params = {
'tr': TR,
'dur': dur,
'snr': snr,
'hrf': orig_hrf,
'random_state': 0,
}
noisy_ar_s, ar_s, ai_s, i_s, t, _, noise = gen_regular_bloc_bold(**params)
###############################################################################
# deconvolve the signal
nb_iter = 100 if not is_travis else 1
params = {
'y': noisy_ar_s,
't_r': TR,
all_lbdas = [lbdas_rh, lbdas_lh, lbdas_cue]
trials = ['rh', 'lh', 'cue'] # other possible values: 'lf' 'rf'
# start main
root_dir = create_result_dir(sufixe='fast_hcp_validation')
print("Saving results under '{0}'".format(root_dir))
print("archiving '{0}' under '{1}'".format(__file__, root_dir))
shutil.copyfile(__file__, os.path.join(root_dir, __file__))
fmri_img, anat_img = get_hcp_fmri_fname(fetch_subject_list()[subject_id],
anat_data=True)
canonical_hrf = inf_norm(
spm_hrf(1.0, t_r=TR_HCP, dur=hrf_dur, normalized_hrf=False)[0])
ref_hrfs, b_est_hrfs, b_est_blocks = {}, {}, {}
for trial, lbdas in zip(trials, all_lbdas):
print('*' * 80)
print("Running validation on HCP dataset for trial '{0}'".format(trial))
print('*' * 80)
subject_hcp_id = fetch_subject_list()[subject_id]
trial_type, onset, p_e, _ = get_protocol_hcp(subject_hcp_id, trial)
masker = NiftiMasker(t_r=TR_HCP, standardize=True)
voxels = masker.fit_transform(fmri_img)
n, v = voxels.shape
date.hour, date.minute, date.second))
if not os.path.exists(dirname):
os.makedirs(dirname)
print("archiving '{0}' under '{1}'".format(__file__, dirname))
shutil.copyfile(__file__, os.path.join(dirname, __file__))
###############################################################################
# generate data
hrf_dur = 20.
dur = 3 # minutes
TR = 0.75
snr = 1.0
orig_hrf, t_hrf = spm_hrf(1.0, t_r=TR, dur=hrf_dur)
params = {
'tr': TR,
'dur': dur,
'snr': snr,
'hrf': orig_hrf,
'random_state': 0,
}
noisy_ar_s, ar_s, ai_s, i_s, t, _, _ = gen_regular_bloc_bold(**params)
###############################################################################
# blind deconvolution
nb_iter = 500 if not is_travis else 1
init_hrf, _ = spm_hrf(MAX_DELTA, t_r=TR, dur=hrf_dur)
params = {
if not os.path.exists(dirname):
os.makedirs(dirname)
print("archiving '{0}' under '{1}'".format(__file__, dirname))
shutil.copyfile(__file__, os.path.join(dirname, __file__))
###############################################################################
# experimentation parameters
dur = 3.5
hrf_dur = 20.0
TR = 0.75
snr = 5.0
random_state = 99
orig_hrf, t_hrf = spm_hrf(1.0, t_r=TR, dur=hrf_dur, normalized_hrf=False)
params = {
'dur': dur,
'tr': TR,
'hrf': orig_hrf,
'nb_events': 2,
'avg_dur': 12,
'std_dur': 0.0,
'overlapping': False,
'snr': snr,
'random_state': random_state
}
y_tilde, y, z, _, t, _, _ = gen_rnd_bloc_bold(**params)
###############################################################################
# HRF estimation
TR = 0.75
hrf_dur = 20.0
orig_hrf_params = 0.7
dur_run = 3.0 # minutes
l_snr = [1.0, 3.0, 5.0, 10.0, 15.0, 20.0]
n_voxels = 100
avg_dur = 12
std_dur = 1
nb_events = 5
# optimal value (already grid-search)
l_lbda = [4.0, 3.0, 2.5, 1.7, 1.6, 1.5]
nb_iter = 500
n_jobs = 3
orig_hrf, t_hrf = spm_hrf(orig_hrf_params, t_r=TR, dur=hrf_dur)
h = len(orig_hrf)
n = int(dur_run * TR)
err_hrfs, err_blocks = {}, {}
for lbda, snr in zip(l_lbda, l_snr):
print('*'*80)
print("Running blind-deconvolution for SNR={0}dB".format(snr))
print('*'*80)
voxels, blocks = gen_voxels_cached(
n_voxels=n_voxels, hrf=orig_hrf.flatten(),
t_r=TR, snr=snr, dur=dur_run, avg_dur=avg_dur,
nb_events=nb_events, std_dur=std_dur,