def abc_setup(birthrate_groups):
"""
create abc model
parameters are stored in the global simtools.PARAMS dict
"""
for curve_resolution in simtools.PARAMS['abc_params']['resolution_limits']:
assert curve_resolution > 0 and curve_resolution <= 9
abc_priors = []
for resolution_limit in range(
simtools.PARAMS['abc_params']['resolution_limits'][0],
simtools.PARAMS['abc_params']['resolution_limits'][1] + 1):
abc_prior_dict = {}
for i in range(resolution_limit):
abc_prior_dict['r' + str(i)] = \
RV("uniform", simtools.PARAMS['abc_params']['rate_limits'][0],
abs(simtools.PARAMS['abc_params']['rate_limits'][1] - \
simtools.PARAMS['abc_params']['rate_limits'][0]))
abc_priors.append(
Distribution(birthrate=copy.deepcopy(abc_prior_dict)))
print('priors', abc_priors)
#abc = ABCSMC([abc_model for __ in abc_priors], abc_priors, abc_distance,
# population_size=AdaptivePopulationSize(
# int(simtools.PARAMS['abc_params']['starting_population_size']),
# 0.15,
# max_population_size=int(simtools.PARAMS['abc_params']['max_population_size']),
# min_population_size=int(simtools.PARAMS['abc_params']['min_population_size'])),
# sampler=MulticoreEvalParallelSampler(
# simtools.PARAMS['abc_params']['parallel_simulations']))
abc = ABCSMC(
[abc_model for __ in abc_priors],
abc_priors,
abc_distance,
population_size=ConstantPopulationSize(
int(simtools.PARAMS['abc_params']['starting_population_size'])),
sampler=MulticoreEvalParallelSampler(
simtools.PARAMS['abc_params']['parallel_simulations']))
return abc
def Constant():
return ConstantPopulationSize(100)
def Constant(nr_calibration_particles: int = None):
return ConstantPopulationSize(
100, nr_calibration_particles=nr_calibration_particles)
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()