Distributions

Example:

import probpy as pp

rv = pp.normal.med(mu=1.0, sigma=2.0)

samples = rv.sample(size=100)
densities = rv.p(samples)

# conditional distribution

rv = pp.normal.med(sigma=2.0)

samples = rv.sample(mu=1.0, size=100)
densities = rv.p(samples, mu=1.0)
class probpy.distributions.normal.MultiVariateNormal[source]

Multivariate Normal Distribution

classmethod med(mu: numpy.ndarray = None, sigma: numpy.ndarray = None, k=None) → probpy.core.RandomVariable[source]
Parameters:
  • mu – mean
  • sigma – variance
  • k – dimensions (optional)
Returns:

RandomVariable
sample[source]

param mu – mean :param sigma: variance :param size: number of samples :return: array of samples

class probpy.distributions.normal.Normal[source]

Standard Normal Distribution

classmethod med(mu: float = None, sigma: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • mu – mean
  • sigma – variance
Returns:

RandomVariable
static p(x: numpy.ndarray, mu: float, sigma: float) → numpy.ndarray[source]
Parameters:
  • x – samples
  • mu – mean
  • sigma – variance
Returns:

densities
sample[source]

param mu – mean :param sigma: variance :param size: number of samples :return: array of samples

class probpy.distributions.bernoulli.Bernoulli[source]

Bernoulli Distribution

classmethod med(probability: numpy.float32 = None) → probpy.core.RandomVariable[source]
Parameters:probability – probability of positive outcome
Returns:RandomVariable
static p(x: numpy.ndarray, probability: numpy.float32) → numpy.ndarray[source]
Parameters:
  • x –
  • probability – probability of positive outcome
Returns:

array of samples
static sample(probability: numpy.float32, size: int = 1) → numpy.ndarray[source]
Parameters:
  • probability – probability of positive outcome
  • size – number of samples
Returns:

array of samples
class probpy.distributions.beta.Beta[source]

Beta distribution

classmethod med(a: float = None, b: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • a – alpha shape
  • b – beta shape
Returns:

RandomVariable
static p(x: numpy.ndarray, a: float, b: float) → numpy.ndarray[source]
Parameters:
  • x – samples
  • a – alpha shape
  • b – beta shape
Returns:

densities
static sample(a: float, b: float, size: int = 1) → numpy.ndarray[source]
Parameters:
  • a – alpha shape
  • b – beta shape
  • size – number of samples
Returns:

array of samples
class probpy.distributions.binomial.Binomial[source]

Binomial distribution

classmethod med(n: int = None, probability: numpy.float32 = None) → probpy.core.RandomVariable[source]
Parameters:
  • n – number of observations
  • probability – probability of positive observation
Returns:

RandomVariable
p[source]

param x – samples :param n: number of observations :param probability: probability of positive observatiosn :return: array of samples

sample[source]

param n – number of observations :param probability: probability of positive observations :param size: number of samples :return: array of samples

class probpy.distributions.categorical.Categorical[source]

Categorical Distribution

classmethod med(probabilities: numpy.ndarray = None, categories: int = None) → probpy.core.RandomVariable[source]
Parameters:
  • probabilities – probability of categories
  • categories – number of categories
Returns:

RandomVariable
static p(x: numpy.ndarray, probabilities: numpy.ndarray) → numpy.ndarray[source]
Parameters:
  • x – samples
  • probabilities – probability of categories
Returns:

densities
sample[source]

param probabilities – probability of categories :param size: number of samples :return: array of samples

class probpy.distributions.dirichlet.Dirichlet[source]

Dirichlet Distribution

classmethod med(alpha: numpy.ndarray = None, categories: int = None) → probpy.core.RandomVariable[source]
Parameters:
  • alpha – probability weights
  • categories – number of categories
Returns:
static p(x: numpy.ndarray, alpha: numpy.ndarray) → numpy.ndarray[source]
Parameters:
  • x – samples
  • alpha – probability weights
Returns:

densities
static sample(alpha: numpy.ndarray, size: int = 1) → numpy.ndarray[source]
Parameters:
  • alpha – probability weights
  • size – number of samples
Returns:

array of samples
class probpy.distributions.exponential.Exponential[source]

Exponential distribution

classmethod med(lam: float = None) → probpy.core.RandomVariable[source]
Parameters:lam – lambda, rate parameter
Returns:RandomVariable
static p(x: numpy.ndarray, lam: float) → numpy.ndarray[source]
Parameters:
  • x – samples
  • lam – lambda, rate parameter
Returns:

densities
static sample(lam: float, size: int = 1) → numpy.ndarray[source]
Parameters:
  • lam – lambda, rate parameter
  • size – number of samples
Returns:

array of samples
class probpy.distributions.function.Function[source]

Distribution from function

classmethod med(density, lower_bound: numpy.ndarray, upper_bound: numpy.ndarray, points: int = 1000, variance: float = 2.0, error: float = 0.1, batch: int = 25, verbose: bool = False) → probpy.core.RandomVariable[source]
Parameters:
  • density – function to act as density
  • lower_bound – lower bound of density
  • upper_bound – upper bound of density
  • points – points to estimate density
  • variance – variance of kernel
  • error – tolerance of normalization constant error
  • batch – particles in each mcmc step
  • verbose – print error will estimating partition
Returns:

RandomVariable
class probpy.distributions.gamma.Gamma[source]

Gamma distribution

classmethod med(a: float = None, b: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • a – shape
  • b – rate
Returns:

RandomVariable
static p(x: numpy.ndarray, a: float, b: float) → numpy.ndarray[source]
Parameters:
  • x – samples
  • a – shape
  • b – rate
Returns:

densities
static sample(a: float, b: float, size: int = 1) → numpy.ndarray[source]
Parameters:
  • a – shape
  • b – rate
  • size – number of samples
Returns:

array of samples
class probpy.distributions.gaussian_process.GaussianProcess[source]

Gaussian Process

classmethod med(x: numpy.ndarray = None, mu: typing.Callable[numpy.ndarray, float] = None, sigma: typing.Callable[[numpy.ndarray, numpy.ndarray], float] = None, X: numpy.ndarray = None, Y: numpy.ndarray = None) → probpy.core.RandomVariable[source]
Parameters:
  • x – non-observed samples
  • mu – mean function
  • sigma – variance function
  • X – observed samples
  • Y – observed values
Returns:

RandomVariable
static p(y: numpy.ndarray, x: numpy.ndarray, mu: typing.Callable[numpy.ndarray, float], sigma: typing.Callable[[numpy.ndarray, numpy.ndarray], float], X: numpy.ndarray, Y: numpy.ndarray) → numpy.ndarray[source]
Parameters:
  • y – non-observed values
  • x – non-observed samples
  • mu – mean function
  • sigma – variance function
  • X – observed samples
  • Y – observed values
Returns:

densities
static sample(x: numpy.ndarray, mu: typing.Callable[numpy.ndarray, float], sigma: typing.Callable[[numpy.ndarray, numpy.ndarray], float], X: numpy.ndarray, Y: numpy.ndarray, size: int = 1) → numpy.ndarray[source]
Parameters:
  • x – non-observed samples
  • mu – mean function
  • sigma – variance function
  • X – observed samples
  • Y – observed values
  • size – number of samples
Returns:

array of samples
class probpy.distributions.geometric.Geometric[source]

Geometric distribution

classmethod med(probability: float = None) → probpy.core.RandomVariable[source]
Parameters:probability – probability of success
Returns:RandomVariable
class probpy.distributions.hypergeometric.Hypergeometric[source]

Hypergeometric distribution

classmethod med(N: int = None, K: int = None, n: int = None) → probpy.core.RandomVariable[source]
Parameters:
  • N – population size
  • K – success states in population
  • n – number of draws
Returns:

RandomVariable
class probpy.distributions.multinomial.Multinomial[source]

Multinomial distribution

classmethod med(n: int = None, probabilities: numpy.ndarray = None, outcomes: int = None) → probpy.core.RandomVariable[source]
Parameters:
  • n – number of observations
  • probabilities – probability for each outcome
  • outcomes – number of outcomes
Returns:

RandomVariable
class probpy.distributions.normal_inverse_gamma.NormalInverseGamma[source]

Normal Inverse Gamma distribution

classmethod med(mu: float = None, lam: float = None, a: float = None, b: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • mu – mean
  • lam – precision
  • a – shape
  • b – rate
Returns:

RandomVariable
class probpy.distributions.points.Points[source]

Distribution of points

classmethod med(points: numpy.ndarray = None, variance: float = 2.0, error: float = 0.1, verbose: bool = False, density_estimator: probpy.core.Density = <class 'probpy.density.nonparametric_convolution.RCKD'>) → probpy.core.RandomVariable[source]
Parameters:
  • points – points to estimate density from
  • variance – variance of kernel
  • error – acceptable error of partition function
  • verbose – print estimation of partition function
  • density_estimator – density estimator
Returns:
class probpy.distributions.poisson.Poisson[source]

Poisson distribution

classmethod med(lam: numpy.float32 = None) → probpy.core.RandomVariable[source]
Parameters:lam – rate
Returns:RandomVariable
class probpy.distributions.uniform.MultiVariateUniform[source]

Multivariate Uniform distribution

classmethod med(a: numpy.ndarray = None, b: numpy.ndarray = None, dimension: typing.Tuple = None) → probpy.core.RandomVariable[source]
Parameters:
  • a – lower bound
  • b – upper bound
  • dimension – dimension of r.v
Returns:

RandomVariable
class probpy.distributions.uniform.Uniform[source]

Uniform Distribution

classmethod med(a: float = None, b: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • a – lower bound
  • b – upper bound
Returns:

RandomVariable
class probpy.distributions.unilinear.UniLinear[source]

Linear with one target distribution

classmethod med(x: numpy.ndarray = None, variables: numpy.ndarray = None, sigma: float = None) → probpy.core.RandomVariable[source]
Parameters:
  • x – input
  • variables – weights
  • sigma – variance of estimates
Returns:

RandomVariable