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 main_h5_model(config=Config()): # -------------------------------Reading data----------------------------------- reader = TVBReader() if config.input.IS_TVB_MODE else H5Reader() writer = H5Writer() logger.info("Reading from: %s", config.input.HEAD) head = reader.read_head(config.input.HEAD) empty_hypothesis = HypothesisBuilder().build_hypothesis() x0_indices = [20] x0_values = [0.9] e_indices = [70] e_values = [0.9] 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() obj = { "hyp_x0_E": hyp_x0_E, "test_dict": { "list0": [ "l00", 1, { "d020": "a", "d021": [True, False, np.inf, np.nan, None, [], (), {}, ""] } ] } } logger.info("Original object: %s", obj) logger.info("Writing object to h5 file...") writer.write_generic( obj, os.path.join(config.out.FOLDER_RES, "test_h5_model.h5")) h5_model1 = read_h5_model(config.out.FOLDER_RES + "/test_h5_model.h5") obj1 = h5_model1.convert_from_h5_model(deepcopy(obj)) if assert_equal_objects(obj, obj1): logger.info("Read identical object: %s", obj1) else: logger.error("Comparison failed!: %s", obj1) h5_model2 = read_h5_model(config.out.FOLDER_RES + "/test_h5_model.h5") obj2 = h5_model2.convert_from_h5_model( obj={"DiseaseHypothesis": empty_hypothesis}) if assert_equal_objects(obj, obj2): logger.info("Read object as dictionary: %s", obj2) else: logger.error("Comparison failed!: %s", obj2)
def test_plot_lsa(self): figure_name = "LSAPlot" hypo_builder = HypothesisBuilder(config=self.config).set_name(figure_name) lsa_hypothesis = hypo_builder.build_lsa_hypothesis() mc = ModelConfigurationBuilder().build_model_from_E_hypothesis(lsa_hypothesis, numpy.array([1])) figure_file = os.path.join(self.config.out.FOLDER_FIGURES, figure_name + ".png") assert not os.path.exists(figure_file) self.plotter.plot_lsa(lsa_hypothesis, mc, True, None, region_labels=numpy.array(["a"]), title="") assert not os.path.exists(figure_file)
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:] hypothesis_builder = HypothesisBuilder(disease_hypothesis.number_of_regions).\ set_attributes_based_on_hypothesis(disease_hypothesis). \ set_lsa_propagation(propagation_indices, lsa_propagation_strength) return hypothesis_builder.build_lsa_hypothesis()
def test_build_hypothesis_from_file_mixed(self): hypo_builder = HypothesisBuilder(76, self.config) hypo = hypo_builder.build_hypothesis_from_file(self.ep, [55, 56]) assert hypo.name == "e_x0_Hypothesis" assert not len(hypo.e_indices) == 0 assert not len(hypo.e_values) == 0 assert not len(hypo.x0_indices) == 0 assert not len(hypo.x0_values) == 0 assert len(hypo.w_indices) == 0 assert len(hypo.w_values) == 0 assert len(hypo.lsa_propagation_indices) == 0 assert len(hypo.lsa_propagation_strengths) == 0
def test_build_empty_hypothesis(self): hypo_builder = HypothesisBuilder(config=self.config) hypo = hypo_builder.build_hypothesis() assert hypo.name == "Hypothesis" assert hypo.number_of_regions == 0 assert len(hypo.x0_indices) == 0 assert len(hypo.x0_values) == 0 assert len(hypo.e_indices) == 0 assert len(hypo.e_values) == 0 assert len(hypo.w_indices) == 0 assert len(hypo.w_values) == 0 assert len(hypo.lsa_propagation_indices) == 0 assert len(hypo.lsa_propagation_strengths) == 0
def test_build_hypothesis_from_file_epileptogenicity(self): hypo_builder = HypothesisBuilder(76, self.config) hypo = hypo_builder.build_hypothesis_from_file( self.ep, [55, 56, 57, 58, 59, 60, 61]) assert hypo.name == "e_Hypothesis" assert not len(hypo.e_indices) == 0 assert not len(hypo.e_values) == 0 assert len(hypo.x0_indices) == 0 assert len(hypo.x0_values) == 0 assert len(hypo.w_indices) == 0 assert len(hypo.w_values) == 0 assert len(hypo.lsa_propagation_indices) == 0 assert len(hypo.lsa_propagation_strengths) == 0
def set_hypotheses(head, config): # Formulate a VEP hypothesis manually hyp_builder = HypothesisBuilder(head.connectivity.number_of_regions, config) # .set_normalize(0.99) # Regions of Pathological Excitability hypothesis: x0_indices = [2, 24] x0_values = [0.01, 0.01] hyp_builder.set_x0_hypothesis(x0_indices, x0_values) # Regions of Model Epileptogenicity hypothesis: e_indices = [1, 26] # e_indices = list(range(head.connectivity.number_of_regions)) # e_indices.remove(2) # e_indices.remove(25) # e_values = np.zeros((head.connectivity.number_of_regions,)) + 0.01 # e_values[[1, 26]] = 0.99 # e_values = np.delete(e_values, [2, 25]).tolist() e_values = np.array([1.5, 1.25]) # np.array([0.99] * 2) hyp_builder.set_e_hypothesis(e_indices, e_values) # Regions of Connectivity hypothesis: # w_indices = [] # [(0, 1), (0, 2)] # w_values = [] # [0.5, 2.0] # hypo_builder.set_w_indices(w_indices).set_w_values(w_values) hypothesis1 = hyp_builder.build_hypothesis() e_indices = [1, 26] # [1, 2, 25, 26] hypothesis2 = hyp_builder.build_hypothesis_from_file( "clinical_hypothesis_postseeg", e_indices) # Change something manually if necessary # hypothesis2.x0_values = [0.01, 0.01] return (hypothesis1, hypothesis2)
def test_plot_sim_results(self): lsa_hypothesis = HypothesisBuilder( config=self.config).build_lsa_hypothesis() mc = ModelConfigurationBuilder().build_model_from_E_hypothesis( lsa_hypothesis, numpy.array([1])) model = build_EpileptorDP2D(mc) # TODO: this figure_name is constructed inside plot method, so it can change figure_name = "Simulated_TAVG" file_name = os.path.join(self.config.out.FOLDER_FIGURES, figure_name + ".png") assert not os.path.exists(file_name) data_3D = numpy.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 1, 2]], [[3, 4, 5], [6, 7, 8], [9, 0, 1], [2, 3, 4]], [[5, 6, 7], [8, 9, 0], [1, 2, 3], [4, 5, 6]]]) self.plotter.plot_simulated_timeseries( Timeseries( data_3D, { TimeseriesDimensions.SPACE.value: ["r1", "r2", "r3", "r4"], TimeseriesDimensions.VARIABLES.value: ["x1", "x2", "z"] }, 0, 1), model, [0]) assert os.path.exists(file_name)
def _prepare_model_for_simulation(connectivity): hypothesis = HypothesisBuilder(connectivity.number_of_regions).set_e_hypothesis([1, 1], [0, 10]).build_hypothesis() model_configuration_builder = ModelConfigurationBuilder(connectivity.number_of_regions) model_configuration = model_configuration_builder.build_model_from_hypothesis(hypothesis, connectivity.normalized_weights) return model_configuration
def test_build_hypothesis_by_user_preferences(self): hypo_builder = HypothesisBuilder(76, self.config).set_x0_hypothesis( [1, 2, 3], [1, 1, 1]).set_e_hypothesis([10, 11], [1, 1]).set_normalize(0.90) hypo = hypo_builder.build_hypothesis() assert hypo.name == "e_x0_Hypothesis" assert hypo.number_of_regions == 76 assert len(hypo.x0_indices) == 3 assert len(hypo.x0_values) == 3 assert len(hypo.e_indices) == 2 assert len(hypo.e_values) == 2 assert len(hypo.w_indices) == 0 assert len(hypo.w_values) == 0 assert len(hypo.lsa_propagation_indices) == 0 assert len(hypo.lsa_propagation_strengths) == 0
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_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 test_write_hypothesis(self): test_file = os.path.join(self.config.out.FOLDER_TEMP, "TestHypothesis.h5") dummy_hypothesis = HypothesisBuilder(3).set_e_hypothesis([0], [0.6]).build_hypothesis() assert not os.path.exists(test_file) self.writer.write_hypothesis(dummy_hypothesis, test_file) assert os.path.exists(test_file)
def test_build_lsa_hypothesis(self): hypo_builder = HypothesisBuilder(76, self.config).set_x0_hypothesis([1, 2], [1, 1]) hypo = hypo_builder.build_hypothesis() lsa_hypo = hypo_builder.set_attributes_based_on_hypothesis( hypo).set_lsa_propagation([3, 4], [0.5, 1]).build_lsa_hypothesis() assert lsa_hypo.name == "LSA_x0_Hypothesis" assert lsa_hypo.number_of_regions == 76 assert len(lsa_hypo.x0_indices) == 2 assert len(lsa_hypo.x0_values) == 2 assert len(lsa_hypo.e_indices) == 0 assert len(lsa_hypo.e_values) == 0 assert len(lsa_hypo.w_indices) == 0 assert len(lsa_hypo.w_values) == 0 assert len(lsa_hypo.lsa_propagation_indices) == 2 assert len(lsa_hypo.lsa_propagation_strengths) == 2
def test_write_pse_service(self): test_file = os.path.join(self.config.out.FOLDER_TEMP, "TestPSEService.h5") hypothesis = HypothesisBuilder(3).set_e_hypothesis([0], [0.6]).build_hypothesis() dummy_pse_service = LSAPSEService(hypothesis=hypothesis, params_pse={"path": [], "indices": [], "name": [], "bounds": []}) assert not os.path.exists(test_file) self.writer.write_pse_service(dummy_pse_service, test_file) assert os.path.exists(test_file)
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 = Plotter(config) plotter.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 test_plot_state_space(self): lsa_hypothesis = HypothesisBuilder(config=self.config).build_lsa_hypothesis() mc = ModelConfigurationBuilder().build_model_from_E_hypothesis(lsa_hypothesis, numpy.array([1])) model = "6d" zmode = "lin" # TODO: this figure_name is constructed inside plot method, so it can change figure_name = "_" + "Epileptor_" + model + "_z-" + str(zmode) file_name = os.path.join(self.config.out.FOLDER_FIGURES, figure_name + ".png") assert not os.path.exists(file_name) self.plotter.plot_state_space(mc, region_labels=numpy.array(["a"]), special_idx=[0], model=model, zmode=zmode, figure_name="") assert os.path.exists(file_name)
def test_plot_sim_results(self): lsa_hypothesis = HypothesisBuilder(config=self.config).build_lsa_hypothesis() mc = ModelConfigurationBuilder().build_model_from_E_hypothesis(lsa_hypothesis, numpy.array([1])) model = build_EpileptorDP2D(mc) res = prepare_vois_ts_dict(VOIS["EpileptorDP2D"], numpy.array([[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]])) res['time'] = numpy.array([1, 2, 3]) res['time_units'] = 'msec' # TODO: this figure_name is constructed inside plot method, so it can change figure_name = "EpileptorDP2D_Simulated_TAVG" file_name = os.path.join(self.config.out.FOLDER_FIGURES, figure_name + ".png") assert not os.path.exists(file_name) self.plotter.plot_sim_results(model, [0], res) assert os.path.exists(file_name)
def run_lsa(self, disease_hypothesis, model_configuration): if self.lsa_method == "auto": if numpy.any(model_configuration.x1eq > X1EQ_CR_DEF): self.lsa_method = "2D" else: self.lsa_method = "1D" if self.lsa_method == "2D" and numpy.all(model_configuration.x1eq <= X1EQ_CR_DEF): warning("LSA with the '2D' method (on the 2D Epileptor model) will not produce interpretable results when" " the equilibrium point of the system is not supercritical (unstable)!") jacobian = self._compute_jacobian(model_configuration) # Perform eigenvalue decomposition eigen_values, eigen_vectors = numpy.linalg.eig(jacobian) eigen_values = numpy.real(eigen_values) eigen_vectors = numpy.real(eigen_vectors) sorted_indices = numpy.argsort(eigen_values, kind='mergesort') if self.lsa_method == "2D": sorted_indices = sorted_indices[::-1] self.eigen_vectors = eigen_vectors[:, sorted_indices] self.eigen_values = eigen_values[sorted_indices] self._ensure_eigen_vectors_number(self.eigen_values[:disease_hypothesis.number_of_regions], model_configuration.e_values, model_configuration.x0_values, disease_hypothesis.regions_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(numpy.array(self.eigen_values[:self.eigen_vectors_number]), numpy.array(self.eigen_vectors[:, :self.eigen_vectors_number]), normalize=True)) else: lsa_propagation_strength = \ numpy.abs(numpy.sum(self.eigen_vectors[:, :self.eigen_vectors_number], axis=1)) if self.lsa_method == "2D": # lsa_propagation_strength = lsa_propagation_strength[:disease_hypothesis.number_of_regions] # or # lsa_propagation_strength = numpy.where(lsa_propagation_strength[:disease_hypothesis.number_of_regions] >= # lsa_propagation_strength[disease_hypothesis.number_of_regions:], # lsa_propagation_strength[:disease_hypothesis.number_of_regions], # lsa_propagation_strength[disease_hypothesis.number_of_regions:]) # or lsa_propagation_strength = numpy.sqrt(lsa_propagation_strength[:disease_hypothesis.number_of_regions]**2 + lsa_propagation_strength[disease_hypothesis.number_of_regions:]**2) lsa_propagation_strength = numpy.log10(lsa_propagation_strength) lsa_propagation_strength -= lsa_propagation_strength.min() 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:] hypothesis_builder = HypothesisBuilder(disease_hypothesis.number_of_regions). \ set_attributes_based_on_hypothesis(disease_hypothesis). \ set_name(disease_hypothesis.name + "_LSA"). \ set_lsa_propagation(propagation_indices, lsa_propagation_strength) return hypothesis_builder.build_lsa_hypothesis()
def main_fit_sim_hyplsa( stan_model_name="vep_sde_ins.stan", empirical_file="", observation_model=OBSERVATION_MODELS.SEEG_LOGPOWER.value, sensors_lbls=[], sensor_id=0, times_on_off=[], fitmethod="optimizing", pse_flag=True, fit_flag=True, config=Config(), **kwargs): def path(name): if len(name) > 0: return base_path + "_" + name + ".h5" else: return base_path + ".h5" # 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 = head.get_sensors_id(sensor_ids=sensor_id) plotter.plot_head(head) # Set hypotheses: hypotheses = set_hypotheses(head, config) # ------------------------------Stan model and service-------------------------------------- model_code_path = os.path.join(config.generic.PROBLSTC_MODELS_PATH, stan_model_name + ".stan") stan_service = CmdStanService(model_name=stan_model_name, model_code_path=model_code_path, fitmethod=fitmethod, config=config) stan_service.set_or_compile_model() for hyp in hypotheses[:1]: base_path = os.path.join(config.out.FOLDER_RES, hyp.name) # Set model configuration and compute LSA model_configuration, lsa_hypothesis, pse_results = \ set_model_config_LSA(head, hyp, reader, config, K_unscaled=3*K_DEF, tau1=TAU1_DEF, tau0=TAU0_DEF, pse_flag=pse_flag, plotter=plotter, writer=writer) # -------------------------- Get model_data and observation signals: ------------------------------------------- # Create model inversion service (stateless) problstc_model_file = path("ProblstcModel") model_data_file = path("ModelData") target_data_file = path("TargetData") 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 = stan_service.load_model_data_from_file( model_data_path=model_data_file) target_data = reader.read_timeseries(target_data_file) else: model_inversion = SDEModelInversionService() # ...or generate a new probabilistic model and model data probabilistic_model = \ SDEProbabilisticModelBuilder(model_name="vep_sde_ins.stan", model_config=model_configuration, parameters=[XModes.X0MODE.value, "sigma_"+XModes.X0MODE.value, "x1_init", "z_init", "tau1", # "tau0", "K", "sigma", "dZt", "epsilon", "scale", "offset"], # "dX1t", xmode=XModes.X0MODE.value, priors_mode=PriorsModes.NONINFORMATIVE.value, sde_mode=SDE_MODES.NONCENTERED.value, observation_model=observation_model).\ generate_model() # 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.2 probabilistic_model = \ model_inversion.update_active_regions(probabilistic_model, e_values=e_values, lsa_propagation_strengths=lsa_propagation_strength, reset=True) # Now some scripts for settting and preprocessing target signals: if os.path.isfile(empirical_file): probabilistic_model.target_data_type = TARGET_DATA_TYPE.EMPIRICAL.value # -------------------------- Get empirical data (preprocess edf if necessary) -------------------------- signals = set_empirical_data( empirical_file, path("ts_empirical"), head, sensors_lbls, sensor_id, probabilistic_model.time_length, times_on_off, label_strip_fun=lambda s: s.split("POL ")[-1], plotter=plotter, title_prefix=hyp.name, bipolar=False) else: # -------------------------- Get simulated data (simulate if necessary) ------------------------------- probabilistic_model.target_data_type = TARGET_DATA_TYPE.SYNTHETIC.value signals, simulator = \ set_simulated_target_data(path("ts"), model_configuration, head, lsa_hypothesis, probabilistic_model, sensor_id, sim_type="fitting", times_on_off=times_on_off, config=config, plotter=plotter, title_prefix=hyp.name, bipolar=False, filter_flag=False, envelope_flag=False, smooth_flag=False, **kwargs) # -------------------------- Select and set target data from signals --------------------------------------- if probabilistic_model.observation_model in OBSERVATION_MODELS.SEEG.value: model_inversion.auto_selection = "correlation-power" model_inversion.sensors_per_electrode = 2 target_data, probabilistic_model, gain_matrix = \ model_inversion.set_target_data_and_time(signals, probabilistic_model, head=head, sensors=sensors) plotter.plot_probabilistic_model(probabilistic_model, hyp.name + " Probabilistic Model") plotter.plot_raster({'Target Signals': target_data.squeezed}, target_data.time_line, time_units=target_data.time_unit, title=hyp.name + ' Target Signals raster', offset=0.1, labels=target_data.space_labels) plotter.plot_timeseries({'Target Signals': target_data.squeezed}, target_data.time_line, time_units=target_data.time_unit, title=hyp.name + ' Target Signals', labels=target_data.space_labels) writer.\ write_probabilistic_model(probabilistic_model, model_configuration.number_of_regions, problstc_model_file) writer.write_timeseries(target_data, target_data_file) # Construct the stan model data dict: model_data = build_stan_model_data_dict( probabilistic_model, target_data.squeezed, model_configuration.model_connectivity, gain_matrix, time=target_data.time_line) # # ...or interface with INS stan models # model_data = build_stan_model_data_dict_to_interface_ins(probabilistic_model, target_data.squeezed, # model_configuration.model_connectivity, gain_matrix, # time=target_data.time_line) writer.write_dictionary(model_data, model_data_file) # -------------------------- Fit and get estimates: ------------------------------------------------------------ n_chains_or_runs = 4 output_samples = max(int(np.round(1000.0 / n_chains_or_runs)), 500) # Sampling (HMC) num_samples = output_samples num_warmup = 1000 max_depth = 12 delta = 0.9 # ADVI or optimization: iter = 1000000 tol_rel_obj = 1e-6 if fitmethod.find("sampl") >= 0: skip_samples = num_warmup else: skip_samples = 0 prob_model_name = probabilistic_model.name.split(".")[0] if fit_flag: estimates, samples, summary = stan_service.fit( debug=0, simulate=0, model_data=model_data, refresh=1, n_chains_or_runs=n_chains_or_runs, iter=iter, tol_rel_obj=tol_rel_obj, num_warmup=num_warmup, num_samples=num_samples, max_depth=max_depth, delta=delta, save_warmup=1, plot_warmup=1, **kwargs) writer.write_generic(estimates, path(prob_model_name + "_FitEst")) writer.write_generic(samples, path(prob_model_name + "_FitSamples")) if summary is not None: writer.write_generic(summary, path(prob_model_name + "_FitSummary")) else: estimates, samples, summary = stan_service.read_output() if fitmethod.find("sampl") >= 0: plotter.plot_HMC(samples, figure_name=hyp.name + "-" + prob_model_name + " HMC NUTS trace") # Model comparison: # scale_signal, offset_signal, time_scale, epsilon, sigma -> 5 (+ K = 6) # x0[active] -> probabilistic_model.model.number_of_active_regions # x1init[active], zinit[active] -> 2 * probabilistic_model.number_of_active_regions # dZt[active, t] -> probabilistic_model.number_of_active_regions * (probabilistic_model.time_length-1) number_of_total_params =\ 5 + probabilistic_model.number_of_active_regions * (3 + (probabilistic_model.time_length-1)) info_crit = \ stan_service.compute_information_criteria(samples, number_of_total_params, skip_samples=skip_samples, # parameters=["amplitude_star", "offset_star", "epsilon_star", # "sigma_star", "time_scale_star", "x0_star", # "x_init_star", "z_init_star", "z_eta_star"], merge_chains_or_runs_flag=False) writer.write_generic(info_crit, path(prob_model_name + "_InfoCrit")) Rhat = stan_service.get_Rhat(summary) # Interface backwards with INS stan models # estimates, samples, Rhat, model_data = \ # convert_params_names_from_ins([estimates, samples, Rhat, model_data]) if fitmethod.find("opt") < 0: stats = {"Rhat": Rhat} else: stats = None # -------------------------- Plot fitting results: ------------------------------------------------------------ # if stan_service.fitmethod.find("opt") < 0: plotter.plot_fit_results( estimates, samples, model_data, target_data, probabilistic_model, info_crit, stats=stats, pair_plot_params=["tau1", "sigma", "epsilon", "scale", "offset"], # "K", region_violin_params=["x0", "x1_init", "z_init"], regions_labels=head.connectivity.region_labels, skip_samples=skip_samples, title_prefix=hyp.name + "-" + prob_model_name) # -------------------------- Reconfigure model after fitting:--------------------------------------------------- for id_est, est in enumerate(ensure_list(estimates)): K = est.get("K", model_configuration.K) tau1 = est.get("tau1", model_configuration.tau1) tau0 = est.get("tau0", model_configuration.tau0) fit_model_configuration_builder = \ ModelConfigurationBuilder(hyp.number_of_regions, K=K * hyp.number_of_regions, tau1=tau1, tau0=tau0) x0_values_fit = model_configuration.x0_values x0_values_fit[probabilistic_model.active_regions] = \ fit_model_configuration_builder._compute_x0_values_from_x0_model(est['x0']) hyp_fit = HypothesisBuilder().set_nr_of_regions(head.connectivity.number_of_regions).\ set_name('fit' + str(id_est+1) + "_" + hyp.name).\ set_x0_hypothesis(list(probabilistic_model.active_regions), x0_values_fit[probabilistic_model.active_regions]).\ build_hypothesis() base_path = os.path.join(config.out.FOLDER_RES, hyp_fit.name) writer.write_hypothesis(hyp_fit, path("")) model_configuration_fit = \ fit_model_configuration_builder.build_model_from_hypothesis(hyp_fit, # est["MC"] model_configuration.model_connectivity) writer.write_model_configuration(model_configuration_fit, path("ModelConfig")) # Plot nullclines and equilibria of model configuration plotter.plot_state_space( model_configuration_fit, region_labels=head.connectivity.region_labels, special_idx=probabilistic_model.active_regions, model="6d", zmode="lin", figure_name=hyp_fit.name + "_Nullclines and equilibria") logger.info("Done!")
if user_home == "/home/denis": output = os.path.join(user_home, 'Dropbox', 'Work', 'VBtech', 'VEP', "results", "INScluster") config = Config(head_folder=head_folder, output_base=output, separate_by_run=False) elif user_home == "/Users/lia.domide": config = Config(head_folder="/WORK/episense/tvb-epilepsy/data/TVB3/Head", raw_data_folder="/WORK/episense/tvb-epilepsy/data/TVB3/ts_seizure") else: output = os.path.join(user_home, 'Dropbox', 'Work', 'VBtech', 'VEP', "results", "fit") config = Config(head_folder=head_folder, output_base=output, separate_by_run=False) # Read head reader = H5Reader() head = reader.read_head(config.input.HEAD) hyp_builder = HypothesisBuilder(head.connectivity.number_of_regions, config).set_normalize(0.99) e_indices = [1, 26] # [1, 2, 25, 26] hypothesis = hyp_builder.build_hypothesis_from_file("clinical_hypothesis_postseeg", e_indices) model_configuration = \ ModelConfigurationBuilder(head.connectivity.number_of_regions).\ build_model_from_E_hypothesis(hypothesis, head.connectivity.normalized_weights) statistical_model = SDEProbabilisticModelBuilder(model_config=model_configuration).generate_model() H5Writer().write_probabilistic_model(statistical_model, config.out.FOLDER_RES, "TestStatsModelorig.h5") statistical_model2 = reader.read_probabilistic_model(os.path.join(config.out.FOLDER_RES, "TestStatsModelorig.h5")) H5Writer().write_probabilistic_model(statistical_model2, config.out.FOLDER_RES, "TestStatsModelread.h5")
def main_vep(config=Config(), ep_name=EP_NAME, K_unscaled=K_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=1000, 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() logger.info("Reading from: " + config.input.HEAD) head = reader.read_head(config.input.HEAD) plotter = Plotter(config) 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(hyp.number_of_regions, K=K_unscaled, tau1=TAU1_DEF, 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 services 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, head.connectivity.normalized_weights) # Fix healthy regions to default x0s: model_configuration = \ model_config_builder.build_model_from_hypothesis(hyp, head.connectivity.normalized_weights) 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, "6d", head.connectivity.region_labels, special_idx=hyp.regions_disease_indices, zmode="lin", 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, head.connectivity.normalized_weights, 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 sensitivity analysis 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, head.connectivity.normalized_weights, 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) integrator = "HeunStochastic" for sim_type in sim_types: # ------------------------------Simulation-------------------------------------- logger.info( "\n\nConfiguring simulation from model_configuration...") sim_builder = SimulatorBuilder(config.simulator.MODE) if isequal_string(sim_type, "realistic"): model.tau0 = 60000.0 model.tau1 = 0.2 model.slope = 0.25 model.Iext2 = 0.45 model.pmode = np.array( "z") # np.array("None") to opt out for feedback sim_settings = \ sim_builder.set_fs(2048.0).set_fs_monitor(1024.0).set_simulated_period(60000).build_sim_settings() sim_settings.noise_type = COLORED_NOISE sim_settings.noise_ntau = 20 integrator = "Dop853Stochastic" elif isequal_string(sim_type, "fitting"): sim_settings = sim_builder.set_model_name("EpileptorDP2D").set_fs(2048.0).set_fs_monitor(2048.0).\ set_simulated_period(2000).build_sim_settings() sim_settings.noise_intensity = 1e-5 model = sim_builder.generate_model_tvb(model_configuration) model.tau0 = 300.0 model.tau1 = 0.5 elif isequal_string(sim_type, "reduced"): sim_settings = sim_builder.set_model_name("EpileptorDP2D").set_fs(4096.0). \ set_simulated_period(1000).build_sim_settings() model = sim_builder.generate_model_tvb(model_configuration) elif isequal_string(sim_type, "paper"): sim_builder.set_model_name("Epileptor") sim_settings = sim_builder.build_sim_settings() model = sim_builder.generate_model_tvb(model_configuration) else: sim_settings = sim_builder.build_sim_settings() model = sim_builder.generate_model_tvb(model_configuration) sim, sim_settings, model = \ sim_builder.build_simulator_TVB_from_model_sim_settings(model_configuration,head.connectivity, model, sim_settings, integrator=integrator) # Integrator and initial conditions initialization. # By default initial condition is set right on the equilibrium point. writer.write_simulator_model( sim.model, sim.connectivity.number_of_regions, os.path.join(config.out.FOLDER_RES, lsa_hypothesis.name + "_sim_model.h5")) logger.info("\n\nSimulating...") sim_output, status = sim.launch_simulation( report_every_n_monitor_steps=100) sim_path = os.path.join( config.out.FOLDER_RES, lsa_hypothesis.name + "_sim_settings.h5") writer.write_simulation_settings(sim.simulation_settings, sim_path) 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.simulation_settings, reader.read_simulation_settings(sim_path), logger=logger))) if not status: logger.warning("\nSimulation failed!") else: time = np.array(sim_output.time_line).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, model._ui_name + "_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_list=seeg, spectral_raster_plot=False, title_prefix=hyp.name, spectral_options={"log_scale": True})
def main_vep(config=Config(), sim_type="default", test_write_read=False, pse_flag=PSE_FLAG, sa_pse_flag=SA_PSE_FLAG, sim_flag=SIM_FLAG): logger = initialize_logger(__name__, config.out.FOLDER_LOGS) # -------------------------------Reading data----------------------------------- reader = TVBReader() if config.input.IS_TVB_MODE else H5Reader() writer = H5Writer() logger.info("Reading from: " + config.input.HEAD) head = reader.read_head(config.input.HEAD) plotter = Plotter(config) plotter.plot_head(head) if test_write_read: writer.write_head(head, os.path.join(config.out.FOLDER_RES, "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_values = x0_values + e_values # disease_indices = x0_indices + e_indices # ...or reading a custom file: hypo_builder = HypothesisBuilder(head.connectivity.number_of_regions, config=config).set_normalize(0.95) # This is an example of Epileptogenicity Hypothesis: you give as ep all indices for values > 0 hyp_E = hypo_builder.build_hypothesis_from_file(EP_NAME, e_indices=[1, 3, 16, 25]) # print(hyp_E.string_regions_disease(head.connectivity.region_labels)) # This is an example of Excitability Hypothesis: hyp_x0 = hypo_builder.build_hypothesis_from_file(EP_NAME) # # This is an example of Mixed Hypothesis set manually by the user: # 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() # This is an example of x0_values mixed Excitability and Epileptogenicity Hypothesis set from file: all_regions_indices = np.array(range(head.number_of_regions)) healthy_indices = np.delete(all_regions_indices, hyp_E.x0_indices + hyp_E.e_indices).tolist() hyp_x0_E = hypo_builder.build_hypothesis_from_file(EP_NAME, e_indices=[16, 25]) hypotheses = (hyp_x0_E, hyp_x0, hyp_E) # --------------------------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, # -multiplicative 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_builder = SimulatorBuilder(config.simulator.MODE) if isequal_string(sim_type, "realistic"): sim_settings = sim_builder.set_model_name("EpileptorDPrealistic").set_simulated_period(50000).build_sim_settings() sim_settings.noise_type = COLORED_NOISE sim_settings.noise_ntau = 10 elif isequal_string(sim_type, "fitting"): sim_settings = sim_builder.set_model_name("EpileptorDP2D").build_sim_settings() sim_settings.noise_intensity = 1e-3 elif isequal_string(sim_type, "paper"): sim_builder.set_model_name("Epileptor") sim_settings = sim_builder.build_sim_settings() else: sim_settings = sim_builder.build_sim_settings() # --------------------------Hypothesis and LSA----------------------------------- for hyp in hypotheses: logger.info("\n\nRunning hypothesis: " + hyp.name) logger.info("\n\nCreating model configuration...") builder = ModelConfigurationBuilder(hyp.number_of_regions) mcs_file = os.path.join(config.out.FOLDER_RES, hyp.name + "_model_config_service.h5") writer.write_model_configuration_builder(builder, mcs_file) if test_write_read: logger.info("Written and read model configuration services are identical?: " + str(assert_equal_objects(builder, reader.read_model_configuration_builder(mcs_file), logger=logger))) if hyp.type == "Epileptogenicity": model_configuration = builder.build_model_from_E_hypothesis(hyp, head.connectivity.normalized_weights) else: model_configuration = builder.build_model_from_hypothesis(hyp, head.connectivity.normalized_weights) 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, "6d", head.connectivity.region_labels, special_idx=hyp_x0.x0_indices + hyp_E.e_indices, zmode="lin", figure_name=hyp.name + "_StateSpace") 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_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) 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, param_range=0.1, global_coupling=[{"indices": all_regions_indices}], healthy_regions_parameters=[ {"name": "x0_values", "indices": healthy_indices}], model_configuration_builder=builder, lsa_service=lsa_service, 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 sensitivity analysis 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(lsa_hypothesis, head.connectivity.normalized_weights, head.connectivity.region_labels, n_samples, method="sobol", param_range=0.1, global_coupling=[{"indices": all_regions_indices, "bounds": [0.0, 2 * builder.K_unscaled[ 0]]}], healthy_regions_parameters=[ {"name": "x0_values", "indices": healthy_indices}], model_configuration_builder=builder, lsa_service=lsa_service, 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-------------------------------------- logger.info("\n\nConfiguring simulation from model_configuration...") model = sim_builder.generate_model(model_configuration) if isequal_string(sim_type, "realistic"): model.tau0 = 30000.0 model.tau1 = 0.2 model.slope = 0.25 elif isequal_string(sim_type, "fitting"): model.tau0 = 10.0 model.tau1 = 0.5 sim, sim_settings, model = sim_builder.build_simulator_TVB_from_model_sim_settings(model_configuration, head.connectivity, model, sim_settings) # Integrator and initial conditions initialization. # By default initial condition is set right on the equilibrium point. writer.write_generic(sim.model, config.out.FOLDER_RES, lsa_hypothesis.name + "_sim_model.h5") logger.info("\n\nSimulating...") ttavg, tavg_data, status = sim.launch_simulation(report_every_n_monitor_steps=100) sim_path = os.path.join(config.out.FOLDER_RES, lsa_hypothesis.name + "_sim_settings.h5") writer.write_simulation_settings(sim.simulation_settings, sim_path) 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.simulation_settings, reader.read_simulation_settings(sim_path), logger=logger))) if not status: logger.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: res_ts = prepare_vois_ts_dict(sim_settings.monitor_expressions, tavg_data) res_ts['time'] = time res_ts['time_units'] = 'msec' res_ts = compute_seeg_and_write_ts_h5_file(config.out.FOLDER_RES, lsa_hypothesis.name + "_ts.h5", sim.model, res_ts, output_sampling_time, sim_settings.simulated_period, hpf_flag=True, hpf_low=10.0, hpf_high=512.0, sensors_list=head.sensorsSEEG) # Plot results if model._ui_name is "EpileptorDP2D": spectral_raster_plot = False trajectories_plot = True else: spectral_raster_plot = "lfp" trajectories_plot = False #TODO: plotting fails when spectral_raster_plot="lfp". Denis will fix this plotter.plot_sim_results(sim.model, lsa_hypothesis.lsa_propagation_indices, res_ts, head.sensorsSEEG, hpf_flag=True, trajectories_plot=trajectories_plot, spectral_raster_plot=False, log_scale=True)
def main_cc_vep(config, head_folder, ep_name="clinical_hypothesis", x0_indices=[], pse_flag=False, sim_flag=True): if not (os.path.isdir(config.out.FOLDER_RES)): os.mkdir(config.out.FOLDER_RES) logger = initialize_logger(__name__, config.out.FOLDER_LOGS) # -------------------------------Reading data----------------------------------- reader = TVBReader() if config.input.IS_TVB_MODE else H5Reader() writer = H5Writer() logger.info("Reading from: %s", head_folder) head = reader.read_head(head_folder) plotter = Plotter(config) plotter.plot_head(head) # --------------------------Hypothesis definition----------------------------------- hypo_builder = HypothesisBuilder(head.connectivity.number_of_regions) all_regions_indices = np.array(range(head.number_of_regions)) # This is an example of Epileptogenicity Hypothesis: hyp_E = hypo_builder.build_hypothesis_from_file(ep_name, x0_indices) # This is an example of Excitability Hypothesis: hyp_x0 = hypo_builder.build_hypothesis_from_file(ep_name) disease_indices = hyp_E.e_indices + hyp_x0.x0_indices healthy_indices = np.delete(all_regions_indices, disease_indices).tolist() if len(x0_indices) > 0: # This is an example of x0_values mixed Excitability and Epileptogenicity Hypothesis: disease_values = reader.read_epileptogenicity(head_folder, name=ep_name) disease_values = disease_values.tolist() x0_values = [] for ix0 in x0_indices: ind = disease_indices.index(ix0) del disease_indices[ind] x0_values.append(disease_values.pop(ind)) e_indices = disease_indices e_values = np.array(disease_values) x0_values = np.array(x0_values) hyp_x0_E = hypo_builder.set_x0_hypothesis( x0_indices, x0_values).set_e_hypothesis(e_indices, e_values).build_hypothesis() hypotheses = (hyp_E, hyp_x0, hyp_x0_E) else: hypotheses = ( hyp_E, hyp_x0, ) # --------------------------Hypothesis and LSA----------------------------------- for hyp in hypotheses: logger.info("Running hypothesis: %s", hyp.name) logger.info("Creating model configuration...") builder = ModelConfigurationBuilder(hyp.number_of_regions) writer.write_model_configuration_builder( builder, os.path.join(config.out.FOLDER_RES, "model_config_service.h5")) if hyp.type == "Epileptogenicity": model_configuration = builder.build_model_from_E_hypothesis( hyp, head.connectivity.normalized_weights) else: model_configuration = builder.build_model_from_hypothesis( hyp, head.connectivity.normalized_weights) writer.write_model_configuration( model_configuration, os.path.join(config.out.FOLDER_RES, "ModelConfiguration.h5")) # Plot nullclines and equilibria of model configuration plotter.plot_state_space(model_configuration, region_labels=head.connectivity.region_labels, special_idx=disease_indices, model="2d", zmode="lin", figure_name=hyp.name + "_StateSpace") logger.info("Running LSA...") lsa_service = LSAService(eigen_vectors_number=None, weighted_eigenvector_sum=True) lsa_hypothesis = lsa_service.run_lsa(hyp, model_configuration) writer.write_hypothesis( lsa_hypothesis, os.path.join(config.out.FOLDER_RES, lsa_hypothesis.name + ".h5")) writer.write_lsa_service( lsa_service, os.path.join(config.out.FOLDER_RES, "lsa_config_service.h5")) plotter.plot_lsa(lsa_hypothesis, model_configuration, lsa_service.weighted_eigenvector_sum, lsa_service.eigen_vectors_number, head.connectivity.region_labels, None) if pse_flag: n_samples = 100 # --------------Parameter Search Exploration (PSE)------------------------------- logger.info("Running PSE LSA...") pse_results = pse_from_lsa_hypothesis( lsa_hypothesis, 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 }], model_configuration_builder=builder, lsa_service=lsa_service, save_flag=True, folder_res=config.out.FOLDER_RES, filename="PSE_LSA", logger=logger)[0] plotter.plot_lsa(lsa_hypothesis, model_configuration, lsa_service.weighted_eigenvector_sum, lsa_service.eigen_vectors_number, head.connectivity.region_labels, pse_results, title="Hypothesis PSE LSA Overview") if sim_flag: config.out.subfolder = "simulations" for folder in (config.out.FOLDER_RES, config.out.FOLDER_FIGURES): if not (os.path.isdir(folder)): os.mkdir(folder) dynamical_models = ["EpileptorDP2D", "EpileptorDPrealistic"] for dynamical_model, sim_type in zip(dynamical_models, ["fitting", "realistic"]): ts_file = None # os.path.join(sim_folder_res, dynamical_model + "_ts.h5") vois_ts_dict = \ from_model_configuration_to_simulation(model_configuration, head, lsa_hypothesis, sim_type=sim_type, dynamical_model=dynamical_model, ts_file=ts_file, plot_flag=True, config=config)