Models and distributions¶

The proposal models, and the machinery that evaluates their densities. The conceptual version of this page is Amortized importance sampling.

JointModel¶

JointModel(robustness_model, trajectory_model)

The ARIS proposal: a joint distribution over inputs and robustness,

model = JointModel(Normal(), ConditionalEMGMM(2, 3, 3))

Sampling¶

rand(rng, jm)                      -> (x, r)      untruncated draw from the joint
rand(rng, jm, γ::Real)             -> (x, r)      r ~ truncated(q_ψ; upper = γ), then x ~ q_θ(·|r)
rand(rng, jm, γ::Vector)           -> xs          one draw per entry of γ; returns inputs only

The vector form is what train! uses: each sample gets its own r drawn from the truncated robustness model, then an input conditioned on it.

Density¶

logpdf(jm, x::AbstractVector, γ::Real)                  -> Real
logpdf(jm, xs::AbstractMatrix, γs::AbstractVector)      -> Vector

These evaluate the marginal input density q^γ_X, not the joint — that is what importance weights need. Both delegate to marginal_logpdf. When every entry of γs is equal, the batch form evaluates the integral once across all samples instead of per sample.

Fitting¶

Distributions.fit(jm, xs, rs, weights) -> JointModel

Fits the two factors separately and returns a new JointModel: the robustness model by weighted MLE of its own type, the conditional model by its own fit.

ConditionalEMGMM¶

ConditionalEMGMM(n_components, n_features, condition_idx; diag_covs = false)

The default conditional model. For an input dimension xdim:

ConditionalEMGMM(k, xdim + 1, xdim + 1)

It works by fitting a joint Gaussian mixture over [x; r] and conditioning it analytically on condition_idx. A Gaussian mixture conditioned on one coordinate is again a Gaussian mixture, so sampling and density evaluation of q_θ(· | r) are closed-form once the joint fit exists.

rand(rng, c_gmm, r::Real)        -> Vector          one input
rand(rng, c_gmm, r::Vector)      -> Matrix          one input per conditioning value
logpdf(c_gmm, X::Matrix, rs::Vector) -> Vector      log q_θ(x_i | r_i), column-wise
fit(c_gmm, X, rs, weights)       -> ConditionalEMGMM

EMGMM¶

EMGMM(n_components, n_features, diag_covs = false)

The unconditional mixture underneath ConditionalEMGMM, usable on its own.

rand(rng, gmm, n)             -> n draws
logpdf(gmm, X::AbstractMatrix)
fit(gmm, X, weights)          -> EMGMM

fit runs five EM restarts from a weighted k-means initialisation and keeps the best by log-likelihood. Components whose covariance determinant falls below 10⁻³ are inflated by 10⁻² I. If every restart fails it falls back to the k-means initialisation; if that also fails it returns the previous mixture unchanged, making the iteration a no-op rather than raising.

Fit diagnostics¶

Those fallbacks are counted, not printed:

reset_fit_stats!()          # before the run
train!(cv, sys)
get_fit_stats()             # a Dict{Symbol,Int}

ConditionalGaussian¶

ConditionalGaussian(d::Int)

A single-Gaussian conditional model: a joint Gaussian over [x; r], stored as its partitioned blocks and conditioned in closed form.

q(r)                                  -> MvNormal    the conditional at robustness r
rand(rng, q, r::Real)                 -> Vector
rand(rng, q, rs::Vector)              -> Matrix
logpdf(q, x::AbstractVector, r::Real) -> Real
fit(q, xs, rs, weights)               -> ConditionalGaussian

Cheap and stable, but unimodal. If the robustness values have standard deviation below 10⁻⁶ the fit degenerates gracefully to an unconditional Gaussian over the inputs. A ridge of 10⁻³ I is added to the conditional covariance.

GaussianMixture¶

GaussianMixture(n_components, d::Int)
GaussianMixture(n_components, data::Matrix; init_strategy = "random")

A standalone mixture type holding weights, means (one per column) and covs (d × d × n_components). Exported, and used by parts of the package that need an explicit mixture representation rather than a Distributions.MixtureModel.

TruncatedJointModel¶

TruncatedJointModel(trajectory_model)

An alternative joint model that, instead of carrying a parametric robustness distribution, retains the observed robustness values and weights and fits a truncated normal to those below the requested threshold at evaluation time.

rand(rng, jm, γ::Real)        -> x
logpdf(jm, x, γ::Real)        -> Real       per-sample adaptive quadrature over [−10, γ]
fit(jm, xs, rs, weights)      -> TruncatedJointModel

Marginal density evaluation¶

The canonical evaluator for

All estimator-side density calls route through it, so weights are numerically consistent.

marginal_pdf(jm, γ::Real, X::AbstractMatrix; method, rtol, lower, nodes) -> Vector{Float64}
marginal_pdf(jm, γ::Real, x::AbstractVector; kwargs...)                  -> Vector{Float64}
marginal_logpdf(jm, x::AbstractVector, γ::Real; kwargs...)               -> Real

Settings¶

Global Refs, so one setting governs every call site:

ARIS.MARGINAL_RTOL[] = 1e-4     # tighter weights, slower

Integration runs over [quantile(q_ψ|_≤γ, 10⁻¹²), γ] rather than literally to −∞, which keeps the (−∞, γ] normalisation while preventing adaptive quadrature from stepping over a sharp peak near γ.

Checking and recording¶

marginal_reference(jm, γ, X; rtol = 1e-10) -> Vector{Float64}
marginal_settings()                        -> Dict

marginal_reference is a high-accuracy per-sample integral for measuring the canonical evaluator's relative error — too slow for production. marginal_settings returns the active configuration for recording in run provenance.

conditional_logpdf_at¶

conditional_logpdf_at(traj, r::Real, X::AbstractMatrix) -> Vector

log q_θ(x | r) for every column of X at a single conditioning value, building the conditional distribution once. Model types add methods here; the fallback works for anything supporting logpdf(traj, X, rs).

Next¶

• Training and sampling: running a model against a system.
• Estimators and baselines: turning a buffer into a number.