Skip to main content
v2026.11,986 entries · CC-BY 4.0

SciPy stats beta: Python Guide to Beta Distribution Fitting and Analysis

A complete guide to scipy.stats.beta in Python: calculate PDF, CDF, and quantiles, fit shape parameters to empirical data, and test goodness of fit.

Written and maintained by CASRAI Editorial Board

Published

On this page

The scipy.stats.beta module in Python provides a continuous random variable implementation of the Beta distribution, inheriting from the scipy.stats.rv_continuous class to evaluate probability density functions, cumulative distributions, quantiles, random variates, and maximum likelihood parameter estimation on bounded empirical data.

Ask CASRAI · free to tryQuestion about this guide? Ask CASRAI answers with linked sources. 2 free questions a day, no account.

Ask your first question freeSubscribe

What it is used for in research

The Beta distribution is a family of continuous probability distributions defined on a bounded interval, typically the standard unit interval [0, 1]. In quantitative research, this bounded support makes scipy.stats.beta indispensable for modeling variables that represent proportions, percentages, probabilities, rates, and normalized test scores. Because the Gaussian normal distribution has infinite support spanning negative to positive infinity, applying normal models to bounded proportions inevitably leads to nonsensical out-of-bounds predictions outside [0, 1] and distorts standard error estimates near boundaries. The Beta distribution naturally respects interval boundaries while offering remarkable distributional flexibility through its two positive shape parameters, α and β (denoted in SciPy documentation as a and b).

Depending on the relative magnitudes of shape parameters a and b, the Beta density can assume diverse functional forms across the unit interval. When both shape parameters equal 1 (a = 1, b = 1), the distribution reduces to a standard uniform density. When both parameters fall below 1 (a is less than 1 and b is less than 1), the density is U-shaped with bimodal accumulation near boundaries. When one parameter falls below 1 while the other exceeds or equals 1, the curve becomes strictly decreasing or strictly increasing (J-shaped). When both parameters exceed 1 (a is greater than 1 and b is greater than 1), the distribution is unimodal and bell-shaped, displaying positive skewness when b exceeds a, negative skewness when a exceeds b, or perfect symmetry about x = 0.5 when a equals b.

Researchers apply scipy.stats.beta across several foundational research paradigms:

  • Empirical proportion and rate modeling: In clinical trials and epidemiology, researchers model patient response rates, adherence proportions, and biomarker clearance fractions. In cognitive psychology and psychometrics, analysts model participant accuracy rates across repeated experimental trials. For mathematical foundations of the density function and moments, consult our guide to the Beta distribution mathematical formula.
  • Bayesian inference and conjugate updating: The Beta distribution serves as the natural conjugate prior for Bernoulli, Binomial, and negative binomial likelihoods. In Bayesian experimental design, combining a Beta(a, b) prior with k successes observed across n trials yields a closed-form Beta(a + k, b + n – k) posterior distribution without requiring computationally intensive Markov Chain Monte Carlo sampling. Researchers can explore our overview of Bayesian prior distributions. When modeling overdispersed binomial counts across clusters, analysts frequently extend this formulation to the Beta-Binomial compound distribution.
  • Project scheduling and PERT analysis: In operations research and clinical trial project management, Program Evaluation and Review Technique models task completion durations using a four-parameter generalized Beta distribution defined over an arbitrary interval [A, B], parameterized by optimistic, most likely (modal), and pessimistic time estimates.
  • Regression and non-linear parameter fitting: While scipy.stats.beta provides univariate distribution fitting, researchers modeling proportions conditional on experimental covariates often pair distribution diagnostics with generalized linear models or custom optimization via our guide to Beta regression modeling and SciPy curve_fit non-linear regression.

Install or access

The scipy.stats.beta class is bundled directly within the standard statistics package of the SciPy scientific computing ecosystem. To use it, you must have Python and SciPy installed in your working environment. The official SciPy project distributes pre-compiled binary wheels for Linux, macOS, and Windows through PyPI and conda-forge.

To install SciPy using the standard Python package manager, execute the following command in your terminal:

pip install scipy

If you manage your scientific dependencies using Conda or Mamba within an active research environment, install SciPy from the conda-forge channel:

conda install -c conda-forge scipy

SciPy requires NumPy as an underlying array computation dependency. Modern package managers automatically resolve and install compatible NumPy releases. To verify the installation and confirm that your environment can access the distribution class, start a Python session and import the module:

import scipy
from scipy import stats
from scipy.stats import beta

print(f"SciPy Version: {scipy.__version__}")
print(f"Beta Object: {beta.name}")

The scipy.stats.beta object is an instantiated singleton of scipy.stats._continuous_distns.beta_gen, which subclasses scipy.stats.rv_continuous. This object provides continuous methods such as pdf, cdf, rvs, and fit without requiring manual class instantiation.

Step-by-step task

The following step-by-step research task walks through an end-to-end workflow on bounded research data: inspecting empirical data, fitting distribution parameters via Maximum Likelihood Estimation (MLE) and Method of Moments (MM), creating frozen distribution instances, computing key analytical statistics, and evaluating goodness-of-fit against theoretical expectations.

Step 1: Inspect and validate bounded empirical data

Before fitting a Beta distribution, researchers must verify that the empirical variable strictly satisfies interval constraints. The standard theoretical Beta distribution is defined over the open interval (0, 1). If your raw research data contains exact zeros (e.g. 0% task accuracy) or exact ones (e.g. 100% adherence), direct maximum likelihood estimation will encounter numerical evaluation errors because the Beta log-likelihood includes terms proportional to (a – 1) log(x) and (b – 1) log(1 – x). Evaluating log(0) produces negative infinity, causing the numerical optimizer to fail.

To resolve boundary points in empirical datasets of sample size n, researchers widely apply the standard transformation established by Smithson and Verkuilen (2006):

y_transformed = (y_raw * (n - 1) + 0.5) / n

This transformation shrinks raw values minimally toward 0.5, ensuring all observations lie strictly within the open interval (0, 1) while preserving rank ordering, empirical moments, and scale properties.

Step 2: Fit Beta distribution parameters

SciPy provides the beta.fit() method to estimate distribution parameters from empirical observations. By default, beta.fit(data) performs unconstrained Maximum Likelihood Estimation across four parameters: shape a, shape b, location loc, and scale scale. In standard research applications where data represents proportions on [0, 1], allowing loc and scale to vary freely introduces unnecessary model flexibility and can lead to numerical instabilities, negative location parameters, or scales exceeding 1.0.

To preserve standard proportion interpretation, analysts should fix location to 0 and scale to 1 using the floc and fscale keyword arguments:

import numpy as np
from scipy import stats

# Generate an illustrative research dataset: participant accuracy rates (n = 120)
# Drawn from underlying Beta(a=3.5, b=7.0) with seed 42
np.random.seed(42)
accuracy_data = stats.beta.rvs(3.5, 7.0, size=120, random_state=42)

# Estimate parameters using constrained Maximum Likelihood Estimation (MLE)
a_mle, b_mle, loc_fixed, scale_fixed = stats.beta.fit(accuracy_data, floc=0, fscale=1)
print(f"MLE Fitted Shapes: a = {a_mle:.4f}, b = {b_mle:.4f}")

# Estimate parameters using constrained Method of Moments (MM)
a_mm, b_mm, _, _ = stats.beta.fit(accuracy_data, floc=0, fscale=1, method='MM')
print(f"MM Fitted Shapes:  a = {a_mm:.4f}, b = {b_mm:.4f}")

The Method of Moments estimator provides a robust closed-form alternative that minimizes relative error between sample raw moments and theoretical distribution moments, making it resilient when sample sizes are small or when optimization surfaces exhibit flat gradients.

Step 3: Instantiate a frozen distribution object

Repeatedly passing estimated shape, location, and scale parameters into individual SciPy functions is cumbersome and prone to coding errors. SciPy allows analysts to create a “frozen” distribution object by calling beta(a, b, loc, scale) as a constructor. A frozen object retains the fixed parameter values, exposing methods that operate directly on arguments without restating parameters:

# Create a frozen Beta distribution with fitted MLE parameters
fitted_beta = stats.beta(a_mle, b_mle, loc=0, scale=1)

Step 4: Compute summary statistics, moments, and credible intervals

With the frozen distribution object constructed, you can compute theoretical moments and analytical intervals:

# Extract theoretical mean, variance, skewness, and excess kurtosis
mean_val, var_val, skew_val, kurt_val = fitted_beta.stats(moments='mvsk')
print(f"Theoretical Mean:     {mean_val:.4f}")
print(f"Theoretical Variance: {var_val:.4f}")
print(f"Theoretical Skewness: {skew_val:.4f}")
print(f"Theoretical Kurtosis: {kurt_val:.4f}")

# Compute quantiles using the Percent Point Function (inverse CDF)
q25 = fitted_beta.ppf(0.25)
median_val = fitted_beta.ppf(0.50)
q75 = fitted_beta.ppf(0.75)
print(f"Interquartile Range: Q1 = {q25:.4f}, Median = {median_val:.4f}, Q3 = {q75:.4f}")

# Compute a two-sided 95% equal-tailed confidence/credible interval
ci_lower, ci_upper = fitted_beta.interval(0.95)
print(f"95% Interval: [{ci_lower:.4f}, {ci_upper:.4f}]")

Step 5: Evaluate probability densities and cumulative probabilities

Researchers frequently need to evaluate probability density values for plotting fitted curves against histograms, or compute cumulative probabilities to evaluate tail risks:

# Evaluate PDF along an evaluation grid from 0.01 to 0.99
x_eval = np.linspace(0.01, 0.99, 100)
pdf_densities = fitted_beta.pdf(x_eval)

# Evaluate probability of observing accuracy below 0.20
p_below_20 = fitted_beta.cdf(0.20)
print(f"P(X  0.60):  {p_above_60:.4f}")

Always use the survival function sf(x) instead of 1 - cdf(x) when computing upper-tail probabilities. In extreme tails, cdf(x) approaches 1.0 within floating-point precision, causing 1 - cdf(x) to suffer catastrophic cancellation and return 0.0, whereas sf(x) computes log-gamma transformations directly to maintain precision.

Step 6: Evaluate goodness-of-fit

To confirm that the Beta distribution adequately characterizes the research data, analysts should conduct formal hypothesis testing. A common error in Python research workflows is applying scipy.stats.kstest to empirical data using parameters estimated from that same dataset. Standard Kolmogorov-Smirnov critical values assume completely pre-specified theoretical parameters; estimating parameters from sample data shrinks empirical discrepancies, producing artificially conservative test statistics and inflated p-values.

The modern and rigorous solution provided in the SciPy statistics module is scipy.stats.goodness_of_fit. This function runs a parametric Monte Carlo simulation to construct the exact finite-sample null distribution under parameter estimation:

# Conduct parametric Monte Carlo Anderson-Darling goodness-of-fit test
gof_result = stats.goodness_of_fit(
    stats.beta,
    accuracy_data,
    known_params={'loc': 0, 'scale': 1},
    statistic='ad',
    n_mc_samples=999,
    random_state=42
)
print(f"Anderson-Darling Statistic: {gof_result.statistic:.4f}")
print(f"Monte Carlo p-value:        {gof_result.pvalue:.4f}")

When the resulting p-value exceeds standard alpha thresholds such as 0.05, the empirical data does not significantly deviate from a Beta distribution with the estimated shape parameters.

Output and how to read it

Interpreting output from scipy.stats.beta requires understanding parameter tuples, moment characteristics, and the physical meaning of shape coefficients in relation to empirical data distributions.

Reading parameter estimation tuples

When calling stats.beta.fit(data, floc=0, fscale=1), SciPy returns a four-element tuple of floating-point values:

(a_hat, b_hat, loc_hat, scale_hat)

In our illustrative cognitive accuracy trial of 120 participants drawn from a true Beta(3.5, 7.0), the constrained MLE fit produced:

a = 3.4366, b = 6.8771, loc = 0.0, scale = 1.0

These values can be interpreted directly:

  • Shape parameter a (3.4366): Represents pseudo-observations supporting positive responses or successful outcomes. Because a exceeds 1, the probability density function approaches zero as x approaches 0, indicating that near-zero accuracy scores are rare in this task cohort.
  • Shape parameter b (6.8771): Represents pseudo-observations supporting negative responses or errors. Because b exceeds a and both exceed 1, the distribution is unimodal and positively skewed (right-skewed), with the bulk of participants achieving moderate scores between 0.15 and 0.45.
  • Location (loc = 0) and Scale (scale = 1): Confirm that the domain corresponds exactly to the standard interval [0, 1]. In generalized Beta applications across an arbitrary range [A, B], loc equals lower bound A and scale equals the interval width (B – A).

Reading distribution moments and quantiles

The fitted distribution yields the following analytical moments and interval values:

  • Theoretical Mean (0.3332): Calculated from the analytical formula μ = a / (a + b) = 3.4366 / (3.4366 + 6.8771) = 0.3332. This matches the empirical sample mean of 0.3326 within rounding margin.
  • Theoretical Variance (0.0196) and Standard Deviation (0.1400): Calculated from σ² = (ab) / [ (a + b)²(a + b + 1) ]. This closely reflects the observed sample standard deviation of 0.1413.
  • Theoretical Skewness (0.3866): Positive skewness confirms a longer right tail extending toward higher accuracy scores.
  • Theoretical Excess Kurtosis (-0.2433): A slightly negative kurtosis indicates a platykurtic profile with slightly lighter tails than a Gaussian distribution.
  • Median (0.3221): In a right-skewed distribution, the median (50th percentile) is lower than the mean (0.3332). Half of the participant cohort scored below 32.21% accuracy.
  • 95% Coverage Interval [0.0965, 0.6307]: Ninety-five percent of task participants in this population fall between 9.65% and 63.07% accuracy.

Reading goodness-of-fit statistics

In our Monte Carlo Anderson-Darling goodness-of-fit evaluation across 999 parametric resamples, the test yielded an Anderson-Darling test statistic of 0.2896 and an empirical p-value of 0.6500. Because 0.6500 is substantially higher than the conventional significance threshold of α = 0.05, researchers fail to reject the null hypothesis, concluding that the Beta distribution provides a statistically sound model for these research observations.

Troubleshooting

When applying scipy.stats.beta in scientific analysis pipelines, researchers frequently encounter specific edge cases, convergence issues, and numerical anomalies. Below are common failure modes and documented resolutions.

1. Unconstrained 4-parameter fit returns negative location or scale exceeding 1

Symptom: Calling stats.beta.fit(data) without constraints on standard proportion data produces a location parameter such as loc = -0.0120 and scale = 1.3265, leading to fitted support spanning [-0.0120, 1.3145].

Cause: By default, SciPy optimizes all four parameters simultaneously using numerical likelihood maximization. When sample sizes are modest or density near boundaries is low, the unconstrained optimizer treats interval bounds as free variables, distorting standard proportion interpretation.

Fix: Explicitly lock the bounds to the unit interval by supplying floc=0 and fscale=1: stats.beta.fit(data, floc=0, fscale=1). If your data spans a known custom physical range [A, B], lock them to your theoretical limits using floc=A, fscale=(B - A).

2. Fit fails with Infinite or NaN values encountered

Symptom: SciPy raises RuntimeError: Optimization routine failed or generates NaN parameter estimates during execution.

Cause: The dataset contains exact boundary values of 0.0 or 1.0. Evaluating the log-likelihood of Beta density at x = 0 or x = 1 evaluates log(0) to negative infinity.

Fix: Preprocess the data using the Smithson-Verkuilen continuous boundary adjustment: y_clean = (y * (len(y) - 1) + 0.5) / len(y). Alternatively, if exact zeros or ones represent distinct physical states (such as complete non-response or perfect ceiling performance), employ zero-one-inflated beta modeling rather than standard continuous fitting.

3. Floating-point underflow in upper tail probabilities

Symptom: Computing 1.0 - stats.beta.cdf(0.99, a, b) returns 0.0, even though theoretical tail probability is non-zero.

Cause: In extreme right tails, cdf(x) is so close to 1.0 that floating-point subtraction suffers from catastrophic precision cancellation.

Fix: Use the survival function stats.beta.sf(x, a, b) or the logarithmic survival function stats.beta.logsf(x, a, b). The survival function computes regularized incomplete beta functions directly without subtracting from 1.0.

4. Optimizer convergence failure on multimodal or highly dispersed data

Symptom: The default Nelder-Mead or BFGS optimizer within beta.fit() fails to converge on noisy empirical data.

Cause: The empirical likelihood surface possesses flat gradients or multiple local optima due to severe overdispersion or clustering.

Fix: Switch the estimation method to Method of Moments using method='MM': stats.beta.fit(data, floc=0, fscale=1, method='MM'). Alternatively, supply starting values for the shape parameters using positional arguments: stats.beta.fit(data, 2.0, 5.0, floc=0, fscale=1).

Free alternatives

While SciPy provides a robust general-purpose statistics framework for Python researchers, other free and open-source scientific computing environments offer specialized implementations of the Beta distribution with unique strengths in sampling speed, Bayesian inference, or statistical ergonomics. The data table below compares the functional properties, primary methods, and licensing models of these alternative environments.

Environment / Package Distribution Functions Core Strength Primary Limitation Open-Source License
Python SciPy (scipy.stats.beta) pdf, cdf, ppf, rvs, fit, stats, sf Full continuous RV class with MLE and MM fitting, frozen objects, and goodness-of-fit integration Requires explicit floc/fscale fixing to avoid boundary drift on unit intervals BSD-3-Clause
Python NumPy (numpy.random) Generator.beta(a, b, size) High-throughput SIMD-vectorized random variate generation for large simulations Variate sampling only; no analytical PDF, CDF, quantiles, or parameter fitting BSD-3-Clause
R (stats + fitdistrplus) dbeta, pbeta, qbeta, rbeta, fitdist Native non-central beta support (ncp), rich diagnostic plots, and standard syntax across packages Fitting requires auxiliary packages (MASS or fitdistrplus) rather than a single unified class GPL-2 / GPL-3
Julia (Distributions.jl) Beta(α, β), pdf, cdf, quantile, rand, fit_mle Exceptional JIT compilation speed, type-stable distribution constructors, and automatic differentiation Smaller user community and documentation ecosystem compared to Python/R MIT
GNU Octave (statistics package) betapdf, betacdf, betainv, betarnd, betafit Full drop-in open-source compatibility with MATLAB syntax and legacy engineering scripts Slower execution on complex iterative optimization tasks GPL-3
PyMC / Stan (Bayesian Frameworks) pm.Beta / beta(alpha, beta) Full probabilistic programming and MCMC posterior parameter estimation with prior regularisation Substantial computational overhead for simple univariate descriptive tasks Apache-2.0 / BSD-3-Clause

For researchers performing high-speed Monte Carlo simulations where only variate generation is needed, NumPy’s default_rng().beta() offers superior execution throughput. For researchers working in R, the base stats package provides standard probability functions (dbeta, pbeta, qbeta, rbeta) and pairs seamlessly with fitdistrplus for goodness-of-fit diagnostics. For full probabilistic modeling with uncertainty quantification across regression covariates, Bayesian frameworks such as PyMC and Stan represent the gold standard.

Frequently asked questions

How do I fit a beta distribution in Python using SciPy?

To fit a Beta distribution in Python, use scipy.stats.beta.fit(data, floc=0, fscale=1). Fixing floc=0 and fscale=1 ensures that the estimated distribution remains bounded on the standard unit interval [0, 1], returning estimated shape parameters a and b via Maximum Likelihood Estimation.

Why does scipy.stats.beta.fit return negative location parameters?

By default, scipy.stats.beta.fit() estimates four parameters simultaneously: shapes a and b, location loc, and scale scale. If your data represents proportions between 0 and 1, the unconstrained numerical optimizer may drift into negative location values and scale parameters greater than 1 to marginally improve likelihood. You must lock location and scale by passing floc=0, fscale=1.

How can I calculate quantiles and credible intervals with scipy.stats.beta?

You can calculate quantiles using the Percent Point Function (inverse CDF) via scipy.stats.beta.ppf(q, a, b), where q represents the quantile level (such as 0.50 for the median). For equal-tailed coverage intervals, use scipy.stats.beta.interval(confidence, a, b), which returns lower and upper bounds for the specified confidence level (e.g., 0.95 for a 95% interval).

What is the difference between scipy.stats.beta and numpy.random.beta?

NumPy’s numpy.random.Generator.beta(a, b, size) is designed solely for rapid generation of random variates. It does not compute probability densities (PDF), cumulative probabilities (CDF), percentiles (PPF), or parameter estimates. SciPy’s scipy.stats.beta provides a complete statistical distribution object with analytical moments, fitting algorithms, hypothesis tests, and frozen distribution instances.

How do I handle boundary zeros and ones when fitting a beta distribution?

The standard continuous Beta probability density function is undefined at exact boundaries x = 0 or x = 1 when shape parameters are less than or equal to 1, causing log-likelihood calculations to evaluate to infinity. For empirical sample sizes of n, apply the Smithson and Verkuilen transformation y_adj = (y * (n - 1) + 0.5) / n before fitting, which maps boundary values safely into the open interval (0, 1).

Sources

Data: Computational Software Specifications for Beta Distribution Modeling

A cross-platform compilation comparing Beta distribution support, functional capabilities, estimation methods, boundary constraints, and licenses across scientific computing environments (Python SciPy, NumPy, R stats, Julia Distributions.jl, and GNU Octave), compiled from official library documentation and API specifications.

Computational Software Specifications for Beta Distribution Modeling
Software EnvironmentDistribution Object / FunctionParameter Estimation MethodsBoundary ParametersRandom Variate GeneratorLicense
Python SciPy (scipy.stats.beta)rv_continuous class instance (beta)MLE and Method of Moments (fit)Arbitrary interval via loc and scalervs(a, b, loc, scale, size)BSD-3-Clause
Python NumPy (numpy.random)Generator.beta(a, b, size)None (variate generation only)Standard interval [0, 1] onlyGenerator.beta(a, b, size)BSD-3-Clause
R stats packagedbeta, pbeta, qbeta, rbetaVia MASS::fitdistr or fitdistrplus (MLE/MME)Standard [0, 1] with non-centrality ncprbeta(n, shape1, shape2)GPL-2 / GPL-3
Julia Distributions.jlBeta(alpha, beta)fit_mle(Beta, data) or fit(Beta, data)Standard [0, 1] (or LocationScale wrapper)rand(Beta(alpha, beta), n)MIT
GNU Octave (statistics package)betapdf, betacdf, betainv, betarndbetafit(data) via maximum likelihoodStandard [0, 1]betarnd(a, b, r, c)GPL-3

Sources

Compiled by CASRAI from the sources above. Free to reuse under CC BY 4.0 with attribution.

Follow CASRAI

Research-administration guidance, standards updates and independent tool reviews.

Ask CASRAI · free to try

Ask about SciPy stats beta: Python Guide to Beta Distribution Fitting and Analysis

2 free questions a day, no account.

An AI assistant for research: funder rules, compliance, methods and publishing. It links the sources behind its answers and labels answers that come from a web search.

Answers draw on CASRAI's guides and dictionary plus the federal and funder documents we index: Federal Register, Grants.gov, Regulations.gov and UKRI.

Works on this site and inside Claude, Cursor and the AI tools you already use.

Everything CASRAI publishes — this page, the dictionary, the guides and the news — stays open to read, with no account and no card.

Referenced across the research world

University of Cambridge logoColumbia University logoCrossref logoUniversity of Edinburgh logoHarvard University logoUniversity of Oxford logoPrinceton University logoStanford School of Medicine logoUniversity College London logoORCID logoUniversity of Cambridge logoColumbia University logoCrossref logoUniversity of Edinburgh logoHarvard University logoUniversity of Oxford logoPrinceton University logoStanford School of Medicine logoUniversity College London logoORCID logo
  • University of Cambridge logo
  • Columbia University logo
  • Crossref logo
  • University of Edinburgh logo
  • Harvard University logo
  • University of Oxford logo
  • Princeton University logo
  • Stanford School of Medicine logo
  • University College London logo
  • ORCID logo

View CASRAI adoption →