Reference

initialize!(model, parameters)

Initalizes the state of the model.

parameters(model)

Returns a named tuple.

logp(data, model, parameters)

Returns $\log P(data|model, parameters)$.

sample(rng, data, model, parameters; kw...)

Takes already generated data as input and returns a new data point. This function is called in the simulate function. Keyword arguments are passed through the simulate function.

PopulationModel(model; prior = DiagonalNormalPrior(), shared = ())

Wrap a model for estimating population parameters. Shared parameters should be given as a tuple of symbols.

maximize_logp(data, model, parameters = parameters(model);
              fixed = (;)
              coupled = [],
              lambda_l2 = 0.,
              hessian_ad = AutoForwardDiff(),
              gradient_ad = AutoForwardDiff(),
              evaluate_training = false,
              evaluate_test_data = nothing,
              evaluation_trigger = EventTrigger(),
              evaluation_options = (;),
              optimizer_options = (;),
              optimizer = default_optimizer(model, parameters; fixed, optimizer_options...),
              callbacks = [],
              verbosity = 1, print_interval = 3,
              return_g! = false,
              kw...
              )

Optimizer(; optimizer = OptimOptimizer(Optim.LBFGS()), finetuner = nothing, fallback = OptimisersOptimizer())

Default optimizer. finetuner can be another optimizer that is called after the first optimizer finished. The fallback optimizer is called, if the optimizer or finetuner fails.

Can also be constructed as

Optimizer(optimizer; finetuner = nothing, fallback = OptimisersOptimizer(), kw...)

where optimizer can be a symbol (to use NLopt), or an optimiser from Optim or Optimiser. See also NLoptOptimizer, OptimOptimizer, OptimisersOptimizer.

NLoptOptimizer(optimizer; options...)

The optimizer is a symbol (e.g. :LD_LBGFS) as specified here. For options, see NLopt options.

OptimOptimizer(optimizer; options...)

Optimizer can be anything from subtypes.(subtypes(Optim.AbstractOptimizer)). For options, see Optim Options.

OptimisersOptimizer(opt; maxeval = 10^5, maxtime = Inf, min_grad_norm = 1e-8, lower_bounds = -Inf, upper_bounds = Inf)

Optimizer opt can be anything from subtypes(Optimisers.AbstractRule). Optimization stops, when the L2-norm of the gradient falls below min_grad_norm or maxeval or maxtime is reached. See also Optimisers.

OptimizationOptimizer(optimizer, adtype, options)

Uses Optimization.jl. options are passed to Optimization.solve

Example

``` using LaplacianExpectationMaximization, Optimization, OptimizationOptimJL, ADTypes OptimizationOptimizer(LBFGS(), AutoForwardDiff(), (;))

LaplaceEM(model, Estep_optimizer = Optimizer(), derivative_threshold = 1e-3, iterations = 10, stopper = () -> false)

Implements the Expectation-Maximization (EM) method with Laplace approximation, as described e.g. in Huys et al. (2012).

simulate(
    model,
    parameters;
    n_steps,
    stop,
    init,
    tracked,
    rng,
    kw...
)

Returns a named tuple (; data, logp). stop(data, i) is a boolean function that depends on the sequence of simulated data and the iteration counter i. If tracked = true the state of the model is saved for every step in the simulation. Additional keyword arguments kw are passed to the sample function.

logp_tracked(data, model, parameters)

Returns a names tuple (; history, logp). In the history the state of the model is saved for every step.

mc_marginal_logp(data, model::PopulationModel, params;
                 repetitions = 20, n_samples = 10^4, rng = Random.default_rng())

Estimate the marginal log probability of the data given a model by sampling from the population.

BIC_int(data, model, params; kw...)

Estimate the Bayesian Information Criterion by sampling from the population. Keyword arguments kw are passed to mc_marginal_logp.

gradient_logp(data, model, parameters; ad = AutoEnzyme())

Compute the gradient of logp.

hessian_logp(data, model, parameters; ad = AutoForwardDiff())

Compute the hessian of logp.