def test_adapt_single_model(population_strategy: PopulationStrategy): n = 10 df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) population_strategy.adapt_population_size([kernel], np.array([1.])) assert population_strategy.nr_particles > 0
def priors_from_kde(df,w): prior_dict = {} for key in df.columns: kde = MultivariateNormalTransition(scaling=1) kde.fit(df[[key]], w) x = kde.rvs(1000) α,β,loc,scale = scst.beta.fit(x[key]) prior_dict.update({key: RV("beta", α,β,loc,scale)}) return(Distribution(**prior_dict))
def test_adapt_two_models(population_strategy: PopulationStrategy): n = 10 kernels = [] for _ in range(2): df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) population_strategy.adapt_population_size(kernels, np.array([.7, .2])) assert population_strategy.nr_particles > 0
def test_no_parameters(population_strategy: PopulationStrategy): n = 10 df = pd.DataFrame(index=list(range(n))) w = np.ones(n) / n kernels = [] for _ in range(2): kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) population_strategy.adapt_population_size(kernels, np.array([.7, .3])) assert population_strategy.nr_particles > 0
def test_no_parameters(population_strategy: PopulationStrategy): n = 10 df = pd.DataFrame(index=list(range(n))) w = np.ones(n) / n kernels = [] for _ in range(2): kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) population_strategy.update(kernels, np.array([0.7, 0.3]), t=0) assert population_strategy(t=0) > 0
def getABC_maxKDE(history, confidence=0.95): '''after pyABC.visualization.credible.plot_credible_intervals() ''' n_run = 1 levels = [confidence] df, w = history.get_distribution(0) par_names = list(df.columns.values) n_par = len(par_names) n_confidence = len(levels) # prepare matrices median = np.empty((n_par, n_run)) kde_max = np.empty((n_par, n_run)) kde_max_1d = np.empty((n_par, n_run)) kde = MultivariateNormalTransition() kde_1d = MultivariateNormalTransition() # fill matrices # normalize weights to be sure w /= w.sum() # fit kde _kde_max_pnt = pyabc.visualization.credible.compute_kde_max(kde, df, w) # iterate over parameters paramKDE = {} for i_par, par in enumerate(par_names): info = {'i': i_par} # as numpy array vals = np.array(df[par]) # median median[i_par] = pyabc.visualization.credible.compute_quantile( vals, w, 0.5) info['median'] = median[i_par] # kde max kde_max[i_par] = _kde_max_pnt[par] info['kde_max'] = median[i_par] _kde_max_1d_pnt = pyabc.visualization.credible.compute_kde_max( kde_1d, df[[par]], w) kde_max_1d[i_par] = _kde_max_1d_pnt[par] info['kde_max_1d'] = kde_max_1d[i_par] lb, ub = pyabc.visualization.credible.compute_credible_interval( vals, w, confidence) info['ci_lb'] = lb info['ci_ub'] = ub paramKDE[par] = info return paramKDE
def __init__(self, df, w, key, min, max): self.df = df self.w = w self.key = key self.kde = MultivariateNormalTransition(scaling=1) self.kde.fit(df[[key]], w) self.min = min self.max = max # Calucating truncated away cdf to compensate in pdf min_xs = np.linspace(self.min - 10., self.min, num=200) min_pdfs = [ self.kde.pdf(pd.DataFrame({self.key: [x]})) for x in min_xs ] min_cdf = np.sum(min_pdfs) * 10 / 200 max_xs = np.linspace(self.max, self.max + 10, num=200) max_pdfs = [ self.kde.pdf(pd.DataFrame({self.key: [x]})) for x in max_xs ] max_cdf = np.sum(max_pdfs) * 10 / 200 self.trunc_cdf = min_cdf + max_cdf
def test_transitions_not_modified(population_strategy: PopulationStrategy): n = 10 kernels = [] test_points = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) for _ in range(2): df = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) w = np.ones(n) / n kernel = MultivariateNormalTransition() kernel.fit(df, w) kernels.append(kernel) test_weights = [k.pdf(test_points) for k in kernels] population_strategy.adapt_population_size(kernels, np.array([.7, .2])) after_adaptation_weights = [k.pdf(test_points) for k in kernels] same = all([(k1 == k2).all() for k1, k2 in zip(test_weights, after_adaptation_weights)]) err_msg = ("Population strategy {}" " modified the transitions".format(population_strategy)) assert same, err_msg
class RVkde(RVBase): def __init__(self, df, w, key, min, max): self.df = df self.w = w self.key = key self.kde = MultivariateNormalTransition(scaling=1) self.kde.fit(df[[key]], w) self.min = min self.max = max # Calucating truncated away cdf to compensate in pdf min_xs = np.linspace(self.min - 10., self.min, num=200) min_pdfs = [ self.kde.pdf(pd.DataFrame({self.key: [x]})) for x in min_xs ] min_cdf = np.sum(min_pdfs) * 10 / 200 max_xs = np.linspace(self.max, self.max + 10, num=200) max_pdfs = [ self.kde.pdf(pd.DataFrame({self.key: [x]})) for x in max_xs ] max_cdf = np.sum(max_pdfs) * 10 / 200 self.trunc_cdf = min_cdf + max_cdf def rvs(self): x = self.kde.rvs() while x[0] < self.min or x[0] > self.max: x = self.kde.rvs() return (x[0]) def pdf(self, x): p = 0. if x > self.min and x < self.max: x = pd.DataFrame({self.key: [x]}) p = self.kde.pdf(x) return p / (1 - self.trunc_cdf) def copy(self): return copy.deepcopy(self) def pmf(self): return 0. def cdf(self, x): cdf = 0 if x > self.min: xs = np.linspace(self.min, x, num=100) pdfs = [self.pdf(x) for x in xs] cdf = np.sum(pdfs) * (x - self.min) / 100 return cdf
def test_one_with_one_without_parameters( population_strategy: PopulationStrategy): n = 10 kernels = [] df_without = pd.DataFrame(index=list(range(n))) w_without = np.ones(n) / n kernel_without = MultivariateNormalTransition() kernel_without.fit(df_without, w_without) kernels.append(kernel_without) df_with = pd.DataFrame([{"s": np.random.rand()} for _ in range(n)]) w_with = np.ones(n) / n kernel_with = MultivariateNormalTransition() kernel_with.fit(df_with, w_with) kernels.append(kernel_with) population_strategy.adapt_population_size(kernels, np.array([.7, .3])) assert population_strategy.nr_particles > 0
def __init__( self, models: Union[List[Model], Model, Callable], parameter_priors: Union[List[Distribution], Distribution, Callable], distance_function: Union[Distance, Callable] = None, population_size: Union[PopulationStrategy, int] = 100, summary_statistics: Callable[[model_output], dict] = identity, model_prior: RV = None, model_perturbation_kernel: ModelPerturbationKernel = None, transitions: Union[List[Transition], Transition] = None, eps: Epsilon = None, sampler: Sampler = None, acceptor: Acceptor = None, stop_if_only_single_model_alive: bool = False, max_nr_recorded_particles: int = np.inf): if not isinstance(models, list): models = [models] models = list(map(SimpleModel.assert_model, models)) self.models = models if not isinstance(parameter_priors, list): parameter_priors = [parameter_priors] self.parameter_priors = parameter_priors # sanity checks if len(self.models) != len(self.parameter_priors): raise AssertionError( "Number models and number parameter priors have to agree.") if distance_function is None: distance_function = PNormDistance() self.distance_function = to_distance(distance_function) self.summary_statistics = summary_statistics if model_prior is None: model_prior = RV("randint", 0, len(self.models)) self.model_prior = model_prior if model_perturbation_kernel is None: model_perturbation_kernel = ModelPerturbationKernel( len(self.models), probability_to_stay=.7) self.model_perturbation_kernel = model_perturbation_kernel if transitions is None: transitions = [MultivariateNormalTransition() for _ in self.models] if not isinstance(transitions, list): transitions = [transitions] self.transitions = transitions # type: List[Transition] if eps is None: eps = MedianEpsilon(median_multiplier=1) self.eps = eps if isinstance(population_size, int): population_size = ConstantPopulationSize( population_size) self.population_size = population_size if sampler is None: sampler = DefaultSampler() self.sampler = sampler if acceptor is None: acceptor = UniformAcceptor() self.acceptor = SimpleFunctionAcceptor.assert_acceptor(acceptor) self.stop_if_only_single_model_alive = stop_if_only_single_model_alive self.max_nr_recorded_particles = max_nr_recorded_particles # will be set later self.x_0 = None self.history = None self._initial_population = None self.minimum_epsilon = None self.max_nr_populations = None self.min_acceptance_rate = None self._sanity_check()
df, w = history.get_distribution(m=1) params = test_priors[1] priors[1].decorator_repr() pyabc.parameters.ParameterStructure pyabc.parameters.from_dictionary_of_dictionaries() #%% from pyabc.visualization import kde_1d from pyabc.transition import MultivariateNormalTransition import pyabc.random_variables as rv kde = MultivariateNormalTransition(scaling=1) kde.fit(df[["p"]], w) scst.beta.fit(kde.rvs(100), loc=0) x, pdf = kde_1d(df, w, "p") class PriorRV(rv.RVBase): def __init__ priors[1]["p"] sckde = scst.gaussian_kde(df["p"]) sckde.pdf(0.9)