def __repr__(self):
d = {
"01. Name": self.name,
"02. Type": self.type,
"03. Number of regions": self.number_of_regions,
"04. Excitability (x0) disease indices":
self.x0_disease_indices, # x0_indices,
"05. Excitability (x0) disease values":
self.x0_disease_values, # x0_values,
"06. Epileptogenicity (E) disease indices":
self.e_disease_indices, # e_indices,
"07. Epileptogenicity (E) disease values":
self.e_disease_values, # e_values,
"08. Connectivity (W) disease indices": self.w_indices,
"09. Connectivity (W) disease values": self.w_values,
"10. Propagation indices": self.lsa_propagation_indices,
}
if len(self.lsa_propagation_indices):
d.update({
"11. Propagation strengths of indices":
self.lsa_propagation_strengths[self.lsa_propagation_indices]
})
else:
d.update({
"11. Propagation strengths of indices":
self.lsa_propagation_strengths
})
# d.update({"11. Connectivity": str(self.connectivity)})
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"1. type": self.name,
"2. number of regions": self.number_of_regions,
"3. number of parameters": self.n_parameters,
"4. parameters": self.parameters
}
return formal_repr(self, sort_dict(d))
def dict_to_h5_model(h5_model, obj, path, container_path):
if len(obj) == 0:
h5_model.add_or_update_datasets_attribute(path, "{}")
return h5_model, None
else:
h5_model.add_or_update_metadata_attribute(
os.path.join(container_path, "create_str"), "OrderedDict()")
return h5_model, sort_dict(obj)
def __repr__(self):
d = {
"1. name": self.name,
"2. low": self.low,
"3. high": self.high,
"4. shape": self.p_shape
}
return formal_repr(self, sort_dict(d))
def read_h5_model(path):
h5_file = h5py.File(path, 'r', libver='latest')
datasets_dict = dict()
metadata_dict = dict()
for attr_key, value in h5_file.attrs.iteritems():
metadata_dict.update({"/" + attr_key: value})
def add_dset_and_attr(name, obj):
if isinstance(obj, h5py.Dataset):
# node is a dataset
datasets_dict.update({"/" + name: obj[()]})
for key, val in obj.attrs.iteritems():
metadata_dict.update({os.path.join("/" + name, key): val})
h5_file.visititems(add_dset_and_attr)
datasets_dict = sort_dict(datasets_dict)
metadata_dict = sort_dict(metadata_dict)
return H5Model(datasets_dict, metadata_dict)
def __repr__(self):
d = {
"00. surface subtype": self.surface_subtype,
"01. vertices": self.vertices,
"02. triangles": self.triangles,
"03. vertex_normals": self.vertex_normals,
"04. triangle_normals": self.triangle_normals,
"05. voxel to ras matrix": self.vox2ras
}
return formal_repr(self, sort_dict(d))
def object_to_h5_model(h5_model, obj, container_path):
obj_dict = sort_dict(vars(obj))
for this_gen_str in [
"context_str", "create_str", "transform_str", "update_str"
]:
gen_str = obj_dict.get(this_gen_str, None)
if isinstance(gen_str, basestring):
h5_model.add_or_update_metadata_attribute(
os.path.join(container_path[1:], this_gen_str), gen_str)
return h5_model, obj_dict
def __repr__(self):
d = {"f. normalized weights": reg_dict(self.normalized_weights, self.region_labels),
"g. weights": reg_dict(self.weights, self.region_labels),
"h. tract_lengths": reg_dict(self.tract_lengths, self.region_labels),
"a. region_labels": reg_dict(self.region_labels),
"b. centres": reg_dict(self.centres, self.region_labels),
"c. hemispheres": reg_dict(self.hemispheres, self.region_labels),
"d. orientations": reg_dict(self.orientations, self.region_labels),
"e. areas": reg_dict(self.areas, self.region_labels)}
return formal_repr(self, sort_dict(d))
def __repr__(self):
d = {
"1. sensors' type": self.s_type,
"2. number of sensors": self.number_of_sensors,
"3. labels": reg_dict(self.labels),
"4. locations": reg_dict(self.locations, self.labels),
"5. orientations": reg_dict(self.orientations, self.labels),
"6. gain_matrix": self.gain_matrix
}
return formal_repr(self, sort_dict(d))
def set_model_data(self, debug=0, simulate=0, **kwargs):
self.model_data_path = kwargs.get("model_data_path", self.model_data_path)
model_data = kwargs.pop("model_data", None)
if not(isinstance(model_data, dict)):
model_data = self.load_model_data_from_file(self.model_data_path)
# -1 for no debugging at all
# 0 for printing only scalar parameters
# 1 for printing scalar and vector parameters
# 2 for printing all (scalar, vector and matrix) parameters
model_data["DEBUG"] = debug
# > 0 for simulating without using the input observation data:
model_data["SIMULATE"] = simulate
model_data = sort_dict(model_data)
return model_data
def __repr__(self):
d = {
"1. name": self.name,
"2. connectivity": self.connectivity,
"3. RM": reg_dict(self.region_mapping,
self.connectivity.region_labels),
"4. VM": reg_dict(self.volume_mapping,
self.connectivity.region_labels),
"5. surface": self.cortical_surface,
"6. T1": self.t1_background,
"7. SEEG": self.sensorsSEEG,
"8. EEG": self.sensorsEEG,
"9. MEG": self.sensorsMEG
}
return formal_repr(self, sort_dict(d))
def __repr__(self):
form_repr = super(ODEStatisticalModel, self).__repr__()
d = {
"6. active regions": self.active_regions,
"7. initial condition std": self.sig_init,
"8. number of active regions": self.n_active_regions,
"9. number of nonactive regions": self.n_nonactive_regions,
"10. number of observation signals": self.n_signals,
"11. number of time points": self.n_times,
"12. time step": self.dt,
"13. observation_expression": self.observation_expression,
"14. observation_model": self.observation_model
}
# "13. euler_method": self.euler_method,
return form_repr + "\n" + formal_repr(self, sort_dict(d))
def _repr(self):
d = {
"01. type": self.type,
"02. pdf_params": self.pdf_params(),
"03. n_params": self.n_params,
"04. constraint": self.constraint_string,
"05. shape": self.__p_shape,
"05. mean": self.__mean,
"06. median": self.__median,
"07. mode": self.__mode,
"08. var": self.__var,
"09. std": self.__std,
"10. skew": self.__skew,
"11. kurt": self.__kurt,
"12. scipy_name": self.scipy_name,
"13. numpy_name": self.numpy_name
}
return formal_repr(self, sort_dict(d))
def compute_estimates_from_samples(self, samples):
ests = []
for chain_or_run_samples in ensure_list(samples):
est = {}
for pkey, pval in chain_or_run_samples.items():
try:
est[pkey + "_low"], est[pkey], est[pkey + "_std"] = describe(chain_or_run_samples[pkey])[1:4]
est[pkey + "_high"] = est[pkey + "_low"][1]
est[pkey + "_low"] = est[pkey + "_low"][0]
est[pkey + "_std"] = np.sqrt(est[pkey + "_std"])
for skey in [pkey, pkey + "_low", pkey + "_high", pkey + "_std"]:
est[skey] = np.squeeze(est[skey])
except:
est[pkey] = chain_or_run_samples[pkey]
ests.append(sort_dict(est))
if len(ests) == 1:
return ests[0]
else:
return ests
def convert_from_h5_model(self, obj=None, output_shape=None):
output_type = obj.__class__.__name__
if isinstance(obj, dict):
obj = sort_dict(obj)
elif np.in1d(output_type, ["tuple", "list"]):
obj = iterable_to_dict(obj)
elif isequal_string(output_type, "numpy.ndarray"):
if isequal_string(obj.dtype, "numpy.ndarray"):
obj = iterable_to_dict(obj.tolist())
else:
obj, output_type = create_object("/", self.metadata_dict)[:2]
if obj is None:
obj = OrderedDict()
if output_type is None:
output_type = obj.__class__.__name__
for abs_path in self.datasets_dict.keys():
child_obj = self.datasets_dict.pop(abs_path)
rel_path = abs_path.split("/", 1)[1]
build_hierarchical_object_recursively(obj, rel_path, child_obj,
"/", abs_path,
self.metadata_dict)
if np.in1d(output_type, ["tuple", "list"]):
obj = dict_to_list_or_tuple(obj, output_type)
elif isequal_string(output_type, "numpy.ndarray"):
obj = np.array(dict.values())
if isinstance(output_shape, tuple):
try:
obj = np.reshape(obj, output_shape)
except:
logger.warning(
"Failed to reshape read object to target shape " +
str(output_shape) + "!" +
"\nReturning array of shape " + str(obj.shape) + "!")
else:
obj = update_object(obj, "/", self.metadata_dict,
getORpop="pop")[0]
if isinstance(obj, dict) and output_type.lower().find("dict") < 0:
return OrderedDictDot(obj)
else:
return obj
def set_simulated_target_data(self, target_data, statistical_model, **kwargs):
self.signals_inds = range(self.number_of_regions)
self.data_type = "lfp"
signals = np.array([])
if statistical_model.observation_model.find("seeg") >= 0:
self.data_type = "seeg"
self.signals_inds = range(self.gain_matrix.shape[0])
if not(isequal_string(statistical_model.observation_model, "seeg_logpower")):
signals = extract_dict_stringkeys(sort_dict(target_data), kwargs.get("seeg_dataset", "SEEG0"),
modefun="find", two_way_search=True, break_after=1)
if len(signals) > 0:
signals = signals.values()[0]
if signals.size == 0:
signals = np.array(target_data.get("lfp", target_data["x1"]))
if isequal_string(statistical_model.observation_model, "seeg_logpower"):
signals = np.log(np.dot(self.gain_matrix[self.signals_inds], np.exp(signals.T))).T
else:
signals = (np.dot(self.gain_matrix[self.signals_inds], signals.T)).T
else:
# if statistical_model.observation_expression == "x1z_offset":
# signals = ((target_data["x1"].T - np.expand_dims(self.x1EQ, 1)).T +
# (target_data["z"].T - np.expand_dims(self.zEQ, 1)).T) / 2.75
# # TODO: a better normalization
# elif statistical_model.observation_expression == "x1_offset":
# # TODO: a better normalization
# signals = (target_data["x1"].T - np.expand_dims(self.x1EQ, 1)).T / 2.0
# else: # statistical_models.observation_expression == "lfp"
signals = np.array(target_data.get("lfp", target_data["x1"]))
target_data["signals"] = np.array(signals)
manual_selection = kwargs.get("manual_selection", [])
if len(manual_selection) > 0:
self.signals_inds = manual_selection
if len(self.signals_inds) < signals.shape[1]:
signals = signals[:, self.signals_inds]
self.observation_shape = signals.shape
(self.n_times, self.n_signals) = self.observation_shape
return signals, target_data
def build_stan_model_dict(statistical_model,
signals,
model_inversion,
gain_matrix=None):
"""
Builds a dictionary with data needed for stan models.
:param statistical_model: StatisticalModel object
:param signals:
:param model_inversion: ModelInversionService object
:param gain_matrix: array
:return: dictionary with stan data
"""
active_regions_flag = np.zeros((statistical_model.number_of_regions, ),
dtype="i")
active_regions_flag[statistical_model.active_regions] = 1
if gain_matrix is None:
if statistical_model.observation_model.find("seeg") >= 0:
gain_matrix = model_inversion.gain_matrix
mixing = deepcopy(gain_matrix)
else:
mixing = np.eye(statistical_model.number_of_regions)
if mixing.shape[0] > len(model_inversion.signals_inds):
mixing = mixing[model_inversion.signals_inds]
SC = model_inversion.get_SC()
model_data = {
"number_of_regions":
statistical_model.number_of_regions,
"n_times":
statistical_model.n_times,
"n_signals":
statistical_model.n_signals,
"n_active_regions":
statistical_model.n_active_regions,
"n_nonactive_regions":
statistical_model.n_nonactive_regions,
"n_connections":
statistical_model.number_of_regions *
(statistical_model.number_of_regions - 1) / 2,
"active_regions_flag":
np.array(active_regions_flag),
"active_regions":
np.array(statistical_model.active_regions) +
1, # cmdstan cannot take lists!
"nonactive_regions":
np.where(1 - active_regions_flag)[0] + 1, # indexing starts from 1!
"x1eq_min":
statistical_model.x1eq_min,
"x1eq_max":
statistical_model.x1eq_max,
"SC":
SC[np.triu_indices(SC.shape[0], 1)],
"dt":
statistical_model.dt,
# "euler_method": np.where(np.in1d(EULER_METHODS, statistical_model.euler_method))[0][0] - 1,
"observation_model":
np.where(
np.in1d(OBSERVATION_MODELS,
statistical_model.observation_model))[0][0],
# "observation_expression": np.where(np.in1d(OBSERVATION_MODEL_EXPRESSIONS,
# statistical_model.observation_expression))[0][0],
"signals":
signals,
"time":
model_inversion.time,
"mixing":
mixing
}
for key, val in model_inversion.epileptor_parameters.iteritems():
model_data.update({key: val})
for p in statistical_model.parameters.values():
model_data.update({p.name + "_lo": p.low, p.name + "_hi": p.high})
if not (isequal_string(p.type, "normal")):
model_data.update({
p.name + "_loc":
p.loc,
p.name + "_scale":
p.scale,
p.name + "_pdf":
np.where(
np.in1d(
ProbabilityDistributionTypes.available_distributions,
p.type))[0][0],
p.name + "_p": (np.array(p.pdf_params().values()).T * np.ones(
(2, ))).squeeze()
})
model_data["x1eq_star_loc"] = statistical_model.parameters[
"x1eq_star"].mean
model_data["x1eq_star_scale"] = statistical_model.parameters[
"x1eq_star"].std
model_data["MC_scale"] = statistical_model.MC_scale
MCsplit_shape = np.ones(statistical_model.parameters["MCsplit"].p_shape)
model_data["MCsplit_loc"] = statistical_model.parameters[
"MCsplit"].mean * MCsplit_shape
model_data["MCsplit_scale"] = statistical_model.parameters[
"MCsplit"].std * MCsplit_shape
model_data["offset_signal_p"] = np.array(
statistical_model.parameters["offset_signal"].pdf_params().values())
return sort_dict(model_data)
def convert_to_h5_model(obj):
h5_model = H5Model(OrderedDict(), OrderedDict())
object_to_h5_model_recursively(h5_model, obj)
h5_model.datasets_dict = sort_dict(h5_model.datasets_dict)
h5_model.metadata_dict = sort_dict(h5_model.metadata_dict)
return h5_model
import os
from collections import OrderedDict
import numpy as np
from tvb_epilepsy.base.utils.data_structures_utils import sort_dict, isequal_string
STAN_STATIC_OPTIONS = sort_dict({"int_time": 2 * np.pi}) # int_time > 0
STAN_NUTS_OPTIONS = sort_dict({"max_depth": 10}) # int > 0
STAN_HMC_OPTIONS = sort_dict({
"metric": "diag_e", # others: "unit_e", "dense_e"
"stepsize": 1, # stepsize > 0
"stepsize_jitter": 0
}) # 0 <= stepsize_jitter <= 1
STAN_HMC_OPTIONS.update({"engine": "nuts"}) # "static"and
STAN_SAMPLE_ADAPT_OPTIONS = sort_dict({
"engaged": 1, # 0, 1
"gamma": 0.05, # gamma > 0
"delta": 0.8, # 1 > delta > 0
"kappa": 0.75, # kappa > 0
"t0": 10, # t0 > 0
"init_buffer": 75, # int > 0
"term_buffer": 50, # int > 0
"window": 25
}) # int > 0
STAN_SAMPLE_OPTIONS = sort_dict({
"num_samples": 1000, # num_samples >= 0
"num_warmup": 1000, # warmup >= 0
"save_warmup": 0, # 0, 1
def plot_fit_timeseries(self,
target_data,
samples,
ests,
stats=None,
probabilistic_model=None,
seizure_indices=[],
skip_samples=0,
trajectories_plot=False,
title_prefix=""):
if len(title_prefix) > 0:
title_prefix = title_prefix + ": "
samples = ensure_list(samples)
region_labels = samples[0]["x1"].space_labels
if probabilistic_model is not None:
sig_prior_str = " sig_prior = " + str(
probabilistic_model.get_prior("sigma")[0])
else:
sig_prior_str = ""
stats_region_labels = region_labels
if stats is not None:
stats_string = {
"fit_target_data": "\n",
"x1": "\n",
"z": "\n",
"MC": ""
}
if isinstance(stats, dict):
for skey, sval in stats.items():
for p_str in ["fit_target_data", "x1", "z"]:
stats_string[p_str] \
= stats_string[p_str] + skey + "_mean=" + str(numpy.mean(sval[p_str])) + ", "
stats_region_labels = [
stats_region_labels[ip] + ", " + skey + "_" + "x1" +
"_mean=" + str(sval["x1"][:, ip].mean()) + ", " +
skey + "_z_mean=" + str(sval["z"][:, ip].mean())
for ip in range(len(region_labels))
]
for p_str in ["fit_target_data", "x1", "z"]:
stats_string[p_str] = stats_string[p_str][:-2]
else:
stats_string = dict(zip(["fit_target_data", "x1", "z"], 3 * [""]))
observation_dict = OrderedDict(
{'observation time series': target_data.squeezed})
time = target_data.time_line
figs = []
for id_est, (est, sample) in enumerate(zip(ensure_list(ests),
samples)):
name = title_prefix + "_chain" + str(id_est + 1)
observation_dict.update({
"fit chain " + str(id_est + 1):
sample["fit_target_data"].data[:, :, :,
skip_samples:].squeeze()
})
figs.append(
self.plot_raster(
sort_dict({
"x1":
sample["x1"].data[:, :, :, skip_samples:].squeeze(),
'z':
sample["z"].data[:, :, :, skip_samples:].squeeze()
}),
time,
special_idx=seizure_indices,
time_units=target_data.time_unit,
title=name + ": Hidden states fit rasterplot",
subtitles=[
'hidden state ' + "x1" + stats_string["x1"],
'hidden state z' + stats_string["z"]
],
offset=1.0,
labels=region_labels,
figsize=FiguresConfig.VERY_LARGE_SIZE))
dWt = {}
subtitles = []
if sample.get("dX1t", None):
dWt.update({
"dX1t":
sample["dX1t"].data[:, :, :, skip_samples:].squeeze()
})
subtitles.append("dX1t")
if sample.get("dZt", None):
dWt.update({
"dZt":
sample["dZt"].data[:, :, :, skip_samples:].squeeze()
})
subtitles.append("dZt")
if len(dWt) > 0:
subtitles[
-1] += "\ndynamic noise" + sig_prior_str + ", sig_post = " + str(
est["sigma"])
figs.append(
self.plot_raster(sort_dict(dWt),
time[:-1],
time_units=target_data.time_unit,
special_idx=seizure_indices,
title=name +
": Hidden states random walk rasterplot",
subtitles=subtitles,
offset=1.0,
labels=region_labels,
figsize=FiguresConfig.VERY_LARGE_SIZE))
if trajectories_plot:
title = name + ' Fit hidden state space trajectories'
figs.append(
self.plot_trajectories(
{
"x1":
sample["x1"].data[:, :, :,
skip_samples:].squeeze(),
'z':
sample['z'].data[:, :, :, skip_samples:].squeeze()
},
special_idx=seizure_indices,
title=title,
labels=stats_region_labels,
figsize=FiguresConfig.SUPER_LARGE_SIZE))
figs.append(
self.plot_raster(observation_dict,
time,
special_idx=[],
time_units=target_data.time_unit,
title=title_prefix +
"Observation target vs fit time series: " +
stats_string["fit_target_data"],
figure_name=title_prefix +
"ObservationTarget_VS_FitTimeSeries",
offset=1.0,
labels=target_data.space_labels,
figsize=FiguresConfig.VERY_LARGE_SIZE))
return tuple(figs)
