MLE for Five-Parameter Generalized Beta Pareto Distribution in R

A Comprehensive Guide to Setting Up and Running the MLE Procedure

statistical distribution plot on computer screen

Key Insights

Defining the Likelihood: Establishing a robust density function and associated log‐likelihood function is central to parameter estimation.
Optimization Approach: Using R’s numerical optimization tools, such as optim() or packages like stats4, is critical for fine-tuning estimates.
Implementation Complexity: Extending MLE from the Generalized Pareto (GPD) to a five-parameter Generalized Beta Pareto (GBP) requires careful attention to bounds, special cases, and initialization.

Understanding the Five-Parameter Generalized Beta Pareto Distribution

The five-parameter Generalized Beta Pareto (GBP) distribution extends the classical Generalized Pareto Distribution (GPD) by incorporating extra parameters that offer more flexibility in modeling data, especially in the context of extreme value analysis. The parameters typically include:

Location parameter (μ): Anchors the distribution along the horizontal axis.
Scale parameter (σ): Determines the spread of the distribution and must always be positive.
Shape parameter (ξ): Controls the tail behavior or the decay rate of the probability density function.
Lower modification parameter (α): Adjusts the distribution’s lower bound.
Upper modification parameter (β): Sets an upper-bound modification, adding further control over the tail behavior.

These additional parameters allow the GBP distribution to cover a broader range of behaviors, making it suitable for complex data that may not be adequately described by simpler Pareto models.

Defining the Density and Log-Likelihood Functions

At the heart of maximum likelihood estimation (MLE) is the likelihood function, which is constructed from the probability density function (pdf) of the distribution. In the case of the GBP distribution, the pdf is more involved due to the extra parameters. Below is a conceptual overview of how one might define a density function for the GBP distribution in R:

The Density Function

The function, typically named dgbp(), computes the probability density by taking into account special cases:

Special Cases in Density Calculation

If the shape parameter (ξ) equals zero, the density corresponds to an exponential-type decay. This scenario simplifies computations.
When ξ is negative, the computation must consider the possibility of a bounded support, for instance by adjusting for an upper limit.
For positive values of ξ, the standard formulation applies, although additional factors might be included, such as corrections from the extra parameters (α and β).

These considerations are vital to ensure that the density function remains valid and integrates to one over its support.

The Log-Likelihood Function

The log-likelihood function is derived from the density function and is the sum of the log-values of the density for each data point. Using the density function, the log-likelihood is defined as:

Log-Likelihood L(θ) = Σ log(dgbp(x_i; θ)), where θ represents the vector of parameters (μ, σ, ξ, α, β).

Minimizing the negative log-likelihood is mathematically equivalent to maximizing the likelihood and is often favored in numerical optimization routines.

Implementing MLE in R

Preparing the R Code

Below is an illustrative R code snippet that lays out the structure of the MLE procedure for the five-parameter GBP distribution. This example builds upon traditional methods used for the Generalized Pareto Distribution and extends them to incorporate the five parameters.

# Define the probability density function (pdf) for the GBP distribution
dgbp <- function(x, mu, sigma, xi, alpha, beta) {
  # Ensure sigma is positive and adjust based on the value of xi
  if (sigma <= 0) {
    stop("Scale parameter 'sigma' must be positive")
  }
  # Check for special cases: xi = 0 implies exponential decay
  if (abs(xi) < 1e-6) {
    # For xi approximately 0, use an exponential-like transformation
    return((1 / sigma) * exp(- (x - mu - alpha) / sigma))
  } else if (xi < 0) {
    # xi negative: include an adjustment with the upper bound parameter beta
    return((1 / sigma) * ((1 + xi * ((x - mu - alpha) / sigma))^(- (1 / xi) - 1)) *
             (1 + xi * ((alpha - beta) / sigma))^(-1 / xi))
  } else {
    # xi positive: the general case
    return((1 / sigma) * ((1 + xi * ((x - mu - alpha) / sigma))^(- (1 / xi) - 1)))
  }
}

# Define the negative log-likelihood function:
log_likelihood_gbp <- function(par, x) {
  mu    <- par[1]
  sigma <- par[2]
  xi    <- par[3]
  alpha <- par[4]
  beta  <- par[5]
  
  # Calculate the density values and check for invalid (NaN or negative) values:
  dens <- dgbp(x, mu, sigma, xi, alpha, beta)
  if (any(dens <= 0)) {
    return(Inf)
  }
  ll <- sum(log(dens))
  # Return the negative log-likelihood for minimization using optim
  return(-ll)
}

# Helper function to generate random samples from a generalized Pareto type distribution,
# extended to accommodate extra parameters (this is conceptual; adjust as necessary)
rgpd <- function(n, mu, sigma, xi, alpha, beta) {
  u <- runif(n)
  if (abs(xi) < 1e-6) {
    return(mu + alpha + sigma * (-log(1 - u)))
  } else if (xi < 0) {
    return(mu + alpha + sigma * ((1 - u^(-xi)) / (-xi)))
  } else {
    return(mu + alpha + sigma * ((u^(-xi) - 1) / xi))
  }
}

# Generate some example data using the random generator function
set.seed(123)
n     <- 1000
mu    <- 0      # location
sigma <- 1      # scale must remain > 0
xi    <- -0.5   # shape parameter
alpha <- 0      # lower modification
beta  <- 10     # upper modification
x     <- rgpd(n, mu, sigma, xi, alpha, beta)

# Set the starting values for the optimizer based on sample statistics
start_values <- c(mean(x), sd(x), -0.5, min(x), max(x))

# Use optim to perform MLE by minimizing the negative log-likelihood
fit <- optim(par = start_values, fn = log_likelihood_gbp, x = x, method = "L-BFGS-B", 
             lower = c(-Inf, 0.001, -Inf, -Inf, -Inf), 
             upper = c(Inf, Inf, 0, Inf, Inf))

# Display the estimated parameters
cat("Estimated Parameters:\n")
print(fit$par)

Explanation of the Code

Density Function (dgbp)

The function dgbp() calculates the probability density. It includes conditions to handle:

When the shape parameter ξ is near zero, an exponential-style decay is adopted.
For ξ < 0, adjustments are made using the additional shape modifier (beta) to account for bounded support.
For ξ greater than zero, the standard formulation applies.

Log-Likelihood Calculation

The log_likelihood_gbp() function:

Extracts the parameter values from the input vector.
Computes the density for all observations and validates that these densities are strictly positive.
Sums the logarithms of the density values and returns the negative result, which is then minimized using the optim() function.

Random Sample Generation (rgpd)

The helper function rgpd() generates synthetic data based on the specified parameters. This simulation is useful for testing the MLE code.

Optimization Using optim()

The key step in the MLE procedure is the optimization of the log-likelihood function. In the provided code, the R function optim() is used with the "L-BFGS-B" method, which allows for constraints. The parameter bounds are specified to ensure parameter validity – particularly, the scale parameter (σ) must remain positive.

Parameter Initialization and Bounds

Initial parameter values are chosen based on basic sample statistics (mean, standard deviation, minimum, and maximum). These serve as starting points for the optimizer. Additionally, constraints such as lower = c(-Inf, 0.001, -Inf, -Inf, -Inf) are applied to maintain the validity of the parameters during optimization.

Consolidated Overview Table

Component	Description	R Function / Code Snippet
Density Function	Computes the probability density based on parameters. Handles special cases for xi=0, xi<0, and xi>0.	`dgbp()`
Log-Likelihood Function	Sums the logarithms of density values for each observation and returns the negative sum for minimization.	`log_likelihood_gbp()`
Random Data Generator	Generates synthetic data from the five-parameter distribution to test the MLE implementation.	`rgpd()`
Optimization Routine	Uses `optim()` with constraints to minimize the negative log-likelihood.	`optim()`