def run_simulation_computation_time(self, nstates, rep):
bounds, subData, _ = self.generate_simulated_data_HRF(rep=rep)
res6 = dict()
res6['duration_GSBS'] = np.zeros([nstates])
res6['duration_HMM_fixK'] = np.zeros([nstates])
res6['duration_HMMsm_fixK'] = np.zeros([nstates])
for i in range(2, nstates):
print(rep, i)
states = gsbs_extra.GSBS(x=subData[0, :, :], kmax=i)
tic = timeit.default_timer()
states.fit()
res6['duration_GSBS'][i] = timeit.default_timer() - tic
tic = timeit.default_timer()
ev = HMM(i, split_merge=False)
ev.fit(subData[0, :, :])
res6['duration_HMM_fixK'][i] = timeit.default_timer() - tic
tic = timeit.default_timer()
ev = HMM(i, split_merge=True)
ev.fit(subData[0, :, :])
res6['duration_HMMsm_fixK'][i] = timeit.default_timer() - tic
res6['duration_HMM_estK'] = np.cumsum(res6['duration_HMM_fixK'])
res6['duration_HMMsm_estK'] = np.cumsum(res6['duration_HMMsm_fixK'])
return res6
def run_simulation_hrf_shape(self, nstates_list, peak_delay_list,
peak_disp_list, rep):
print(rep)
res5 = dict()
list = ['optimum']
for key in list:
res5[key] = np.zeros([
np.shape(nstates_list)[0],
np.shape(peak_delay_list)[0],
np.shape(peak_disp_list)[0]
])
for idxe, e in enumerate(nstates_list):
for idxde, de in enumerate(peak_delay_list):
for idxdp, dp in enumerate(peak_disp_list):
bounds, subData, _ = self.generate_simulated_data_HRF(
nstates=e, peak_delay=de, peak_disp=dp, rep=rep)
states = gsbs_extra.GSBS(x=subData[0, :, :],
kmax=self.maxK)
states.fit()
res5['optimum'][idxe, idxde, idxdp] = states.nstates
return res5
def run_simulation_sub_specific_states(self, CV_list, sub_evprob_list,
kfold_list, sub_std, nsub, rep):
res4 = dict()
list = ['optimum', 'sim_GS', 'sim_GS_fixK', 'simz_GS', 'simz_GS_fixK']
for key in list:
res4[key] = np.zeros([
np.shape(CV_list)[0],
np.shape(sub_evprob_list)[0],
np.shape(kfold_list)[0]
])
res4['tdist'] = np.zeros([
np.shape(CV_list)[0],
np.shape(sub_evprob_list)[0],
np.shape(kfold_list)[0], self.maxK + 1
])
list = ['optimum_subopt', 'sim_GS_subopt', 'simz_GS_subopt']
for key in list:
res4[key] = np.zeros([np.shape(sub_evprob_list)[0], nsub])
for idxs, s in enumerate(sub_evprob_list):
bounds, subData, subbounds = self.generate_simulated_data_HRF(
sub_evprob=s, nsub=nsub, sub_std=sub_std, rep=rep)
for idxi, i in enumerate(kfold_list):
print(rep, s, i)
if i > 1:
kf = KFold(n_splits=i, shuffle=True)
for idxl, l in enumerate(CV_list):
tdist_temp = np.zeros([i, self.maxK + 1])
optimum_temp = np.zeros(i)
GS_sim_temp = np.zeros(i)
GS_sim_temp_fixK = np.zeros(i)
simz_temp = np.zeros(i)
simz_temp_fixK = np.zeros(i)
count = -1
for train_index, test_index in kf.split(
np.arange(0, np.max(kfold_list))):
count = count + 1
if l is False:
states = gsbs_extra.GSBS(x=np.mean(
subData[test_index, :, :], axis=0),
kmax=self.maxK)
elif l is True:
states = gsbs_extra.GSBS(
x=np.mean(subData[train_index, :, :],
axis=0),
y=np.mean(subData[test_index, :, :],
axis=0),
kmax=self.maxK)
states.fit()
optimum_temp[count] = states.nstates
tdist_temp[count, :] = states.tdists
GS_sim_temp[count], simz_temp[
count], dist = fit_metrics_simulation(
bounds, states.bounds)
GS_sim_temp_fixK[count], simz_temp_fixK[
count], dist = fit_metrics_simulation(
bounds, states.get_bounds(k=self.nstates))
res4['optimum'][idxl, idxs,
idxi] = np.mean(optimum_temp)
res4['sim_GS'][idxl, idxs, idxi] = np.mean(GS_sim_temp)
res4['sim_GS_fixK'][idxl, idxs,
idxi] = np.mean(GS_sim_temp_fixK)
res4['simz_GS'][idxl, idxs, idxi] = np.mean(simz_temp)
res4['simz_GS_fixK'][idxl, idxs,
idxi] = np.mean(simz_temp_fixK)
res4['tdist'][idxl, idxs, idxi, :] = tdist_temp.mean(0)
else:
states = gsbs_extra.GSBS(x=np.mean(subData[:, :, :],
axis=0),
kmax=self.maxK)
states.fit()
res4['optimum'][:, idxs, idxi] = states.nstates
res4['sim_GS'][:, idxs, idxi], res4[
'simz_GS'][:, idxs,
idxi], dists = fit_metrics_simulation(
bounds, states.bounds)
res4['sim_GS_fixK'][:, idxs, idxi], res4[
'simz_GS_fixK'][:, idxs,
idxi], dists = fit_metrics_simulation(
bounds,
states.get_bounds(k=self.nstates))
res4['tdist'][:, idxs, idxi, :] = states.tdists
# subbounds = states.fitsubject(subData)
# for isub in range(nsub):
# res4['optimum_subopt'][idxs, isub] = np.max(subbounds[isub])
# res4['sim_GS_subopt'][idxs, isub], res4['simz_GS_subopt'][idxs, isub], dists = fit_metrics_simulation(bounds,subbounds[isub])
return res4
def run_simulation_compare_nstates(self, nstates_list, mindist, run_HMM,
finetune, zs, rep):
res2 = dict()
list = [
'optimum_tdist', 'optimum_wac', 'optimum_mdist', 'optimum_meddist',
'optimum_mwu', 'optimum_LL_HMM', 'optimum_WAC_HMM',
'optimum_mdist_HMM', 'optimum_meddist_HMM', 'optimum_mwu_HMM',
'optimum_tdist_HMM', 'sim_GS_tdist', 'sim_GS_WAC', 'simz_GS_tdist',
'simz_GS_WAC', 'sim_HMM_LL', 'simz_HMM_LL', 'sim_HMMsplit_LL',
'simz_HMMsplit_LL', 'sim_HMM_WAC', 'simz_HMM_WAC',
'sim_HMMsplit_WAC', 'simz_HMMsplit_WAC', 'sim_HMM_tdist',
'simz_HMM_tdist', 'sim_HMMsplit_tdist', 'simz_HMMsplit_tdist'
]
for i in list:
res2[i] = np.zeros([np.shape(nstates_list)[0]])
list2 = [
'tdist', 'wac', 'mdist', 'meddist', 'LL_HMM', 'WAC_HMM',
'tdist_HMM', 'fit_W_mean', 'fit_W_std', 'fit_Ball_mean',
'fit_Ball_std', 'fit_Bcon_mean', 'fit_Bcon_std'
]
for i in list2:
res2[i] = np.zeros([np.shape(nstates_list)[0], self.maxK + 1])
for idxl, l in enumerate(nstates_list):
print(rep, l)
bounds, subData, _ = self.generate_simulated_data_HRF(nstates=l,
rep=rep)
states = gsbs_extra.GSBS(x=subData[0, :, :],
kmax=self.maxK,
outextra=True,
dmin=mindist,
finetune=finetune)
states.fit()
res2['sim_GS_tdist'][idxl], res2['simz_GS_tdist'][
idxl], dist = fit_metrics_simulation(bounds, states.deltas)
res2['sim_GS_WAC'][idxl], res2['simz_GS_WAC'][
idxl], dist = fit_metrics_simulation(
bounds, states.get_deltas(k=states.nstates_WAC))
if run_HMM is True:
t = None
ind = None
for i in range(2, self.maxK):
res2['LL_HMM'][idxl, i], res2['WAC_HMM'][idxl, i],res2['tdist_HMM'][idxl, i], \
hmm_bounds, t, ind = compute_fits_hmm(subData[0, :, :], i, mindist, type='HMM', y=None, t1=t, ind1=ind, zs=zs)
res2['optimum_LL_HMM'][idxl] = np.argmax(
res2['LL_HMM'][idxl][2:90]) + 2
res2['optimum_WAC_HMM'][idxl] = np.argmax(
res2['WAC_HMM'][idxl])
res2['optimum_tdist_HMM'][idxl] = np.argmax(
res2['tdist_HMM'][idxl])
i = int(res2['optimum_LL_HMM'][idxl])
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMM',
y=None,
t1=t,
ind1=ind)
res2['sim_HMM_LL'][idxl], res2['simz_HMM_LL'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMMsplit',
y=None,
t1=t,
ind1=ind)
res2['sim_HMMsplit_LL'][idxl], res2['simz_HMMsplit_LL'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
i = int(res2['optimum_WAC_HMM'][idxl])
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMM',
y=None,
t1=t,
ind1=ind)
res2['sim_HMM_WAC'][idxl], res2['simz_HMM_WAC'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMMsplit',
y=None,
t1=t,
ind1=ind)
res2['sim_HMMsplit_WAC'][idxl], res2['simz_HMMsplit_WAC'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
i = int(res2['optimum_tdist_HMM'][idxl])
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMM',
y=None,
t1=t,
ind1=ind)
res2['sim_HMM_tdist'][idxl], res2['simz_HMM_tdist'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
_, _, _, hmm_bounds, t, ind = compute_fits_hmm(
data=subData[0, :, :],
k=i,
mindist=1,
type='HMMsplit',
y=None,
t1=t,
ind1=ind)
res2['sim_HMMsplit_tdist'][idxl], res2['simz_HMMsplit_tdist'][
idxl], dist = fit_metrics_simulation(bounds, hmm_bounds)
res2['optimum_tdist'][idxl] = states.nstates
res2['optimum_wac'][idxl] = states.nstates_WAC
res2['optimum_meddist'][idxl] = states.nstates_meddist
res2['optimum_mdist'][idxl] = states.nstates_mdist
res2['fit_W_mean'][idxl, :] = states.all_m_W
res2['fit_W_std'][idxl, :] = states.all_sd_W
res2['fit_Ball_mean'][idxl, :] = states.all_m_Ball
res2['fit_Ball_std'][idxl, :] = states.all_sd_Ball
res2['fit_Bcon_mean'][idxl, :] = states.all_m_Bcon
res2['fit_Bcon_std'][idxl, :] = states.all_sd_Bcon
res2['tdist'][idxl, :] = states.tdists
res2['wac'][idxl, :] = states.WAC
res2['mdist'][idxl, :] = states.mdist
res2['meddist'][idxl, :] = states.meddist
return res2
def run_simulation_evlength(self,
length_std,
nstates_list,
run_HMM,
rep,
TRfactor=1,
finetune=1):
res = dict()
list2 = ['dists_GS', 'dists_HMM', 'dists_HMMsplit']
for key in list2:
res[key] = np.zeros([
np.shape(length_std)[0],
np.shape(nstates_list)[0], nstates_list[-1]
])
list = [
'sim_GS', 'sim_HMM', 'sim_HMMsplit', 'simz_GS', 'simz_HMM',
'simz_HMMsplit'
]
for key in list:
res[key] = np.zeros(
[np.shape(length_std)[0],
np.shape(nstates_list)[0]])
res['statesreal'] = np.zeros(
[np.shape(length_std)[0],
np.shape(nstates_list)[0], self.ntime])
res['bounds'] = np.zeros(
[np.shape(length_std)[0],
np.shape(nstates_list)[0], self.ntime])
res['bounds_HMMsplit'] = np.zeros(
[np.shape(length_std)[0],
np.shape(nstates_list)[0], self.ntime])
for idxl, l in enumerate(length_std):
for idxn, n in enumerate(nstates_list):
print(rep, l)
bounds, subData, _ = self.generate_simulated_data_HRF(
length_std=l, nstates=n, TRfactor=TRfactor, rep=rep)
res['statesreal'][idxl, idxn, :] = deltas_states(bounds)
states = gsbs_extra.GSBS(kmax=n,
x=subData[0, :, :],
finetune=finetune)
states.fit()
res['sim_GS'][idxl, idxn], res['simz_GS'][
idxl,
idxn], res['dists_GS'][idxl, idxn,
0:n] = fit_metrics_simulation(
bounds,
np.double(
states.get_bounds(k=n) > 0))
res['bounds'][idxl, idxn, :] = states.bounds
if run_HMM is True:
ev = HMM(n, split_merge=False)
ev.fit(subData[0, :, :])
hmm_bounds = np.insert(
np.diff(np.argmax(ev.segments_[0], axis=1)), 0,
0).astype(int)
ev = HMM(n, split_merge=True)
ev.fit(subData[0, :, :])
hmm_bounds_split = np.insert(
np.diff(np.argmax(ev.segments_[0], axis=1)), 0,
0).astype(int)
res['sim_HMM'][idxl, idxn], res['simz_HMM'][
idxl,
idxn], res['dists_HMM'][idxl, idxn,
0:n] = fit_metrics_simulation(
bounds, hmm_bounds)
res['sim_HMMsplit'][idxl, idxn], res['simz_HMMsplit'][
idxl, idxn], res['dists_HMMsplit'][
idxl, idxn, 0:n] = fit_metrics_simulation(
bounds, hmm_bounds_split)
res['bounds_HMMsplit'][idxl, idxn, :] = hmm_bounds_split
return res
def run_state_detection(kfold, roi, savedir, CV, radius, ISSth=-1, hyp=1, maxk:int=100, overwrite=False):
if hyp == 0:
outname = savedir + 'results_roi' + str(roi) + '_kfold' + str(kfold) + '_radius' + str(radius) + '_CV' + str(
CV) + 'typeGS_nohyp.p'
fname = savedir + 'group_data_roi' + str(roi) + '_radius' + str(radius) + '_nohyp.p'
elif hyp == 1:
outname = savedir + 'results_roi' + str(roi) + '_kfold' + str(kfold) + '_radius' + str(radius) + '_CV' + str(
CV) + '_typeGS.p'
fname = savedir + 'group_data_roi' + str(roi) + '_radius' + str(radius) + '.p'
if ISSth != 0.35:
outname=outname[0:-2] + 'ISS' + str(ISSth) + '.p'
print(outname)
if not os.path.exists(outname) or overwrite is True:
file = open(fname, 'rb')
res = pickle.load(file)
ISS = res['ISS']
ISSm = np.nanmean(ISS, 0)
if hyp == 1:
indices = np.squeeze(np.argwhere(ISSm >= ISSth))
elif hyp==0:
#make sure that only voxels that are hyperaligned are included in the analysis
fname2 = savedir + 'group_data_roi' + str(roi) + '_radius' + str(radius) + '.p'
file2 = open(fname2, 'rb')
res2 = pickle.load(file2)
ISS2 = res2['ISS']
ISSm2 = np.nanmean(ISS2, 0)
indices = np.intersect1d(np.squeeze(np.argwhere(ISSm >= ISSth)), np.squeeze(np.argwhere(ISSm2 >= -1)))
group_data = res['group_data'][:, :, indices]
nvox = len(indices)
optimum_fold = np.zeros(kfold)
optimum_wac_fold = np.zeros(kfold)
fin_bounds_folds = np.zeros([kfold, np.shape(group_data)[1]])
all_bounds_folds = np.zeros([kfold, maxk+1, np.shape(group_data)[1]])
optimum_mdist_fold = np.zeros(kfold)
fit_W = np.zeros([kfold, maxk+1])
fit_Bcon = np.zeros([kfold, maxk+1])
fit_Ball = np.zeros([kfold, maxk+1])
tdist = np.zeros([kfold, maxk+1])
wac = np.zeros([kfold, maxk+1])
mdist = np.zeros([kfold, maxk+1])
if kfold > 1:
kf = KFold(n_splits=kfold, shuffle=True, random_state=1)
count = -1
for train_index, test_index in kf.split(np.arange(0, np.shape(group_data)[0])):
count = count + 1
traindata = np.mean(group_data[train_index, :, :], axis=0)
if kfold == group_data.shape[0]:
testdata = np.squeeze(group_data[test_index, :, :])
else:
testdata = np.mean(group_data[test_index, :, :], axis=0)
if CV is True:
states = gsbs_extra.GSBS(x=traindata, y=testdata, kmax=maxk, outextra=True)
else:
states = gsbs_extra.GSBS(x=testdata, kmax=maxk, outextra=True)
states.fit()
optimum_fold[count] = states.nstates
optimum_wac_fold[count] = states.nstates_WAC
optimum_mdist_fold[count] = states.nstates_mdist
fin_bounds_folds[count, :] = states.bounds
all_bounds_folds[count, :,:] = states.all_bounds
fit_W[count, :] = states.all_m_W
fit_Bcon[count, :] = states.all_m_Bcon
fit_Ball[count, :] = states.all_m_Ball
tdist[count, :] = states.tdists
mdist[count, :] = states.mdist
wac[count, :] = states.WAC
else:
traindata = np.squeeze(np.mean(group_data[:, :, :], axis=0))
states = gsbs_extra.GSBS(x=traindata, kmax=maxk, outextra=True)
states.fit()
optimum_fold = states.nstates
optimum_wac_fold = states.nstates_WAC
optimum_mdist_fold = states.nstates_mdist
fin_bounds_folds = states.bounds
all_bounds_folds = states.all_bounds
fit_W = states.all_m_W
fit_Bcon = states.all_m_Bcon
fit_Ball = states.all_m_Ball
tdist = states.tdists
mdist = states.mdist
wac = states.WAC
res = {'optimum_fold': optimum_fold, 'optimum_wac_fold': optimum_wac_fold,'all_bounds_folds': all_bounds_folds,
'fin_bounds_folds': fin_bounds_folds, 'fit_W': fit_W,
'fit_Bcon': fit_Bcon, 'fit_Ball': fit_Ball, 'tdist': tdist,
'wac': wac, 'mdist':mdist, 'optimum_mdist_fold':optimum_mdist_fold, 'nvox':nvox}
with open(outname, 'wb') as output:
pickle.dump(res, output, pickle.HIGHEST_PROTOCOL)
else:
file = open(outname, 'rb')
res = pickle.load(file)
return res
