PyMC is a production-grade Bayesian modeling and probabilistic programming library built on PyTensor. It exposes a model-building API (pm.Model, pm.Normal, pm.sample), automatic log-probability derivation through graph rewriting, MCMC samplers (NUTS, HMC, Metropolis, Slice, DEMetropolis), Sequential Monte Carlo, variational inference (ADVI, FullRankADVI, SVGD), Gaussian processes, ODE support, and data containers (pm.Data, Minibatch). Users construct symbolic random-variable graphs using PyTensor; PyMC rewrites those graphs into measurable IR, computes log-probabilities and transforms, compiles sampling or variational objective functions, and returns posterior traces as xarray/ArviZ DataTree objects. Although the library primarily serves research and statistical workflows, the repository itself is an application/library, not a data-research pipeline. Architecturally, this is a library, not a service: there are no daemons or network endpoints. The entry points are Python APIs in pymc/model/core.py, pymc/sampling/mcmc.py, pymc/distributions/, pymc/step_methods/, and pymc/variational/. The core data flow is model specification -> PyTensor graph -> fgraph_from_model -> logprob rewrites -> compiled sampling functions -> trace backends (ndarray, zarr) -> to_inference_data for posterior analysis. External dependencies include NumPy, SciPy, PyTensor, ArviZ, and optional JAX/BlackJAX/NumPyro, Numba, Zarr, Rich, and Marimo. The codebase has an extensive test suite and CI, with some experimental areas such as pymc.dims and ongoing deprecations. Maintenance is active, with recent commits and rigorous CI. Technical drift is medium: most of the stack tracks current Python, but the Zarr backend is not yet ported to Zarr 3 and several optional integrations carry compatibility shims. Overall craftsmanship is strong but not exceptional: the code is deeply engineered, though its size and internal coupling make individual components less trivially extractable, and some deprecated APIs and experimental modules add friction.
Pyro is a deep probabilistic programming library built on PyTorch, providing a unified framework for Bayesian inference, variational inference, and Monte Carlo methods. Its architecture centers on composable effect handlers (poutine) that enable tracing, conditioning, replay, and reparameterization of probabilistic programs. The library includes a rich set of distributions, bijective transforms for normalizing flows, automatic guide construction, and a variety of inference algorithms (SVI, HMC, NUTS, SVGD, SMC). It also offers domain-specific contrib modules for Gaussian processes, time series forecasting, epidemiology, optimal experimental design, and multi-object tracking. While primarily a software library, Pyro has strong research roots, with many features inspired by recent papers and experimental modules that may evolve. The codebase is well-structured, extensively tested, and actively maintained, though some contrib modules carry instability warnings and a few internal patches to PyTorch may require attention.
GPflow is a mature, pip-installable Python library for Gaussian process (GP) modeling built on TensorFlow and TensorFlow Probability. It is not a deployed service or CLI; it is a scientific software library that researchers and practitioners import directly. The library provides exact and approximate GP inference (GPR, SGPR, VGP, SVGP, GPMC, SGPMC, CGLB), a wide range of stationary, non-stationary, multi-output, convolutional, and hierarchical kernels, multiple likelihoods including quadrature and Monte Carlo fallbacks, and optimizers such as Scipy L-BFGS-B, natural gradient, and MCMC sampling helpers. The dominant architecture is modular and dispatch-driven: covariances, conditionals, expectations, KL divergences, and posterior construction are all implemented via a custom multiple-dispatch mechanism, making the library extensible to new kernel/inducing-variable/likelihood combinations. It also includes posterior caching for fast repeated predictions, TensorBoard monitoring, and shape annotations via check_shapes. While the repository contains extensive Jupyter/Sphinx notebooks and a dedicated benchmark harness, these are supporting assets rather than the primary deliverable; the core is clearly a reusable application library. The code is generally high-craftsmanship: clean abstractions, strong test coverage, and several genuinely generic components such as Gauss-Hermite quadrature helpers, a TensorFlow-module traversal utility, and a TF-Scipy optimizer wrapper with compile caching. However, the codebase shows meaningful drift risk: it supports a very wide TensorFlow/TFP version matrix (TF 2.4-2.16, TFP 0.12-0.24), uses private TensorFlow and TFP APIs in places, carries backward-compatibility/deprecation layers (e.g., GPR_deprecated, SVGP_with_posterior), and contains occasional debug leftovers or commented-out code. Maintenance is clearly active, with recent releases, CI matrices across Python 3.7-3.11, and versioned fixes to newly added hierarchical kernels.
This is a mature Python library for global optimization of expensive black-box functions using Bayesian optimization. It provides the `BayesianOptimization` class that iteratively fits a Gaussian process regressor (via scikit-learn) to observed function evaluations and uses an acquisition function (Upper Confidence Bound, Expected Improvement, Probability of Improvement, or combined) to propose the next point to evaluate. The library supports constrained optimization, domain reduction, mixed continuous/integer/categorical parameters, asynchronous/parallel optimization, and state persistence. Its architecture is modular: acquisition functions are organized in a strategy pattern, parameters are polymorphic with a base class for custom types, constraints are modeled with separate GPs, and domain reduction is implemented as a transformer. The core algorithm is well-tested and documented, with examples ranging from toy functions to hyperparameter tuning. It is not a research notebook collection or data pipeline; it is a production-grade library intended for integration into optimization workflows.