tessl/pypi-ultranest

Fit and compare complex models reliably and rapidly with advanced nested sampling techniques for Bayesian inference.

Overview

Eval results

Files

Step Sampling Techniques

Name: tessl/pypi-ultranest
Author: tessl

Modular step sampling algorithms for efficient exploration of parameter spaces within nested sampling. UltraNest provides various sampling techniques that can be customized based on the problem geometry and likelihood structure.

Capabilities

Base Step Samplers

Foundation classes for implementing custom step sampling algorithms.

class StepSampler:
    """Base class for all step samplers."""

class MHSampler(StepSampler):
    """Metropolis-Hastings sampler for general parameter space exploration."""

class SliceSampler(StepSampler):
    """Slice sampler providing robust sampling for complex geometries."""

Convenience Samplers

Pre-configured sampler factory functions combining sampling algorithms with direction generators for common use cases.

def CubeMHSampler(*args, **kwargs):
    """Metropolis-Hastings sampler with cube-oriented direction generation."""

def RegionMHSampler(*args, **kwargs):
    """Metropolis-Hastings sampler with region-oriented directions."""

def CubeSliceSampler(*args, **kwargs):
    """Slice sampler using axis-aligned directions."""

def RegionSliceSampler(*args, **kwargs):
    """Slice sampler with region-adaptive directions."""

def BallSliceSampler(*args, **kwargs):
    """Slice sampler constrained to ball geometry."""

def RegionBallSliceSampler(*args, **kwargs):
    """Slice sampler combining region and ball constraints."""

Direction Generation Functions

Functions for generating sampling directions based on different geometric strategies.

def generate_random_direction(ui, region, scale=1):
    """
    Generate random direction for sampling moves.
    
    Parameters:
    - ui: Current point in unit cube
    - region: Current constraining region
    - scale (float): Direction scaling factor
    
    Returns:
    array: Random direction vector
    """

def generate_cube_oriented_direction(ui, region, scale=1):
    """
    Generate axis-aligned direction for cube-oriented sampling.
    
    Parameters:
    - ui: Current point in unit cube
    - region: Current constraining region  
    - scale (float): Direction scaling factor
    
    Returns:
    array: Axis-aligned direction vector
    """

def generate_region_oriented_direction(ui, region, scale=1):
    """
    Generate direction oriented towards region structure.
    
    Parameters:
    - ui: Current point in unit cube
    - region: Current constraining region
    - scale (float): Direction scaling factor
    
    Returns:
    array: Region-oriented direction vector
    """

def generate_region_random_direction(ui, region, scale=1):
    """
    Generate random direction within region constraints.
    
    Parameters:
    - ui: Current point in unit cube
    - region: Current constraining region
    - scale (float): Direction scaling factor
    
    Returns:
    array: Random region-constrained direction
    """

def generate_mixture_random_direction(ui, region, scale=1):
    """
    Generate direction using mixture of strategies.
    
    Parameters:
    - ui: Current point in unit cube
    - region: Current constraining region
    - scale (float): Direction scaling factor
    
    Returns:
    array: Mixed strategy direction vector
    """

Direction Generators

Classes for systematic direction generation with adaptive behavior.

class SequentialDirectionGenerator:
    """Generate directions in sequential patterns."""

class SequentialRegionDirectionGenerator:
    """Generate region-based sequential directions."""

class OrthogonalDirectionGenerator:
    """Generate orthogonal direction sets."""

class SpeedVariableGenerator:
    """Adaptive speed control for direction generation."""

Population Samplers

Advanced samplers that work with multiple points simultaneously for improved efficiency.

class PopulationRandomWalkSampler:
    """Population-based random walk sampler."""

class PopulationSliceSampler:
    """Population-based slice sampler."""

class PopulationSimpleSliceSampler:
    """Simplified population slice sampler."""

Population Direction Functions

Direction generation functions optimized for population-based sampling.

def generate_cube_oriented_direction_scaled(*args, **kwargs):
    """Generate scaled cube-oriented directions for populations."""

def generate_random_direction(*args, **kwargs):
    """Generate random directions for population sampling."""

def generate_region_oriented_direction(*args, **kwargs):
    """Generate region-oriented directions for populations."""

def generate_region_random_direction(*args, **kwargs):
    """Generate region-random directions for populations."""

Advanced Sampling Algorithms

Dynamic Hamiltonian Monte Carlo

High-performance sampling using Hamiltonian dynamics for smooth likelihood surfaces.

class DynamicHMCSampler:
    """Dynamic Hamiltonian Monte Carlo sampler for smooth posteriors."""

class FlattenedProblem:
    """Flattened problem formulation for HMC sampling."""

No-U-Turn Sampler (NUTS)

Adaptive Hamiltonian Monte Carlo that automatically tunes step sizes and trajectory lengths.

class ClockedNUTSSampler:
    """No-U-Turn sampler with clock-based termination."""

class ClockedBisectSampler:
    """Bisection sampler with clock-based timing."""

class ClockedStepSampler:
    """Clock-based step sampler for precise control."""

Trajectory Samplers

Specialized samplers for trajectory-based exploration.

class SingleJumper:
    """Single-jump trajectory sampler."""

class DirectJumper:
    """Direct trajectory jumping."""

class IntervalJumper:
    """Interval-based trajectory sampling."""

Path Samplers

Samplers that use path-based exploration strategies.

class SamplingPathSliceSampler(StepSampler):
    """Path-based slice sampling algorithm."""

class SamplingPathStepSampler(StepSampler):
    """Path-based step sampling algorithm."""

Usage Examples

Custom Step Sampler Configuration

from ultranest import ReactiveNestedSampler
from ultranest.stepsampler import RegionSliceSampler

# Create sampler with custom step sampler
sampler = ReactiveNestedSampler(
    param_names=['x', 'y', 'z'],
    loglike=loglike,
    transform=prior_transform
)

# Configure step sampler (done automatically by ReactiveNestedSampler)
# Manual configuration would be:
# step_sampler = RegionSliceSampler()
# sampler.stepsampler = step_sampler

Population-Based Sampling

from ultranest.popstepsampler import PopulationSliceSampler

# Population sampling is typically configured automatically
# based on problem dimensionality and structure

Advanced Sampling for Smooth Posteriors

from ultranest.dyhmc import DynamicHMCSampler

# HMC sampling is automatically selected for smooth,
# differentiable likelihood functions when beneficial

Sampler Selection Guidelines

Problem-Dependent Recommendations

General problems: ReactiveNestedSampler automatically selects appropriate step samplers
High-dimensional smooth: Dynamic HMC samplers for differentiable likelihoods
Complex geometries: Region-oriented slice samplers
Multimodal distributions: Mixed direction generation with random components
Constrained parameters: Ball slice samplers for bounded regions
Circular parameters: Wrapped parameter handling with appropriate direction generators

Performance Considerations

Population samplers: More efficient for high-dimensional problems
HMC/NUTS: Best for smooth, differentiable posteriors
Slice samplers: Robust for complex, irregular likelihood surfaces
MH samplers: Simple and reliable for general use

The ReactiveNestedSampler automatically selects and adapts step sampling strategies based on the problem characteristics, making manual configuration unnecessary for most applications.

Install with Tessl CLI