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)
