pymc.smc.smc.SMC_KERNEL#

class pymc.smc.smc.SMC_KERNEL(draws=2000, start=None, model=None, random_seed=None, threshold=0.5)[source]#

Base class for the Sequential Monte Carlo kernels

To create a new SMC kernel you should subclass from this.

Before sampling, the following methods are called once in order:

initialize_population

Choose initial population of SMC particles. Should return a dictionary with {var.name : numpy array of size (draws, var.size)}. Defaults to sampling from the prior distribution. This method is only called if start is not specified.

_initialize_kernel: default

Creates initial population of particles in the variable self.tempered_posterior and populates the self.var_info dictionary with information about model variables shape and size as {var.name : (var.shape, var.size)

The functions self.prior_logp_func and self.likelihood_logp_func are created in this step. These expect a 1D numpy array with the summed sizes of each raveled model variable (in the order specified in model.inial_point).

Finally, this method computes the log prior and log likelihood for the initial particles, and saves them in self.prior_logp and self.likelihood_logp.

This method should not be modified.

setup_kernel: optional

May include any logic that should be performed before sampling starts.

During each sampling stage the following methods are called in order:

update_beta_and_weights: default

The inverse temperature self.beta is updated based on the self.likelihood_logp and threshold parameter

The importance self.weights of each particle are computed from the old and newly selected inverse temperature

The iteration number stored in self.iteration is updated by this method.

Finally the model log_marginal_likelihood of the tempered posterior is updated from these weights

resample: default

The particles in self.posterior are sampled with replacement based on self.weights, and the used resampling indexes are saved in self.resampling_indexes.

The arrays self.prior_logp, self.likelihood_logp are rearranged according to the order of the resampled particles. self.tempered_posterior_logp is computed from these and the current self.beta

tune: optional

May include logic that should be performed before every mutation step

mutate: REQUIRED

Mutate particles in self.tempered_posterior

This method is further responsible to update the self.prior_logp, self.likelihod_logp and self.tempered_posterior_logp, corresponding to each mutated particle

sample_stats: default

Returns important sampling_stats at the end of each stage in a dictionary format. This will be saved in the final InferenceData objcet under sample_stats.

Finally, at the end of sampling the following methods are called:

_posterior_to_trace: default

Convert final population of particles to a posterior trace object. This method should not be modified.

sample_settings: default:

Returns important sample_settings at the end of sampling in a dictionary format. This will be saved in the final InferenceData objcet under sample_stats.

Methods

SMC_KERNEL.__init__([draws, start, model, ...])

Parameters

SMC_KERNEL.initialize_population()

Create an initial population from the prior distribution

SMC_KERNEL.mutate()

Apply kernel-specific perturbation to the particles once per stage

SMC_KERNEL.resample()

Resample particles based on importance weights

SMC_KERNEL.sample_settings()

Kernel settings to be saved once at the end of sampling

SMC_KERNEL.sample_stats()

Stats to be saved at the end of each stage

SMC_KERNEL.setup_kernel()

Setup logic performed once before sampling starts

SMC_KERNEL.tune()

Tuning logic performed before every mutation step

SMC_KERNEL.update_beta_and_weights()

Calculate the next inverse temperature (beta)