Poisson distribution

The Poisson distribution is a discrete distribution used to model occurrences and counts of rare events in an interval of time and/or space, when these are independent with constant average event rate \(\lambda\). The probability mass function for \(k \in \mathbb{N}_0\) is

\[f(k; \lambda) = \frac{\lambda^k e^{-\lambda}}{k!}\]

and the cumulative distribution function is

\[F(k; \lambda) = Q(1 + \lfloor k \rfloor, \lambda),\]

where \(Q(a, z)\) is the regularized incomplete gamma function and \(\lfloor x \rfloor\) is the floor function. Finally, the expected value and variance is \(\lambda\).

The Poisson distribution is applied to forecast arrival of customers for service at the checkout or visits to a website.

class cprior.models.PoissonModel(name='', shape=0.001, rate=0.001)

Bases: cprior.cdist.gamma.GammaModel

Bayesian model with a Poisson likelihood and a gamma prior distribution.

Given data samples \(\mathbf{x} = (x_1, \ldots, x_n)\) from a Poisson distribution with parameter \(\lambda\), the posterior distribution is

\[\lambda | \mathbf{x} \sim \mathcal{G}\left(\alpha + \sum_{i=1}^n x_i, \beta + n \right).\]

with prior parameters \(\alpha\) (shape) and \(\beta\) (rate).

Parameters:
  • name (str (default="")) – Model name.
  • shape (float (default=0.001)) – Prior parameter shape.
  • rate (float (default=0.001)) – Prior parameter rate.
n_samples_

Number of samples.

Type:int
cdf(x)

Cumulative distribution function of the posterior distribution.

Parameters:x (array-like) – Quantiles.
Returns:cdf – Cumulative distribution function evaluated at x.
Return type:numpy.ndarray
credible_interval(interval_length)

Credible interval of the posterior distribution.

Parameters:interval_length (float (default=0.9)) – Compute interval_length% credible interval. This is a value in [0, 1].
Returns:interval – Lower and upper credible interval limits.
Return type:tuple
mean()

Mean of the posterior distribution.

Returns:mean
Return type:float
pdf(x)

Probability density function of the posterior distribution.

Parameters:x (array-like) – Quantiles.
Returns:pdf – Probability density function evaluated at x.
Return type:numpy.ndarray
ppf(q)

Percent point function (quantile) of the posterior distribution.

Parameters:x (array-like) – Lower tail probability.
Returns:ppf – Quantile corresponding to the lower tail probability q.
Return type:numpy.ndarray
ppmean()

Posterior predictive mean.

If \(X\) follows a Poisson distribution with parameter \(\lambda\), then the posterior predictive expected value is given by

\[\mathrm{E}[X] = \frac{\alpha}{\beta},\]

where \(\alpha\) and \(\beta\) are the posterior values of the parameters.

Returns:mean
Return type:float
pppdf(x)

Posterior predictive probability density function.

If \(X\) follows a Poisson distribution with parameter \(\lambda\), then the posterior predictive probability density function is given by

\[f(x; \alpha, \beta) = \binom{x + \alpha - 1}{\alpha -1} \left(\frac{\beta}{\beta + 1}\right)^{\alpha} \left(\frac{1}{\beta + 1}\right)^x,\]

where \(\alpha\) and \(\beta\) are the posterior values of the parameters. Note that this is the probability mass function of the negative binomial distribution, thus

\[X \sim \mathcal{NB}\left(\alpha, \frac{\beta}{\beta + 1}\right)\]
Parameters:x (array-like) – Quantiles.
Returns:pdf – Probability density function evaluated at x.
Return type:float
ppvar()

Posterior predictive variance.

If \(X\) follows a Poisson distribution with parameter \(\lambda\), then the posterior predictive variance is given by

\[\mathrm{Var}[X] = \frac{\alpha(\beta + 1)}{\beta^2},\]

where \(\alpha\) and \(\beta\) are the posterior values of the parameters.

Returns:var
Return type:float
rate_posterior

Posterior parameter beta (rate).

Returns:beta
Return type:float
rvs(size=1, random_state=None)

Random variates of the posterior distribution.

Parameters:
  • size (int (default=1)) – Number of random variates.
  • random_state (int or None (default=None)) – The seed used by the random number generator.
Returns:

rvs – Random variates of given size.
Return type:

numpy.ndarray or scalar
shape_posterior

Posterior parameter alpha (shape).

Returns:alpha
Return type:float
std()

Standard deviation of the posterior distribution.

Returns:std
Return type:float
update(data)

Update posterior parameters with new data.

Parameters:data (array-like, shape = (n_samples)) – Data samples from a Poisson distribution.
var()

Variance of the posterior distribution.

Returns:var
Return type:float
class cprior.models.PoissonABTest(modelA, modelB, simulations=1000000, random_state=None)

Bases: cprior.cdist.gamma.GammaABTest

Poisson A/B test.

Parameters:
  • modelA (object) – The control model.
  • modelB (object) – The variation model.
  • simulations (int or None (default=1000000)) – Number of Monte Carlo simulations.
  • random_state (int or None (default=None)) – The seed used by the random number generator.
expected_loss(method='exact', variant='A', lift=0)

Compute the expected loss. This is the expected uplift lost by choosing a given variant.

  • If variant == "A", \(\mathrm{E}[\max(B - A - lift, 0)]\)
  • If variant == "B", \(\mathrm{E}[\max(A - B - lift, 0)]\)
  • If variant == "all", both.

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • variant (str (default="A")) – The chosen variant. Options are “A”, “B”, “all”.
  • lift (float (default=0.0)) – The amount of uplift.
Returns:

exoected_loss
Return type:

float or tuple of floats
expected_loss_ci(method='MC', variant='A', interval_length=0.9, ci_method='ETI')

Compute credible intervals on the difference distribution of \(Z = B-A\) and/or \(Z = A-B\).

  • If variant == "A", \(Z = B - A\)
  • If variant == "B", \(Z = A - B\)
  • If variant == "all", both.
Parameters:
  • method (str (default="MC")) – The method of computation. Options are “asymptotic” and “MC”.
  • variant (str (default="A")) – The chosen variant. Options are “A”, “B”, “all”.
  • interval_length (float (default=0.9)) – Compute interval_length% credible interval. This is a value in [0, 1].
  • ci_method (str (default="ETI")) – Method to compute credible intervals. Supported methods are Highest Density interval (method="HDI) and Equal-tailed interval (method="ETI"). Currently, method="HDI is only available for method="MC".
Returns:

expected_loss_ci
Return type:

np.ndarray or tuple of np.ndarray
expected_loss_relative(method='exact', variant='A')

Compute expected relative loss for choosing a variant. This can be seen as the negative expected relative improvement or uplift.

  • If variant == "A", \(\mathrm{E}[(B - A) / A]\)
  • If variant == "B", \(\mathrm{E}[(A - B) / B]\)
  • If variant == "all", both.
Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • variant (str (default="A")) – The chosen variant. Options are “A”, “B”, “all”.
Returns:

expected_loss_relative
Return type:

float or tuple of floats
expected_loss_relative_ci(method='MC', variant='A', interval_length=0.9, ci_method='ETI')

Compute credible intervals on the relative difference distribution of \(Z = (B-A)/A\) and/or \(Z = (A-B)/B\).

  • If variant == "A", \(Z = (B-A)/A\)
  • If variant == "B", \(Z = (A-B)/B\)
  • If variant == "all", both.
Parameters:
  • method (str (default="MC")) – The method of computation. Options are “asymptotic”, “exact” and “MC”.
  • variant (str (default="A")) – The chosen variant. Options are “A”, “B”, “all”.
  • interval_length (float (default=0.9)) – Compute interval_length% credible interval. This is a value in [0, 1].
  • ci_method (str (default="ETI")) – Method to compute credible intervals. Supported methods are Highest Density interval (method="HDI) and Equal-tailed interval (method="ETI"). Currently, method="HDI is only available for method="MC".
Returns:

expected_loss_relative_ci
Return type:

np.ndarray or tuple of np.ndarray
probability(method='exact', variant='A', lift=0)

Compute the error probability or chance to beat control.

  • If variant == "A", \(P[A > B + lift]\)
  • If variant == "B", \(P[B > A + lift]\)
  • If variant == "all", both.

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • variant (str (default="A")) – The chosen variant. Options are “A”, “B”, “all”.
  • lift (float (default=0.0)) – The amount of uplift.
Returns:

probability
Return type:

float or tuple of floats
update_A(data)

Update posterior parameters for variant A with new data samples.

Parameters:data (array-like, shape = (n_samples)) –
update_B(data)

Update posterior parameters for variant B with new data samples.

Parameters:data (array-like, shape = (n_samples)) –
class cprior.models.PoissonMVTest(models, simulations=1000000, random_state=None, n_jobs=None)

Bases: cprior.cdist.gamma.GammaMVTest

Poisson Multivariate test.

Parameters:
  • models (dict) – The control and variations models.
  • simulations (int or None (default=1000000)) – Number of Monte Carlo simulations.
  • random_state (int or None (default=None)) – The seed used by the random number generator.
expected_loss(method='exact', control='A', variant='B', lift=0)

Compute the expected loss. This is the expected uplift lost by choosing a given variant, i.e., \(\mathrm{E}[\max(control - variant - lift, 0)]\).

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • control (str (default="A")) – The control variant.
  • variant (str (default="B")) – The tested variant.
  • lift (float (default=0.0)) – The amount of uplift.
Returns:

expected_loss
Return type:

float
expected_loss_ci(method='MC', control='A', variant='B', interval_length=0.9, ci_method='ETI')

Compute credible intervals on the difference distribution of \(Z = control-variant\).

Parameters:
  • method (str (default="MC")) – The method of computation. Options are “asymptotic” and “MC”.
  • control (str (default="A")) – The control variant.
  • variant (str (default="B")) – The tested variant.
  • interval_length (float (default=0.9)) – Compute interval_length% credible interval. This is a value in [0, 1].
  • ci_method (str (default="ETI")) – Method to compute credible intervals. Supported methods are Highest Density interval (method="HDI) and Equal-tailed interval (method="ETI"). Currently, method="HDI is only available for method="MC".
Returns:

expected_loss_ci
Return type:

np.ndarray or tuple of np.ndarray
expected_loss_relative(method='exact', control='A', variant='B')

Compute expected relative loss for choosing a variant. This can be seen as the negative expected relative improvement or uplift, i.e., \(\mathrm{E}[(control - variant) / variant]\).

Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • control (str (default="A")) – The control variant.
  • variant (str (default="B")) – The tested variant.
Returns:

expected_loss_relative
Return type:

float
expected_loss_relative_ci(method='MC', control='A', variant='B', interval_length=0.9, ci_method='ETI')

Compute credible intervals on the relative difference distribution of \(Z = (control - variant) / variant\).

Parameters:
  • method (str (default="MC")) – The method of computation. Options are “asymptotic”, “exact” and “MC”.
  • control (str (default="A")) – The control variant.
  • variant (str (default="B")) – The tested variant.
  • interval_length (float (default=0.9)) – Compute interval_length% credible interval. This is a value in [0, 1].
  • ci_method (str (default="ETI")) – Method to compute credible intervals. Supported methods are Highest Density interval (method="HDI) and Equal-tailed interval (method="ETI"). Currently, method="HDI is only available for method="MC".
Returns:

expected_loss_relative_ci
Return type:

np.ndarray or tuple of np.ndarray
expected_loss_relative_vs_all(method='MLHS', control='A', variant='B', mlhs_samples=1000)

Compute the expected relative loss against all variations. For example, given variants “A”, “B”, “C” and “D”, and choosing variant=”B”, we compute \(\mathrm{E}[(\max(A, C, D) - B) / B]\).

Parameters:
  • method (str (default="MLHS")) – The method of computation. Options are “MC” (Monte Carlo), “MLHS” (Monte Carlo + Median Latin Hypercube Sampling) and “quad” (numerical integration).
  • variant (str (default="B")) – The chosen variant.
  • mlhs_samples (int (default=1000)) – Number of samples for MLHS method.
Returns:

expected_loss_relative_vs_all
Return type:

float
expected_loss_vs_all(method='quad', variant='B', lift=0, mlhs_samples=1000)

Compute the expected loss against all variations. For example, given variants “A”, “B”, “C” and “D”, and choosing variant=”B”, we compute \(\mathrm{E}[\max(\max(A, C, D) - B, 0)]\).

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="quad")) – The method of computation. Options are “MC” (Monte Carlo), “MLHS” (Monte Carlo + Median Latin Hypercube Sampling) and “quad” (numerical integration).
  • variant (str (default="B")) – The chosen variant.
  • lift (float (default=0.0)) – The amount of uplift.
  • mlhs_samples (int (default=1000)) – Number of samples for MLHS method.
Returns:

expected_loss_vs_all
Return type:

float
probability(method='exact', control='A', variant='B', lift=0)

Compute the error probability or chance to beat control, i.e., \(P[variant > control + lift]\).

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="exact")) – The method of computation. Options are “exact” and “MC”.
  • control (str (default="A")) – The control variant.
  • variant (str (default="B")) – The tested variant.
  • lift (float (default=0.0)) – The amount of uplift.
Returns:

probability
Return type:

float
probability_vs_all(method='quad', variant='B', lift=0, mlhs_samples=1000)

Compute the error probability or chance to beat all variations. For example, given variants “A”, “B”, “C” and “D”, and choosing variant=”B”, we compute \(P[B > \max(A, C, D) + lift]\).

If lift is positive value, the computation method must be Monte Carlo sampling.

Parameters:
  • method (str (default="quad")) – The method of computation. Options are “MC” (Monte Carlo), “MLHS” (Monte Carlo + Median Latin Hypercube Sampling) and “quad” (numerical integration).
  • variant (str (default="B")) – The chosen variant.
  • lift (float (default=0.0)) – The amount of uplift.
  • mlhs_samples (int (default=1000)) – Number of samples for MLHS method.
Returns:

probability_vs_all
Return type:

float
update(data, variant)

Update posterior parameters for a given variant with new data samples.

Parameters:
  • data (array-like, shape = (n_samples)) –
  • variant (str) –