pyABC: Distributed Likelihood-Free ABC-SMC Inference

pyABC is a Python framework for Approximate Bayesian Computation (ABC), a likelihood-free parameter inference method. It is particularly useful when evaluating the likelihood function of a complex stochastic model is computationally infeasible.

Core Functionality:

• ABC-SMC Scheme: Implements a Sequential Monte-Carlo (SMC) algorithm that gradually reduces acceptance thresholds to improve posterior approximations.
• Scalability: Provides efficient parallelization for multi-core and distributed systems, including dynamic scheduling for improved wall-time efficiency.
• Modularity: Designed to be highly extensible, allowing users to plug in different simulators, distance metrics, and summary statistics.
• Interoperability: Supports models written in Python, R, and Julia, as well as biochemical models in SBML/COPASI format and the PEtab inference standard (specifically for the AMICI ODE simulator).

pyABC (v0.12+) includes several advanced algorithmic features to handle complex inference problems:

Distance Metrics and Robustness

• Adaptive Distance Scaling: Iteratively updates distance weights to normalize contributions from data points that vary on different scales.
• Outlier Robustness: Implements methods to identify and reduce the impact of measurement errors (outliers) that the model does not account for.
• Wasserstein Distances: Implements optimal transport-based distances, which can potentially circumvent the need for manual summary statistics.

Summary Statistics and Data Informativeness

• Regression-based Statistics: Uses inverse regression models (interfaced via scikit-learn) to identify informative data points. This includes support for linear regression, neural networks, and Gaussian processes.
• Sensitivity Weights: Uses regression models to inform robust sensitivity weights that account for the informativeness of data.

Inference Refinement

• Handling Measurement Noise: Provides an exact inference scheme for ABC-SMC in the presence of measurement noise.
• Predictive Acceptance Thresholds: Uses importance sampling to predict acceptance rate curves, helping to avoid local optima in the acceptance threshold sequence.

pyABC uses cloudpickle to serialize objects (including lambda functions) for transmission to remote workers.

Warning for Developers: Large objects can significantly increase serialization time and memory usage. When defining functions to be run remotely, ensure they do not capture unnecessary large state from their parent scope. Instead of capturing a whole class instance, capture only the specific small attributes required for the computation.

import cloudpickle as pickle
import numpy as np

class A:
   def __init__(self):
      self.big_arr = np.eye(10000)
      self.small_arr = np.zeros(2)

   def costly_function(self):
      # This captures the entire 'self' object, including big_arr
      def fun(x):
         print(self.small_arr, x)
      return fun

   def efficient_function(self):
      # This captures only the specific small attribute needed
      small_arr = self.small_arr
      def fun(x):
         print(small_arr, x)
      return fun

a = A()

# 'costly_function' results in a massive serialized object
print(len(pickle.dumps(a.costly_function()))) 

# 'efficient_function' results in a very small serialized object
print(len(pickle.dumps(a.efficient_function()))) 

pyABC provides several samplers to handle the computationally expensive parts of ABC (simulation, statistics, and distance calculation). Samplers are categorized by their execution environment and scheduling strategy:

Scheduling Strategies

• Static Scheduling (STAT): Minimizes total execution time. Used by ParticleParallel samplers, MappingSampler, and RedisStaticSampler.
• Dynamic Scheduling (DYN): Minimizes wall-time and generally finishes faster. Used by EvalParallel samplers, DaskDistributedSampler, and ConcurrentFutureSampler.

Sampler Types

• Single-core: Use SingleCoreSampler for debugging or deterministic purposes. It executes sequentially.
• Multi-core (Local):
  • MulticoreEvalParallelSampler: Implements DYN strategy. This is the default sampler. Highly efficient via forking (not recommended for Windows).
  • MulticoreParticleParallelSampler: Implements STAT strategy.
• Distributed:
  • RedisEvalParallelSampler: Low overhead, supports "look-ahead mode" for proactive sampling. Best for fast function evaluations.
  • RedisStaticSampler: Implements STAT strategy for distributed settings.
  • DaskDistributedSampler: Better at handling worker failures/terminations, but has higher communication overhead. Not suitable for simulations running < 100ms.
• Extensible/Generic:
  • MappingSampler: Uses a provided map implementation (e.g., multiprocessing.Pool.map or pyabc.sge.SGE.map).
  • ConcurrentFutureSampler: Uses any python.concurrent.futures.Executor (e.g., ProcessPoolExecutor or Dask).