RxInfer.jl

RxInfer.jl is a Julia package designed for real-time, variational Bayesian inference on infinite asynchronous data streams. It uses a reactive message passing paradigm on a factor graph representation of probabilistic models.

Key capabilities include:

• Hybrid Inference Engine: Combines different message passing methods (e.g., belief propagation, expectation propagation, mean-field variational message passing) at different locations in the graph to trade off accuracy for speed.
• Model Specification: Uses Julia macros to transform textual model descriptions into factor graphs.
• Scalability: Supports both real-time stream processing and batch processing of large datasets with hundreds of thousands of latent variables.
• Extensibility: Provides a public API to add custom nodes and message update rules.
• Auto-differentiation: Compatible with ForwardDiff.jl and ReverseDiff.jl.

RxInfer.jl is a Julia-based probabilistic programming library primarily focused on message-passing inference. It is designed for high efficiency and modularity, allowing users to compose complex models from smaller ones.

Key differentiators include:

• Inference Engine: Uses reactive message passing, which supports real-time updates, parallelization, and interruptibility.
• Modularity: Unlike many other toolboxes (e.g., Turing.jl, PyMC, Stan), RxInfer.jl allows for the fusion of models by integrating smaller models into larger ones.
• Universality: Highly effective for models derived from the exponential family of distributions (e.g., Gaussian, Bernoulli, Autoregressive models, Gamma Mixture models) and deterministic transformations of these variables. For models outside the exponential family, users must define custom nodes and rules.
• Expressiveness: Uses Julia macros to mirror probabilistic notation. Note that RxInfer uses := for deterministic relationships to enable its message-passing capabilities.

Callbacks can store arbitrary information in the ProbabilisticModel's metadata dictionary (Dict{Any, Any}). This is useful for tracking history (like marginal updates) across iterations. The stored data is accessible from the inference result via result.model.metadata.

struct MarginalHistoryCollector end

ReactiveMP.handle_event(::MarginalHistoryCollector, ::ReactiveMP.Event) = nothing

function ReactiveMP.handle_event(::MarginalHistoryCollector, event::OnMarginalUpdateEvent)
    # Access or initialize the metadata dictionary
    history = get!(() -> [], event.model.metadata, :marginal_history)
    push!(history, (iteration_variable = event.variable_name, value = event.update))
end

result = infer(
    model = my_model(),
    data  = my_data,
    callbacks = MarginalHistoryCollector(),
    # ... other params
)

# Access the data later
history = result.model.metadata[:marginal_history]

RxInfer provides three primary inference paradigms depending on your data availability and latency requirements:

Static Inference

Processes a complete dataset all at once. It is best for offline analysis and batch processing where all data is available upfront.

• Return Type: InferenceResult (contains final posteriors).
• Pros: Simple to implement; best for exploration.
• Cons: High memory usage (scales with dataset); no real-time updates; high latency (must wait for all data).

Streaming (Online) Inference

Processes data points sequentially as they arrive. Designed for real-time applications and online learning.

• Return Type: RxInferenceEngine (provides reactive streams).
• Pros: Low latency; real-time belief updates; controlled memory usage via history buffers.
• Cons: Requires managing state updates (autoupdates).

Batched Inference

A hybrid approach that processes data in configurable chunks. It balances memory usage and update frequency.

• Return Type: RxInferenceEngine.
• Pros: More efficient than streaming for large datasets; allows for batch-level autoupdates; medium memory footprint.
• Cons: Latency is dependent on batch size.