class surpyval.univariate.parametric.distributions.gamma.Gamma_(name)

Bases: ParametricFitter

Class used to generate the Gamma class.

from surpyval import Gamma
Hf(x, alpha, beta)

Cumulative hazard rate for the Gamma Distribution:

\[H(x) = -\ln(1 - \frac{\gamma \left ( \alpha, \beta x \right )} {\Gamma \left ( \alpha \right )})\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

Hf – The cumulative hazard rate of the distribution at each x

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.Hf(x, 3, 2)
array([0.39056209, 1.43505064, 2.78112418, 4.28642793, 5.88912614])
cs(x, X, alpha, beta)

Conditional survival function for the Gamma Distribution:

\[R(x) = e^{-\lambda x}\]
Parameters

  • x (numpy array or scalar) – The value(s) at which the function will be calculated

  • X (numpy array or scalar) – The value(s) at which each value(s) in x was known to have survived

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

cs – the conditional survival probability.

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.cs(x, 5, 3, 4)
array([2.59402488e-02, 6.39048747e-04, 1.51519143e-05, 3.48776510e-07,
       7.79933496e-09])
df(x, alpha, beta)

Density function for the Gamma Distribution:

\[f(x) = \frac{\beta^{\alpha }}{\Gamma \left ( \alpha \right )} x^{\alpha - 1}e^{-\beta x}\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

df – The density of the distribution at each x

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.df(x, 3, 2)
array([0.54134113, 0.29305022, 0.08923508, 0.02146961, 0.00453999])
entropy(alpha, beta)

Calculates the entropy of the Gamma distribution.

\[S = \alpha - \ln \left ( \beta \right ) + \ln \Gamma \left ( \alpha \right ) + \left ( 1 - \alpha \right ) \psi \left ( \alpha \right )\]

Where psi is the digamma function

Parameters

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The rate parameter for the Gamma distribution

Returns

entropy – The entropy(ies) of the Gamma distribution

Return type

scalar or numpy array

Examples

>>> from surpyval import Gamma
>>> Gamma.entropy(3, 4)
0.46128414924312033
ff(x, alpha, beta)

CDF (or unreliability or failure) function for the Gamma Distribution:

\[F(x) = \frac{\gamma \left ( \alpha, \beta x \right )} {\Gamma \left ( \alpha \right )}\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

ff – The value(s) for the CDF at each x

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.ff(x, 3, 2)
array([0.32332358, 0.76189669, 0.9380312 , 0.98624603, 0.9972306 ])
fit(x: ArrayLike | None = None, c: ArrayLike | None = None, n: ArrayLike | None = None, t: ArrayLike | None = None, how: str = 'MLE', offset: bool = False, zi: bool = False, lfp: bool = False, tl: ArrayLike | numbers.Number | None = None, tr: ArrayLike | numbers.Number | None = None, xl: ArrayLike | None = None, xr: ArrayLike | None = None, fixed: dict[str, float] | None = None, heuristic: str = 'Nelson-Aalen', init: ArrayLike = [], rr: str = 'y', on_d_is_0: bool = False, turnbull_estimator: str = 'Fleming-Harrington') → Parametric

The central feature to SurPyval’s capability. This function aimed to have an API to mimic the simplicity of the scipy API. That is, to use a simple fit() call, with as many or as few parameters as is needed.

Parameters

  • x (array like, optional) – Array of observations of the random variables. If x is None, xl and xr must be provided.

  • c (array like, optional) – Array of censoring flag. -1 is left censored, 0 is observed, 1 is right censored, and 2 is intervally censored. If not provided will assume all values are observed.

  • n (array like, optional) – Array of counts for each x. If data is provided as counts, then this can be provided. If None will assume each observation is 1.

  • t (2D-array like, optional) – 2D array like of the left and right values at which the respective observation was truncated. If not provided it assumes that no truncation occurs.

  • how ({'MLE', 'MPP', 'MOM', 'MSE', 'MPS'}, optional) –

    Method to estimate parameters, these are:

    • MLE, Maximum Likelihood Estimation

    • MPP, Method of Probability Plotting

    • MOM, Method of Moments

    • MSE, Mean Square Error

    • MPS, Maximum Product Spacing

  • offset (boolean, optional) – If True finds the shifted distribution. If not provided assumes not a shifted distribution. Only works with distributions that are supported on the half-real line.

  • tl (array like or scalar, optional) – Values of left truncation for observations. If it is a scalar value assumes each observation is left truncated at the value. If an array, it is the respective ‘late entry’ of the observation

  • tr (array like or scalar, optional) – Values of right truncation for observations. If it is a scalar value assumes each observation is right truncated at the value. If an array, it is the respective right truncation value for each observation

  • xl (array like, optional) – Array like of the left array for 2-dimensional input of x. This is useful for data that is all intervally censored. Must be used with the xr input.

  • xr (array like, optional) – Array like of the right array for 2-dimensional input of x. This is useful for data that is all intervally censored. Must be used with the xl input.

  • fixed (dict, optional) – Dictionary of parameters and their values to fix. Fixes parameter by name.

  • heuristic ({"Blom", "Median", "ECDF", "Modal", "Midpoint", "Mean", "Weibull", "Benard", "Beard", "Hazen", "Gringorten", "None", "Tukey", "DPW", "Fleming-Harrington", "Kaplan-Meier", "Nelson-Aalen", "Filliben", "Larsen", "Turnbull"}, str, optional.) – Plotting method to use, if using the probability plotting, MPP, method.

  • init (array like, optional) – initial guess of parameters. Instead of finding an initial guess for the optimization you can provide one. Can be useful to see if optimization is failing due to poor initial guess.

  • rr ({'y', 'x'}, str, optional) – The dimension on which to minimise the spacing between the line and the observation. If ‘y’ the mean square error between the line and vertical distance to each point is minimised. If ‘x’ the mean square error between the line and horizontal distance to each point is minimised.

  • on_d_is_0 (boolean, optional) – For the case when using MPP and the highest value is right censored, you can choose to include this value into the regression analysis or not. That is, if False, all values where there are 0 deaths are excluded from the regression. If True all values regardless of whether there is a death or not are included in the regression.

  • turnbull_estimator ({'Nelson-Aalen', 'Kaplan-Meier', or 'Fleming-Harrington'), str, optional) – If using the Turnbull heuristic, you can elect to use either the KM, NA, or FH estimator with the Turnbull estimates of r, and d. Defaults to FH.

Returns

A parametric model with the fitted parameters and methods for all functions of the distribution using the fitted parameters.

Return type

Parametric

Examples

>>> from surpyval import Weibull
>>> import numpy as np
>>> x = Weibull.random(100, 10, 4)
>>> model = Weibull.fit(x)
>>> print(model)
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : MLE
Parameters          :
     alpha: 10.551521182640098
      beta: 3.792549834495306
>>> Weibull.fit(x, how='MPS', fixed={'alpha' : 10})
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : MPS
Parameters          :
     alpha: 10.0
      beta: 3.4314657446866836
>>> Weibull.fit(xl=x-1, xr=x+1, how='MPP')
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : MPP
Parameters          :
     alpha: 9.943092756713078
      beta: 8.613016934518258
>>> c = np.zeros_like(x)
>>> c[x > 13] = 1
>>> x[x > 13] = 13
>>> c = c[x > 6]
>>> x = x[x > 6]
>>> Weibull.fit(x=x, c=c, tl=6)
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : MLE
Parameters          :
     alpha: 10.363725328793413
      beta: 4.9886821457305865
fit_from_df(df: DataFrame, x: str | None = None, c: str | None = None, n: str | None = None, xl: str | None = None, xr: str | None = None, tl: str | float | None = None, tr: str | float | None = None, **fit_options) → Parametric

The central feature to SurPyval’s capability. This function aimed to have an API to mimic the simplicity of the scipy API. That is, to use a simple fit() call, with as many or as few parameters as is needed.

Parameters

  • df (DataFrame) – DataFrame of data to be used to create surpyval model

  • x (string, optional) – column name for the column in df containing the variable data. If not provided must provide both xl and xr.

  • c (string, optional) – column name for the column in df containing the censor flag of x. If not provided assumes all values of x are observed.

  • n (string, optional) – column name in for the column in df containing the counts of x. If not provided assumes each x is one observation.

  • tl (string or scalar, optional) – If string, column name in for the column in df containing the left truncation data. If scalar assumes each x is left truncated by that value. If not provided assumes x is not left truncated.

  • tr (string or scalar, optional) – If string, column name in for the column in df containing the right truncation data. If scalar assumes each x is right truncated by that value. If not provided assumes x is not right truncated.

  • xl (string, optional) – column name for the column in df containing the left interval for interval censored data. If left interval is -Inf, assumes left censored. If xl[i] == xr[i] assumes observed. Cannot be provided with x, must be provided with xr.

  • xr (string, optional) – column name for the column in df containing the right interval for interval censored data. If right interval is Inf, assumes right censored. If xl[i] == xr[i] assumes observed. Cannot be provided with x, must be provided with xl.

  • fit_options (dict, optional) – dictionary of fit options that will be passed to the fit method, see that method for options.

Returns

A parametric model with the fitted parameters and methods for all functions of the distribution using the fitted parameters.

Return type

Parametric

Examples

>>> import surpyval as surv
>>> from surpyval.datasets import load_bofors_steel
>>> df = load_bofors_steel()
>>> model = surv.Weibull.fit_from_df(df, x='x', n='n', offset=True)
>>> print(model)
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : MLE
Offset (gamma)      : 39.76562962867477
Parameters          :
     alpha: 7.141925216146524
      beta: 2.6204524040137844
fit_from_surpyval_data(surv_data: SurpyvalData, how: str = 'MLE', offset: bool = False, zi: bool = False, lfp: bool = False, fixed: dict[str, float] | None = None, heuristic: str = 'Nelson-Aalen', init: ArrayLike = [], rr: str = 'y', on_d_is_0: bool = False, turnbull_estimator: str = 'Fleming-Harrington') → Parametric

The central feature to SurPyval’s capability. This function aimed to have an API to mimic the simplicity of the scipy API. That is, to use a simple fit() call, with as many or as few parameters as is needed.

Parameters

surv_data (SurpyvalData) – Survival data in the SurpyvalData class.

For other input options see fit method.

Returns

A parametric model with the fitted parameters and methods for all functions of the distribution using the fitted parameters.

Return type

Parametric

from_params(params, gamma=None, p=None, f0=None)

Creating a SurPyval Parametric class with provided parameters.

Parameters

  • params (array like) – array of the parameters of the distribution.

  • gamma (scalar, optional) – offset value for the distribution. If not provided will fit a regular, unshifted/not offset, distribution.

  • p (scalar, optional) – The proportion of the population that will never die or fail. If used it must be a value between 0 and 1. If None will assume 1, i.e. no proportion of the population will never die or fail.

  • f0 (scalar, optional) – The proportion of the population that will die or fail at time 0. If used it must be a value between 0 and 1. If None will assume 0, i.e. no proportion of the population will die or fail at time 0.

Returns

A parametric model with the parameters provided.

Return type

Parametric

Examples

>>> from surpyval import Weibull
>>> model = Weibull.from_params([10, 4])
>>> print(model)
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : given parameters
Parameters          :
     alpha: 10
      beta: 4
>>> model = Weibull.from_params([10, 4], gamma=2)
>>> print(model)
Parametric SurPyval Model
=========================
Distribution        : Weibull
Fitted by           : given parameters
Offset (gamma)      : 2
Parameters          :
     alpha: 10
      beta: 4
hf(x, alpha, beta)

Instantaneous hazard rate for the Gamma Distribution:

\[h(x) = \frac{\frac{\beta^{\alpha }}{\Gamma \left ( \alpha \right ) }x^{\alpha - 1}e^{-\beta x}}{1 - \frac{\gamma \left ( \alpha, \beta x \right )}{\Gamma \left ( \alpha \right )}}\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

hf – The instantaneous hazard rate of the distribution at each x

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.hf(x, 3, 2)
array([0.8       , 1.23076923, 1.44      , 1.56097561, 1.63934426])
log_df(x, alpha, beta)

Calculates the log of the density function of the Gamma distribution at x.

\[\log f(x) = \log \left ( \frac{\lambda^{\alpha}}{\Gamma(\alpha)} x^{\alpha - 1}e^{-\lambda x} \right )\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

log_df – The log of the density function of the Gamma distribution at x

Return type

scalar or numpy array

mean(alpha, beta)

Calculates the mean of the Gamma distribution with given parameters.

\[E = \frac{\alpha}{\beta}\]
Parameters

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

mean – The mean(s) of the Gamma distribution

Return type

scalar or numpy array

Examples

>>> from surpyval import Gamma
>>> Gamma.mean(3, 4)
0.75
moment(n, alpha, beta)

Calculates the n-th moment of the Gamma distribution with given parameters.

\[E = \frac{\Gamma \left ( n + \alpha \right )}{\beta^{n}\Gamma \left ( \alpha \right )}\]
Parameters

  • n (integer or numpy array of integers) – The ordinal of the moment to calculate

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

mean – The moment(s) of the Gamma distribution

Return type

scalar or numpy array

Examples

>>> from surpyval import Gamma
>>> Gamma.moment(3, 3, 4)
0.9375
qf(p, alpha, beta)

Quantile function for the Gamma Distribution:

\[q(p) = \frac{-\ln\left ( p \right )}{\lambda}\]
Parameters

  • p (numpy array or scalar) – The percentiles at which the quantile will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

q – The quantiles for the Gamma distribution at each value p.

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> p = np.array([.1, .2, .3, .4, .5])
>>> Gamma.qf(p, 3, 4)
array([0.27551633, 0.38376105, 0.47844395, 0.57126923, 0.66851508])
random(size, *params)

Draws random samples from the distribution in shape size, using the inverse transform method with the distribution’s quantile function.

Parameters

  • size (integer or tuple of positive integers) – Shape or size of the random draw

  • params (numpy array or scalar) – The parameters of the distribution

Returns

random – Random values drawn from the distribution in shape size

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Weibull
>>> np.random.seed(1)
>>> Weibull.random(5, 3, 4)
array([2.57122697, 3.18730986, 0.31024877, 2.32381059, 1.89352939])
sf(x, alpha, beta)

Survival (or Reliability) function for the Gamma Distribution:

\[R(x) = 1 - \frac{\gamma \left ( \alpha, \beta x \right ) }{\Gamma \left ( \alpha \right )}\]
Parameters

  • x (numpy array or scalar) – The values at which the function will be calculated

  • alpha (numpy array or scalar) – The shape parameter for the Gamma distribution

  • beta (numpy array or scalar) – The scale parameter for the Gamma distribution

Returns

sf – The value(s) for the survival function at each x

Return type

scalar or numpy array

Examples

>>> import numpy as np
>>> from surpyval import Gamma
>>> x = np.array([1, 2, 3, 4, 5])
>>> Gamma.sf(x, 3, 2)
array([0.67667642, 0.23810331, 0.0619688 , 0.01375397, 0.0027694 ])