Particle filter

Description

A plain vanilla sequential Monte Carlo (particle filter) algorithm. Resampling is performed at each observation.

Usage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
## S4 method for signature 'pomp'
pfilter(object, params, Np, tol = 1e-17,
    max.fail = Inf, pred.mean = FALSE, pred.var = FALSE,
    filter.mean = FALSE, save.states = FALSE,
    save.params = FALSE, seed = NULL,
    verbose = getOption("verbose"), ...)
## S4 method for signature 'pfilterd.pomp'
pfilter(object, params, Np, tol, ...)
## S4 method for signature 'pfilterd.pomp'
logLik(object, ...)
## S4 method for signature 'pfilterd.pomp'
cond.logLik(object, ...)
## S4 method for signature 'pfilterd.pomp'
eff.sample.size(object, ...)
## S4 method for signature 'pfilterd.pomp'
pred.mean(object, pars, ...)
## S4 method for signature 'pfilterd.pomp'
pred.var(object, pars, ...)
## S4 method for signature 'pfilterd.pomp'
filter.mean(object, pars, ...)

Arguments

object

An object of class pomp or inheriting class pomp.

params

A npars x Np numeric matrix containing the parameters corresponding to the initial state values in xstart. This must have a ‘rownames’ attribute. If it desired that all particles should share the same parameter values, one one may supply params as a named numeric vector.

Np

the number of particles to use. This may be specified as a single positive integer, in which case the same number of particles will be used at each timestep. Alternatively, if one wishes the number of particles to vary across timesteps, one may specify Np either as a vector of positive integers of length

length(time(object,t0=TRUE))

or as a function taking a positive integer argument. In the latter case, Np(k) must be a single positive integer, representing the number of particles to be used at the k-th timestep: Np(0) is the number of particles to use going from timezero(object) to time(object)[1], Np(1), from timezero(object) to time(object)[1], and so on, while when T=length(time(object,t0=TRUE)), Np(T) is the number of particles to sample at the end of the time-series. When object is of class mif, this is by default the same number of particles used in the mif iterations.

tol

positive numeric scalar; particles with likelihood less than tol are considered to be “lost”. A filtering failure occurs when, at some time point, all particles are lost. When all particles are lost, the conditional likelihood at that time point is set to tol.

max.fail

integer; the maximum number of filtering failures allowed. If the number of filtering failures exceeds this number, execution will terminate with an error. By default, max.fail is set to infinity, so no error can be triggered.

pred.mean

logical; if TRUE, the prediction means are calculated for the state variables and parameters.

pred.var

logical; if TRUE, the prediction variances are calculated for the state variables and parameters.

filter.mean

logical; if TRUE, the filtering means are calculated for the state variables and parameters.

save.states, save.params

logical. If save.states=TRUE, the state-vector for each particle at each time is saved in the saved.states slot of the returned pfilterd.pomp object. If save.params=TRUE, the parameter-vector for each particle at each time is saved in the saved.params slot of the returned pfilterd.pomp object.

seed

optional; an object specifying if and how the random number generator should be initialized (‘seeded’). If seed is an integer, it is passed to set.seed prior to any simulation and is returned as the “seed” element of the return list. By default, the state of the random number generator is not changed and the value of .Random.seed on the call is stored in the “seed” element of the return list.

verbose

logical; if TRUE, progress information is reported as pfilter works.

pars

Names of parameters.

...

additional arguments that override the defaults.

Value

An object of class pfilterd.pomp. This class inherits from class pomp and contains the following additional slots:

pred.mean, pred.var, filter.mean

matrices of prediction means, variances, and filter means, respectively. In each of these, the rows correspond to states and parameters (if appropriate), in that order, the columns to successive observations in the time series contained in object.

eff.sample.size

numeric vector containing the effective number of particles at each time point.

cond.loglik

numeric vector containing the conditional log likelihoods at each time point.

saved.states

If pfilter was called with save.states=TRUE, this is the list of state-vectors at each time point, for each particle. It is a length-ntimes list of nvars-by-Np arrays. In particular, saved.states[[t]][,i] can be considered a sample from f[X_t|y_{1:t}].

saved.params

If pfilter was called with save.params=TRUE, this is the list of parameter-vectors at each time point, for each particle. It is a length-ntimes list of npars-by-Np arrays. In particular, saved.params[[t]][,i] is the parameter portion of the i-th particle at time t.

seed

the state of the random number generator at the time pfilter was called. If the argument seed was specified, this is a copy; if not, this is the internal state of the random number generator at the time of call.

Np, tol, nfail

the number of particles used, failure tolerance, and number of filtering failures, respectively.

loglik

the estimated log-likelihood.

These can be accessed using the $ operator as if the returned object were a list. Note that if the argument params is a named vector, then these parameters are included in the params slot of the returned pfilterd.pomp object.

Methods

logLik

Extracts the estimated log likelihood.

cond.logLik

Extracts the estimated conditional log likelihood

ell_t(theta)=Prob[y_t | y_1, …, y_(t-1)],

where y_t are the data, at time t.

eff.sample.size

Extracts the (time-dependent) estimated effective sample size, computed as

1/(sum(w_it^2)),

where w_it is the normalized weight of particle i at time t.

pred.mean, pred.var

Extract the mean and variance of the approximate prediction distribution. This prediction distribution is that of

X_t | y_1,…,y_(t-1),

where X_t, y_t are the state vector and data, respectively, at time t.

filter.mean

Extract the mean of the filtering distribution, which is that of

X_t | y_1,…,y_t,

where X_t, y_t are the state vector and data, respectively, at time t.

Author(s)

Aaron A. King kingaa at umich dot edu

References

M. S. Arulampalam, S. Maskell, N. Gordon, & T. Clapp. A Tutorial on Particle Filters for Online Nonlinear, Non-Gaussian Bayesian Tracking. IEEE Trans. Sig. Proc. 50:174–188, 2002.

See Also

pomp, mif, pmcmc, bsmc2, and the tutorials on the package website.

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
pompExample(gompertz)
pf <- pfilter(gompertz,Np=1000)	## use 1000 particles
plot(pf)
logLik(pf)
cond.logLik(pf)			## conditional log-likelihoods
eff.sample.size(pf)             ## effective sample size
logLik(pfilter(pf))      	## run it again with 1000 particles
## run it again with 2000 particles
pf <- pfilter(pf,Np=2000,filter.mean=TRUE)
fm <- filter.mean(pf)    	## extract the filtering means

Want to suggest features or report bugs for rdrr.io? Use the GitHub issue tracker.