The ParticleFilter Module

ParticleFilter.jl

This is the bones for a discrete-time particle filter that I built to infer the infection numbers based on wastewater surveillance data

Filter(T::Real,particles::Vector{Particle},Measurements::DataFrame,MeasurementModel::Function,DynamicModel::Function)

• T - Time
• particles - Vector of particles
• Measurements - DataFrame of measurements
• MeasurementModel - A function that takes a DataFrameRow and a particle and outputs a real number
• DynamicModel - An inplace function that mutates a particle

FilterHistory(T::Vector{Real},particles::Vector{Vector{Particle}})

Particle(weight::Float64,state::Vector{:<Real},pars::NamedTuple)

Particle(w::Float64,p::Particle)

Construct a particle using a new weight and an old particle

average_particle(p::Filter)

Determines the average particle from given particle filter

average_particle(p::Vector{Particle})

Find the average particle from a vector of particles

avg_pars(p::Filter)

Find the average of the parameters

avg_pars(p::Vector{Particle})

Compute the average parameters from a vector of particles

iterated_filtering(p::Filter,)

Implements an iterated particle filter, which varies the parameters along with the state variables to try to converge to parameters that give the maximum log likelihood.

Returns parameters

likelihood(H::FilterHistory)

Computes an estimate of the log likelihood of the filter.

max_weight(p::Filter)

Return the particle with the highest weight

multinomial_sampling!(p::Filter)

Resamples particles using a multinomial sampling procedure. If n is the number of particles, then this draws n samples from a multinomial distribution defined using the weights of the particles

normalize_weights(p::Filter)

Normalize the weights

percentile_sampling(particle_filter,measurement;q::Float64)

resamples the particles based on the current measurement. Particles with a weight in the lowest q-th percentile are dropped and replaced by particles with the highest percentile.

propogate_sample!(p::Filter,sample::Particle)

Uses the dynamic model to push particles forward one time step.

quant(particle_filter,q::Float64)

Determines the weight that separates the particles into two groups

reinitialize!(p::Filter)
Restarts the particle filter in the case that the filter
deviates too much from predictions.

run_filter!(p::Filter)

updates the filter so that T is equal to the number of rows in the measurements dataframe. Returns a FilterHistory

systematic_resampling!(p::Filter)

Applies the systematic resampling procedure described in the POMP documentation by Aaron King et al.

update!(p::Filter)

Move the particle filter forward one time-step. The particles are propogated using the dynamic model, and their weights updated using the measurement model. The particle weights are normalized so that they sum to 1, and then particles are resampled from a multinomial distribution.

update_history!(History::FilterHistory,p::Filter)

Adds the current state of the particle filter to the filter history.

update_likelihood!(p::filter,sample::particle)

Changes the weight of the particle to its likelihood according to the measurement model

varypars!(p::Filter,V::Vector{Distribution})

For the iterated filtering algorithm.