def calc_new_method(x, new_method, params_new_method=None, mi='alpha'):
if params_new_method['name'] == None:
params_new_method['name'] = new_method.__name__
mi = list(x.index.names)
if len(x.index.names) > 1:
mi.remove('time')
elif len(x.index.names) == 1 and x.index.names == [None]:
x.index.names = ['time']
if x.index.names == ['time']:
mi = []
params = {}
for m in mi:
params[m] = np.unique(x.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
dfc_estimate = []
for sim_it, mi_params in enumerate(mi_parameters):
if mi_params == ():
mi_params = np.arange(0, len(x))
time_points = int(
len(x.index.get_level_values('time')) / len(mi_parameters))
tmp = np.array(
new_method(
np.array([
x['timeseries_1'][mi_params], x['timeseries_2'][mi_params]
]), **params_new_method['params']))
# Fix the output in case it is no node,node,time (for full entire timeseries)
if len(tmp) != time_points:
window = int((time_points - len(tmp)) / 2)
tmp = np.lib.pad(tmp,
window,
mode='constant',
constant_values=np.nan)
if len(tmp) == time_points - 1:
tmp = np.hstack([np.nan, tmp])
if len(tmp.shape) == 3:
connectivity = tmp[0, 1, :]
else:
connectivity = tmp
dfc_estimate.append(connectivity)
dfc_estimate = np.concatenate(dfc_estimate)
return dfc_estimate
def gen_data_sim1(params,mi=None):
"""
*INPUT*
params is a dictionary which must contain the following:
:n_samples: length of time series. Default=10,000
:alpha: auto-correlation of time series. Can be single integer or np.array with length of mu
:mu: Mean of auto-correlated time-series sampled from a multivariate Gaussian distribution. Must be of length 2 or greater.
:sigma: Covariance matrix for multivariate Gaussian distribution. Array or list with shape of (len(mu),len(mu)).
:randomseed: set random seed
*LIMITATIONS*
Mean and sigma must always stay the same.
n_samples cannot be multiindex
*RETURNS*
:df: pandas dataframe with timeseries_1, timeseries_2.
"""
np.random.seed(params['randomseed'])
# generate data
# Check multiindex and get number of each multiindex
mi,mi_num,mi_parameters,mi_param_list = dfcbenchmarker.multiindex_preproc(params,mi)
x=np.zeros([2, params['n_samples']] + mi_num)
x = x.reshape([2,int(np.prod(x.shape)/2)])
for sim_it, mi_params in enumerate(mi_parameters):
d = dict(params)
for i in range(0,len(mi)):
d[mi[i]] = mi_params[i]
x_start = d['n_samples'] * sim_it
x_end = d['n_samples'] * (sim_it + 1)
w=np.random.multivariate_normal(d['mu'],d['sigma'],d['n_samples']).transpose()
x[:,x_start:x_end] = np.array(w)
for t in range(1,d['n_samples']):
x[:,(d['n_samples']*sim_it)+t]=d['alpha']*x[:,(d['n_samples']*sim_it)+t-1]+w[:,t]
multi_ind = pd.MultiIndex.from_product((mi_param_list) + [np.arange(0,d['n_samples'])], names=mi + ['time'])
df = pd.DataFrame(data={'timeseries_1': x[0,:],'timeseries_2':x[1,:]}, index=multi_ind)
return df
def model_dfc(x,
dfc,
dat_dir,
model_prefix,
bayes_model='bayes_model',
mi='alpha',
model_params={}):
"""
General stats functions that calls the bayes_model, saves the output.
**Input**
:x: raw time series (DF)
:dfc: dynamic connectivity estimates (DF)
:dat_dir: Place to save the stats data.
:model_predix: Prefix name for saved file
:model_params: string of parameters for bayes_model function
"""
if model_params == None:
model_params = ''
if isinstance(mi, str):
mi = [mi]
params = {}
for m in mi:
params[m] = np.unique(dfc.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
for sim_it, mi_params in enumerate(mi_parameters):
for method in dfc.columns:
X = dfc[method][mi_params]
Y = x['covariance_parameter'][mi_params][X.index]
trace_and_model = dfcbenchmarker.bayes_model(X, Y, **model_params)
#Save data
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
param_sname = '_' + param_sname.replace(' ', '')
file_name = model_prefix + '_' + 'method-' + method + param_sname
dfcbenchmarker.trace_plot(dat_dir, file_name, trace_and_model[0])
dfcbenchmarker.save_bayes_model(dat_dir, file_name,
trace_and_model)
def dfc_calc(data,
methods=['SW', 'TSW', 'SD', 'JC', 'TD'],
sw_window=63,
taper_name='norm',
taper_properties=[0, 10],
sd_distance='euclidean',
td_window=7,
mi='alpha',
col_ind=[]):
"""
Required parameters for the various differnet methods:
If method == 'SW'
sw_window = [Integer]
Length of sliding window
If method == 'TSW'
sw_window = [Integer]
Length of sliding window
taper_name = [string]
Name of scipy.stats distribution used (see teneto.derive.derive for more information)
taper_properties = [list]
List of the different scipy.stats.[taper_name] properties. E.g. if taper_name = 'norm'; taper_properties = [0,10] with me the mean and standard deviation of the distribution.
If method == 'SD'
sd_distance = [string]
Distance funciton used to calculate the similarity between time-points. Can be any of the distances functions in scipy.spatial.distance.
if method == 'JC'
There are no parmaeters, have empty dictionary as parameter input.
if method == 'TD'
td_window= [Integer]
Length of window
# mi='alpha'
"""
# If data is a string, load precalcuated data
if isinstance(data, str):
if data == 'sim-1':
colind = 1
elif data == 'sim-2' or data == 'sim-3' or data == 'sim-4':
colind = 2
else:
raise ValueError(
'unknown simulation. Input must be "sim-1", "sim-2", "sim-3" or "sim-4"'
)
df = pd.read_csv(dfcbenchmarker.__path__[0] + '/data/dfc/' + data +
'_dfc.csv',
index_col=np.arange(0, colind))
# Get methods
requested_methods = list(set(methods).intersection(df.columns))
df[requested_methods]
#Otherwise calculate
else:
# Make methods variable a list if single string is given
if isinstance(methods, str):
methods = [methods]
if isinstance(mi, str):
mi = [mi]
dfc = {}
params = {}
for m in mi:
params[m] = np.unique(data.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
#Sliding window
if 'SW' in methods:
dfc['SW'] = []
dfc_params = {}
dfc_params['windowsize'] = sw_window
dfc_params['method'] = 'slidingwindow'
dfc_params['dimord'] = 'node,time'
dfc_params['postpro'] = 'fisher'
dfc_params['report'] = 'no'
if mi_parameters[0]:
# Do this if there are multiple mi parameters
for sim_it, mi_params in enumerate(mi_parameters):
ts1 = data['timeseries_1'][mi_params]
ts2 = data['timeseries_2'][mi_params]
connectivity = teneto.derive.derive(
np.array([ts1, ts2]), dfc_params)[0, 1, :]
dfc['SW'].append(
np.lib.pad(connectivity,
int((sw_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Otherwise do this
else:
ts1 = data['timeseries_1']
ts2 = data['timeseries_2']
connectivity = teneto.derive.derive(np.array([ts1, ts2]),
dfc_params)[0, 1, :]
dfc['SW'].append(
np.lib.pad(connectivity,
int((sw_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Line up all appened arrays
dfc['SW'] = np.concatenate(dfc['SW'])
#Tapered sliding window
if 'TSW' in methods:
dfc['TSW'] = []
dfc_params = {}
dfc_params['windowsize'] = sw_window
dfc_params['distribution'] = taper_name
dfc_params['distribution_params'] = taper_properties
dfc_params['method'] = 'taperedslidingwindow'
dfc_params['dimord'] = 'node,time'
dfc_params['postpro'] = 'fisher'
dfc_params['report'] = 'no'
if mi_parameters[0]:
# Do this if there are multiple mi parameters
for sim_it, mi_params in enumerate(mi_parameters):
ts1 = data['timeseries_1'][mi_params]
ts2 = data['timeseries_2'][mi_params]
connectivity = teneto.derive.derive(
np.array([ts1, ts2]), dfc_params)[0, 1, :]
dfc['TSW'].append(
np.lib.pad(connectivity,
int((sw_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Otherwise do this
else:
ts1 = data['timeseries_1']
ts2 = data['timeseries_2']
connectivity = teneto.derive.derive(np.array([ts1, ts2]),
dfc_params)[0, 1, :]
dfc['TSW'].append(
np.lib.pad(connectivity,
int((sw_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Line up all appened arrays
dfc['TSW'] = np.concatenate(dfc['TSW'])
#Spatial distance
if 'SD' in methods:
dfc['SD'] = []
dfc_params = {}
dfc_params['distance'] = 'euclidean'
dfc_params['method'] = 'spatialdistance'
dfc_params['dimord'] = 'node,time'
dfc_params['postpro'] = 'fisher'
dfc_params['report'] = 'no'
if mi_parameters[0]:
# Do this if there are multiple mi parameters
for sim_it, mi_params in enumerate(mi_parameters):
ts1 = data['timeseries_1'][mi_params]
ts2 = data['timeseries_2'][mi_params]
connectivity = teneto.derive.derive(
np.array([ts1, ts2]), dfc_params)[0, 1, :]
dfc['SD'].append(connectivity)
# Otherwise do this
else:
ts1 = data['timeseries_1']
ts2 = data['timeseries_2']
connectivity = teneto.derive.derive(np.array([ts1, ts2]),
dfc_params)[0, 1, :]
dfc['SD'].append(connectivity)
# Line up all appened arrays
dfc['SD'] = np.concatenate(dfc['SD'])
#Jackknife
if 'JC' in methods:
dfc['JC'] = []
dfc_params = {}
dfc_params['method'] = 'jackknife'
dfc_params['dimord'] = 'node,time'
dfc_params['postpro'] = 'fisher'
dfc_params['report'] = 'no'
if mi_parameters[0]:
# Do this if there are multiple mi parameters
for sim_it, mi_params in enumerate(mi_parameters):
ts1 = data['timeseries_1'][mi_params]
ts2 = data['timeseries_2'][mi_params]
connectivity = teneto.derive.derive(
np.array([ts1, ts2]), dfc_params)[0, 1, :]
dfc['JC'].append(connectivity)
# Otherwise do this
else:
ts1 = data['timeseries_1']
ts2 = data['timeseries_2']
connectivity = teneto.derive.derive(np.array([ts1, ts2]),
dfc_params)[0, 1, :]
dfc['JC'].append(connectivity)
# Line up all appened arrays
dfc['JC'] = np.concatenate(dfc['JC'])
#Temporal derivative
if 'TD' in methods:
dfc['TD'] = []
dfc_params = {}
dfc_params['method'] = 'temporalderivative'
dfc_params['dimord'] = 'node,time'
dfc_params['postpro'] = 'no'
dfc_params['windowsize'] = td_window
dfc_params['report'] = 'no'
if mi_parameters[0]:
# Do this if there are multiple mi parameters
for sim_it, mi_params in enumerate(mi_parameters):
ts1 = data['timeseries_1'][mi_params]
ts2 = data['timeseries_2'][mi_params]
connectivity = teneto.derive.derive(
np.array([ts1, ts2]), dfc_params)[0, 1, :]
dfc['TD'].append(
np.lib.pad(np.hstack([np.nan, connectivity]),
int((td_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Otherwise do this
else:
ts1 = data['timeseries_1']
ts2 = data['timeseries_2']
connectivity = teneto.derive.derive(np.array([ts1, ts2]),
dfc_params)[0, 1, :]
dfc['TD'].append(
np.lib.pad(np.hstack([np.nan, connectivity]),
int((td_window - 1) / 2),
mode='constant',
constant_values=np.nan))
# Line up all appened arrays
dfc['TD'] = np.concatenate(dfc['TD'])
df = pd.DataFrame(data=dfc, index=data.index)
return df
def gen_data_sim2(params,mi='alpha'):
"""
*INPUT*
Params is a dictionary which contains the following
:n_samples: length of time series. Default=10,000
:alpha: auto-correlation of time series. Can be single integer or np.array with length of mu
:mu: Mean of auto-correlated time-series sampled from a multivariate Gaussian distribution. Must be a array/list of length 2 or 2xn_samples.
:var: Variance of the time series. Integer or np.array with length of mu
:covar_mu: Mean of the covariance of the time series.
:covar_sigma: Variance of the covariance of the time series.
:randomseed: set random seed
Additionally, if there is a multi_index variable, this should be specified differently
:mi: multi_index. list of variable names which have multiple parameters. These parameters should be in a list. E.g. if mi='mu', then mu becomes a list surrounding its contents. e.g. mu=[[0,0],[1,1]]
*LIMITATIONS*
As the parameters stand, only 2 time series can be generated (some minor modifications are needed to generate more).
Input `var` must be integer and cannot vary between the time series.
*RETURNS*
:df: pandas dataframe with timeseries_1, timeseries_2, covariance_parameter. Table is multiindexed with alpha and time as the two indexes.
"""
# Random seed
np.random.seed(params['randomseed'])
# Check multiindex and get number of each multiindex
mi,mi_num,mi_parameters,mi_param_list = dfcbenchmarker.multiindex_preproc(params,mi)
# Pre allocate output
x=np.zeros([2,params['n_samples']] + mi_num)
fluct_cv = np.zeros([params['n_samples']] + mi_num)
x = x.reshape([2,int(np.prod(x.shape)/2)])
fluct_cv = fluct_cv.flatten()
# Set preliminary arguments
for sim_it, mi_params in enumerate(mi_parameters):
d = dict(params)
for i in range(0,len(mi)):
d[mi[i]] = mi_params[i]
# extend mu through timeseries if it is (list of) integers
d['mu']=np.array(d['mu'],ndmin=2)
if d['mu'].shape[-1]!=d['n_samples']:
d['mu']=np.tile(d['mu'].transpose(),d['n_samples'])
# extend covar_mu through timeseries if is integer
d['covar_mu']=np.array(d['covar_mu'],ndmin=1)
if d['covar_mu'].shape[-1]!=d['n_samples']:
d['covar_mu']=np.tile(d['covar_mu'].transpose(),d['n_samples'])
for t in range(0,d['n_samples']):
# At first time point, no autocorrelation of covariance
if t==0:
covar = np.random.normal(d['covar_mu'][t],d['covar_sigma'])
else:
covar = np.random.normal(d['covar_mu'][t],d['covar_sigma'])+d['alpha']*fluct_cv[(d['n_samples']*sim_it)+t-1]
x[:,(d['n_samples']*sim_it)+t]=np.random.multivariate_normal(d['mu'][:,t], [[d['var'], covar], [covar, d['var']]], 1)
fluct_cv[(d['n_samples']*sim_it)+t]=covar
#x=np.reshape(x,[x.shape[0],np.prod(x.shape[1:])],order='F')
#fluct_cv=np.reshape(fluct_cv,[np.prod(fluct_cv.shape)],order='F')
multi_ind = pd.MultiIndex.from_product((mi_param_list) + [np.arange(0,d['n_samples'])], names=mi + ['time'])
df = pd.DataFrame(data={'timeseries_1': x[0,:],'timeseries_2':x[1,:],'covariance_parameter':fluct_cv}, index=multi_ind)
return df
def gen_data_sim4(params,mi=None):
"""
*INPUT*
No input runs the default simulation.
:n_samples: length of time series. Default=10,000
:mu: Mean of auto-correlated time-series sampled from a multivariate Gaussian distribution. Must be a array/list of length 2 or 2xn_samples.
:var: Variance of the time series. Integer or np.array with length of mu
:covar_range: list of possible covariance
:state_length: List of lists of possible times before covariance changes.
:state_length_name: Name of each stat
:randomseed: set random seed
*LIMITATIONS*
As the parameters stand, only 2 time series can be generated (some minor modifications are needed to generate more).
Input `var` must be integer and cannot vary between the time series.
*RETURNS*
:df: pandas dataframe with timeseries_1, timeseries_2, covariance_parameter. Table is multiindexed with alpha and time as the two indexes.
"""
# Random seed
np.random.seed(params['randomseed'])
# Check multiindex and get number of each multiindex
mi,mi_num,mi_parameters,mi_param_list = dfcbenchmarker.multiindex_preproc(params,mi)
# Pre allocate output
x=np.zeros([2,params['n_samples']] + mi_num)
x = x.reshape([2,int(np.prod(x.shape)/2)])
fluct_cv = np.zeros([params['n_samples']*len(mi_parameters)])
fluct_cv_state= np.zeros([params['n_samples']*len(mi_parameters)])
# Set preliminary arguments
for sim_it, mi_params in enumerate(mi_parameters):
d = dict(params)
for i in range(0,len(mi)):
d[mi[i]] = mi_params[i]
# extend mu through timeseries if it is (list of) integers
d['mu']=np.array(d['mu'],ndmin=2)
if d['mu'].shape[-1]!=d['n_samples']:
d['mu']=np.tile(d['mu'].transpose(),d['n_samples'])
covar_mu=np.array([])
while len(covar_mu)<d['n_samples']:
new_covariance = np.random.permutation(d['covar_range'])[0]
covariance_length = np.random.permutation(d['state_length'])[0]
covar_mu = np.hstack([covar_mu,np.tile(new_covariance,covariance_length)])
covar_mu=covar_mu[:d['n_samples']]
fluct_cv_state[(d['n_samples']*sim_it):(d['n_samples']*(sim_it+1))]=covar_mu
for t in range(0,d['n_samples']):
covar = np.random.normal(covar_mu[t],d['covar_sigma'])
x[:,(d['n_samples']*sim_it)+t]=np.random.multivariate_normal(d['mu'][:,t],[[d['var'],covar],[covar,d['var']]],1)
fluct_cv[(d['n_samples']*sim_it)+t]=covar
# Reshape for pandas dataframe
x=np.reshape(x,[x.shape[0],np.prod(x.shape[1:])],order='F')
fluct_cv=np.reshape(fluct_cv,[np.prod(fluct_cv.shape)],order='F')
fluct_cv_state=np.reshape(fluct_cv_state,[np.prod(fluct_cv_state.shape)],order='F')
multi_ind = pd.MultiIndex.from_product((mi_param_list + [np.arange(0,d['n_samples'])]), names=mi + ['time'])
df = pd.DataFrame(data={'timeseries_1': x[0,:],'timeseries_2':x[1,:],'covariance_parameter':fluct_cv,'covariance_mean':fluct_cv_state}, index=multi_ind)
return df
def calc_waic(dfc,
model_dir,
save_dir,
file_prefix=None,
mi='alpha',
burn=1000):
"""
Calculates WAIC of a bayes model, saves table
**Input**
:dfc: dfc dataframe
:model_dir: where the bayesian models are saved
:save_dir: where to save the tables
:file_prefix: appended model name
:mi: Loop over multiple models of this multiindex
:burn: how many from start of trace to discard.
**Returns**
:waic: (numpy array)
"""
if file_prefix:
file_prefix += '_'
if isinstance(mi, str):
mi = [mi]
params = {}
for m in mi:
params[m] = np.unique(dfc.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
param_sname = '_' + param_sname.replace(' ', '')
waic = np.zeros([len(dfc.columns), 3])
for i, method in enumerate(dfc.columns):
file_name = file_prefix + 'method-' + method + param_sname
tm = dfcbenchmarker.load_bayes_model(model_dir, file_name)
waic[i, :] = np.array(pm.stats.waic(tm[0][burn:], tm[1]))
odr = np.argsort(waic[:, 0])
delta_waic = waic[:, 0] - waic[odr[0], 0]
#Create table for tabulate
tablelst = [["Model", "WAIC", "WAIC SE", "$\Delta$ WAIC"]]
for i in odr:
tablelst.append(
[dfc.columns[i], waic[i, 0], waic[i, 1], delta_waic[i]])
#Make markdown table and save
mdtable = tabulate.tabulate(tablelst,
headers="firstrow",
tablefmt='simple')
with open(
save_dir + '/' + file_prefix + 'waictable' + param_sname +
'.md', 'w') as f:
f.write(mdtable)
f.close()
print(mdtable)
return waic
def plot_fluctuating_covariance(x,
fig_dir=None,
lags=10,
limitaxis=500,
cm='Set2',
mi='alpha',
fig_prefix=None):
# if labels == None:
# labels=np.unique(x.index.get_level_values(mi))
if isinstance(mi, str):
mi = [mi]
if not fig_dir:
fig_dir = './'
if fig_prefix:
fig_prefix += '_'
else:
fig_prefix = ''
if not os.path.exists(fig_dir):
os.makedirs(fig_dir, exist_ok=True)
params = {}
for m in mi:
params[m] = np.unique(x.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
colormap = dfcbenchmarker.get_discrete_colormap(cm)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
if param_sname:
param_sname = '_' + param_sname.replace(' ', '')
param_title = [
p[0] + '=' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_title = ','.join(param_title)
param_title = param_title.replace(' ', '').replace(',', ', ')
if mi_params == ():
mi_params = np.arange(0, len(x))
covariance_autocorrelation = dfcbenchmarker.autocorr(
x['covariance_parameter'][mi_params], lags=lags)
# Create grid
fig = plt.figure()
ax = []
ax.append(plt.subplot2grid((2, 2), (0, 0), colspan=2))
ax.append(plt.subplot2grid((2, 2), (1, 0)))
ax.append(plt.subplot2grid((2, 2), (1, 1)))
ax[0].plot(np.arange(1, limitaxis + 1),
x['covariance_parameter'][mi_params][:limitaxis],
color=colormap(0),
alpha=0.5,
linewidth=2)
ax[0].set_xlabel('Time')
ax[0].set_ylabel(r'Covariance ($r_t$)')
ymin = x['covariance_parameter'][mi_params][:limitaxis].min()
ymax = x['covariance_parameter'][mi_params][:limitaxis].max()
ax[0].axis([
1, limitaxis + 1,
np.around(ymin - 0.05, 1),
np.around(ymax + 0.05, 1)
])
ax[1].hist(x['covariance_parameter'][mi_params],
np.arange(-.1, 1, 0.02),
color=colormap(1),
alpha=0.9,
linewidth=0,
histtype='stepfilled',
normed='true')
ax[1].set_xlabel('Covariance')
ax[1].set_ylabel('Frequency')
xmin = x['covariance_parameter'][mi_params].min()
xmax = x['covariance_parameter'][mi_params].max()
ax[1].axis([
np.around(xmin - 0.05, 1),
np.around(xmax + 0.05, 1), 0,
np.ceil(ax[1].get_ylim()[-1])
])
dfcbenchmarker.square_axis(ax[1])
ax[2].plot(np.arange(0, 11),
covariance_autocorrelation,
color=colormap(2),
alpha=0.9,
linewidth=2)
ax[2].set_ylabel('Correlation (r)')
ax[2].set_xlabel('Lag')
ymin = covariance_autocorrelation.min()
ymax = 1
ax[2].axis(
[0, 10,
np.around(ymin - 0.05, 1),
np.around(ymax + 0.05, 1)])
dfcbenchmarker.square_axis(ax[2])
plt.suptitle(param_title, fontsize=11)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.savefig(fig_dir + '/' + fig_prefix + 'fluctuating-covariance' +
param_sname + '.pdf',
r=600)
plt.close('all')
def plot_betadfc_distribution(dfc,
dat_dir,
fig_dir=None,
model_prefix=None,
burn=1000,
mi='alpha',
cm='Set2'):
if isinstance(mi, str):
mi = [mi]
if model_prefix:
model_prefix += '_'
if not fig_dir:
fig_dir = './'
if not os.path.exists(fig_dir):
os.makedirs(fig_dir, exist_ok=True)
params = {}
for m in mi:
params[m] = np.unique(dfc.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
colormap = dfcbenchmarker.get_discrete_colormap(cm)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
if param_sname:
param_sname = '_' + param_sname.replace(' ', '')
param_title = [
p[0] + '=' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_title = ','.join(param_title)
param_title = param_title.replace(' ', '').replace(',', ', ')
if mi_params == ():
mi_params = np.arange(0, len(dfc))
fig, ax = plt.subplots(len(dfc.columns),
sharex=True,
sharey=True,
figsize=(5, len(dfc.columns)))
beta_col = []
lines = []
for i, method in enumerate(sorted(dfc.columns)):
beta_dfc = dfcbenchmarker.load_bayes_model(
dat_dir, model_prefix + 'method-' + method +
param_sname)[0][burn:].get_values('beta')
#Plot
ltmp = ax[i].hist(beta_dfc,
np.arange(-1, 1, 0.001),
histtype='stepfilled',
color=colormap(i),
normed=True,
alpha=0.4,
linewidth=2,
label=method)
lines.append(ltmp)
ax[i].set_yticklabels([])
ax[i].set_ylabel(method)
beta_col.append(beta_dfc)
#ax[i].set_ylabel('Posterior Frequency (' + method + ')')
beta_col = np.vstack(beta_col)
xmin = beta_col.min()
xmax = beta_col.max()
ax[0].get_yaxis().set_major_locator(LinearLocator(numticks=4))
ax[0].set_xlim(
[np.around(xmin - 0.005, 2),
np.around(xmax + 0.005, 2)])
ax[-1].set_xlabel('Posterior (' + r'$β$' + ')')
fig.suptitle(param_title, fontsize=11)
fig.tight_layout(rect=[0, 0, 1, 0.95])
plt.savefig(fig_dir + '/' + model_prefix + 'beta-posterior' +
param_sname + '.pdf',
r=600)
plt.close('all')
def plot_dfc_timeseries(dfc,
limitaxis=500,
cm='Set2',
fig_dir=None,
fig_prefix=None,
mi=[]):
if isinstance(mi, str):
mi = [mi]
if fig_prefix:
fig_prefix += '_'
else:
fig_prefix = ''
if not fig_dir:
fig_dir = './'
if not os.path.exists(fig_dir):
os.makedirs(fig_dir, exist_ok=True)
params = {}
for m in mi:
params[m] = np.unique(dfc.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
colormap = dfcbenchmarker.get_discrete_colormap(cm)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
if param_sname:
param_sname = '_' + param_sname.replace(' ', '')
param_title = [
p[0] + '=' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_title = ','.join(param_title)
param_title = param_title.replace(' ', '').replace(',', ', ')
if mi_params == ():
mi_params = np.arange(0, len(dfc))
fig, ax = plt.subplots(len(dfc.columns), 1, sharex=True)
for i, dfc_method in enumerate(sorted(dfc.columns)):
ax[i].plot(dfc[dfc_method][mi_params][:limitaxis],
color=colormap(i),
alpha=0.5,
linewidth=2)
ax[i].set_ylabel('DFC (' + dfc_method + ')')
ax[i].get_yaxis().set_major_locator(LinearLocator(numticks=5))
ax[i].set_xlim(1, limitaxis)
ax[-1].set_xlabel('time')
plt.suptitle(param_title, fontsize=11)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.savefig(fig_dir + '/' + fig_prefix + 'dfc-timeseries' +
param_sname + '.pdf',
r=600)
plt.close('all')
def plot_method_correlation(dfc,
cmap='RdBu_r',
fig_dir=None,
fig_prefix=None,
mi=[]):
if isinstance(mi, str):
mi = [mi]
if fig_prefix:
fig_prefix += '_'
else:
fig_prefix = ''
if not fig_dir:
fig_dir = './'
if not os.path.exists(fig_dir):
os.makedirs(fig_dir, exist_ok=True)
params = {}
for m in mi:
params[m] = np.unique(dfc.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
if param_sname:
param_sname = '_' + param_sname.replace(' ', '')
param_title = [
p[0] + '=' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_title = ','.join(param_title)
param_title = param_title.replace(' ', '').replace(',', ', ')
if mi_params == ():
mi_params = np.arange(0, len(dfc))
R = np.zeros([len(dfc.columns), len(dfc.columns)])
for i, m1 in enumerate(sorted(dfc.columns)):
for j, m2 in enumerate(sorted(dfc.columns)):
notnan = np.intersect1d(
np.where(np.isnan(dfc[m1][mi_params]) == 0),
np.where(np.isnan(dfc[m2][mi_params]) == 0))
R[i, j] = sps.spearmanr(dfc[m1][mi_params][notnan],
dfc[m2][mi_params][notnan])[0]
fig, ax = plt.subplots(1)
pax = ax.pcolormesh(R, vmin=-1, vmax=1, cmap=cmap)
dfcbenchmarker.square_axis(ax)
ax.set_xticks(np.arange(0.5, len(dfc.columns) - 0.49, 1))
ax.set_xticklabels(sorted(dfc.columns))
ax.set_yticks(np.arange(0.5, len(dfc.columns) - 0.49, 1))
ax.set_yticklabels(sorted(dfc.columns))
ax.axis([0, len(dfc.columns), len(dfc.columns), 0])
plt.suptitle(param_title, fontsize=11)
plt.tight_layout(rect=[0, 0, 1, 0.95])
fig.colorbar(pax)
plt.savefig(fig_dir + '/' + fig_prefix + 'dfc-method-correlation' +
param_sname + '.pdf',
r=600)
plt.close('all')
def plot_timeseries(x,
plot_autocorr='no',
fig_dir=None,
fig_prefix=None,
cm='Set2',
limitaxis=100,
mi='alpha'):
if isinstance(mi, str):
mi = [mi]
if fig_prefix:
fig_prefix += '_'
else:
fig_prefix = ''
if not fig_dir:
fig_dir = './'
if not os.path.exists(fig_dir):
os.makedirs(fig_dir, exist_ok=True)
params = {}
for m in mi:
params[m] = np.unique(x.index.get_level_values(m))
mi, mi_num, mi_parameters, mi_param_list = dfcbenchmarker.multiindex_preproc(
params, mi)
colormap = dfcbenchmarker.get_discrete_colormap(cm)
for sim_it, mi_params in enumerate(mi_parameters):
param_sname = [
p[0] + '-' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_sname = '_'.join(param_sname)
if param_sname:
param_sname = '_' + param_sname.replace(' ', '')
param_title = [
p[0] + '=' + str(p[1]) for p in list(zip(mi, mi_params))
]
param_title = ','.join(param_title)
param_title = param_title.replace(' ', '').replace(',', ', ')
if mi_params == ():
mi_params = np.arange(0, len(x))
if plot_autocorr == 'no':
fig, ax = plt.subplots(1)
ax.plot(np.arange(1, limitaxis + 1),
x['timeseries_1'][mi_params][:limitaxis],
color=colormap(0),
alpha=0.9,
linewidth=2)
ax.plot(np.arange(1, limitaxis + 1),
x['timeseries_2'][mi_params][:limitaxis],
color=colormap(1),
alpha=0.9,
linewidth=2)
ax.set_xlim(1, limitaxis)
ax.set_ylabel('Signal Amplitude')
ax.set_xlabel('Time')
else:
autocorrelation = np.array([
dfcbenchmarker.autocorr(x[ts][mi_params])
for ts in ['timeseries_1', 'timeseries_2']
])
fig = plt.figure()
ax = []
ax.append(plt.subplot2grid((2, 3), (0, 0), colspan=3))
for n in range(0, 3):
ax.append(plt.subplot2grid((2, 3), (1, n)))
# Plot 1: raw time series
ax[0].plot(np.arange(1, limitaxis + 1),
x['timeseries_1'][mi_params][:limitaxis],
color=colormap(0),
alpha=0.9,
linewidth=2)
ax[0].plot(np.arange(1, limitaxis + 1),
x['timeseries_2'][mi_params][:limitaxis],
color=colormap(1),
alpha=.9,
linewidth=2)
ax[0].set_xlim(1, limitaxis)
ax[0].set_ylabel('Signal Amplitude')
ax[0].set_xlabel('Time')
# Plot 2 and 3: autocorrelation of timeseries 1 and 2
for p in range(1, 3):
ax[p].plot(np.arange(0, autocorrelation.shape[1]),
autocorrelation[p - 1, :],
color=colormap(p - 1),
alpha=0.9,
linewidth=2)
ax[p].set_ylabel('Correlation (r)')
ax[p].set_xlabel('Lag')
ax[p].axis([0, autocorrelation.shape[1] - 1, 0, 1])
ax[p].set_yticks(np.arange(0, 1.05, 0.25))
ax[p].set_xticks(np.arange(0, autocorrelation.shape[1], 2))
# Plot 4: correlation of timeseries 1 and 2
cmap = sns.cubehelix_palette(start=1 / 3, light=1, as_cmap=True)
ax[3] = sns.kdeplot(x['timeseries_1'][mi_params],
x['timeseries_2'][mi_params],
shade=True,
cmap=cmap)
ax[3].set_xlabel('Signal 1 amplitude')
ax[3].set_ylabel('Signal 2 amplitude')
[dfcbenchmarker.square_axis(ax[n]) for n in [1, 2, 3]]
plt.suptitle(param_title, fontsize=11)
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.savefig(fig_dir + '/' + fig_prefix + 'raw-timeseries' +
param_sname + '.pdf',
r=600)
plt.close('all')