or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

configuration-management.mddata-operations.mdframework-integrations.mdindex.mdperformance-utilities.mdstatistical-analysis.mdvisualization-plotting.md
tile.json

tessl/pypi-arviz

Exploratory analysis of Bayesian models with comprehensive data manipulation, statistical diagnostics, and visualization capabilities

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/arviz@0.22.x

To install, run

npx @tessl/cli install tessl/pypi-arviz@0.22.0

index.mddocs/

ArviZ

Exploratory analysis of Bayesian models with comprehensive data manipulation, statistical diagnostics, and visualization capabilities. ArviZ provides a unified interface for working with Bayesian inference results from multiple probabilistic programming frameworks, enabling model checking, comparison, and interpretation through an extensive suite of statistical functions and publication-quality visualizations.

Package Information

  • Package Name: arviz
  • Language: Python
  • Installation: pip install arviz
  • Requires: Python 3.10+

Core Imports

import arviz as az

Basic Usage

import arviz as az
import numpy as np

# Load built-in example dataset
idata = az.load_arviz_data("centered_eight")

# Create summary statistics
summary = az.summary(idata)
print(summary)

# Generate diagnostic plots
az.plot_trace(idata, var_names=["mu", "tau"])
az.plot_posterior(idata, var_names=["mu", "tau"])

# Compute diagnostics
rhat = az.rhat(idata)
ess = az.ess(idata)

# Model comparison (requires multiple models)
model_dict = {"model1": idata1, "model2": idata2}  # hypothetical models
comparison = az.compare(model_dict)
az.plot_compare(comparison)

Architecture

ArviZ is built around the InferenceData structure, a NetCDF-based data container using xarray that organizes Bayesian inference results into logical groups:

  • Posterior: MCMC samples from the posterior distribution
  • Prior: Samples from the prior distribution
  • Observed Data: Observed/input data used in the model
  • Posterior Predictive: Samples from the posterior predictive distribution
  • Sample Stats: MCMC diagnostics and metadata (divergences, energy, etc.)
  • Log Likelihood: Log likelihood evaluations for model comparison

This design enables seamless integration across probabilistic programming frameworks (Stan, PyMC, Pyro, NumPyro, JAX, etc.) while providing a consistent interface for analysis and visualization.

Capabilities

Data Operations

Comprehensive data loading, conversion, and manipulation capabilities supporting multiple Bayesian frameworks and file formats. Create, transform, and manage InferenceData objects with built-in dataset examples and extensive I/O operations.

class InferenceData:
    """Main data container for Bayesian inference results."""
    
def load_arviz_data(dataset: str, data_home: str = None, **kwargs) -> InferenceData:
    """Load built-in example datasets."""

def convert_to_inference_data(obj, *, group: str = None, coords: dict = None, dims: dict = None, **kwargs) -> InferenceData:
    """Convert various objects to InferenceData format."""

def concat(*args, dim: str, copy: bool = True, inplace: bool = False, reset_dim: bool = True) -> InferenceData:
    """Concatenate multiple InferenceData objects."""

Data Operations

Statistical Analysis and Diagnostics

MCMC diagnostics, model comparison, and statistical functions for Bayesian analysis. Compute convergence diagnostics, effective sample sizes, information criteria, and perform Bayesian model comparison with advanced techniques like PSIS-LOO.

def summary(data: InferenceData, *, var_names: list = None, hdi_prob: float = 0.94, **kwargs) -> pd.DataFrame:
    """Create summary statistics table for inference data."""

def rhat(data: InferenceData, *, var_names: list = None, method: str = "rank") -> xr.Dataset:
    """Compute R-hat convergence diagnostic."""

def ess(data: InferenceData, *, var_names: list = None, method: str = "bulk", relative: bool = False) -> xr.Dataset:
    """Compute effective sample size."""

def compare(data_dict: dict, *, ic: str = "loo", method: str = "stacking", scale: str = "log") -> pd.DataFrame:
    """Compare models using information criteria."""

def loo(data: InferenceData, *, pointwise: bool = False, var_name: str = None, reff: float = 1.0) -> ELPDData:
    """Compute Leave-One-Out Cross-Validation."""

Statistical Analysis and Diagnostics

Visualization and Plotting

Comprehensive plotting functions for Bayesian analysis including diagnostic plots, distribution visualizations, model comparison plots, and posterior predictive checks. Support for multiple backends (Matplotlib, Bokeh, Plotly) with publication-quality output.

def plot_trace(data: InferenceData, *, var_names: list = None, coords: dict = None, **kwargs):
    """Plot MCMC trace plots."""

def plot_posterior(data: InferenceData, *, var_names: list = None, coords: dict = None, **kwargs):
    """Plot posterior distributions."""

def plot_forest(data: InferenceData, *, var_names: list = None, coords: dict = None, **kwargs):
    """Plot forest plots for parameter estimates."""

def plot_compare(comp_df: pd.DataFrame, *, insample_dev: bool = True, plot_ic_diff: bool = True, **kwargs):
    """Plot model comparison results."""

def plot_ppc(data: InferenceData, *, var_names: list = None, coords: dict = None, **kwargs):
    """Plot posterior predictive checks."""

Visualization and Plotting

Framework Integrations

Convert inference results from various probabilistic programming frameworks to ArviZ's unified InferenceData format. Supports Stan (CmdStan, PyStan, CmdStanPy), PyMC, Pyro, NumPyro, JAX, emcee, and more.

def from_pystan(fit, *, posterior_predictive: str = None, observed_data: dict = None, **kwargs) -> InferenceData:
    """Convert PyStan fit results to InferenceData."""

def from_cmdstanpy(fit, *, posterior_predictive: str = None, observed_data: dict = None, **kwargs) -> InferenceData:
    """Convert CmdStanPy fit results to InferenceData."""

def from_pyro(posterior, *, prior: dict = None, posterior_predictive: dict = None, **kwargs) -> InferenceData:
    """Convert Pyro MCMC results to InferenceData."""

def from_numpyro(posterior, *, prior: dict = None, posterior_predictive: dict = None, **kwargs) -> InferenceData:
    """Convert NumPyro MCMC results to InferenceData."""

Framework Integrations

Configuration Management

Global and context-specific configuration management for ArviZ behavior including plotting backends, statistical defaults, and data handling preferences.

rcParams: RcParams
    """Global configuration parameters object."""

class rc_context:
    """Context manager for temporary configuration changes."""
    def __init__(self, rc: dict = None, fname: str = None): ...

Configuration Management

Performance and Utilities

Performance optimization utilities including Numba JIT compilation, Dask parallelization, and interactive backend management for Jupyter environments.

class Numba:
    """Numba JIT compilation utilities."""
    numba_flag: bool
    @classmethod
    def enable_numba(cls): ...
    @classmethod  
    def disable_numba(cls): ...

class Dask:
    """Dask parallel computation utilities."""
    dask_flag: bool
    @classmethod
    def enable_dask(cls, dask_kwargs: dict = None): ...
    @classmethod
    def disable_dask(cls): ...

class interactive_backend:
    """Context manager for interactive plotting backends."""
    def __init__(self, backend: str = ""): ...

Performance and Utilities

Global Types

class InferenceData:
    """
    Main data container for Bayesian inference results.
    
    NetCDF-based data structure using xarray groups to organize
    posterior samples, prior samples, observed data, diagnostics,
    and metadata from Bayesian inference.
    """

class ELPDData:
    """
    Expected log pointwise predictive density data container.
    
    Contains information criteria results from loo() and waic()
    including pointwise values, diagnostics, and summary statistics.
    """

CoordSpec = Dict[str, List[Any]]
"""Type alias for coordinate specifications in data conversion."""

DimSpec = Dict[str, List[str]]  
"""Type alias for dimension specifications in data conversion."""