GaussianSystem{T₁, T₂, T₃, T₄, T₅}

A Gaussian system.

CanonicalForm{T₁, T₂} = GaussianSystem{
    T₁,
    ZerosMatrix{Bool, Tuple{OneTo{Int}, OneTo{Int}}},
    T₂,
    ZerosVector{Bool, Tuple{OneTo{Int}}},
    Bool}

A canonical form.

DenseGaussianSystem{T} = GaussianSystem{
    Matrix{T},
    Matrix{T},
    Vector{T},
    Vector{T},
    T}

A Gaussian system represented by dense matrices and vectors.

DenseCanonicalForm{T} = CanonicalForm{
    Matrix{T},
    Vector{T}}

A canonical form represented by a dense matrix and vector.

GaussianSystem(
    P::AbstractMatrix,
    S::AbstractMatrix,
    p::AbstractVector,
    s::AbstractVector,
    σ::Real)

Construct a Gaussian system by specifying its energy function. You should set

σ  = dot(s, pinv(S) * s)

CanonicalForm(K::AbstractMatrix, h::AbstractVector)

Construct the canonical form

\[\mathcal{C}(K, h, g),\]

where the normalization constant $g$ is inferred from $K$ and $h$.

normal(μ::AbstractVector, Σ::AbstractMatrix)

Construct a multivariate normal distribution with mean vector μ and covariance matrix Σ.

normal(μ::Real, σ::Real)

Construct a normal distribution with mean μ and standard deviation σ.

kernel(L::AbstractMatrix, μ::AbstractVector, Σ::AbstractMatrix)

Construct a conditional distribution of the form

\[p(Y \mid X = x) = \mathcal{N}(Lx + \mu, \Sigma).\]

kernel(l::AbstractVector, μ::Real, σ::Real)

Construct a conditional distribution of the form

\[p(Y \mid X = x) = \mathcal{N}(l^\mathsf{T}x + \mu, \sigma^2).\]

length(Σ::GaussianSystem)

Get the dimension of Σ.

cov(Σ::GaussianSystem; atol::Real=1e-8)

Get the covariance matrix of Σ.

invcov(Σ::GaussianSystem)

Get the precision matrix of Σ.

var(Σ::GaussianSystem; atol::Real=1e-8)

Get the variances of Σ.

mean(Σ::GaussianSystem; atol::Real=1e-8)

Get the mean vector of Σ.

InferenceProblem{T₁, T₂, T₃, T₄}

An inference problem.

InferenceProblem(
    diagram::RelationDiagram,
    hom_map::AbstractDict,
    ob_map::AbstractDict;
    hom_attr::Symbol=:name,
    ob_attr::Symbol=:junction_type,
    var_attr::Symbol=:variable
    check::Bool=true)

Construct an inference problem that performs undirected compositon.

InferenceProblem(
    network::BayesNet,
    query::AbstractVector,
    context::AbstractDict)

Construct an inference problem that queries a Bayesian network.

solve(
    problem::InferenceProblem,
    elimination_algorithm::EliminationAlgorithm=MinFill()
    supernode_type::SupernodeType=Node()
    architecture_type::ArchitectureType=ShenoyShafer())

Solve an inference problem. This involves several steps:

interaction graph
    ↓ elimination algorithm
elimination tree
    ↓ supernode type
join tree
    ↓ architecture type
solution

First an elimination agorithm is used to construct an elimination tree from the model's interaction graph. Then, nodes of the elimination tree are merged into supernodes, forming a join (or junction) tree. Finally, a message passing algorithm is used to compute a solution.

init(
    problem::InferenceProblem,
    elimination_algorithm::EliminationAlgorithm=MinFill(),
    supernode_type::SupernodeType=Node(),
    architecture_type::ArchitectureType=ShenoyShafer())

Construct a solver for an inference problem. This involves several steps:

interaction graph
    ↓ elimination algorithm
elimination tree
    ↓ supernode type
join tree

First an elimination agorithm is used to construct an elimination tree from the model's interaction graph. Then, nodes of the elimination tree are merged into supernodes, forming a join (or junction) tree.

When solve! is called on the solver, a message passing algorithm is used to compute the solution.

InferenceSolver{T₁, T₂, T₃, T₄, T₅}

A solver for an inference problem.

solve!(solver::InferenceSolver)

Solve an inference problem.

mean(solver::InferenceSolver{AncestralSampler()})

rand(solver::InferenceSolver{AncestralSampler()})

rand(rng::AbstractRNG, solver::InferenceSolver{AncestralSampler()})

EliminationAlgorithm

A graph elimination algorithm. The options are

• MinDegree
• MinFill
• MaxCardinality
• ChordalGraph
• CuthillMcKeeJL_RCM
• AMDJL_AMD
• MetisJL_ND

MaxCardinality <: EliminationAlgorithm

The maximum cardinality search algorithm.

MinDegree <: EliminationAlgorithm

The minimum-degree heuristic.

MinFill <: EliminationAlgorithm

The minimum-fill heuristic.

ChordalGraph <: EliminationAlgorithm

An efficient algorithm for chordal graphs.

CuthillMcKeeJL_RCM <: EliminationAlgorithm

The reverse Cuthill-McKee algorithm. Uses CuthillMckee.jl.

AMDJL_AMD <: EliminationAlgorithm

The approximate minimum degree algorithm. Uses AMD.jl.

MetisJL_ND <: EliminationAlgorithm

The nested dissection heuristic. Uses Metis.jl.

ischordal(graph::AbstractGraph)

Determine if a graph is chordal.

SupernodeType

A type of supernode. The options are

• Node
• MaximalSupernode
• FundamentalSupernode

Node <: SupernodeType

The single-vertex supernode.

MaximalSupernode <: SupernodeType

The maximal supernode.

FundamentalSupernode <: SupernodeType

The fundamental supernode.

ArchitectureType

A message-passing algorithm. The options are

• ShenoyShafer
• LauritzenSpiegelhalter
• HUGIN
• Idempotent

There is one additional type, which you can use for sampling from a graphical model:

• AncestralSampler

ShenoyShafer <: ArchitectureType

The Shenoy-Shafer architecture.

LauritzenSpiegelhalter <: ArchitectureType

The Lauritzen-Spiegelhalter architecture.

HUGIN <: ArchitectureType

The HUGIN architecture.

Idempotent <: ArchitectureType

The idempotent architecture.

AncestralSampler <: ArchitectureType

A type for sampling graphical models.