def calc_equilibrium_point(epileptor_model, model_configuration, weights): # Update zeq given the specific model, and assuming the model_configuration x1eq for the moment in the context of a 2d model: # It is assumed that the model.x0_values has been adjusted already at the phase of model creation if epileptor_model._ui_name == "EpileptorDP2D": x1eq = model_configuration.x1EQ zeq = model_configuration.zEQ equilibrium_point = numpy.c_[x1eq, zeq].T elif epileptor_model._ui_name == "EpileptorDP": #EpileptorDP equilibrium_point = calc_eq_6d(epileptor_model.x0, epileptor_model.K, weights, epileptor_model.yc, epileptor_model.Iext1, epileptor_model.Iext2, model_configuration.x1EQ, epileptor_model.a, epileptor_model.b, epileptor_model.d, epileptor_model.s, epileptor_model.gamma, zmode=epileptor_model.zmode) elif epileptor_model._ui_name == "EpileptorDPrealistic": equilibrium_point = calc_eq_11d(epileptor_model.x0, epileptor_model.K, weights, epileptor_model.yc, epileptor_model.Iext1, epileptor_model.Iext2, epileptor_model.slope, epileptor_model.fun_slope_Iext2, model_configuration.x1EQ, epileptor_model.a, epileptor_model.b, epileptor_model.d, epileptor_model.s, epileptor_model.gamma, zmode=epileptor_model.zmode, pmode=epileptor_model.pmode)[0] else: # all 6D models (tvb, java) equilibrium_point = calc_eq_6d(epileptor_model.x0, epileptor_model.Ks, weights, epileptor_model.c, epileptor_model.Iext, epileptor_model.Iext2, model_configuration.x1EQ, epileptor_model.a, epileptor_model.b, epileptor_model.d, epileptor_model.aa, gamma=GAMMA_DEF, zmode=numpy.array("lin")) if (epileptor_model._ui_name != "JavaEpileptor"): assert_equilibrium_point(epileptor_model, weights, equilibrium_point) else: #TODO: Implement dfun for the Java simulator raise_not_implemented_error("The dfun for Java simulator is not implemented yet!") return equilibrium_point
def get_epileptor_parameters(self, model_config): self.logger.info("Unpacking epileptor parameters...") epileptor_params = {} for p in ["a", "b", "d", "yc", "Iext1", "slope"]: temp = getattr(model_config, p) if isinstance(temp, (np.ndarray, list)): if np.all(temp[0], np.array(temp)): temp = temp[0] else: raise_not_implemented_error( "Statistical models where not all regions have the same value " + " for parameter " + p + " are not implemented yet!") epileptor_params.update({p: temp}) x0cr, rx0 = calc_x0cr_r(epileptor_params["yc"], epileptor_params["Iext1"], epileptor_params["a"], epileptor_params["b"], epileptor_params["d"], zmode=np.array("lin"), x1_rest=X1_DEF, x1_cr=X1_EQ_CR_DEF, x0def=X0_DEF, x0cr_def=X0_CR_DEF, test=False, shape=None, calc_mode="non_symbol") epileptor_params.update({"x0cr": x0cr, "rx0": rx0}) return epileptor_params
def read_vb_results(self, fit): est = {} samples = {} for ip, p in enumerate(fit['sampler_param_names']): p_split = p.split('.') p_name = p_split.pop(0) if est.get(p_name) is None: samples.update({p_name: []}) est.update({p_name: []}) if len(p_split) == 0: # scalar parameters samples[p_name] = fit["sampler_params"][ip] est[p_name] = fit["mean_pars"][ip] else: if len(p_split) == 1: # vector parameters samples[p_name].append(fit["sampler_params"][ip]) est[p_name].append(fit["mean_pars"][ip]) else: ii = int(p_split.pop(0)) - 1 if len(p_split) == 0: # 2D matrix parameters if len(est[p_name]) < ii + 1: samples[p_name].append([fit["sampler_params"][ip]]) est[p_name].append([fit["mean_pars"][ip]]) else: samples[p_name][ii].append( fit["sampler_params"][ip]) est[p_name][ii].append(fit["mean_pars"][ip]) else: if len(est[p_name]) < ii + 1: samples[p_name].append([]) est[p_name].append([]) jj = int(p_split.pop(0)) - 1 if len(p_split) == 0: # 3D matrix parameters if len(est[p_name][ii]) < jj + 1: samples[p_name][ii].append( [fit["sampler_params"][ip]]) est[p_name][ii].append([fit["mean_pars"][ip]]) else: if len(est[p_name][ii]) < jj + 1: samples[p_name][ii].append([]) est[p_name][ii].append([]) samples[p_name][ii][jj].append( fit["sampler_params"][ip]) est[p_name][ii][jj].append( fit["mean_pars"][ip]) else: raise_not_implemented_error( "Extracting of parameters of more than 3 dimensions is not " + "implemented yet for vb!", self.logger) for key in est.keys(): if isinstance(est[key], list): est[key] = np.squeeze(np.array(est[key])) if isinstance(samples[key], list): samples[key] = np.squeeze(np.array(samples[key])) return samples, est
def jacobian(self, state_variables, coupling, local_coupling=0.0, array=numpy.array, where=numpy.where, concat=numpy.concatenate): raise_not_implemented_error("Jacobian calculation of model " + self._ui_name + " is not implemented yet!")
def scipy_method(self, method, *args, **kwargs): if method in [ "rvs", "ppf", "isf", "stats", "moment", "median", "mean", "interval" ]: return self._scipy_method(method, self.loc, self.scale, *args, **kwargs) elif method in ["pdf", "logpdf", "cdf", "logcdf", "sf", "logsf"]: x, args, kwargs = get_x_arg_for_param_distrib( self, *args, **kwargs) return x, self._scipy_method(method, self.loc, self.scale, *args, **kwargs) else: raise_not_implemented_error("Scipy method " + method + " is not implemented for parameter " + self.name + "!")
def scipy_method(self, method, *args, **kwargs): if method in [ "rvs", "ppf", "isf", "stats", "moment", "median", "mean", "interval" ]: return self.max - self.star.scipy_method(method, *args, **kwargs) elif method in ["pdf", "logpdf", "cdf", "logcdf", "sf", "logsf"]: x, args, kwargs = get_x_arg_for_param_distrib( self, *args, **kwargs) args[0] = self.max - x pdf = self.star.scipy_method(method, *args, **kwargs)[1] return x, pdf else: raise_not_implemented_error( "Scipy method " + method + " is not implemented for transformed parameter " + self.name + "!")
def sample(self, parameter=(), loc=0.0, scale=1.0, **kwargs): if isinstance(parameter, Parameter): parameter_shape = parameter.p_shape low = parameter.low high = parameter.high loc = getattr(parameter, "loc", loc) scale = getattr(parameter, "scale", scale) else: low = np.array(kwargs.pop("low", -CalculusConfig.MAX_SINGLE_VALUE)) high = np.array(kwargs.pop("high", CalculusConfig.MAX_SINGLE_VALUE)) parameter_shape = kwargs.pop("shape", (1, )) scale = (high - low) * scale low = low + loc high = low + scale low, high = self.check_for_infinite_bounds(low.tolist(), high.tolist()) low, high, n_outputs, parameter_shape = self.check_size( low, high, parameter_shape) bounds = [list(b) for b in zip(low.tolist(), high.tolist())] self.adjust_shape(parameter_shape) self.sampler = importlib.import_module("SALib.sample." + self.sampler).sample size = self.n_samples problem = {'num_vars': n_outputs, 'bounds': bounds} if self.sampler is ff.sample: samples = (self.sampler(problem)).T else: other_params = {} if self.sampler is saltelli.sample: size = int(np.round(1.0 * size / (2 * n_outputs + 2))) elif self.sampler is fast_sampler.sample: other_params = {"M": kwargs.get("M", 4)} elif self.sampler is morris.sample: # I don't understand this method and its inputs. I don't think we will ever use it. raise_not_implemented_error() samples = self.sampler(problem, size, **other_params) # Adjust samples number: self.n_samples = samples.shape[0] self.shape = list(self.shape) self.shape[-1] = self.n_samples self.shape = tuple(self.shape) transpose_shape = tuple([self.n_samples] + list(self.shape)[0:-1]) return np.reshape(samples.T, transpose_shape).T
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!") for key in model_data.keys(): if key[:3] == "EPI": del model_data[key] return model_data
def run_pse_parallel(self): raise_not_implemented_error("PSE parallel not implemented!", self.logger)
def _numpy(self, loc=0.0, scale=1.0, size=(1, )): raise_not_implemented_error( "No implementation of bernoulli distribution in numpy.random module!" )