struct RandomWalkUpdate{TRW,TA,K,TP} <: MCMCParamUpdate
    rw::TRW
    adpt::TA
    coords::K
    prior::TP
end

Definition of an MCMC update that uses Metropolis-Hastings algorithm with random walk proposals. rw is the random walk sampler, adpt is the struct responsible for adaptation of hyperparameters, coords lists the coordinate indeces of the global state that the given update operates on and prior is a prior for this update step (i.e. for a given subset of parameter vector).

function RandomWalkUpdate(
    rw::TRW,
    idx_of_global::K;
    prior::TP=ImproperPrior(),
    adpt::TA=NoAdaptation()
) where {TRW<:RandomWalk,K,TA,TP}

Base constructor.

mutable struct UniformRandomWalk{T,S} <: RandomWalk
    ϵ::T
    pos::S
end

A uniform random walker that moves all unrestricted coordinates according to the additive rule

and moves all coordinates restricted to be positive according to the rule

mutable struct AdaptationUnifRW{T} <: Adaptation
    proposed::Int64
    accepted::Int64
    target_accpt_rate::Float64
    adapt_every_k_steps::Int64
    scale::T
    min::T
    max::T
    offset::T
    N::Int64
end

A struct containing information about the way in which to adapt the steps of the uniform random walker. proposed and accepted are the internal counters that keep track of the number of proposed and accepted samples. target_accpt_rate is the acceptance rate of the Metropolis-Hastings steps that is supposed to be targetted. min is used to enforce the minimal allowable range that the random walker can sample from, max enforces the maximum. offset introduces some delay in the start of decelerting the adaptation extent and scale is a scaling parameter for adaptation speed. N is the number of coordinates of the random walker.

AdaptationUnifRW(θ::K; kwargs...) where K

Define an adaptation scheme for a random walker that does updates on the parameter of shape and type θ. The following named parameters can be specified

Arguments

• adapt_every_k_steps=100: number of steps based on which adaptation happens
• target_accpt_rate=0.234: acceptance rate of MH step that is to be targetted
• scale=1.0: scaling of the adaptation
• min=1e-12: minimum allowable (half)-range of the uniform sampler
• max=1e7: maximum allowable (half)-range of the unifor sampler
• offset=1e2: number of adaptation steps after which the shrinking of adaptive steps is supposed to start.

mutable struct GaussianRandomWalk{T} <: RandomWalk
    Σ::Symmetric{T,Array{T,2}}
    pos::Vector{Bool}
end

A Gaussian random walker that first transforms all coordinates restricted to be positive to a log-scale via

then moves according to

and finally, transforms the restricted coordinates back to the original scale via

Restrictions are specified in the vector pos (and no restrictions correspond to all entries in pos being false).

mutable struct HaarioTypeAdaptation{T,TF} <: Adaptation
    mean::Vector{T}
    cov::Matrix{T}
    adapt_every_k_steps::Int64
    scale::Float64
    N::Int64
    M::Int64
    fλ::TF
end

A struct containing information about the way in which to adapt the steps of the Gaussian random walker in a scheme:

and

with $Σ_A$ the covariance matrix that the adaptive scheme aims to learn. mean and cov are the empirical mean and covariance of the (appropriately log-transformed) local state vector. Every adapt_every_k_steps number of steps an adaptation is performed. scale is a scaling for going from the empirical covariance to the covariance of the Gaussian random walker. N is the total number of terms based on which the mean and cov were computed, M is the number of updates since the last call to adaptation and fλ is a function for determining the λ weight.

HaarioTypeAdaptation(
        state::Vector{T};
        adapt_every_k_steps=100,
        scale = 2.38^2,
        f::TF=((x,y,z)->x),
    ) where {T,TF}

Base constructor.

mutable struct GaussianRandomWalkMix{T} <: RandomWalk
    gsn_A::GaussianRandomWalk{T}
    gsn_B::GaussianRandomWalk{T}
    λ::Float64
end

A mixture of two Gaussian random walkers. It performs updates according to

where

(with $X_i$ being already appropriately log-transformed if needed).

log_transition_density(updt::MCMCParamUpdate, θ, θ°)

Evaluates the log-transition density for an update θ → θ°

proposal!(updt::MCMCParamUpdate, global_ws, ws::LocalWorkspace, step)

Sample a proposal value for the MCMC's local state variable.

set_parameters!(
    ::Proposal,
    updt::MCMCParamUpdate,
    global_ws::GlobalWorkspace,
    ws::LocalWorkspace,
)

Set the parameters of the proposal Law to the current value held by the proposal state.

set_parameters!(
    ::Previous,
    updt::MCMCParamUpdate,
    global_ws::GlobalWorkspace,
    ws::LocalWorkspace,
)

Set the parameters of the currently accepted Law to the current value held by the accepted state.

log_prior(updt::MCMCParamUpdate, θ)

Evaluate log-prior at θ.

coords(updt::MCMCParamUpdate)

Return a list of coordinates that updt is concerned with

subidx(θ, updt::MCMCParamUpdate)

Return a view of subset of θ that updt is concerned with

compute_gradients_and_momenta!(
    updt::MCMCParamUpdate, ws::LocalWorkspace, ::Any
)

To be overwritten for methods that are gradient or momentum based.