Helpers

Helper functions to extract sufficient statistics from observations.

These functions bridge the gap between raw data and the summary statistics required by conjugate model functions.

Example

from conjugate.distributions import Gamma
from conjugate.models import poisson_gamma
from conjugate.helpers import poisson_gamma_inputs

observations = [3, 5, 2, 4, 1]
prior = Gamma(1, 1)
posterior = poisson_gamma(**poisson_gamma_inputs(observations), prior=prior)

For PyTensor compatibility

from conjugate.helpers import poisson_gamma_inputs, pytensor_ops

inputs = poisson_gamma_inputs(observations, **pytensor_ops)

bernoulli_beta_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for bernoulli_beta model.

For multiple Bernoulli trials, returns statistics compatible with binomial_beta model. For a single trial, use directly with bernoulli_beta (n will be 1).

Parameters:

Name	Type	Description	Default
x		Binary outcomes (0 or 1, array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x' and 'n' for use with binomial_beta() or bernoulli_beta()

Example

# Multiple Bernoulli trials - use with binomial_beta
from conjugate.models import binomial_beta
from conjugate.helpers import bernoulli_beta_inputs

data = [1, 0, 1, 1, 0]  # 5 trials, 3 successes
inputs = bernoulli_beta_inputs(data)
# inputs = {'x': 3, 'n': 5}
posterior = binomial_beta(**inputs, prior=prior)

Source code in conjugate/helpers.py

def bernoulli_beta_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for bernoulli_beta model.

    For multiple Bernoulli trials, returns statistics compatible with binomial_beta model.
    For a single trial, use directly with bernoulli_beta (n will be 1).

    Args:
        x: Binary outcomes (0 or 1, array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x' and 'n' for use with binomial_beta() or bernoulli_beta()

    Example:
        ```python
        # Multiple Bernoulli trials - use with binomial_beta
        from conjugate.models import binomial_beta
        from conjugate.helpers import bernoulli_beta_inputs

        data = [1, 0, 1, 1, 0]  # 5 trials, 3 successes
        inputs = bernoulli_beta_inputs(data)
        # inputs = {'x': 3, 'n': 5}
        posterior = binomial_beta(**inputs, prior=prior)
        ```
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x": sum_fn(x),
        "n": len_fn(x),
    }

beta_inputs(x, *, prod_fn=None, len_fn=None, asarray_fn=None)

Extract sufficient statistics for beta model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
prod_fn	Callable | None	Function to take product of elements, defaults to np.prod	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
asarray_fn	Callable | None	Function to convert to array, defaults to np.asarray	None

Returns:

Type	Description
dict	Dict with keys 'x_prod', 'one_minus_x_prod', and 'n'

Source code in conjugate/helpers.py

def beta_inputs(
    x,
    *,
    prod_fn: Callable | None = None,
    len_fn: Callable | None = None,
    asarray_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for beta model.

    Args:
        x: Observations (array-like or scalar)
        prod_fn: Function to take product of elements, defaults to np.prod
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        asarray_fn: Function to convert to array, defaults to np.asarray

    Returns:
        Dict with keys 'x_prod', 'one_minus_x_prod', and 'n'
    """
    if prod_fn is None:
        prod_fn = _default_prod
    if len_fn is None:
        len_fn = _default_len
    if asarray_fn is None:
        asarray_fn = np.asarray

    # Convert to array first to handle list inputs properly
    x_arr = asarray_fn(x)

    return {
        "x_prod": prod_fn(x_arr),
        "one_minus_x_prod": prod_fn(1 - x_arr),
        "n": len_fn(x),
    }

binomial_beta_inputs(x, n, *, sum_fn=None)

Extract sufficient statistics for binomial_beta model.

Parameters:

Name	Type	Description	Default
x		Number of successes (array-like or scalar)	required
n		Number of trials (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None

Returns:

Type	Description
dict	Dict with keys 'x' and 'n' for use with binomial_beta()

Source code in conjugate/helpers.py

def binomial_beta_inputs(
    x,
    n,
    *,
    sum_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for binomial_beta model.

    Args:
        x: Number of successes (array-like or scalar)
        n: Number of trials (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum

    Returns:
        Dict with keys 'x' and 'n' for use with binomial_beta()
    """
    if sum_fn is None:
        sum_fn = _default_sum

    return {
        "x": sum_fn(x),
        "n": sum_fn(n),
    }

categorical_dirichlet_inputs(x)

Extract sufficient statistics for categorical_dirichlet model.

Parameters:

Name	Type	Description	Default
x		Observed counts for each category (array-like)	required

Returns:

Type	Description
dict	Dict with key 'x' for use with categorical_dirichlet()

Source code in conjugate/helpers.py

def categorical_dirichlet_inputs(x) -> dict:
    """Extract sufficient statistics for categorical_dirichlet model.

    Args:
        x: Observed counts for each category (array-like)

    Returns:
        Dict with key 'x' for use with categorical_dirichlet()
    """
    return {"x": x}

gamma_inputs(x, *, sum_fn=None, prod_fn=None, len_fn=None)

Extract sufficient statistics for gamma model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
prod_fn	Callable | None	Function to take product of elements, defaults to np.prod	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total', 'x_prod', and 'n'

Source code in conjugate/helpers.py

def gamma_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    prod_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for gamma model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        prod_fn: Function to take product of elements, defaults to np.prod
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total', 'x_prod', and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if prod_fn is None:
        prod_fn = _default_prod
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "x_prod": prod_fn(x),
        "n": len_fn(x),
    }

gamma_known_rate_inputs(x, *, prod_fn=None, len_fn=None)

Extract sufficient statistics for gamma_known_rate model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
prod_fn	Callable | None	Function to take product of elements, defaults to np.prod	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_prod' and 'n'

Source code in conjugate/helpers.py

def gamma_known_rate_inputs(
    x,
    *,
    prod_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for gamma_known_rate model.

    Args:
        x: Observations (array-like or scalar)
        prod_fn: Function to take product of elements, defaults to np.prod
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_prod' and 'n'
    """
    if prod_fn is None:
        prod_fn = _default_prod
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_prod": prod_fn(x),
        "n": len_fn(x),
    }

gamma_known_shape_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for gamma_known_shape model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n' for use with gamma_known_shape()

Source code in conjugate/helpers.py

def gamma_known_shape_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for gamma_known_shape model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n' for use with gamma_known_shape()
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

geometric_beta_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for geometric_beta model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n' for use with geometric_beta()

Source code in conjugate/helpers.py

def geometric_beta_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for geometric_beta model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n' for use with geometric_beta()
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

hypergeometric_beta_binomial_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for hypergeometric_beta_binomial model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n' for use with hypergeometric_beta_binomial()

Source code in conjugate/helpers.py

def hypergeometric_beta_binomial_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for hypergeometric_beta_binomial model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n' for use with hypergeometric_beta_binomial()
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

inverse_gamma_known_rate_inputs(x, *, sum_fn=None, len_fn=None, reciprocal_fn=None, asarray_fn=None)

Extract sufficient statistics for inverse_gamma_known_rate model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
reciprocal_fn	Callable | None	Function for reciprocal (1/x), defaults to lambda x: 1.0/x	None
asarray_fn	Callable | None	Function to convert to array, defaults to np.asarray	None

Returns:

Type	Description
dict	Dict with keys 'reciprocal_x_total' and 'n'

Source code in conjugate/helpers.py

def inverse_gamma_known_rate_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    reciprocal_fn: Callable | None = None,
    asarray_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for inverse_gamma_known_rate model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        reciprocal_fn: Function for reciprocal (1/x), defaults to lambda x: 1.0/x
        asarray_fn: Function to convert to array, defaults to np.asarray

    Returns:
        Dict with keys 'reciprocal_x_total' and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if reciprocal_fn is None:
        reciprocal_fn = _default_reciprocal
    if asarray_fn is None:
        asarray_fn = np.asarray

    # Convert to array first to handle list inputs properly
    x_arr = asarray_fn(x)

    return {
        "reciprocal_x_total": sum_fn(reciprocal_fn(x_arr)),
        "n": len_fn(x),
    }

linear_regression_inputs(X, y)

Identity helper for linear_regression model.

Returns X and y unchanged for API consistency.

Parameters:

Name	Type	Description	Default
X		Design matrix	required
y		Response vector	required

Returns:

Type	Description
dict	Dict with keys 'X' and 'y'

Source code in conjugate/helpers.py

def linear_regression_inputs(X, y) -> dict:
    """Identity helper for linear_regression model.

    Returns X and y unchanged for API consistency.

    Args:
        X: Design matrix
        y: Response vector

    Returns:
        Dict with keys 'X' and 'y'
    """
    return {"X": X, "y": y}

log_normal_inputs(x, *, sum_fn=None, len_fn=None, log_fn=None, power_fn=None)

Extract sufficient statistics for log_normal model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
log_fn	Callable | None	Function for natural log, defaults to np.log	None
power_fn	Callable | None	Function for element-wise power, defaults to np.power	None

Returns:

Type	Description
dict	Dict with keys 'ln_x_total', 'ln_x2_total', and 'n'

Source code in conjugate/helpers.py

def log_normal_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    log_fn: Callable | None = None,
    power_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for log_normal model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        log_fn: Function for natural log, defaults to np.log
        power_fn: Function for element-wise power, defaults to np.power

    Returns:
        Dict with keys 'ln_x_total', 'ln_x2_total', and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if log_fn is None:
        log_fn = _default_log
    if power_fn is None:
        power_fn = _default_power

    ln_x = log_fn(x)

    return {
        "ln_x_total": sum_fn(ln_x),
        "ln_x2_total": sum_fn(power_fn(ln_x, 2)),
        "n": len_fn(x),
    }

multinomial_dirichlet_inputs(x)

Extract sufficient statistics for multinomial_dirichlet model.

Parameters:

Name	Type	Description	Default
x		Observed counts for each category (array-like)	required

Returns:

Type	Description
dict	Dict with key 'x' for use with multinomial_dirichlet()

Source code in conjugate/helpers.py

def multinomial_dirichlet_inputs(x) -> dict:
    """Extract sufficient statistics for multinomial_dirichlet model.

    Args:
        x: Observed counts for each category (array-like)

    Returns:
        Dict with key 'x' for use with multinomial_dirichlet()
    """
    return {"x": x}

multivariate_normal_inputs(X)

Identity helper for multivariate_normal model.

Parameters:

Name	Type	Description	Default
X		Observations matrix	required

Returns:

Type	Description
dict	Dict with key 'X'

Source code in conjugate/helpers.py

def multivariate_normal_inputs(X) -> dict:
    """Identity helper for multivariate_normal model.

    Args:
        X: Observations matrix

    Returns:
        Dict with key 'X'
    """
    return {"X": X}

multivariate_normal_known_covariance_inputs(X, *, len_fn=None, mean_fn=None)

Extract sufficient statistics for multivariate_normal_known_covariance model.

Parameters:

Name	Type	Description	Default
X		Array of multivariate observations	required
len_fn	Callable | None	Function to compute length, defaults to x.shape[0]	None
mean_fn	Callable | None	Function to compute mean along axis 0, defaults to np.mean	None

Returns:

Type	Description
dict	Dict with keys 'x_bar' and 'n'

Source code in conjugate/helpers.py

def multivariate_normal_known_covariance_inputs(
    X,
    *,
    len_fn: Callable | None = None,
    mean_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for multivariate_normal_known_covariance model.

    Args:
        X: Array of multivariate observations
        len_fn: Function to compute length, defaults to x.shape[0]
        mean_fn: Function to compute mean along axis 0, defaults to np.mean

    Returns:
        Dict with keys 'x_bar' and 'n'
    """
    if len_fn is None:

        def default_len_fn(x):
            return x.shape[0]  # Number of rows

        len_fn = default_len_fn
    if mean_fn is None:

        def default_mean_fn(x):
            return np.mean(x, axis=0)

        mean_fn = default_mean_fn

    return {
        "x_bar": mean_fn(X),
        "n": len_fn(X),
    }

multivariate_normal_known_mean_inputs(X, mu)

Identity helper for multivariate_normal_known_mean model.

Parameters:

Name	Type	Description	Default
X		Observations matrix	required
mu		Known mean	required

Returns:

Type	Description
dict	Dict with keys 'X' and 'mu'

Source code in conjugate/helpers.py

def multivariate_normal_known_mean_inputs(X, mu) -> dict:
    """Identity helper for multivariate_normal_known_mean model.

    Args:
        X: Observations matrix
        mu: Known mean

    Returns:
        Dict with keys 'X' and 'mu'
    """
    return {"X": X, "mu": mu}

multivariate_normal_known_precision_inputs(X, *, len_fn=None, mean_fn=None)

Extract sufficient statistics for multivariate_normal_known_precision model.

Parameters:

Name	Type	Description	Default
X		Observations matrix (n_samples x n_features)	required
len_fn	Callable | None	Function to count samples (rows), defaults to len-like	None
mean_fn	Callable | None	Function to compute mean along axis 0, defaults to np.mean	None

Returns:

Type	Description
dict	Dict with keys 'x_bar' and 'n'

Source code in conjugate/helpers.py

def multivariate_normal_known_precision_inputs(
    X,
    *,
    len_fn: Callable | None = None,
    mean_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for multivariate_normal_known_precision model.

    Args:
        X: Observations matrix (n_samples x n_features)
        len_fn: Function to count samples (rows), defaults to len-like
        mean_fn: Function to compute mean along axis 0, defaults to np.mean

    Returns:
        Dict with keys 'x_bar' and 'n'
    """
    if len_fn is None:

        def default_len_fn(x):
            return x.shape[0]  # Number of rows

        len_fn = default_len_fn
    if mean_fn is None:

        def default_mean_fn(x):
            return np.mean(x, axis=0)

        mean_fn = default_mean_fn

    return {
        "x_bar": mean_fn(X),
        "n": len_fn(X),
    }

negative_binomial_beta_inputs(x, r, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for negative_binomial_beta model.

Parameters:

Name	Type	Description	Default
x		Number of successes per experiment (array-like or scalar)	required
r		Known number of failures per experiment (constant across all experiments)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x', 'n', and 'r' for use with negative_binomial_beta()

Example

from conjugate.models import negative_binomial_beta
from conjugate.helpers import negative_binomial_beta_inputs

successes = [2, 3, 1]  # successes in 3 experiments
failures_per_exp = 5  # known failures per experiment
inputs = negative_binomial_beta_inputs(successes, failures_per_exp)
# inputs = {'x': 6, 'n': 3, 'r': 5}
posterior = negative_binomial_beta(**inputs, prior=prior)

Source code in conjugate/helpers.py

def negative_binomial_beta_inputs(
    x,
    r,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for negative_binomial_beta model.

    Args:
        x: Number of successes per experiment (array-like or scalar)
        r: Known number of failures per experiment (constant across all experiments)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x', 'n', and 'r' for use with negative_binomial_beta()

    Example:
        ```python
        from conjugate.models import negative_binomial_beta
        from conjugate.helpers import negative_binomial_beta_inputs

        successes = [2, 3, 1]  # successes in 3 experiments
        failures_per_exp = 5  # known failures per experiment
        inputs = negative_binomial_beta_inputs(successes, failures_per_exp)
        # inputs = {'x': 6, 'n': 3, 'r': 5}
        posterior = negative_binomial_beta(**inputs, prior=prior)
        ```
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x": sum_fn(x),
        "n": len_fn(x),
        "r": r,
    }

normal_inputs(x, *, sum_fn=None, len_fn=None, power_fn=None)

Extract sufficient statistics for normal model.

Works with: normal

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
power_fn	Callable | None	Function for element-wise power, defaults to np.power	None

Returns:

Type	Description
dict	Dict with keys 'x_total', 'x2_total', and 'n'

Source code in conjugate/helpers.py

def normal_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    power_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for normal model.

    Works with: normal

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        power_fn: Function for element-wise power, defaults to np.power

    Returns:
        Dict with keys 'x_total', 'x2_total', and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if power_fn is None:
        power_fn = _default_power

    return {
        "x_total": sum_fn(x),
        "x2_total": sum_fn(power_fn(x, 2)),
        "n": len_fn(x),
    }

normal_known_mean_inputs(x, *, sum_fn=None, len_fn=None, power_fn=None)

Extract sufficient statistics for normal_known_mean model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
power_fn	Callable | None	Function for element-wise power, defaults to np.power	None

Returns:

Type	Description
dict	Dict with keys 'x_total', 'x2_total', and 'n'

Source code in conjugate/helpers.py

def normal_known_mean_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    power_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for normal_known_mean model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        power_fn: Function for element-wise power, defaults to np.power

    Returns:
        Dict with keys 'x_total', 'x2_total', and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if power_fn is None:
        power_fn = _default_power

    return {
        "x_total": sum_fn(x),
        "x2_total": sum_fn(power_fn(x, 2)),
        "n": len_fn(x),
    }

normal_known_precision_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for normal_known_precision model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n'

Source code in conjugate/helpers.py

def normal_known_precision_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for normal_known_precision model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

normal_known_variance_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for normal_known_variance model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n'

Source code in conjugate/helpers.py

def normal_known_variance_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for normal_known_variance model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

pareto_gamma_inputs(x, *, x_m=None, sum_fn=None, len_fn=None, log_fn=None)

Extract sufficient statistics for pareto_gamma model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
x_m	float | None	Known minimum value. If provided, returns ready-to-use dict. If None, returns raw ln_x_total (user must handle x_m separately).	None
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
log_fn	Callable | None	Function for natural log, defaults to np.log	None

Returns:

Type	Description
dict	Dict with keys 'ln_x_total', 'n', and 'x_m' (if provided)

Source code in conjugate/helpers.py

def pareto_gamma_inputs(
    x,
    *,
    x_m: float | None = None,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    log_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for pareto_gamma model.

    Args:
        x: Observations (array-like or scalar)
        x_m: Known minimum value. If provided, returns ready-to-use dict.
             If None, returns raw ln_x_total (user must handle x_m separately).
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        log_fn: Function for natural log, defaults to np.log

    Returns:
        Dict with keys 'ln_x_total', 'n', and 'x_m' (if provided)
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if log_fn is None:
        log_fn = _default_log

    n = len_fn(x)
    ln_x_total = sum_fn(log_fn(x))

    result = {"n": n, "ln_x_total": ln_x_total}

    if x_m is not None:
        result["x_m"] = x_m

    return result

poisson_gamma_inputs(x, *, sum_fn=None, len_fn=None)

Extract sufficient statistics for poisson_gamma model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_total' and 'n' for use with poisson_gamma()

Example

from conjugate.models import poisson_gamma
from conjugate.helpers import poisson_gamma_inputs

data = [3, 5, 2, 4]
inputs = poisson_gamma_inputs(data)
# inputs = {'x_total': 14, 'n': 4}
posterior = poisson_gamma(**inputs, prior=prior)

Source code in conjugate/helpers.py

def poisson_gamma_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for poisson_gamma model.

    Args:
        x: Observations (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_total' and 'n' for use with poisson_gamma()

    Example:
        ```python
        from conjugate.models import poisson_gamma
        from conjugate.helpers import poisson_gamma_inputs

        data = [3, 5, 2, 4]
        inputs = poisson_gamma_inputs(data)
        # inputs = {'x_total': 14, 'n': 4}
        posterior = poisson_gamma(**inputs, prior=prior)
        ```
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_total": sum_fn(x),
        "n": len_fn(x),
    }

uniform_pareto_inputs(x, *, max_fn=None, len_fn=None)

Extract sufficient statistics for uniform_pareto model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
max_fn	Callable | None	Function to find maximum, defaults to np.max	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None

Returns:

Type	Description
dict	Dict with keys 'x_max' and 'n'

Source code in conjugate/helpers.py

def uniform_pareto_inputs(
    x,
    *,
    max_fn: Callable | None = None,
    len_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for uniform_pareto model.

    Args:
        x: Observations (array-like or scalar)
        max_fn: Function to find maximum, defaults to np.max
        len_fn: Function to count elements, defaults to size via np.atleast_1d

    Returns:
        Dict with keys 'x_max' and 'n'
    """
    if max_fn is None:
        max_fn = _default_max
    if len_fn is None:
        len_fn = _default_len

    return {
        "x_max": max_fn(x),
        "n": len_fn(x),
    }

von_mises_known_concentration_inputs(x, *, sum_fn=None, len_fn=None, cos_fn=None, sin_fn=None)

Extract sufficient statistics for von_mises_known_concentration model.

Parameters:

Name	Type	Description	Default
x		Observations - angular data (array-like or scalar)	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
cos_fn	Callable | None	Function for cosine, defaults to np.cos	None
sin_fn	Callable | None	Function for sine, defaults to np.sin	None

Returns:

Type	Description
dict	Dict with keys 'cos_total', 'sin_total', and 'n'

Source code in conjugate/helpers.py

def von_mises_known_concentration_inputs(
    x,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    cos_fn: Callable | None = None,
    sin_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for von_mises_known_concentration model.

    Args:
        x: Observations - angular data (array-like or scalar)
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        cos_fn: Function for cosine, defaults to np.cos
        sin_fn: Function for sine, defaults to np.sin

    Returns:
        Dict with keys 'cos_total', 'sin_total', and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if cos_fn is None:
        cos_fn = _default_cos
    if sin_fn is None:
        sin_fn = _default_sin

    return {
        "cos_total": sum_fn(cos_fn(x)),
        "sin_total": sum_fn(sin_fn(x)),
        "n": len_fn(x),
    }

von_mises_known_direction_inputs(x, mu, *, sum_fn=None, len_fn=None, cos_fn=None, asarray_fn=None)

Extract sufficient statistics for von_mises_known_direction model.

Parameters:

Name	Type	Description	Default
x		Observations - angular data (array-like or scalar)	required
mu		Known direction parameter	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
cos_fn	Callable | None	Function for cosine, defaults to np.cos	None
asarray_fn	Callable | None	Function to convert to array, defaults to np.asarray	None

Returns:

Type	Description
dict	Dict with keys 'centered_cos_total' and 'n'

Source code in conjugate/helpers.py

def von_mises_known_direction_inputs(
    x,
    mu,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    cos_fn: Callable | None = None,
    asarray_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for von_mises_known_direction model.

    Args:
        x: Observations - angular data (array-like or scalar)
        mu: Known direction parameter
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        cos_fn: Function for cosine, defaults to np.cos
        asarray_fn: Function to convert to array, defaults to np.asarray

    Returns:
        Dict with keys 'centered_cos_total' and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if cos_fn is None:
        cos_fn = _default_cos
    if asarray_fn is None:
        asarray_fn = np.asarray

    x = asarray_fn(x)

    return {
        "centered_cos_total": sum_fn(cos_fn(x - mu)),
        "n": len_fn(x),
    }

weibull_inverse_gamma_known_shape_inputs(x, beta, *, sum_fn=None, len_fn=None, power_fn=None)

Extract sufficient statistics for weibull_inverse_gamma_known_shape model.

Parameters:

Name	Type	Description	Default
x		Observations (array-like or scalar)	required
beta		Known shape parameter	required
sum_fn	Callable | None	Function to sum elements, defaults to np.sum	None
len_fn	Callable | None	Function to count elements, defaults to size via np.atleast_1d	None
power_fn	Callable | None	Function for element-wise power, defaults to np.power	None

Returns:

Type	Description
dict	Dict with keys 'x_beta_total' and 'n'

Source code in conjugate/helpers.py

def weibull_inverse_gamma_known_shape_inputs(
    x,
    beta,
    *,
    sum_fn: Callable | None = None,
    len_fn: Callable | None = None,
    power_fn: Callable | None = None,
) -> dict:
    """Extract sufficient statistics for weibull_inverse_gamma_known_shape model.

    Args:
        x: Observations (array-like or scalar)
        beta: Known shape parameter
        sum_fn: Function to sum elements, defaults to np.sum
        len_fn: Function to count elements, defaults to size via np.atleast_1d
        power_fn: Function for element-wise power, defaults to np.power

    Returns:
        Dict with keys 'x_beta_total' and 'n'
    """
    if sum_fn is None:
        sum_fn = _default_sum
    if len_fn is None:
        len_fn = _default_len
    if power_fn is None:
        power_fn = _default_power

    return {
        "x_beta_total": sum_fn(power_fn(x, beta)),
        "n": len_fn(x),
    }

Comments