def main_sensitivity_analysis(config=Config()):
# -------------------------------Reading data-----------------------------------
reader = Reader()
writer = H5Writer()
head = reader.read_head(config.input.HEAD)
# --------------------------Hypothesis definition-----------------------------------
n_samples = 100
# Manual definition of hypothesis...:
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 = HypothesisBuilder(
head.connectivity.number_of_regions).set_x0_hypothesis(
x0_indices,
x0_values).set_e_hypothesis(e_indices,
e_values).build_hypothesis()
# Now running the sensitivity analysis:
logger.info("running sensitivity analysis PSE LSA...")
for m in METHODS:
try:
model_configuration_builder, 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, param_range=0.1,
global_coupling=[{"indices": all_regions_indices,
"low": 0.0, "high": 2 * K_UNSCALED_DEF}],
healthy_regions_parameters=[
{"name": "x0_values", "indices": healthy_indices}],
config=config, save_services=True)
Plotter(config).plot_lsa(
lsa_hypothesis,
model_configuration,
lsa_service.weighted_eigenvector_sum,
lsa_service.eigen_vectors_number,
region_labels=head.connectivity.region_labels,
pse_results=pse_results,
title=m + "_PSE_LSA_overview_" + lsa_hypothesis.name,
lsa_service=lsa_service)
# , show_flag=True, save_flag=False
result_file = os.path.join(
config.out.FOLDER_RES,
m + "_PSE_LSA_results_" + lsa_hypothesis.name + ".h5")
writer.write_dictionary(pse_results, result_file)
result_file = os.path.join(
config.out.FOLDER_RES,
m + "_SA_LSA_results_" + lsa_hypothesis.name + ".h5")
writer.write_dictionary(sa_results, result_file)
except:
logger.warning("Method " + m + " failed!")
def main_pse(config=Config()):
# -------------------------------Reading data-----------------------------------
reader = Reader()
writer = H5Writer()
head = reader.read_head(config.input.HEAD)
logger = initialize_logger(__name__, config.out.FOLDER_LOGS)
# --------------------------Manual Hypothesis definition-----------------------------------
n_samples = 100
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.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 = HypothesisBuilder(
head.connectivity.number_of_regions).set_x0_hypothesis(
x0_indices,
x0_values).set_e_hypothesis(e_indices,
e_values).build_hypothesis()
# Now running the parameter search analysis:
logger.info("running PSE LSA...")
model_config, lsa_service, lsa_hypothesis, pse_res = pse_from_hypothesis(
hyp_x0_E,
head.connectivity.normalized_weights,
head.connectivity.region_labels,
n_samples,
param_range=0.1,
global_coupling=[{
"indices": all_regions_indices
}],
healthy_regions_parameters=[{
"name": "x0_values",
"indices": healthy_indices
}],
save_services=True)[:4]
logger.info("Plotting LSA...")
Plotter(config).plot_lsa(lsa_hypothesis,
model_config,
lsa_service.weighted_eigenvector_sum,
lsa_service.eigen_vectors_number,
region_labels=head.connectivity.region_labels,
pse_results=pse_res,
lsa_service=lsa_service)
logger.info("Saving LSA results ...")
writer.write_dictionary(
pse_res,
os.path.join(config.out.FOLDER_RES,
lsa_hypothesis.name + "_PSE_LSA_results.h5"))
def set_empirical_data(empirical_file,
ts_file,
head,
sensors_lbls,
sensor_id=0,
seizure_length=SEIZURE_LENGTH,
times_on_off=[],
time_units="ms",
label_strip_fun=None,
preprocessing=TARGET_DATA_PREPROCESSING,
low_hpf=LOW_HPF,
high_hpf=HIGH_HPF,
low_lpf=LOW_LPF,
high_lpf=HIGH_LPF,
bipolar=BIPOLAR,
win_len_ratio=WIN_LEN_RATIO,
plotter=None,
title_prefix=""):
try:
return H5Reader().read_timeseries(ts_file)
except:
seizure_name = os.path.basename(empirical_file).split(".")[0]
if title_prefix.find(seizure_name) < 0:
title_prefix = title_prefix + seizure_name
# ... or preprocess empirical data for the first time:
if len(sensors_lbls) == 0:
sensors_lbls = head.get_sensors_by_index(
sensor_ids=sensor_id).labels
signals = prepare_seeg_observable_from_mne_file(
empirical_file, head.get_sensors_by_index(sensor_ids=sensor_id),
sensors_lbls, seizure_length, times_on_off, time_units,
label_strip_fun, preprocessing, low_hpf, high_hpf, low_lpf,
high_lpf, bipolar, win_len_ratio, plotter, title_prefix)
H5Writer().write_timeseries(signals, ts_file)
move_overwrite_files_to_folder_with_wildcard(
os.path.join(plotter.config.out.FOLDER_FIGURES,
"fitData_EmpiricalSEEG"),
os.path.join(plotter.config.out.FOLDER_FIGURES,
title_prefix.replace(" ", "_")) + "*")
return signals
def from_head_to_hypotheses(ep_name, config, plot_head=False):
# -------------------------------Reading model_data-----------------------------------
reader = TVBReader() if config.input.IS_TVB_MODE else H5Reader()
logger.info("Reading from: " + config.input.HEAD)
head = reader.read_head(config.input.HEAD)
if plot_head:
Plotter(config).plot_head(head)
# --------------------------Hypothesis definition-----------------------------------
# # 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:
# FOLDER_RES = os.path.join(data_folder, ep_name)
hypo_builder = HypothesisBuilder(head.connectivity.number_of_regions,
config=config).set_normalize(0.95)
# This is an example of Excitability Hypothesis:
hyp_x0 = hypo_builder.build_hypothesis_from_file(ep_name)
# This is an example of Epileptogenicity Hypothesis:
hyp_E = hypo_builder.build_hypothesis_from_file(
ep_name, e_indices=hyp_x0.x0_indices)
# This is an example of Mixed Hypothesis:
x0_indices = [hyp_x0.x0_indices[-1]]
x0_values = [hyp_x0.x0_values[-1]]
e_indices = hyp_x0.x0_indices[0:-1].tolist()
e_values = hyp_x0.x0_values[0:-1].tolist()
hyp_x0_E = hypo_builder.set_x0_hypothesis(x0_indices, x0_values). \
set_e_hypothesis(e_indices, e_values).build_hypothesis()
hypos = (hyp_x0, hyp_E, hyp_x0_E)
return head, hypos
def main_vep(config=Config(),
ep_name=EP_NAME,
K_unscaled=K_UNSCALED_DEF,
ep_indices=[],
hyp_norm=0.99,
manual_hypos=[],
sim_type="paper",
pse_flag=PSE_FLAG,
sa_pse_flag=SA_PSE_FLAG,
sim_flag=SIM_FLAG,
n_samples=100,
test_write_read=False):
logger = initialize_logger(__name__, config.out.FOLDER_LOGS)
# -------------------------------Reading data-----------------------------------
reader = TVBReader() if config.input.IS_TVB_MODE else H5Reader()
writer = H5Writer()
plotter = Plotter(config)
logger.info("Reading from: " + config.input.HEAD)
head = reader.read_head(config.input.HEAD)
plotter.plot_head(head)
if test_write_read:
writer.write_head(head, os.path.join(config.out.FOLDER_RES, "Head"))
# --------------------------Hypothesis definition-----------------------------------
hypotheses = []
# Reading a h5 file:
if len(ep_name) > 0:
# For an Excitability Hypothesis you leave e_indices empty
# For a Mixed Hypothesis: you give as e_indices some indices for values > 0
# For an Epileptogenicity Hypothesis: you give as e_indices all indices for values > 0
hyp_file = HypothesisBuilder(head.connectivity.number_of_regions, config=config).set_normalize(hyp_norm). \
build_hypothesis_from_file(ep_name, e_indices=ep_indices)
hyp_file.name += ep_name
# print(hyp_file.string_regions_disease(head.connectivity.region_labels))
hypotheses.append(hyp_file)
hypotheses += manual_hypos
# --------------------------Hypothesis and LSA-----------------------------------
for hyp in hypotheses:
logger.info("\n\nRunning hypothesis: " + hyp.name)
all_regions_indices = np.array(range(head.number_of_regions))
healthy_indices = np.delete(all_regions_indices,
hyp.regions_disease_indices).tolist()
logger.info("\n\nCreating model configuration...")
model_config_builder = ModelConfigurationBuilder("EpileptorDP2D", head.connectivity, K_unscaled=K_unscaled). \
set_parameter("tau1", TAU1_DEF).set_parameter("tau0", TAU0_DEF)
mcs_file = os.path.join(config.out.FOLDER_RES,
hyp.name + "_model_config_builder.h5")
writer.write_model_configuration_builder(model_config_builder,
mcs_file)
if test_write_read:
logger.info(
"Written and read model configuration builders are identical?: "
+ str(
assert_equal_objects(
model_config_builder,
reader.read_model_configuration_builder(mcs_file),
logger=logger)))
# Fix healthy regions to default equilibria:
# model_configuration = \
# model_config_builder.build_model_from_E_hypothesis(hyp)
# Fix healthy regions to default x0s:
model_configuration = model_config_builder.build_model_from_hypothesis(
hyp)
mc_path = os.path.join(config.out.FOLDER_RES,
hyp.name + "_ModelConfig.h5")
writer.write_model_configuration(model_configuration, mc_path)
if test_write_read:
logger.info(
"Written and read model configuration are identical?: " + str(
assert_equal_objects(model_configuration,
reader.read_model_configuration(
mc_path),
logger=logger)))
# Plot nullclines and equilibria of model configuration
plotter.plot_state_space(model_configuration,
head.connectivity.region_labels,
special_idx=hyp.regions_disease_indices,
figure_name=hyp.name + "_StateSpace")
logger.info("\n\nRunning LSA...")
lsa_service = LSAService(eigen_vectors_number=1)
lsa_hypothesis = lsa_service.run_lsa(hyp, model_configuration)
lsa_path = os.path.join(config.out.FOLDER_RES,
lsa_hypothesis.name + "_LSA.h5")
lsa_config_path = os.path.join(config.out.FOLDER_RES,
lsa_hypothesis.name + "_LSAConfig.h5")
writer.write_hypothesis(lsa_hypothesis, lsa_path)
writer.write_lsa_service(lsa_service, lsa_config_path)
if test_write_read:
logger.info("Written and read LSA services are identical?: " + str(
assert_equal_objects(lsa_service,
reader.read_lsa_service(lsa_config_path),
logger=logger)))
logger.info(
"Written and read LSA hypotheses are identical (no input check)?: "
+ str(
assert_equal_objects(lsa_hypothesis,
reader.read_hypothesis(lsa_path),
logger=logger)))
plotter.plot_lsa(lsa_hypothesis,
model_configuration,
lsa_service.weighted_eigenvector_sum,
lsa_service.eigen_vectors_number,
head.connectivity.region_labels,
None,
lsa_service=lsa_service)
if pse_flag:
# --------------Parameter Search Exploration (PSE)-------------------------------
logger.info("\n\nRunning PSE LSA...")
pse_results = pse_from_lsa_hypothesis(
n_samples,
lsa_hypothesis,
model_configuration.connectivity,
model_config_builder,
lsa_service,
head.connectivity.region_labels,
param_range=0.1,
global_coupling=[{
"indices": all_regions_indices
}],
healthy_regions_parameters=[{
"name": "x0_values",
"indices": healthy_indices
}],
logger=logger,
save_flag=True)[0]
plotter.plot_lsa(lsa_hypothesis, model_configuration,
lsa_service.weighted_eigenvector_sum,
lsa_service.eigen_vectors_number,
head.connectivity.region_labels, pse_results)
pse_lsa_path = os.path.join(
config.out.FOLDER_RES,
lsa_hypothesis.name + "_PSE_LSA_results.h5")
writer.write_dictionary(pse_results, pse_lsa_path)
if test_write_read:
logger.info(
"Written and read parameter search results are identical?: "
+ str(
assert_equal_objects(pse_results,
reader.read_dictionary(
pse_lsa_path),
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(n_samples, lsa_hypothesis,
model_configuration.connectivity,
model_config_builder, lsa_service,
head.connectivity.region_labels,
method="sobol", param_range=0.1,
global_coupling=[{"indices": all_regions_indices,
"bounds": [0.0, 2 *
model_config_builder.K_unscaled[
0]]}],
healthy_regions_parameters=[
{"name": "x0_values", "indices": healthy_indices}],
config=config)
plotter.plot_lsa(lsa_hypothesis,
model_configuration,
lsa_service.weighted_eigenvector_sum,
lsa_service.eigen_vectors_number,
head.connectivity.region_labels,
pse_sa_results,
title="SA PSE Hypothesis Overview")
sa_pse_path = os.path.join(
config.out.FOLDER_RES,
lsa_hypothesis.name + "_SA_PSE_LSA_results.h5")
sa_lsa_path = os.path.join(
config.out.FOLDER_RES,
lsa_hypothesis.name + "_SA_LSA_results.h5")
writer.write_dictionary(pse_sa_results, sa_pse_path)
writer.write_dictionary(sa_results, sa_lsa_path)
if test_write_read:
logger.info(
"Written and read sensitivity analysis results are identical?: "
+ str(
assert_equal_objects(sa_results,
reader.read_dictionary(
sa_lsa_path),
logger=logger)))
logger.info(
"Written and read sensitivity analysis parameter search results are identical?: "
+ str(
assert_equal_objects(pse_sa_results,
reader.read_dictionary(
sa_pse_path),
logger=logger)))
if sim_flag:
# --------------------------Simulation preparations-----------------------------------
# If you 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,
# -correlated noise is also used
# We don't want any time delays for the moment
head.connectivity.tract_lengths *= config.simulator.USE_TIME_DELAYS_FLAG
sim_types = ensure_list(sim_type)
for sim_type in sim_types:
# ------------------------------Simulation--------------------------------------
logger.info(
"\n\nConfiguring %s simulation from model_configuration..."
% sim_type)
if isequal_string(sim_type, "realistic"):
sim_builder = SimulatorBuilder(model_configuration).set_model("EpileptorDPrealistic"). \
set_fs(2048.0).set_simulation_length(60000.0)
sim_builder.model_config.tau0 = 60000.0
sim_builder.model_config.tau1 = 0.2
sim_builder.model_config.slope = 0.25
sim_builder.model_config.pmode = np.array([PMODE_DEF])
sim_settings = sim_builder.build_sim_settings()
sim_settings.noise_type = COLORED_NOISE
sim_settings.noise_ntau = 20
# Necessary a more stable integrator:
sim_settings.integrator_type = "Dop853Stochastic"
elif isequal_string(sim_type, "fitting"):
sim_builder = SimulatorBuilder(model_configuration).set_model("EpileptorDP2D"). \
set_fs(2048.0).set_fs_monitor(2048.0).set_simulation_length(300.0)
sim_builder.model_config.tau0 = 30.0
sim_builder.model_config.tau1 = 0.5
sim_settings = sim_builder.build_sim_settings()
sim_settings.noise_intensity = np.array([0.0, 1e-5])
elif isequal_string(sim_type, "reduced"):
sim_builder = \
SimulatorBuilder(model_configuration).set_model("EpileptorDP2D").set_fs(
4096.0).set_simulation_length(1000.0)
sim_settings = sim_builder.build_sim_settings()
elif isequal_string(sim_type, "paper"):
sim_builder = SimulatorBuilder(
model_configuration).set_model("Epileptor")
sim_settings = sim_builder.build_sim_settings()
else:
sim_builder = SimulatorBuilder(
model_configuration).set_model("EpileptorDP")
sim_settings = sim_builder.build_sim_settings()
# Integrator and initial conditions initialization.
# By default initial condition is set right on the equilibrium point.
sim, sim_settings = \
sim_builder.build_simulator_TVB_from_model_sim_settings(head.connectivity, sim_settings)
sim_path = os.path.join(
config.out.FOLDER_RES,
lsa_hypothesis.name + "_" + sim_type + "_sim_settings.h5")
model_path = os.path.join(
config.out.FOLDER_RES,
lsa_hypothesis.name + sim_type + "_model.h5")
writer.write_simulation_settings(sim.settings, sim_path)
writer.write_simulator_model(
sim.model, model_path, sim.connectivity.number_of_regions)
if test_write_read:
# TODO: find out why it cannot set monitor expressions
logger.info(
"Written and read simulation settings are identical?: "
+ str(
assert_equal_objects(
sim.settings,
reader.read_simulation_settings(sim_path),
logger=logger)))
# logger.info("Written and read simulation model are identical?: " +
# str(assert_equal_objects(sim.model,
# reader.read_epileptor_model(model_path), logger=logger)))
logger.info("\n\nSimulating %s..." % sim_type)
sim_output, status = sim.launch_simulation(
report_every_n_monitor_steps=100, timeseries=Timeseries)
if not status:
logger.warning("\nSimulation failed!")
else:
time = np.array(sim_output.time).astype("f")
logger.info("\n\nSimulated signal return shape: %s",
sim_output.shape)
logger.info("Time: %s - %s", time[0], time[-1])
logger.info("Values: %s - %s", sim_output.data.min(),
sim_output.data.max())
if not status:
logger.warning("\nSimulation failed!")
else:
sim_output, seeg = compute_seeg_and_write_ts_to_h5(
sim_output,
sim.model,
head.sensorsSEEG,
os.path.join(config.out.FOLDER_RES,
sim_type + "_ts.h5"),
seeg_gain_mode="lin",
hpf_flag=True,
hpf_low=10.0,
hpf_high=512.0)
# Plot results
plotter.plot_simulated_timeseries(
sim_output,
sim.model,
lsa_hypothesis.lsa_propagation_indices,
seeg_dict=seeg,
spectral_raster_plot=False,
title_prefix=hyp.name,
spectral_options={"log_scale": True})
def from_model_configuration_to_simulation(model_configuration, head, lsa_hypothesis, rescale_x1eq=None,
sim_type="realistic", ts_file=None, seeg_gain_mode="lin", hpf_flag=False,
hpf_low=10.0, hpf_high=512.0, config=Config(), plotter=False,
title_prefix=""):
# 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:
if rescale_x1eq is not None:
model_config = deepcopy(model_configuration)
x1eq_min = np.min(model_config.x1eq)
model_config.x1eq = interval_scaling(model_config.x1eq, min_targ=x1eq_min, max_targ=rescale_x1eq,
min_orig=x1eq_min, max_orig=np.max(model_config.x1eq))
zeq = calc_eq_z(model_config.x1eq, model_config.yc, model_config.Iext1, "2d",
np.zeros(model_config.zeq.shape), model_config.slope, model_config.a,
model_config.b, model_config.d)
model_config.x0 = calc_x0(model_config.x1eq, zeq, model_config.K, model_config.connectivity,
model_config.zmode, z_pos=True, shape=zeq.shape, calc_mode="non_symbol")
else:
model_config = model_configuration
# ------------------------------Simulation--------------------------------------
hypname = lsa_hypothesis.name.replace("_LSA", "")
logger.info("\n\nConfiguring simulation...")
if isequal_string(sim_type, "realistic"):
sim, sim_settings= build_simulator_TVB_realistic(model_config, head.connectivity)
elif isequal_string(sim_type, "fitting"):
sim, sim_settings = build_simulator_TVB_fitting(model_config, head.connectivity)
elif isequal_string(sim_type, "paper"):
sim, sim_settings = build_simulator_TVB_paper(model_config, head.connectivity)
else:
sim, sim_settings = build_simulator_TVB_default(model_config, head.connectivity)
dynamical_model = sim.model
writer = H5Writer()
if config.out.FOLDER_RES.find(hypname) >= 0:
model_path = os.path.join(config.out.FOLDER_RES, dynamical_model._ui_name + "_model.h5")
title_prefix += ""
else:
model_path = os.path.join(config.out.FOLDER_RES, hypname + dynamical_model._ui_name + "_model.h5")
title_prefix += hypname
writer.write_simulator_model(sim.model, model_path, sim.connectivity.number_of_regions)
seeg=[]
if ts_file is not None and os.path.isfile(ts_file):
logger.info("\n\nLoading previously simulated time series from file: " + ts_file)
sim_output = H5Reader().read_timeseries(ts_file)
seeg = TimeseriesService().compute_seeg(sim_output.get_source(), head.sensorsSEEG, sum_mode=seeg_gain_mode)
else:
logger.info("\n\nSimulating %s..." % sim_type)
sim_output, status = sim.launch_simulation(report_every_n_monitor_steps=100, timeseries=Timeseries)
if not status:
logger.warning("\nSimulation failed!")
else:
time = np.array(sim_output.time).astype("f")
logger.info("\n\nSimulated signal return shape: %s", sim_output.shape)
logger.info("Time: %s - %s", time[0], time[-1])
sim_output, seeg = compute_seeg_and_write_ts_to_h5(sim_output, sim.model, head.sensorsSEEG,
ts_file, seeg_gain_mode=seeg_gain_mode,
hpf_flag=hpf_flag, hpf_low=hpf_low, hpf_high=hpf_high)
if plotter:
if not isinstance(plotter, Plotter):
plotter = Plotter(config)
# Plot results
plotter.plot_simulated_timeseries(sim_output, sim.model, lsa_hypothesis.all_disease_indices, seeg_dict=seeg,
spectral_raster_plot=False, title_prefix=title_prefix,
spectral_options={"log_scale": True})
return {"source": sim_output, "seeg": seeg}, sim
def main_fit_sim_hyplsa(stan_model_name,
empirical_files,
times_on,
time_length,
sim_times_on_off,
sensors_lbls,
normal_flag=False,
sim_source_type="fitting",
observation_model=OBSERVATION_MODELS.SEEG_POWER.value,
downsampling=2,
normalization="baseline-maxstd",
fitmethod="sample",
pse_flag=True,
fit_flag=True,
test_flag=False,
config=Config(),
**kwargs):
# Prepare necessary services:
logger = initialize_logger(__name__, config.out.FOLDER_LOGS)
reader = H5Reader()
writer = H5Writer()
plotter = Plotter(config)
# Read head
logger.info("Reading from: " + config.input.HEAD)
head = reader.read_head(config.input.HEAD)
sensors = ensure_list(head.get_sensors_by_name("distance"))[0]
if isinstance(sensors, dict):
sensors = sensors.values()[0]
sensor_id = head.sensors_name_to_id(sensors.name)
elif sensors is None:
sensors = head.get_sensors_by_index()
sensor_id = 0
plotter.plot_head(head)
# Set hypothesis:
hyp = set_hypotheses(head, config)[0]
config.out._out_base = os.path.join(config.out._out_base, hyp.name)
plotter = Plotter(config)
# Set model configuration and compute LSA
model_configuration, lsa_hypothesis, pse_results = \
set_model_config_LSA(head, hyp, reader, config, K_unscaled=3 * K_UNSCALED_DEF, tau1=TAU1_DEF, tau0=TAU0_DEF,
pse_flag=pse_flag, plotter=plotter, writer=writer)
base_path = os.path.join(config.out.FOLDER_RES)
# -----------Get prototypical simulated data from the fitting version of Epileptor(simulate if necessary) ----------
source2D_file = path("Source2Dts", base_path)
source2D_ts = get_2D_simulation(model_configuration,
head,
lsa_hypothesis,
source2D_file,
sim_times_on_off,
config=config,
reader=reader,
writer=writer,
plotter=plotter)
# -------------------------- Get model_data and observation signals: -------------------------------------------
target_data_file = path("FitTargetData", base_path)
sim_target_file = path("ts_fit", base_path)
empirical_target_file = path("ts_empirical", base_path)
problstc_model_file = path("ProblstcModel", base_path)
model_data_file = path("ModelData", base_path)
if os.path.isfile(problstc_model_file) and os.path.isfile(
model_data_file) and os.path.isfile(target_data_file):
# Read existing probabilistic model and model data...
probabilistic_model = reader.read_probabilistic_model(
problstc_model_file)
model_data = reader.read_dictionary(model_data_file)
target_data = reader.read_timeseries(target_data_file)
else:
# Create model inversion service (stateless)
model_inversion = SDEModelInversionService()
model_inversion.normalization = normalization
# Exclude ctx-l/rh-unknown regions from fitting
model_inversion.active_regions_exlude = find_labels_inds(
head.connectivity.region_labels, ["unknown"])
# Generate probabilistic model and model data
probabilistic_model = \
SDEProbabilisticModelBuilder(model_name=stan_model_name, model_config=model_configuration,
xmode=XModes.X1EQMODE.value, priors_mode=PriorsModes.NONINFORMATIVE.value,
sde_mode=SDE_MODES.NONCENTERED.value, observation_model=observation_model,
normal_flag=normal_flag, K=np.mean(model_configuration.K),
sigma=SIGMA_DEF).generate_model(generate_parameters=False)
# Get by simulation and/or loading prototypical source 2D timeseries and the target (simulater or empirical)
# time series for fitting
signals, probabilistic_model, simulator = \
get_target_timeseries(probabilistic_model, head, lsa_hypothesis, times_on, time_length,
sensors_lbls, sensor_id, observation_model, sim_target_file,
empirical_target_file, sim_source_type, downsampling, empirical_files, config, plotter)
# Update active model's active region nodes
e_values = pse_results.get("e_values_mean",
model_configuration.e_values)
lsa_propagation_strength = pse_results.get(
"lsa_propagation_strengths_mean",
lsa_hypothesis.lsa_propagation_strengths)
model_inversion.active_e_th = 0.05
probabilistic_model = \
model_inversion.update_active_regions(probabilistic_model, sensors=sensors, e_values=e_values,
lsa_propagation_strengths=lsa_propagation_strength, reset=True)
# Select and set the target time series
target_data, probabilistic_model, model_inversion = \
set_target_timeseries(probabilistic_model, model_inversion, signals, sensors, head,
target_data_file, writer, plotter)
#---------------------------------Finally set priors for the parameters-------------------------------------
probabilistic_model = \
set_prior_parameters(probabilistic_model, target_data, source2D_ts, None, problstc_model_file,
[XModes.X0MODE.value, "x1_init", "z_init", "tau1", # "tau0", "K", "x1",
"sigma", "dWt", "epsilon", "scale", "offset"], normal_flag,
writer=writer, plotter=plotter)
# Construct the stan model data dict:
model_data = build_stan_model_data_dict(
probabilistic_model,
target_data.squeezed,
model_configuration.connectivity,
time=target_data.time)
# # ...or interface with INS stan models
# from tvb_fit.service.model_inversion.vep_stan_dict_builder import \
# build_stan_model_data_dict_to_interface_ins
# model_data = build_stan_model_data_dict_to_interface_ins(probabilistic_model, target_data.squeezed,
# model_configuration.connectivity, gain_matrix,
# time=target_data.time)
writer.write_dictionary(model_data, model_data_file)
# -------------------------- Fit or load results from previous fitting: -------------------------------------------
estimates, samples, summary, info_crit = \
run_fitting(probabilistic_model, stan_model_name, model_data, target_data, config, head,
hyp.all_disease_indices, ["tau1", "sigma", "epsilon", "scale", "offset"], ["x0", "PZ", "x1eq", "zeq"],
fit_flag, test_flag, base_path, fitmethod, n_chains_or_runs=2,
output_samples=200, num_warmup=100, min_samples_per_chain=200, max_depth=15, delta=0.95,
iter=500000, tol_rel_obj=1e-6, debug=1, simulate=0, writer=writer, plotter=plotter, **kwargs)
# -------------------------- Reconfigure model after fitting:---------------------------------------------------
model_configuration_fit = reconfigure_model_with_fit_estimates(
head, model_configuration, probabilistic_model, estimates, base_path,
writer, plotter)
logger.info("Done!")
def build_hypothesis_from_file(self, hyp_file, e_indices=None):
self.set_diseased_regions_values(H5Reader().read_epileptogenicity(
self.config.input.HEAD, name=hyp_file))
if e_indices:
self.set_e_indices(e_indices)
return self.build_hypothesis()
class TestCustomH5Reader(BaseTest):
reader = H5Reader()
writer = H5Writer()
in_head = InputConfig().HEAD
not_existent_file = "NotExistent.h5"
def test_read_hypothesis(self):
test_file = os.path.join(self.config.out.FOLDER_TEMP,
"TestHypothesis.h5")
hypothesis_builder = HypothesisBuilder(3, self.config)
dummy_hypothesis = hypothesis_builder.set_e_hypothesis(
[0], [0.6]).build_hypothesis()
self.writer.write_hypothesis(dummy_hypothesis, test_file)
hypothesis = self.reader.read_hypothesis(test_file)
assert dummy_hypothesis.number_of_regions == hypothesis.number_of_regions
assert numpy.array_equal(dummy_hypothesis.x0_values,
hypothesis.x0_values)
assert dummy_hypothesis.x0_indices == hypothesis.x0_indices
assert numpy.array_equal(dummy_hypothesis.e_values,
hypothesis.e_values)
assert dummy_hypothesis.e_indices == hypothesis.e_indices
assert numpy.array_equal(dummy_hypothesis.w_values,
hypothesis.w_values)
assert dummy_hypothesis.w_indices == hypothesis.w_indices
assert numpy.array_equal(dummy_hypothesis.lsa_propagation_indices,
hypothesis.lsa_propagation_indices)
if len(dummy_hypothesis.lsa_propagation_indices) == 0:
assert numpy.array_equal([0, 0, 0],
hypothesis.lsa_propagation_strengths)
else:
assert numpy.array_equal(
dummy_hypothesis.lsa_propagation_strengths,
hypothesis.lsa_propagation_strengths)
def test_read_model_configuration(self):
test_file = os.path.join(self.config.out.FOLDER_TEMP,
"TestModelConfiguration.h5")
dummy_mc = ModelConfiguration(x1eq=numpy.array([2.0, 3.0, 1.0]),
zmode=None,
zeq=numpy.array([3.0, 2.0, 1.0]),
connectivity=numpy.array(
[[1.0, 2.0, 3.0], [1.0, 2.0, 3.0],
[2.0, 2.0, 2.0]]),
Ceq=numpy.array([1.0, 2.0, 3.0]))
self.writer.write_model_configuration(dummy_mc, test_file)
mc = self.reader.read_model_configuration(test_file)
assert numpy.array_equal(dummy_mc.x1eq, mc.x1eq)
assert numpy.array_equal(dummy_mc.zeq, mc.zeq)
assert numpy.array_equal(dummy_mc.Ceq, mc.Ceq)
assert numpy.array_equal(dummy_mc.connectivity, mc.connectivity)
def test_read_model_configuration_builder(self):
test_file = os.path.join(self.config.out.FOLDER_TEMP,
"TestModelConfigService.h5")
dummy_mc_service = ModelConfigurationBuilder("Epileptor",
connectivity=numpy.array(
[[1.0, 2.0, 3.0],
[1.0, 2.0, 3.0],
[2.0, 2.0, 2.0]]))
self.writer.write_model_configuration_builder(dummy_mc_service,
test_file)
mc_service = self.reader.read_model_configuration_builder(test_file)
assert dummy_mc_service.number_of_regions == mc_service.number_of_regions
assert numpy.array_equal(dummy_mc_service.x0_values,
mc_service.x0_values)
assert numpy.array_equal(dummy_mc_service.K_unscaled,
mc_service.K_unscaled)
assert numpy.array_equal(dummy_mc_service.e_values,
mc_service.e_values)
assert numpy.array_equal(dummy_mc_service.yc, mc_service.yc)
assert numpy.array_equal(dummy_mc_service.Iext1, mc_service.Iext1)
assert numpy.array_equal(dummy_mc_service.Iext2, mc_service.Iext2)
assert numpy.array_equal(dummy_mc_service.a, mc_service.a)
assert numpy.array_equal(dummy_mc_service.b, mc_service.b)
assert numpy.array_equal(dummy_mc_service.d, mc_service.d)
assert numpy.array_equal(dummy_mc_service.slope, mc_service.slope)
assert numpy.array_equal(dummy_mc_service.s, mc_service.s)
assert numpy.array_equal(dummy_mc_service.gamma, mc_service.gamma)
assert numpy.array_equal(dummy_mc_service.tau1, mc_service.tau1)
assert numpy.array_equal(dummy_mc_service.tau0, mc_service.tau0)
assert numpy.array_equal(dummy_mc_service.zmode, mc_service.zmode)
assert dummy_mc_service.x1eq_mode == mc_service.x1eq_mode
assert dummy_mc_service.K.all() == mc_service.K.all()
assert numpy.array_equal(dummy_mc_service.x0cr, mc_service.x0cr)
assert numpy.array_equal(dummy_mc_service.rx0, mc_service.rx0)
def test_read_lsa_service(self):
test_file = os.path.join(self.config.out.FOLDER_TEMP,
"TestLSAService.h5")
dummy_lsa_service = LSAService()
self.writer.write_lsa_service(dummy_lsa_service, test_file)
lsa_service = self.reader.read_lsa_service(test_file)
assert dummy_lsa_service.eigen_vectors_number_selection == lsa_service.eigen_vectors_number_selection
assert dummy_lsa_service.eigen_vectors_number == lsa_service.eigen_vectors_number
assert dummy_lsa_service.eigen_values.size == lsa_service.eigen_values.size
assert dummy_lsa_service.eigen_vectors.size == lsa_service.eigen_vectors.size
assert dummy_lsa_service.weighted_eigenvector_sum == lsa_service.weighted_eigenvector_sum
assert dummy_lsa_service.normalize_propagation_strength == lsa_service.normalize_propagation_strength