def pdf_params(self, parametrization="lamda"): if isequal_string(parametrization, "scale"): return {"scale": 1.0 / self.lamda} elif isequal_string(parametrization, "rate"): return {"rate": self.rate} else: return {"lamda": self.lamda}
def pdf_params(self, parametrization="lamda"): if isequal_string(parametrization, "scipy"): return {"mu": self.mu} elif isequal_string(parametrization, "numpy"): return {"lam": self.mu} else: return {"lamda": self.lamda}
def prepare_constraints(distribution, target_stats, loc=0.0, scale=1.0, use="manual"): # Preparing constraints: constraints = [{ "type": "ineq", "fun": lambda p: fconstr(p, distribution, loc, scale, use) }] if isequal_string(distribution.type, "gamma") and np.any( np.in1d("mode", target_stats.keys())): constraints.append({ "type": "ineq", "fun": lambda p: fconstr_gamma_mode(p, distribution) }) elif isequal_string(distribution.type, "beta") and np.any( np.in1d(["mode", "median"], target_stats.keys())): constraints.append({ "type": "ineq", "fun": lambda p: fconstr_beta_mode_median(p, distribution) }) return constraints
def pdf_params(self, parametrization="mu-sigma"): p = OrderedDict() if isequal_string(parametrization, "scipy") or isequal_string( parametrization, "numpy"): p.update(zip(["shape", "scale"], [self.shape, np.exp(self.mu)])) return p else: p.update(zip(["mu", "sigma"], [self.mu, self.sigma])) return p
def pdf_params(self, parametrization="alpha-beta"): p = OrderedDict() if isequal_string(parametrization, "a-b") or \ isequal_string(parametrization, "scipy") or \ isequal_string(parametrization, "numpy"): p.update(zip(["a", "b"], [self.a, self.b])) return p else: p.update(zip(["alpha", "beta"], [self.alpha, self.beta])) return p
def pdf_params(self, parametrization="a-b"): p = OrderedDict() if isequal_string(parametrization, "scipy"): p.update(zip(["loc", "scale"], [self.a, self.b - self.a])) return p elif isequal_string(parametrization, "numpy"): p.update(zip(["low", "high"], [self.low, self.high])) return p else: p.update(zip(["a", "b"], [self.a, self.b])) return p
def read_dictionary_from_group(self, group, type=None): dictionary = dict() for dataset in group.keys(): dictionary.update({dataset: group[dataset][()]}) for attr in group.attrs.keys(): dictionary.update({attr: group.attrs[attr]}) if type is None: type = group.attrs[H5_SUBTYPE_ATTRIBUTE] if isequal_string(type, "DictDot"): return DictDot(dictionary) elif isequal_string(type, "OrderedDictDot"): return OrderedDictDot(dictionary) else: return dictionary
def plot_fit_results(self, ests, samples, model_data, target_data, probabilistic_model=None, info_crit=None, stats=None, pair_plot_params=["tau1", "sigma", "epsilon", "scale", "offset"], region_violin_params=["x0", "PZ", "x1eq", "zeq"], region_labels=[], regions_mode="active", seizure_indices=[], trajectories_plot=True, connectivity_plot=False, skip_samples=0, title_prefix=""): sigma = [] if probabilistic_model is not None: n_regions = probabilistic_model.number_of_regions region_labels = generate_region_labels(n_regions, region_labels, ". ", True) if probabilistic_model.parameters.get("sigma", None) is not None: sigma = ["sigma"] active_regions = ensure_list(probabilistic_model.active_regions) else: active_regions = ensure_list(model_data.get("active_regions", [])) if isequal_string(regions_mode, "all"): if len(seizure_indices) == 0: seizure_indices = active_regions else: if len(active_regions) > 0: seizure_indices = [active_regions.index(ind) for ind in seizure_indices] if len(region_labels) > 0: region_labels = region_labels[active_regions] if len(region_labels) == 0: self.print_regions_indices = True self.print_ts_indices = True figs = [] # Pack fit samples time series into timeseries objects: from tvb_fit.tvb_epilepsy.top.scripts.fitting_scripts import samples_to_timeseries samples, target_data, x1prior, x1eps = samples_to_timeseries(samples, model_data, target_data, region_labels) figs.append(self.plot_fit_timeseries(target_data, samples, ests, stats, probabilistic_model, "fit_target_data", ["x1", "z"], ["dWt", "dX1t", "dZt"], sigma, seizure_indices, skip_samples, trajectories_plot, region_labels, title_prefix)) figs.append( self.plot_fit_region_params(samples, stats, probabilistic_model, region_violin_params, seizure_indices, region_labels, regions_mode, False, skip_samples, title_prefix)) figs.append( self.plot_fit_region_params(samples, stats, probabilistic_model, region_violin_params, seizure_indices, region_labels, regions_mode, True, skip_samples, title_prefix)) figs.append(self.plot_fit_scalar_params(samples, stats, probabilistic_model, pair_plot_params, skip_samples, title_prefix)) figs.append(self.plot_fit_scalar_params_iters(samples, pair_plot_params, 0, title_prefix, subplot_shape=None)) if info_crit is not None: figs.append(self.plot_scalar_model_comparison(info_crit, title_prefix)) figs.append(self.plot_array_model_comparison(info_crit, title_prefix, labels=target_data.space_labels, xdata=target_data.time, xlabel="Time")) if connectivity_plot: figs.append(self.plot_fit_connectivity(ests, stats, probabilistic_model, "MC", region_labels, title_prefix)) return tuple(figs)
def pdf_params(self, parametrization="alpha-beta"): p = OrderedDict() if isequal_string(parametrization, "shape-scale"): p.update(zip(["shape", "scale"], [self.alpha, self.theta])) return p elif isequal_string(parametrization, "k-theta"): p.update(zip(["k", "theta"], [self.k, self.theta])) return p elif isequal_string(parametrization, "shape-rate"): p.update(zip(["shape", "rate"], [self.alpha, self.beta])) return p elif isequal_string(parametrization, "scipy"): p.update(zip(["a", "scale"], [self.alpha, self.theta])) return p else: p.update(zip(["alpha", "beta"], [self.alpha, self.beta])) return p
def eqtn_fx1(x1, z, y1, Iext1, slope, a, b, d, tau1, x1_neg=True, model="2d", x2=0.0): if isequal_string(str(model), '2d'): # Correspondence with EpileptorDP2D b = b - d return np.multiply(y1 - z + Iext1 + np.multiply(x1, np.where(x1_neg, if_ydot0(x1, a, b), else_ydot0_2d(x1, z, slope, d))), tau1) else: return np.multiply(y1 - z + Iext1 + np.multiply(x1, np.where(x1_neg, if_ydot0(x1, a, b), else_ydot0_6d(x2, z, slope))), tau1)
def write_model_data_to_file(self, model_data, reset_path=False, **kwargs): model_data_path = kwargs.get("model_data_path", self.model_data_path) if reset_path: self.model_data_path = model_data_path extension = model_data_path.split(".", -1)[-1] if isequal_string(extension, "npy"): np.save(model_data_path, model_data) elif isequal_string(extension, "mat"): savemat(model_data_path, model_data) elif isequal_string(extension, "pkl"): with open(model_data_path, 'wb') as f: pickle.dump(model_data, f) elif isequal_string(extension, "R"): rdump(model_data_path, model_data) else: H5Writer().write_dictionary( model_data, os.path.join(os.path.dirname(model_data_path), os.path.basename(model_data_path)))
def update_active_regions(self, probabilistic_model, e_values=[], x0_values=[], lsa_propagation_strengths=[], reset=False): if reset: probabilistic_model.update_active_regions([]) for m in ensure_list(self.active_regions_selection_methods): if isequal_string(m, "E"): probabilistic_model = self.update_active_regions_e_values( probabilistic_model, e_values, reset=False) elif isequal_string(m, "x0"): probabilistic_model = self.update_active_regions_x0_values( probabilistic_model, x0_values, reset=False) elif isequal_string(m, "LSA"): probabilistic_model = self.update_active_regions_lsa( probabilistic_model, lsa_propagation_strengths, reset=False) return probabilistic_model
def load_model_data_from_file(self, reset_path=False, **kwargs): model_data_path = kwargs.get("model_data_path", self.model_data_path) if reset_path: self.model_data_path = model_data_path extension = model_data_path.split(".", -1)[-1] if isequal_string(extension, "R"): model_data = rload(model_data_path) elif isequal_string(extension, "npy"): model_data = np.load(model_data_path).item() elif isequal_string(extension, "mat"): model_data = loadmat(model_data_path) elif isequal_string(extension, "pkl"): with open(model_data_path, 'wb') as f: model_data = pickle.load(f) elif isequal_string(extension, "h5"): model_data = H5Reader().read_dictionary(model_data_path) else: raise_not_implemented_error( "model_data file (" + model_data_path + ") that are not one of (.R, .npy, .mat, .pkl) cannot be read!") return model_data
def set_noise(self, sim_settings, **kwargs): # Check if the user provides a preconfigured noise instance to override noise = kwargs.get("noise", None) if isinstance(noise, Noise): self._check_noise_intesity_size(noise.nsig) sim_settings.noise_intensity = noise.nsig if noise.ntau == 0: sim_settings.noise_type = WHITE_NOISE else: sim_settings.noise_type = COLORED_NOISE sim_settings.noise_ntau = noise.ntau else: if isequal_string(sim_settings.noise_type, COLORED_NOISE): noise = self.generate_colored_noise( sim_settings.noise_intensity, sim_settings.noise_ntau, **kwargs) else: noise = self.generate_white_noise(sim_settings.noise_intensity) sim_settings.noise_ntau = noise.ntau return noise, sim_settings
def normalize_signals(signals, normalization=None): if isinstance(normalization, basestring): if isequal_string(normalization, "zscore"): signals = zscore(signals, axis=None) # / 3.0 elif isequal_string(normalization, "mean"): signals -= (signals.mean(axis=0) * np.ones(signals.shape[1:])) elif isequal_string(normalization, "baseline-maxstd"): signals -= np.percentile(np.percentile(signals, 1, axis=0), 1) signals /= np.max(np.std(signals, axis=0)) elif isequal_string(normalization, "minmax"): signals -= signals.min() signals /= signals.max() elif isequal_string(normalization, "min"): signals -= signals.min() elif isequal_string(normalization, "baseline"): signals -= np.percentile(np.percentile(signals, 1, axis=0), 1) elif isequal_string(normalization, "baseline-amplitude"): signals -= np.percentile(np.percentile(signals, 1, axis=0), 1) signals /= np.percentile(np.percentile(signals, 99, axis=0), 99) elif isequal_string(normalization, "baseline-std"): signals -= np.percentile(np.percentile(signals, 1, axis=0), 1) signals /= signals.std() elif normalization.find("baseline") == 0: signals -= np.percentile(np.percentile(signals, 1, axis=0), 1) try: amplitude = float(normalization.split("baseline-")[1]) signals /= np.percentile(np.percentile(signals, 99, axis=0), 99) signals *= amplitude except: pass else: raise_value_error( "Ignoring signals' normalization " + normalization + ",\nwhich is not one of the currently available " + str(NORMALIZATION_METHODS) + "!") return signals
def generate_cmdstan_options(method, **kwargs): options = OrderedDict() if isequal_string(method, "sample"): # for sample or sampling for option, value in STAN_SAMPLE_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) if isequal_string(options["algorithm"], "hmc"): for option, value in STAN_HMC_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) if isequal_string(options["engine"], "nuts"): options.update({ "max_depth": kwargs.pop("max_depth", STAN_NUTS_OPTIONS["max_depth"]) }) elif isequal_string(options["engine"], "static"): options.update({ "int_time": kwargs.pop("int_time", STAN_STATIC_OPTIONS["int_time"]) }) for option, value in STAN_SAMPLE_ADAPT_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) elif isequal_string(method, "variational"): # for variational or vb or advi for option, value in STAN_VARIATIONAL_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) for option, value in STAN_VARIATIONAL_ADAPT_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) elif isequal_string( method, "optimize"): # for optimization or optimizing or optimize for option, value in STAN_OPTIMIZE_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) if (options["algorithm"].find("bfgs") >= 0): for option, value in STAN_BFGS_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) elif isequal_string(method, "diagnose"): # for diagnose or diagnosing for option, value in STAN_DIAGNOSE_TEST_GRADIENT_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) for option, value in STAN_OUTPUT_OPTIONS.iteritems(): options.update({option: kwargs.pop(option, value)}) options.update({"init": kwargs.get("init", 2)}) options.update({"random_seed": kwargs.get("random_seed", 12345)}) options.update({"random_seed": kwargs.get("seed", options["random_seed"])}) options.update({"n_chains_or_runs": kwargs.get("n_chains_or_runs", 4)}) return options
def _calc_kurt(self, loc=0.0, scale=1.0, use="scipy"): if isequal_string(use, "scipy"): return self._scipy(loc, scale).stats(moments="k") else: return self.calc_kurt_manual(loc, scale)
def _calc_std(self, loc=0.0, scale=1.0, use="scipy"): if isequal_string(use, "scipy"): return self._scipy(loc, scale).std() else: return self.calc_std_manual(loc, scale)
def prepare_signal_observable(data, seizure_length=SEIZURE_LENGTH, on_off_set=[], rois=[], preprocessing=TARGET_DATA_PREPROCESSING, low_hpf=LOW_HPF, high_hpf=HIGH_HPF, low_lpf=LOW_LPF, high_lpf=HIGH_LPF, win_len_ratio=WIN_LEN_RATIO, plotter=None, title_prefix=""): title_prefix = title_prefix + str(np.where(len(title_prefix) > 0, "_", "")) + "fit_data_preproc" ts_service = TimeseriesService() # Select rois if any: n_rois = len(rois) if n_rois > 0: if data.number_of_labels > n_rois: logger.info("Selecting signals...") if isinstance(rois[0], basestring): data = data.get_subspace_by_labels(rois) else: data = data.get_subspace_by_index(rois) # First cut data close to the desired interval if len(on_off_set) == 0: on_off_set = [data.time_start, data.time_end] duration = on_off_set[1] - on_off_set[0] temp_on_off = [ np.maximum(data.time_start, on_off_set[0] - 2 * duration / win_len_ratio), np.minimum(data.time_end, on_off_set[1] + 2 * duration / win_len_ratio) ] data = data.get_time_window_by_units(temp_on_off[0], temp_on_off[1]) if plotter: plotter.plot_raster({"SelectedTimeInterval": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Selected time interval time series', offset=0.1, figure_name=title_prefix + '_SelectedRaster', labels=data.space_labels) plotter.plot_timeseries({"SelectedTimeInterval": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Selected time interval time series', figure_name=title_prefix + '_SelectedTS', labels=data.space_labels) for i_preproc, preproc in enumerate(preprocessing): stri_preproc = str(i_preproc + 1) # Now filter, if needed, before decimation introduces any artifacts if isequal_string(preproc, "hpf"): high_hpf = np.minimum(high_hpf, 256.0) logger.info("High-pass filtering signals...") data = ts_service.filter(data, low_hpf, high_hpf, "bandpass", order=3) if plotter: plotter.plot_raster({"High-pass filtering": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='High-pass filtered Time Series', offset=0.1, figure_name=title_prefix + '_%sHpfRaster' % stri_preproc, labels=data.space_labels) plotter.plot_timeseries({"High-pass filtering": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='High-pass filtered Time Series', figure_name=title_prefix + '_%sHpfTS' % stri_preproc, labels=data.space_labels) if isequal_string(preproc, "mean-center"): logger.info("Mean center data...") data = ts_service.normalize(data, "mean") if plotter: plotter.plot_raster({"Mean centered signals": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Mean centered Time Series', offset=0.1, figure_name=title_prefix + '_%sMeanCenteredRaster' % stri_preproc, labels=data.space_labels) plotter.plot_timeseries( {"Mean centered signals": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Mean centered Time Series', figure_name=title_prefix + '_%sMeanCenteredTS' % stri_preproc, labels=data.space_labels) if isequal_string(preproc, "spectrogram"): # or # ...get the signals' envelope via Hilbert transform temp_duration = temp_on_off[1] - temp_on_off[0] decim_ratio = np.maximum( 1, int( np.floor((1.0 * data.time_length / seizure_length) * (duration / temp_duration)))) data.data = np.array(data.data).astype("float64") data = ts_service.spectrogram_envelope(data, high_hpf, low_hpf, decim_ratio) data.data /= data.data.std() data.data = np.array(data.data).astype("float32") temp_on_off = [data.time_start, data.time_end] if plotter: plotter.plot_raster({"Spetrogram signals": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Spectrogram Time Series', offset=0.1, figure_name=title_prefix + '_%sSpectrogramRaster' % stri_preproc, labels=data.space_labels) plotter.plot_timeseries({"Spectrogram signals": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Spectrogram Time Series', figure_name=title_prefix + '_%sSpectrogramTS' % stri_preproc, labels=data.space_labels) plot_envelope = "" if preproc.lower().find( "envelope" ) >= 0: # isequal_string(preproc, "hilbert_envelope") or isequal_string(preproc, "abs_envelope"): plot_envelope = preproc if isequal_string(preproc, "hilbert_envelope"): # or # ...get the signals' envelope via Hilbert transform data = ts_service.hilbert_envelope(data) # or # elif isequal_string(preproc, "square"): # # Square data to get positive "power like" timeseries (introducing though higher frequencies) # data = ts_service.square(data) else: # isequal_string(preproc, "abs_envelope"): # "abs_envelope" data = ts_service.abs_envelope(data) if plotter: plot_envelop_ = plot_envelope.replace(" ", "_") plotter.plot_raster({plot_envelop_: data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title=plot_envelope, offset=0.1, figure_name=title_prefix + "_%s" % stri_preproc + plot_envelop_ + "Raster", labels=data.space_labels) plotter.plot_timeseries({plot_envelop_: data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title=plot_envelope, figure_name=title_prefix + "_%s" % stri_preproc + plot_envelop_ + "TS", labels=data.space_labels) if isequal_string(preproc, "log"): logger.info("Computing log of signals...") data = ts_service.log(data) if plotter: plotter.plot_raster({"LogTimeSeries": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Log of Time Series', offset=0.1, figure_name=title_prefix + '_%sLogRaster' % stri_preproc, labels=data.space_labels) plotter.plot_timeseries({"LogTimeSeries": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Log of Time Series', figure_name=title_prefix + '_%sLogTS' % stri_preproc, labels=data.space_labels) # Now convolve or low pass filter to smooth... if isequal_string(preproc, "convolve"): win_len = int(np.round(1.0 * data.time_length / win_len_ratio)) str_win_len = str(win_len) data = ts_service.convolve(data, win_len) logger.info("Convolving signals with a square window of " + str_win_len + " points...") if plotter: plotter.plot_raster( {"ConvolutionSmoothing": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], offset=0.1, title='Convolved Time Series with a window of ' + str_win_len + " points", figure_name=title_prefix + '_%s_%spointWinConvolRaster' % (stri_preproc, str_win_len), labels=data.space_labels) plotter.plot_timeseries( {"ConvolutionSmoothing": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Convolved Time Series with a window of ' + str_win_len + " points", figure_name=title_prefix + '_%s_%spointWinConvolTS' % (stri_preproc, str_win_len), labels=data.space_labels) elif isequal_string(preproc, "lpf"): high_lpf = np.minimum(high_lpf, 512.0) logger.info("Low-pass filtering signals...") data = ts_service.filter(data, low_lpf, high_lpf, "bandpass", order=3) if plotter: plotter.plot_raster({"Low-pass filtering": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Low-pass filtered Time Series', offset=0.1, figure_name=title_prefix + '_%sLpfRaster' % stri_preproc, labels=data.space_labels) if plotter: plotter.plot_timeseries( {"Low-pass filtering": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Low-pass filtered Time Series', figure_name=title_prefix + '_%sLpfTS' % stri_preproc, labels=data.space_labels) if "decimate" in preprocessing: # Now decimate to get close to seizure_length points temp_duration = temp_on_off[1] - temp_on_off[0] decim_ratio = np.maximum( 1, int( np.round((1.0 * data.time_length / seizure_length) * (duration / temp_duration)))) if decim_ratio > 1: str_decim_ratio = str(decim_ratio) logger.info("Decimating signals " + str_decim_ratio + " times...") data = ts_service.decimate(data, decim_ratio) if plotter: plotter.plot_raster( {str_decim_ratio + " wise Decimation": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title=str_decim_ratio + " wise Decimation", offset=0.1, figure_name=title_prefix + "_%s_%sxDecimRaster" % (stri_preproc, str_decim_ratio), labels=data.space_labels) plotter.plot_timeseries( {str_decim_ratio + " wise Decimation": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title=str_decim_ratio + " wise Decimation", figure_name=title_prefix + "_%s_%sxDecimTS" % (stri_preproc, str_decim_ratio), labels=data.space_labels) # # Cut to the desired interval data = data.get_time_window_by_units(on_off_set[0], on_off_set[1]) for preproc in preprocessing: if preproc in NORMALIZATION_METHODS: # Finally, normalize signals logger.info("Normalizing signals...") data = ts_service.normalize( data, preproc ) # "baseline", "baseline-std", "baseline-amplitude" or "zscore if plotter: plotter.plot_raster({"ObservationRaster": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], offset=0.1, title='Observation Raster Plot', figure_name=title_prefix + 'ObservationRaster', labels=data.space_labels) plotter.plot_timeseries({"Observation": data.squeezed}, data.time, time_units=data.time_unit, special_idx=[], title='Observation Time Series', figure_name=title_prefix + 'ObservationTS', labels=data.space_labels) return data
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 plot_timeseries(self, data_dict, time=None, mode="ts", subplots=None, special_idx=[], subtitles=[], labels=[], offset=0.5, time_units="ms", title='Time series', figure_name=None, figsize=FiguresConfig.LARGE_SIZE): n_vars = len(data_dict) vars = data_dict.keys() data = data_dict.values() data_lims = [] for id, d in enumerate(data): if isequal_string(mode, "raster"): data[id] = (d - d.mean(axis=0)) drange = numpy.max(data[id].max(axis=0) - data[id].min(axis=0)) data[id] = data[id] / drange # zscore(d, axis=None) data_lims.append([d.min(), d.max()]) data_shape = data[0].shape n_times, nTS = data_shape[:2] if len(data_shape) > 2: nSamples = data_shape[2] else: nSamples = 1 if special_idx is None: special_idx = [] n_special_idx = len(special_idx) if len(subtitles) == 0: subtitles = vars if isinstance(labels, list) and len(labels) == n_vars: labels = [ generate_region_labels(nTS, label, ". ", self.print_ts_indices) for label in labels ] else: labels = [ generate_region_labels(nTS, labels, ". ", self.print_ts_indices) for _ in range(n_vars) ] if isequal_string(mode, "traj"): data_fun, plot_lines, projection, n_rows, n_cols, def_alpha, loopfun, \ subtitle, subtitle_col, axlabels, axlimits = \ self._trajectories_plot(n_vars, nTS, nSamples, subplots) else: if isequal_string(mode, "raster"): data_fun, time, plot_lines, projection, n_rows, n_cols, def_alpha, loopfun, \ subtitle, subtitle_col, axlabels, axlimits, axYticks = \ self._timeseries_plot(time, n_vars, nTS, n_times, time_units, 0, offset, data_lims) else: data_fun, time, plot_lines, projection, n_rows, n_cols, def_alpha, loopfun, \ subtitle, subtitle_col, axlabels, axlimits, axYticks = \ self._timeseries_plot(time, n_vars, nTS, n_times, time_units, ensure_list(subplots)[0]) alpha_ratio = 1.0 / nSamples alphas = numpy.maximum( numpy.array([def_alpha] * nTS) * alpha_ratio, 0.1) alphas[special_idx] = numpy.maximum(alpha_ratio, 0.1) if isequal_string(mode, "traj") and (n_cols * n_rows > 1): colors = numpy.zeros((nTS, 4)) colors[special_idx] = \ numpy.array([numpy.array([1.0, 0, 0, 1.0]) for _ in range(n_special_idx)]).reshape((n_special_idx, 4)) else: cmap = matplotlib.cm.get_cmap('jet') colors = numpy.array([cmap(0.5 * iTS / nTS) for iTS in range(nTS)]) colors[special_idx] = \ numpy.array([cmap(1.0 - 0.25 * iTS / nTS) for iTS in range(n_special_idx)]).reshape((n_special_idx, 4)) colors[:, 3] = alphas lines = [] pyplot.figure(title, figsize=figsize) pyplot.hold(True) axes = [] for icol in range(n_cols): if n_rows == 1: # If there are no more rows, create axis, and set its limits, labels and possible subtitle axes += ensure_list( pyplot.subplot(n_rows, n_cols, icol + 1, projection=projection)) axlimits(data_lims, time, n_vars, icol) axlabels(labels[icol % n_vars], vars, n_vars, n_rows, 1, 0) pyplot.gca().set_title(subtitles[icol]) for iTS in loopfun(nTS, n_rows, icol): if n_rows > 1: # If there are more rows, create axes, and set their limits, labels and possible subtitles axes += ensure_list( pyplot.subplot(n_rows, n_cols, iTS + 1, projection=projection)) axlimits(data_lims, time, n_vars, icol) subtitle(labels[icol % n_vars], iTS) axlabels(labels[icol % n_vars], vars, n_vars, n_rows, (iTS % n_rows) + 1, iTS) lines += ensure_list( plot_lines(data_fun(data, time, icol), iTS, colors, labels[icol % n_vars])) if isequal_string( mode, "raster"): # set yticks as labels if this is a raster plot axYticks(labels[icol % n_vars], nTS) yticklabels = pyplot.gca().yaxis.get_ticklabels() self.tick_font_size = numpy.minimum( self.tick_font_size, int(numpy.round(self.tick_font_size * 100.0 / nTS))) for iTS in range(nTS): yticklabels[iTS].set_fontsize(self.tick_font_size) if iTS in special_idx: yticklabels[iTS].set_color(colors[iTS, :3].tolist() + [1]) pyplot.gca().yaxis.set_ticklabels(yticklabels) pyplot.gca().invert_yaxis() if self.config.figures.MOUSE_HOOVER: for line in lines: self.HighlightingDataCursor(line, formatter='{label}'.format, bbox=dict(fc='white'), arrowprops=dict( arrowstyle='simple', fc='white', alpha=0.5)) self._save_figure(pyplot.gcf(), figure_name) self._check_show() return pyplot.gcf(), axes, lines
def main_sampling_service(config=Config()): logger = initialize_logger(__name__, config.out.FOLDER_LOGS) n_samples = 100 logger.info("\nDeterministic numpy.linspace sampling:") sampler = DeterministicSampler(n_samples=n_samples, grid_mode=True) samples, stats = sampler.generate_samples(low=1.0, high=2.0, shape=(2, ), stats=True) for key, value in stats.items(): logger.info("\n" + key + ": " + str(value)) logger.info(sampler.__repr__()) logger.info("\nStochastic uniform sampling with numpy:") sampler = ProbabilisticSampler(n_samples=n_samples, sampling_module="numpy") # a (low), b (high) samples, stats = sampler.generate_samples( parameter=(1.0, 2.0), probability_distribution=ProbabilityDistributionTypes.UNIFORM, shape=(2, ), stats=True) for key, value in stats.items(): logger.info("\n" + key + ": " + str(value)) logger.info(sampler.__repr__()) logger.info("\nStochastic truncated normal sampling with scipy:") sampler = ProbabilisticSampler(n_samples=n_samples) # loc (mean), scale (sigma) samples, stats = sampler.generate_samples(parameter=(1.5, 1.0), probability_distribution="norm", low=1, high=2, shape=(2, ), stats=True) for key, value in stats.items(): logger.info("\n" + key + ": " + str(value)) logger.info(sampler.__repr__()) logger.info("\nSensitivity analysis sampling:") sampler = SalibSamplerInterface(n_samples=n_samples, sampler="latin") samples, stats = sampler.generate_samples(low=1, high=2, shape=(2, ), stats=True) for key, value in stats.items(): logger.info("\n" + key + ": " + str(value)) logger.info(sampler.__repr__()) logger.info("\nTesting distribution class and conversions...") sampler = ProbabilisticSampler(n_samples=n_samples) for distrib_name in ProbabilityDistributionTypes.available_distributions: logger.info("\n" + distrib_name) logger.info("\nmode/mean, std to distribution " + distrib_name + ":") if np.in1d(distrib_name, [ ProbabilityDistributionTypes.EXPONENTIAL, ProbabilityDistributionTypes.CHISQUARE ]): target_stats = {"mean": 1.0} stats_m = "mean" elif np.in1d(distrib_name, [ ProbabilityDistributionTypes.BERNOULLI, ProbabilityDistributionTypes.POISSON ]): target_stats = {"mean": np.ones((2, ))} stats_m = "mean" elif isequal_string(distrib_name, ProbabilityDistributionTypes.BINOMIAL): target_stats = {"mean": 1.0, "std": 2.0} stats_m = "mean" else: if isequal_string(distrib_name, ProbabilityDistributionTypes.UNIFORM): target_stats = {"mean": 1.0, "std": 2.0} stats_m = "mean" else: target_stats = {"mean": 1.0, "std": 2.0} stats_m = "mean" parameter1 = generate_probabilistic_parameter( name="test1_" + distrib_name, low=0.0, high=2.0, p_shape=(2, 2), probability_distribution=distrib_name, optimize_pdf=True, use="manual", **target_stats) name2 = "test2_" + distrib_name defaults = set_parameter_defaults(name2, _pdf=distrib_name, _shape=(2, 2), _lo=0.0, _hi=2.0, **(deepcopy(target_stats))) parameter2 = set_parameter(name=name2, use="manual", **defaults) for parameter in (parameter1, parameter2): logger.info(str(parameter)) samples = sampler.generate_samples(parameter=parameter, stats=True) for key, value in stats.items(): logger.info("\n" + key + ": " + str(value)) diff = target_stats[stats_m] - stats[stats_m] if np.any(np.abs(diff.flatten()) > 0.001): logger.warning( "Large difference between target and resulting samples' " + stats_m + "!: " + str(diff)) del parameter
def sample(self, parameter=(), loc=0.0, scale=1.0, **kwargs): nr.seed(self.random_seed) if isinstance(parameter, (ProbabilisticParameterBase, TransformedProbabilisticParameterBase)): parameter_shape = parameter.p_shape low = parameter.low high = parameter.high prob_distr = parameter loc = parameter.loc scale = parameter.scale else: parameter_shape = kwargs.pop("shape", (1, )) low = kwargs.pop("low", -CalculusConfig.MAX_SINGLE_VALUE) high = kwargs.pop("high", CalculusConfig.MAX_SINGLE_VALUE) prob_distr = kwargs.pop("probability_distribution", "uniform") low, high = self.check_for_infinite_bounds(low, high) low, high, n_outputs, parameter_shape = self.check_size( low, high, parameter_shape) self.adjust_shape(parameter_shape) out_shape = tuple([self.n_samples] + list(self.shape)[:-1]) if np.any(low > -CalculusConfig.MAX_SINGLE_VALUE) or np.any( high < CalculusConfig.MAX_SINGLE_VALUE): if not (isequal_string(self.sampling_module, "scipy")): self.logger.warning( "Switching to scipy for truncated distributions' sampling!" ) self.sampling_module = "scipy" if isinstance(prob_distr, basestring): self.sampler = getattr(ss, prob_distr)(*parameter, **kwargs) samples = self._truncated_distribution_sampling( { "low": low, "high": high }, out_shape) * scale + loc elif isinstance(prob_distr, (ProbabilisticParameterBase, TransformedProbabilisticParameterBase)): self.sampler = prob_distr.scipy() samples = self._truncated_distribution_sampling( { "low": low, "high": high }, out_shape) elif self.sampling_module.find("scipy") >= 0: if isinstance(prob_distr, basestring): self.sampler = getattr(ss, prob_distr)(*parameter, **kwargs) samples = self.sampler.rvs(size=out_shape) * scale + loc elif isinstance(prob_distr, ProbabilisticParameterBase): self.sampler = prob_distr._scipy(**kwargs) samples = self.sampler.rvs(size=out_shape) elif self.sampling_module.find("numpy") >= 0: if isinstance(prob_distr, basestring): self.sampler = lambda size: getattr(nr, prob_distr)( *parameter, size=size, **kwargs) samples = self.sampler(out_shape) * scale + loc elif isinstance(prob_distr, (ProbabilisticParameterBase, TransformedProbabilisticParameterBase)): self.sampler = lambda size: prob_distr.numpy(size=size) samples = self.sampler(out_shape) return samples.T
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 build_simulator(self, connectivity, **kwargs): if isequal_string(self.simulator, "java"): return self.build_simulator_java_from_model_configuration( connectivity, **kwargs) else: return self.build_simulator_TVB(connectivity, **kwargs)
def plot_state_space(self, model_config, region_labels=[], special_idx=[], figure_name="", approximations=False): if model_config.model_name == "Epileptor2D": model = "2d" else: model = "6d" add_name = " " + "Epileptor " + model + " z-" + str(numpy.where(model_config.zmode[0], "exp", "lin")) figure_name = figure_name + add_name region_labels = generate_region_labels(model_config.number_of_regions, region_labels, ". ") # n_region_labels = len(region_labels) # if n_region_labels == model_config.number_of_regions: # region_labels = numpy.array(["%d. %s" % l for l in zip(range(model_config.number_of_regions), region_labels)]) # else: # region_labels = numpy.array(["%d" % l for l in range(model_config.number_of_regions)]) # Fixed parameters for all regions: x1eq = model_config.x1eq zeq = model_config.zeq x0 = a = b = d = yc = slope = Iext1 = Iext2 = s = tau1 = tau0 = zmode = 0.0 for p in ["x0", "a", "b", "d", "yc", "slope", "Iext1", "Iext2", "s", "tau1", "tau0", "zmode"]: exec (p + " = numpy.mean(model_config." + p + ")") fig = pyplot.figure(figure_name, figsize=FiguresConfig.SMALL_SIZE) # Lines: x1 = numpy.linspace(-2.0, 1.0, 100) if isequal_string(model, "2d"): y1 = yc else: y1 = calc_eq_y1(x1, yc, d=d) # x1 nullcline: zX1 = calc_fx1(x1, z=0, y1=y1, Iext1=Iext1, slope=slope, a=a, b=b, d=d, tau1=1.0, x1_neg=True, model=model, x2=0.0) # yc + Iext1 - x1 ** 3 - 2.0 * x1 ** 2 x1null, = pyplot.plot(x1, zX1, 'b-', label='x1 nullcline', linewidth=1) ax = pyplot.gca() ax.axes.hold(True) # z nullcines # center point (critical equilibrium point) without approximation: # zsq0 = yc + Iext1 - x1sq0 ** 3 - 2.0 * x1sq0 ** 2 x0e = calc_x0_val_to_model_x0(X0_CR_DEF, yc, Iext1, a=a, b=b, d=d, zmode=model_config.zmode) x0ne = calc_x0_val_to_model_x0(X0_DEF, yc, Iext1, a=a, b=b, d=d, zmode=model_config.zmode) zZe = calc_fz(x1, z=0.0, x0=x0e, tau1=1.0, tau0=1.0, zmode=model_config.zmode) # for epileptogenic regions zZne = calc_fz(x1, z=0.0, x0=x0ne, tau1=1.0, tau0=1.0, zmode=model_config.zmode) # for non-epileptogenic regions zE1null, = pyplot.plot(x1, zZe, 'g-', label='z nullcline at critical point (e_values=1)', linewidth=1) zE2null, = pyplot.plot(x1, zZne, 'g--', label='z nullcline for e_values=0', linewidth=1) if approximations: # The point of the linear approximation (1st order Taylor expansion) x1LIN = def_x1lin(X1_DEF, X1EQ_CR_DEF, len(region_labels)) x1SQ = X1EQ_CR_DEF x1lin0 = numpy.mean(x1LIN) # The point of the square (parabolic) approximation (2nd order Taylor expansion) x1sq0 = numpy.mean(x1SQ) # approximations: # linear: x1lin = numpy.linspace(-5.5 / 3.0, -3.5 / 3, 30) # x1 nullcline after linear approximation: # yc + Iext1 + 2.0 * x1lin0 ** 3 + 2.0 * x1lin0 ** 2 - \ # (3.0 * x1lin0 ** 2 + 4.0 * x1lin0) * x1lin # x1 zX1lin = calc_fx1_2d_taylor(x1lin, x1lin0, z=0, y1=yc, Iext1=Iext1, slope=slope, a=a, b=b, d=d, tau1=1.0, x1_neg=None, order=2) # # center point without approximation: # zlin0 = yc + Iext1 - x1lin0 ** 3 - 2.0 * x1lin0 ** 2 # square: x1sq = numpy.linspace(-5.0 / 3, -1.0, 30) # x1 nullcline after parabolic approximation: # + 2.0 * x1sq ** 2 + 16.0 * x1sq / 3.0 + yc + Iext1 + 64.0 / 27.0 zX1sq = calc_fx1_2d_taylor(x1sq, x1sq0, z=0, y1=yc, Iext1=Iext1, slope=slope, a=a, b=b, d=d, tau1=1.0, x1_neg=None, order=3, shape=x1sq.shape) sq, = pyplot.plot(x1sq, zX1sq, 'm--', label='Parabolic local approximation', linewidth=2) lin, = pyplot.plot(x1lin, zX1lin, 'c--', label='Linear local approximation', linewidth=2) pyplot.legend(handles=[x1null, zE1null, zE2null, lin, sq]) else: pyplot.legend(handles=[x1null, zE1null, zE2null]) # Points: ii = range(len(region_labels)) n_special_idx = len(special_idx) if n_special_idx > 0: ii = numpy.delete(ii, special_idx) points = [] for i in ii: point = pyplot.text(x1eq[i], zeq[i], str(i), fontsize=10, color='k', alpha=0.3, label=str(i) + '.' + region_labels[i]) # point, = pyplot.plot(x1eq[i], zeq[i], '*', mfc='k', mec='k', # ms=10, alpha=0.3, label=str(i) + '.' + region_labels[i]) points.append(point) if n_special_idx > 0: for i in special_idx: point = pyplot.text(x1eq[i], zeq[i], str(i), fontsize=10, color='r', alpha=0.8, label=str(i) + '.' + region_labels[i]) # point, = pyplot.plot(x1eq[i], zeq[i], '*', mfc='r', mec='r', ms=10, alpha=0.8, # label=str(i) + '.' + region_labels[i]) points.append(point) # ax.plot(x1lin0, zlin0, '*', mfc='r', mec='r', ms=10) # ax.axes.text(x1lin0 - 0.1, zlin0 + 0.2, 'e_values=0.0', fontsize=10, color='r') # ax.plot(x1sq0, zsq0, '*', mfc='m', mec='m', ms=10) # ax.axes.text(x1sq0, zsq0 - 0.2, 'e_values=1.0', fontsize=10, color='m') # Vector field X1, Z = numpy.meshgrid(numpy.linspace(-2.0, 1.0, 41), numpy.linspace(0.0, 6.0, 31), indexing='ij') if isequal_string(model, "2d"): y1 = yc x2 = 0.0 else: y1 = calc_eq_y1(X1, yc, d=d) x2 = 0.0 # as a simplification for faster computation without important consequences # x2 = calc_eq_x2(Iext2, y2eq=None, zeq=X1, x1eq=Z, s=s)[0] fx1 = calc_fx1(X1, Z, y1=y1, Iext1=Iext1, slope=slope, a=a, b=b, d=d, tau1=tau1, x1_neg=None, model=model, x2=x2) fz = calc_fz(X1, Z, x0=x0, tau1=tau1, tau0=tau0, zmode=zmode) C = numpy.abs(fx1) + numpy.abs(fz) pyplot.quiver(X1, Z, fx1, fz, C, edgecolor='k', alpha=.5, linewidth=.5) pyplot.contour(X1, Z, fx1, 0, colors='b', linestyles="dashed") ax.set_title("Epileptor states pace at the x1-z phase plane of the" + add_name) ax.axes.autoscale(tight=True) ax.axes.set_ylim([0.0, 6.0]) ax.axes.set_xlabel('x1') ax.axes.set_ylabel('z') if self.config.figures.MOUSE_HOOVER: self.HighlightingDataCursor(points[0], formatter='{label}'.format, bbox=dict(fc='white'), arrowprops=dict(arrowstyle='simple', fc='white', alpha=0.5)) if len(fig.get_label()) == 0: fig.set_label(figure_name) else: figure_name = fig.get_label().replace(": ", "_").replace(" ", "_").replace("\t", "_") self._save_figure(None, figure_name) self._check_show() return fig
def generate_cmdstan_fit_command(fitmethod, options, model_path, model_data_path, output_filepath, diagnostic_filepath, command_path=None): command = model_path if isequal_string(fitmethod, "sample"): command += " method=sample" ' \\' + "\n" for option in STAN_SAMPLE_OPTIONS.keys(): command += "\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" if isequal_string(options["algorithm"], "hmc"): for option in STAN_HMC_OPTIONS.keys(): command += "\t\t\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" if isequal_string(options["engine"], "nuts"): command += "\t\t\t\t\t\tmax_depth=" + str( options["max_depth"]) + ' \\' + "\n" elif isequal_string(options["engine"], "static"): command += "\t\t\t\t\t\tint_time=" + str( options["int_time"]) + ' \\' + "\n" elif isequal_string(fitmethod, "variational"): command += " method=variational" ' \\' + "\n" for option in STAN_VARIATIONAL_OPTIONS.keys(): # due to sort_dict, we know that algorithm is the first option command += "\t\t\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" elif isequal_string(fitmethod, "optimize"): command += " method=optimize" ' \\' + "\n" for option in STAN_OPTIMIZE_OPTIONS.keys(): command += "\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" if (options["algorithm"].find("bfgs") >= 0): for option in STAN_BFGS_OPTIONS.keys(): command += "\t\t\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" # + " data file=" + model_data_path elif isequal_string(fitmethod, "diagnose"): command += " method=diagnose" ' \\' + "\n" + "\t\ttest=gradient " for option in STAN_DIAGNOSE_TEST_GRADIENT_OPTIONS.keys(): command += "\t\t\t\t" + +option + "=" + str( options[option]) + ' \\' + "\n" if isequal_string(fitmethod, "sample") or isequal_string( fitmethod, "variational"): command += "\t\tadapt" ' \\' + "\n" if isequal_string(fitmethod, "sample"): adapt_options = STAN_SAMPLE_ADAPT_OPTIONS else: adapt_options = STAN_VARIATIONAL_ADAPT_OPTIONS for option in adapt_options.keys(): if option.find("iter") < 0: command += "\t\t\t\t" + option + "=" + str( options[option]) + ' \\' + "\n" else: command += "\t\t\t\t" + "iter=" + str( options[option]) + ' \\' + "\n" command += "\t\tdata file=" + model_data_path + ' \\' + "\n" command += "\t\tinit=" + str(options["init"]) + ' \\' + "\n" command += "\t\trandom seed=" + str(options["random_seed"]) + ' \\' + "\n" if diagnostic_filepath == "": diagnostic_filepath = os.path.join( os.path.dirname(output_filepath), STAN_OUTPUT_OPTIONS["diagnostic_file"]) if options["n_chains_or_runs"] > 1: command = ("for i in {1.." + str(options["n_chains_or_runs"]) + "}\ndo\n" + "\t" + command + "\t\tid=$i" + ' \\' + "\n" + "\t\toutput file=" + output_filepath[:-4] + "$i.csv" ' \\' + "\n" + "\t\tdiagnostic_file=" + diagnostic_filepath[:-4] + "$i.csv" ' \\' + "\n" + "\t\trefresh=" + str(options["refresh"]) + " &" + "\n" + "done") else: command += "\t\toutput file=" + output_filepath + ' \\' + "\n" command += "\t\tdiagnostic_file=" + diagnostic_filepath + ' \\' + "\n" command += "\t\trefresh=" + str(options["refresh"]) command = "chmod +x " + model_path + "\n" + command command = ''.join(command) if isinstance(command_path, basestring): command_path = os.path.join(os.path.dirname(output_filepath), "command.sh") command_file = open(command_path, "w") command_file.write("#!/bin/bash\n" + command.replace("\t", "")) command_file.close() return command, output_filepath, diagnostic_filepath