def test_h5_conversion(self):
nr_of_regions = 76
x0_indices = [20]
x0_values = [0.9]
lsa_hypothesis = DiseaseHypothesis(
nr_of_regions,
excitability_hypothesis={tuple(x0_indices): x0_values},
epileptogenicity_hypothesis={},
connectivity_hypothesis={},
propagation_indices=[0],
propagation_strenghts=[18])
hypothesis_template = DiseaseHypothesis(nr_of_regions)
folder = get_temporary_files_path()
file_name = "hypo.h5"
lsa_hypothesis.write_to_h5(folder, file_name)
lsa_hypothesis1 = read_h5_model(os.path.join(
folder,
file_name)).convert_from_h5_model(obj=deepcopy(lsa_hypothesis))
assert_equal_objects(lsa_hypothesis, lsa_hypothesis1)
lsa_hypothesis2 = read_h5_model(os.path.join(
folder, file_name)).convert_from_h5_model(
children_dict=hypothesis_template)
assert_equal_objects(lsa_hypothesis, lsa_hypothesis2)
def read_hypothesis(self, path, simplify=True):
"""
:param path: Path towards a Hypothesis H5 file
:return: DiseaseHypothesis object
"""
self.logger.info("Starting to read Hypothesis from: %s" % path)
h5_file = h5py.File(path, 'r', libver='latest')
if h5_file.attrs["EPI_Subtype"] != "DiseaseHypothesis":
self.logger.warning(
"This file does not seem to holds a DiseaseHypothesis!")
hypothesis = DiseaseHypothesis()
for dataset in h5_file.keys():
hypothesis.set_attribute(dataset, h5_file["/" + dataset][()])
for attr in h5_file.attrs.keys():
if attr in ["x0_indices", "e_indices", "w_indices"]:
hypothesis.set_attribute(attr, h5_file.attrs[attr].tolist())
else:
hypothesis.set_attribute(attr, h5_file.attrs[attr])
h5_file.close()
if simplify:
hypothesis.simplify_hypothesis_from_h5()
return hypothesis
def run_lsa(self, disease_hypothesis, model_configuration):
jacobian = self._compute_jacobian(model_configuration)
# Perform eigenvalue decomposition
eigen_values, eigen_vectors = numpy.linalg.eig(jacobian)
sorted_indices = numpy.argsort(eigen_values, kind='mergesort')
self.eigen_values = eigen_values[sorted_indices]
self.eigen_vectors = eigen_vectors[:, sorted_indices]
self._ensure_eigen_vectors_number(
self.eigen_values, model_configuration.e_values,
model_configuration.x0_values,
disease_hypothesis.get_all_disease_indices())
if self.eigen_vectors_number == disease_hypothesis.number_of_regions:
# Calculate the propagation strength index by summing all eigenvectors
lsa_propagation_strength = numpy.abs(
numpy.sum(self.eigen_vectors, axis=1))
else:
sorted_indices = max(self.eigen_vectors_number, 1)
# Calculate the propagation strength index by summing the first n eigenvectors (minimum 1)
if self.weighted_eigenvector_sum:
lsa_propagation_strength = numpy.abs(
weighted_vector_sum(self.eigen_values[:sorted_indices],
self.eigen_vectors[:, :sorted_indices],
normalize=True))
else:
lsa_propagation_strength = numpy.abs(
numpy.sum(self.eigen_vectors[:, :sorted_indices], axis=1))
if self.normalize_propagation_strength:
# Normalize by the maximum
lsa_propagation_strength /= numpy.max(lsa_propagation_strength)
# # TODO: this has to be corrected
# if self.eigen_vectors_number < 0.2 * disease_hypothesis.number_of_regions:
# propagation_strength_elbow = numpy.max([self.get_curve_elbow_point(lsa_propagation_strength),
# self.eigen_vectors_number])
# else:
propagation_strength_elbow = self.get_curve_elbow_point(
lsa_propagation_strength)
propagation_indices = lsa_propagation_strength.argsort(
)[-propagation_strength_elbow:]
return DiseaseHypothesis(
disease_hypothesis.number_of_regions, {
tuple(disease_hypothesis.x0_indices):
disease_hypothesis.x0_values
},
{tuple(disease_hypothesis.e_indices): disease_hypothesis.e_values},
{tuple(disease_hypothesis.w_indices): disease_hypothesis.w_values},
propagation_indices, lsa_propagation_strength,
"LSA_" + disease_hypothesis.name)
def test_create(self):
x0_indices = [20]
x0_values = [0.9]
hyp = DiseaseHypothesis(
76,
excitability_hypothesis={tuple(x0_indices): x0_values},
epileptogenicity_hypothesis={},
connectivity_hypothesis={})
assert x0_indices == hyp.x0_indices
assert x0_values == hyp.x0_values
def build_hypothesis(self):
self._normalize_disease_values()
disease_indices, = numpy.where(self.diseased_regions_values != 0.0)
x0_indices = numpy.setdiff1d(disease_indices, self.e_indices)
return DiseaseHypothesis(self.number_of_regions,
excitability_hypothesis={tuple(x0_indices):
self.diseased_regions_values[x0_indices]},
epileptogenicity_hypothesis={tuple(self.e_indices):
self.diseased_regions_values[self.e_indices]},
connectivity_hypothesis={tuple(self.w_indices): self.w_values},
lsa_propagation_indices=self.lsa_propagation_indices,
lsa_propagation_strenghts=self.lsa_propagation_strengths, name=self.name)
def _prepare_model_for_simulation(self, connectivity):
hypothesis = DiseaseHypothesis(
connectivity.number_of_regions,
excitability_hypothesis={tuple([0, 10]): [1, 1]},
epileptogenicity_hypothesis={},
connectivity_hypothesis={})
model_configuration_service = ModelConfigurationService(
connectivity.number_of_regions)
model_configuration = model_configuration_service.configure_model_from_hypothesis(
hypothesis, connectivity.normalized_weights)
return model_configuration
def main_fit_sim_hyplsa(stats_model_name="vep_original",
EMPIRICAL='',
times_on_off=[],
channel_lbls=[],
channel_inds=[]):
# ------------------------------Model code--------------------------------------
# Compile or load model:
model_file = os.path.join(FOLDER_VEP_HOME,
stats_model_name + "_stan_model.pkl")
if os.path.isfile(model_file):
stats_model = pickle.load(open(model_file, 'rb'))
else:
# vep_original_DP
if stats_model_name is "vep_dWt":
model_path = os.path.join(STATISTICAL_MODELS_PATH, "vep_dWt.stan")
elif stats_model_name is "vep_original_x0":
model_path = os.path.join(STATISTICAL_MODELS_PATH,
"vep_original_x0.stan")
else:
model_path = os.path.join(STATISTICAL_MODELS_PATH,
"vep_original_DP.stan")
stats_model = compile_model(model_stan_code_path=model_path)
with open(model_file, 'wb') as f:
pickle.dump(stats_model, f)
# -------------------------------Reading data-----------------------------------
data_folder = os.path.join(DATA_CUSTOM, 'Head')
reader = Reader()
logger.info("Reading from: " + data_folder)
head = reader.read_head(data_folder,
seeg_sensors_files=[("SensorsInternal.h5", "")])
# head.plot()
if len(channel_inds) > 1:
channel_inds, _ = get_bipolar_channels(channel_inds, channel_lbls)
# --------------------------Hypothesis definition-----------------------------------
n_samples = 100
# # Manual definition of hypothesis...:
# x0_indices = [20]
# x0_values = [0.9]
# e_indices = [70]
# e_values = [0.9]
# disease_values = x0_values + e_values
# disease_indices = x0_indices + e_indices
# ...or reading a custom file:
ep_name = "ep_l_frontal_complex"
# FOLDER_RES = os.path.join(data_folder, ep_name)
from tvb_epilepsy.custom.readers_custom import CustomReader
if not isinstance(reader, CustomReader):
reader = CustomReader()
disease_values = reader.read_epileptogenicity(data_folder, name=ep_name)
disease_indices, = np.where(disease_values > np.min([X0_DEF, E_DEF]))
disease_values = disease_values[disease_indices]
inds = np.argsort(disease_values)
disease_values = disease_values[inds]
disease_indices = disease_indices[inds]
x0_indices = [disease_indices[-1]]
x0_values = [disease_values[-1]]
e_indices = disease_indices[0:-1].tolist()
e_values = disease_values[0:-1].tolist()
disease_indices = list(disease_indices)
n_x0 = len(x0_indices)
n_e = len(e_indices)
n_disease = len(disease_indices)
all_regions_indices = np.array(range(head.number_of_regions))
healthy_indices = np.delete(all_regions_indices, disease_indices).tolist()
n_healthy = len(healthy_indices)
# This is an example of Excitability Hypothesis:
hyp_x0 = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(disease_indices): disease_values},
epileptogenicity_hypothesis={},
connectivity_hypothesis={})
# This is an example of Mixed Hypothesis:
hyp_x0_E = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(x0_indices): x0_values},
epileptogenicity_hypothesis={tuple(e_indices): e_values},
connectivity_hypothesis={})
hyp_E = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={},
epileptogenicity_hypothesis={tuple(disease_indices): disease_values},
connectivity_hypothesis={})
hypos = (hyp_x0_E, hyp_x0, hyp_E)
# --------------------------Simulation preparations-----------------------------------
tau1 = 0.5
# TODO: maybe use a custom Monitor class
fs = 10 * 2048.0 * (
2 * tau1
) # this is the simulation sampling rate that is necessary for the simulation to be stable
time_length = 50.0 / tau1 # msecs, the final output nominal time length of the simulation
report_every_n_monitor_steps = 100.0
(dt, fsAVG, sim_length, monitor_period, n_report_blocks) = \
set_time_scales(fs=fs, time_length=time_length, scale_fsavg=1,
report_every_n_monitor_steps=report_every_n_monitor_steps)
# Choose model
# Available models beyond the TVB Epileptor (they all encompass optional variations from the different papers):
# EpileptorDP: similar to the TVB Epileptor + optional variations,
# EpileptorDP2D: reduced 2D model, following Proix et all 2014 +optional variations,
# EpleptorDPrealistic: starting from the TVB Epileptor + optional variations, but:
# -x0, Iext1, Iext2, slope and K become noisy state variables,
# -Iext2 and slope are coupled to z, g, or z*g in order for spikes to appear before seizure,
# -multiplicative correlated noise is also used
# Optional variations:
zmode = "lin" # by default, or "sig" for the sigmoidal expression for the slow z variable in Proix et al. 2014
pmode = "z" # by default, "g" or "z*g" for the feedback coupling to Iext2 and slope for EpileptorDPrealistic
model_name = "EpileptorDP2D"
if model_name is "EpileptorDP2D":
spectral_raster_plot = False
trajectories_plot = True
else:
spectral_raster_plot = False # "lfp"
trajectories_plot = False
# We don't want any time delays for the moment
# head.connectivity.tract_lengths *= TIME_DELAYS_FLAG
# --------------------------Hypothesis and LSA-----------------------------------
for hyp in hypos: #hypotheses:
logger.info("\n\nRunning hypothesis: " + hyp.name)
# hyp.write_to_h5(FOLDER_RES, hyp.name + ".h5")
logger.info("\n\nCreating model configuration...")
model_configuration_service = ModelConfigurationService(
hyp.number_of_regions, K=10.0)
# model_configuration_service.write_to_h5(FOLDER_RES, hyp.name + "_model_config_service.h5")
if hyp.type == "Epileptogenicity":
model_configuration = model_configuration_service. \
configure_model_from_E_hypothesis(hyp, head.connectivity.normalized_weights)
else:
model_configuration = model_configuration_service. \
configure_model_from_hypothesis(hyp, head.connectivity.normalized_weights)
model_configuration.write_to_h5(FOLDER_RES,
hyp.name + "_ModelConfig.h5")
# Plot nullclines and equilibria of model configuration
model_configuration_service.plot_nullclines_eq(
model_configuration,
head.connectivity.region_labels,
special_idx=disease_indices,
model="6d",
zmode="lin",
figure_name=hyp.name + "_Nullclines and equilibria")
logger.info("\n\nRunning LSA...")
lsa_service = LSAService(eigen_vectors_number=None,
weighted_eigenvector_sum=True)
lsa_hypothesis = lsa_service.run_lsa(hyp, model_configuration)
lsa_hypothesis.write_to_h5(FOLDER_RES, lsa_hypothesis.name + "_LSA.h5")
lsa_service.write_to_h5(FOLDER_RES,
lsa_hypothesis.name + "_LSAConfig.h5")
lsa_service.plot_lsa(lsa_hypothesis, model_configuration,
head.connectivity.region_labels, None)
# ------------------------------Simulation--------------------------------------
logger.info("\n\nConfiguring simulation...")
noise_intensity = 10**-2.8
sim = setup_simulation_from_model_configuration(
model_configuration,
head.connectivity,
dt,
sim_length,
monitor_period,
model_name,
zmode=np.array(zmode),
pmode=np.array(pmode),
noise_instance=None,
noise_intensity=noise_intensity,
monitor_expressions=None)
sim.model.tau1 = tau1
sim.model.tau0 = 30.0
# Integrator and initial conditions initialization.
# By default initial condition is set right on the equilibrium point.
sim.config_simulation(initial_conditions=None)
# convert_to_h5_model(sim.model).write_to_h5(FOLDER_RES, lsa_hypothesis.name + "_sim_model.h5")
if os.path.isfile(EMPIRICAL):
observation, time, fs = prepare_seeg_observable(EMPIRICAL,
times_on_off,
channel_lbls,
log_flag=True)
vois_ts_dict = {"time": time, "signals": observation}
#
# prepare_seeg_observable(os.path.join(SEEG_data, 'SZ2_0001.edf'), [15.0, 40.0], channel_lbls)
# prepare_seeg_observable(os.path.join(SEEG_data, 'SZ5_0001.edf'), [20.0, 45.0], channel_lbls)
else:
ts_file = os.path.join(FOLDER_VEP_HOME,
lsa_hypothesis.name + "_ts.mat")
if os.path.isfile(ts_file):
logger.info("\n\nLoading previously simulated time series...")
vois_ts_dict = loadmat(ts_file)
else:
logger.info("\n\nSimulating...")
ttavg, tavg_data, status = sim.launch_simulation(
n_report_blocks)
# convert_to_h5_model(sim.simulation_settings).write_to_h5(FOLDER_RES,
# lsa_hypothesis.name + "_sim_settings.h5")
if not status:
warning("\nSimulation failed!")
else:
time = np.array(ttavg, dtype='float32').flatten()
output_sampling_time = np.mean(np.diff(time))
tavg_data = tavg_data[:, :, :, 0]
logger.info("\n\nSimulated signal return shape: %s",
tavg_data.shape)
logger.info("Time: %s - %s", time[0], time[-1])
logger.info("Values: %s - %s", tavg_data.min(),
tavg_data.max())
# Variables of interest in a dictionary:
vois_ts_dict = prepare_vois_ts_dict(
VOIS[model_name], tavg_data)
vois_ts_dict['time'] = time
vois_ts_dict['time_units'] = 'msec'
vois_ts_dict = compute_seeg_and_write_ts_h5_file(
FOLDER_RES,
lsa_hypothesis.name + "_ts.h5",
sim.model,
vois_ts_dict,
output_sampling_time,
time_length,
hpf_flag=True,
hpf_low=10.0,
hpf_high=512.0,
sensor_dicts_list=[head.sensorsSEEG])
# Plot results
plot_sim_results(sim.model,
lsa_hypothesis.propagation_indices,
lsa_hypothesis.name,
head,
vois_ts_dict,
head.sensorsSEEG.keys(),
hpf_flag=False,
trajectories_plot=trajectories_plot,
spectral_raster_plot=spectral_raster_plot,
log_scale=True)
# Optionally save results in mat files
savemat(
os.path.join(FOLDER_RES,
lsa_hypothesis.name + "_ts.mat"),
vois_ts_dict)
# Get data and observation signals:
data, active_regions = prepare_data_for_fitting_vep(
stats_model_name,
model_configuration,
lsa_hypothesis,
fsAVG,
vois_ts_dict,
sim.model,
noise_intensity,
active_regions=None,
active_regions_th=0.1,
euler_method=1,
observation_model=1,
channel_inds=channel_inds,
mixing=head.sensorsSEEG.values()[0])
savemat(
os.path.join(FOLDER_RES, lsa_hypothesis.name + "_fit_data.mat"),
data)
# Fit and get estimates:
est, fit = stanfit_model(stats_model,
data,
mode="optimizing",
iter=30000) #
savemat(os.path.join(FOLDER_RES, lsa_hypothesis.name + "_fit_est.mat"),
est)
plot_fit_results(lsa_hypothesis.name,
head,
est,
data,
active_regions,
time=vois_ts_dict['time'],
seizure_indices=[0, 1],
trajectories_plot=True)
# Reconfigure model after fitting:
fit_model_configuration_service = ModelConfigurationService(
hyp.number_of_regions, K=est['K'] * hyp.number_of_regions)
x0_values_fit = fit_model_configuration_service._compute_x0_values_from_x0_model(
est['x0'])
disease_indices = active_regions.tolist()
hyp_fit = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(disease_indices): x0_values_fit},
epileptogenicity_hypothesis={},
connectivity_hypothesis={},
name='fit_' + hyp_x0.name)
connectivity_matrix_fit = np.array(
model_configuration.connectivity_matrix)
connectivity_matrix_fit[active_regions][:, active_regions] = est["FC"]
model_configuration_fit = fit_model_configuration_service.configure_model_from_hypothesis(
hyp_fit, connectivity_matrix_fit)
model_configuration_fit.write_to_h5(FOLDER_RES,
hyp_fit.name + "_ModelConfig.h5")
# Plot nullclines and equilibria of model configuration
model_configuration_service.plot_nullclines_eq(
model_configuration_fit,
head.connectivity.region_labels,
special_idx=disease_indices,
model="6d",
zmode="lin",
figure_name=hyp_fit.name + "_Nullclines and equilibria")
print("Done!")
from tvb_epilepsy.base.model.model_vep import Connectivity
from tvb_epilepsy.base.model.disease_hypothesis import DiseaseHypothesis
if DATA_MODE is TVB:
from tvb_epilepsy.tvb_api.readers_tvb import TVBReader as Reader
else:
from tvb_epilepsy.custom.readers_custom import CustomReader as Reader
logger = initialize_logger(__name__)
if __name__ == "__main__":
# -------------------------------Reading data-----------------------------------
empty_connectivity = Connectivity("", np.array([]), np.array([]))
empty_hypothesis = DiseaseHypothesis(empty_connectivity)
data_folder = os.path.join(DATA_CUSTOM, 'Head')
reader = Reader()
logger.info("Reading from: " + data_folder)
head = reader.read_head(data_folder)
# # Manual definition of hypothesis...:
x0_indices = [20]
x0_values = [0.9]
e_indices = [70]
e_values = [0.9]
disease_values = x0_values + e_values
disease_indices = x0_indices + e_indices
def main_vep(test_write_read=False,
pse_flag=PSE_FLAG,
sa_pse_flag=SA_PSE_FLAG,
sim_flag=SIM_FLAG):
logger = initialize_logger(__name__)
# -------------------------------Reading data-----------------------------------
data_folder = os.path.join(DATA_CUSTOM, 'Head')
reader = Reader()
logger.info("Reading from: " + data_folder)
head = reader.read_head(data_folder)
head.plot()
# --------------------------Hypothesis definition-----------------------------------
n_samples = 100
# # Manual definition of hypothesis...:
# x0_indices = [20]
# x0_values = [0.9]
# e_indices = [70]
# e_values = [0.9]
# disease_values = x0_values + e_values
# disease_indices = x0_indices + e_indices
# ...or reading a custom file:
ep_name = "ep_test1"
#FOLDER_RES = os.path.join(data_folder, ep_name)
from tvb_epilepsy.custom.readers_custom import CustomReader
if not isinstance(reader, CustomReader):
reader = CustomReader()
disease_values = reader.read_epileptogenicity(data_folder, name=ep_name)
disease_indices, = np.where(disease_values > np.min([X0_DEF, E_DEF]))
disease_values = disease_values[disease_indices]
if disease_values.size > 1:
inds_split = np.ceil(disease_values.size * 1.0 / 2).astype("int")
x0_indices = disease_indices[:inds_split].tolist()
e_indices = disease_indices[inds_split:].tolist()
x0_values = disease_values[:inds_split].tolist()
e_values = disease_values[inds_split:].tolist()
else:
x0_indices = disease_indices.tolist()
x0_values = disease_values.tolist()
e_indices = []
e_values = []
disease_indices = list(disease_indices)
n_x0 = len(x0_indices)
n_e = len(e_indices)
n_disease = len(disease_indices)
all_regions_indices = np.array(range(head.number_of_regions))
healthy_indices = np.delete(all_regions_indices, disease_indices).tolist()
n_healthy = len(healthy_indices)
# This is an example of Excitability Hypothesis:
hyp_x0 = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(disease_indices): disease_values},
epileptogenicity_hypothesis={},
connectivity_hypothesis={})
# This is an example of Epileptogenicity Hypothesis:
hyp_E = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={},
epileptogenicity_hypothesis={tuple(disease_indices): disease_values},
connectivity_hypothesis={})
if len(e_indices) > 0:
# This is an example of x0_values mixed Excitability and Epileptogenicity Hypothesis:
hyp_x0_E = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(x0_indices): x0_values},
epileptogenicity_hypothesis={tuple(e_indices): e_values},
connectivity_hypothesis={})
hypotheses = (hyp_x0, hyp_E, hyp_x0_E)
else:
hypotheses = (hyp_x0, hyp_E)
# --------------------------Simulation preparations-----------------------------------
# TODO: maybe use a custom Monitor class
fs = 2048.0 # this is the simulation sampling rate that is necessary for the simulation to be stable
time_length = 10000.0 # =100 secs, the final output nominal time length of the simulation
report_every_n_monitor_steps = 100.0
(dt, fsAVG, sim_length, monitor_period, n_report_blocks) = \
set_time_scales(fs=fs, time_length=time_length, scale_fsavg=None,
report_every_n_monitor_steps=report_every_n_monitor_steps)
# Choose model
# Available models beyond the TVB Epileptor (they all encompass optional variations from the different papers):
# EpileptorDP: similar to the TVB Epileptor + optional variations,
# EpileptorDP2D: reduced 2D model, following Proix et all 2014 +optional variations,
# EpleptorDPrealistic: starting from the TVB Epileptor + optional variations, but:
# -x0, Iext1, Iext2, slope and K become noisy state variables,
# -Iext2 and slope are coupled to z, g, or z*g in order for spikes to appear before seizure,
# -multiplicative correlated noise is also used
# Optional variations:
zmode = "lin" # by default, or "sig" for the sigmoidal expression for the slow z variable in Proix et al. 2014
pmode = "z" # by default, "g" or "z*g" for the feedback coupling to Iext2 and slope for EpileptorDPrealistic
model_name = "EpileptorDPrealistic"
if model_name is "EpileptorDP2D":
spectral_raster_plot = False
trajectories_plot = True
else:
spectral_raster_plot = "lfp"
trajectories_plot = False
# We don't want any time delays for the moment
# head.connectivity.tract_lengths *= TIME_DELAYS_FLAG
# --------------------------Hypothesis and LSA-----------------------------------
for hyp in hypotheses:
logger.info("\n\nRunning hypothesis: " + hyp.name)
# hyp.write_to_h5(FOLDER_RES, hyp.name + ".h5")
logger.info("\n\nCreating model configuration...")
model_configuration_service = ModelConfigurationService(
hyp.number_of_regions)
model_configuration_service.write_to_h5(
FOLDER_RES, hyp.name + "_model_config_service.h5")
if test_write_read:
logger.info(
"Written and read model configuration services are identical?: "
+ str(
assert_equal_objects(
model_configuration_service,
read_h5_model(
os.path.join(FOLDER_RES, hyp.name +
"_model_config_service.h5")
).convert_from_h5_model(
obj=deepcopy(model_configuration_service)),
logger=logger)))
if hyp.type == "Epileptogenicity":
model_configuration = model_configuration_service.\
configure_model_from_E_hypothesis(hyp, head.connectivity.normalized_weights)
else:
model_configuration = model_configuration_service.\
configure_model_from_hypothesis(hyp, head.connectivity.normalized_weights)
model_configuration.write_to_h5(FOLDER_RES,
hyp.name + "_ModelConfig.h5")
if test_write_read:
logger.info(
"Written and read model configuration are identical?: " + str(
assert_equal_objects(
model_configuration,
read_h5_model(
os.path.join(
FOLDER_RES, hyp.name +
"_ModelConfig.h5")).convert_from_h5_model(
obj=deepcopy(model_configuration)),
logger=logger)))
# Plot nullclines and equilibria of model configuration
model_configuration_service.plot_nullclines_eq(
model_configuration,
head.connectivity.region_labels,
special_idx=disease_indices,
model="6d",
zmode="lin",
figure_name=hyp.name + "_Nullclines and equilibria")
logger.info("\n\nRunning LSA...")
lsa_service = LSAService(eigen_vectors_number=None,
weighted_eigenvector_sum=True)
lsa_hypothesis = lsa_service.run_lsa(hyp, model_configuration)
lsa_hypothesis.write_to_h5(FOLDER_RES, lsa_hypothesis.name + "_LSA.h5")
lsa_service.write_to_h5(FOLDER_RES,
lsa_hypothesis.name + "_LSAConfig.h5")
if test_write_read:
hypothesis_template = DiseaseHypothesis(hyp.number_of_regions)
logger.info("Written and read LSA services are identical?: " + str(
assert_equal_objects(
lsa_service,
read_h5_model(
os.path.join(FOLDER_RES, lsa_hypothesis.name +
"_LSAConfig.h5")).convert_from_h5_model(
obj=deepcopy(lsa_service)),
logger=logger)))
logger.info(
"Written and read LSA hypotheses are identical (input object check)?: "
+ str(
assert_equal_objects(
lsa_hypothesis,
read_h5_model(
os.path.join(FOLDER_RES, lsa_hypothesis.name +
"_LSA.h5")).convert_from_h5_model(
obj=deepcopy(lsa_hypothesis),
hypothesis=True),
logger=logger)))
logger.info(
"Written and read LSA hypotheses are identical (input template check)?: "
+ str(
assert_equal_objects(
lsa_hypothesis,
read_h5_model(
os.path.join(FOLDER_RES, lsa_hypothesis.name +
"_LSA.h5")).convert_from_h5_model(
obj=hypothesis_template,
hypothesis=True),
logger=logger)))
lsa_service.plot_lsa(lsa_hypothesis, model_configuration,
head.connectivity.region_labels, None)
if pse_flag:
#--------------Parameter Search Exploration (PSE)-------------------------------
logger.info("\n\nRunning PSE LSA...")
pse_results = pse_from_lsa_hypothesis(
lsa_hypothesis,
head.connectivity.normalized_weights,
head.connectivity.region_labels,
n_samples,
half_range=0.1,
global_coupling=[{
"indices": all_regions_indices
}],
healthy_regions_parameters=[{
"name": "x0_values",
"indices": healthy_indices
}],
model_configuration_service=model_configuration_service,
lsa_service=lsa_service,
logger=logger)[0]
lsa_service.plot_lsa(lsa_hypothesis, model_configuration,
head.connectivity.region_labels, pse_results)
# , show_flag=True, save_flag=False
convert_to_h5_model(pse_results).write_to_h5(
FOLDER_RES, lsa_hypothesis.name + "_PSE_LSA_results.h5")
if test_write_read:
logger.info(
"Written and read sensitivity analysis parameter search results are identical?: "
+ str(
assert_equal_objects(
pse_results,
read_h5_model(
os.path.join(
FOLDER_RES, lsa_hypothesis.name +
"_PSE_LSA_results.h5")
).convert_from_h5_model(),
logger=logger)))
if sa_pse_flag:
# --------------Sensitivity Analysis Parameter Search Exploration (PSE)-------------------------------
logger.info("\n\nrunning sensitivity analysis PSE LSA...")
sa_results, pse_sa_results = \
sensitivity_analysis_pse_from_lsa_hypothesis(lsa_hypothesis,
head.connectivity.normalized_weights,
head.connectivity.region_labels,
n_samples, method="sobol", half_range=0.1,
global_coupling=[{"indices": all_regions_indices,
"bounds":[0.0, 2 * model_configuration_service.K_unscaled[ 0]]}],
healthy_regions_parameters=[{"name": "x0_values", "indices": healthy_indices}],
model_configuration_service=model_configuration_service,
lsa_service=lsa_service, logger=logger)
lsa_service.plot_lsa(lsa_hypothesis,
model_configuration,
head.connectivity.region_labels,
pse_sa_results,
title="SA PSE Hypothesis Overview")
# , show_flag=True, save_flag=False
convert_to_h5_model(pse_sa_results).write_to_h5(
FOLDER_RES, lsa_hypothesis.name + "_SA_PSE_LSA_results.h5")
convert_to_h5_model(sa_results).write_to_h5(
FOLDER_RES, lsa_hypothesis.name + "_SA_LSA_results.h5")
if test_write_read:
logger.info(
"Written and read sensitivity analysis results are identical?: "
+ str(
assert_equal_objects(
sa_results,
read_h5_model(
os.path.join(
FOLDER_RES, lsa_hypothesis.name +
"_SA_LSA_results.h5")
).convert_from_h5_model(),
logger=logger)))
logger.info(
"Written and read sensitivity analysis parameter search results are identical?: "
+ str(
assert_equal_objects(
pse_sa_results,
read_h5_model(
os.path.join(
FOLDER_RES, lsa_hypothesis.name +
"_SA_PSE_LSA_results.h5")
).convert_from_h5_model(),
logger=logger)))
if sim_flag:
# ------------------------------Simulation--------------------------------------
logger.info("\n\nConfiguring simulation...")
sim = setup_simulation_from_model_configuration(
model_configuration,
head.connectivity,
dt,
sim_length,
monitor_period,
model_name,
zmode=np.array(zmode),
pmode=np.array(pmode),
noise_instance=None,
noise_intensity=None,
monitor_expressions=None)
# Integrator and initial conditions initialization.
# By default initial condition is set right on the equilibrium point.
sim.config_simulation(initial_conditions=None)
convert_to_h5_model(sim.model).write_to_h5(
FOLDER_RES, lsa_hypothesis.name + "_sim_model.h5")
logger.info("\n\nSimulating...")
ttavg, tavg_data, status = sim.launch_simulation(n_report_blocks)
convert_to_h5_model(sim.simulation_settings).write_to_h5(
FOLDER_RES, lsa_hypothesis.name + "_sim_settings.h5")
if test_write_read:
logger.info(
"Written and read simulation settings are identical?: " +
str(
assert_equal_objects(
sim.simulation_settings,
read_h5_model(
os.path.join(
FOLDER_RES, lsa_hypothesis.name +
"_sim_settings.h5")).convert_from_h5_model(
obj=deepcopy(sim.simulation_settings)),
logger=logger)))
if not status:
warning("\nSimulation failed!")
else:
time = np.array(ttavg, dtype='float32')
output_sampling_time = np.mean(np.diff(time))
tavg_data = tavg_data[:, :, :, 0]
logger.info("\n\nSimulated signal return shape: %s",
tavg_data.shape)
logger.info("Time: %s - %s", time[0], time[-1])
logger.info("Values: %s - %s", tavg_data.min(),
tavg_data.max())
# Variables of interest in a dictionary:
vois_ts_dict = prepare_vois_ts_dict(VOIS[model_name],
tavg_data)
vois_ts_dict['time'] = time
vois_ts_dict['time_units'] = 'msec'
vois_ts_dict = compute_seeg_and_write_ts_h5_file(
FOLDER_RES,
lsa_hypothesis.name + "_ts.h5",
sim.model,
vois_ts_dict,
output_sampling_time,
time_length,
hpf_flag=True,
hpf_low=10.0,
hpf_high=512.0,
sensor_dicts_list=[head.sensorsSEEG])
# Plot results
plot_sim_results(sim.model,
lsa_hypothesis.propagation_indices,
lsa_hypothesis.name,
head,
vois_ts_dict,
head.sensorsSEEG.keys(),
hpf_flag=True,
trajectories_plot=trajectories_plot,
spectral_raster_plot=spectral_raster_plot,
log_scale=True)
x0_indices = [20]
x0_values = [0.9]
e_indices = [70]
e_values = [0.9]
disease_indices = x0_indices + e_indices
n_disease = len(disease_indices)
n_x0 = len(x0_indices)
n_e = len(e_indices)
all_regions_indices = np.array(range(head.connectivity.number_of_regions))
healthy_indices = np.delete(all_regions_indices, disease_indices).tolist()
n_healthy = len(healthy_indices)
# This is an example of x0_values mixed Excitability and Epileptogenicity Hypothesis:
hyp_x0_E = DiseaseHypothesis(
head.connectivity.number_of_regions,
excitability_hypothesis={tuple(x0_indices): x0_values},
epileptogenicity_hypothesis={tuple(e_indices): e_values},
connectivity_hypothesis={})
# Now running the sensitivity analysis:
logger.info("running sensitivity analysis PSE LSA...")
for m in METHODS:
try:
model_configuration_service, model_configuration, lsa_service, lsa_hypothesis, sa_results, pse_results = \
sensitivity_analysis_pse_from_hypothesis(hyp_x0_E,
head.connectivity.normalized_weights,
head.connectivity.region_labels,
n_samples, method=m, half_range=0.1,
global_coupling=[{"indices": all_regions_indices,
"bounds": [0.0, 2 * K_DEF]}],
healthy_regions_parameters=[