Log-Beta Funktion Rechner

📈 Definition und Eigenschaften

Die Log-Beta-Funktion und ihre fundamentalen Eigenschaften:

\[\text{Definition: } \ln B(a,b) = \ln\left(\int_0^1 t^{a-1}(1-t)^{b-1} \, dt\right)\] \[\text{Gamma-Beziehung: } \ln B(a,b) = \ln \Gamma(a) + \ln \Gamma(b) - \ln \Gamma(a+b)\] \[\text{Symmetrie: } \ln B(a,b) = \ln B(b,a)\] \[\text{Rekursion: } \ln B(a+1,b) = \ln B(a,b) + \ln\left(\frac{a}{a+b}\right)\]

🔄 Numerische Vorteile

Warum die logarithmische Form überlegen ist:

\[\text{Overflow-Vermeidung: } B(100,200) \text{ vs. } \ln B(100,200)\] \[\text{B(100,200) ≈ 10^{-58} \text{ (Underflow!)}\] \[\text{ln B(100,200) ≈ -134.6 \text{ (stabil)}\] \[\text{Additive Eigenschaften in Log-Likelihood:}\] \[\text{ln L = } \sum_i \ln f(x_i) = \sum_i [\alpha_i \ln B(a_i,b_i) + \ldots]\]

📊 Spezielle Werte

Wichtige Log-Beta-Funktionswerte:

\[\ln B(1,1) = \ln(1) = 0\] \[\ln B(1,n) = \ln\left(\frac{1}{n}\right) = -\ln(n)\] \[\ln B(m,n) = \ln(m-1)! + \ln(n-1)! - \ln(m+n-1)!\] \[\ln B(1/2,1/2) = \ln(\pi) \approx 1.1447\] \[\ln B(a,b) \to -\infty \text{ wenn } a \to 0^+ \text{ oder } b \to 0^+\]

📝 Beispiel 1: Numerische Stabilität

Aufgabe: Berechne B(50,100) vs. ln B(50,100)
Problem: B(50,100) ist extrem klein
Lösung:

\[\text{Direkte Berechnung: } B(50,100) = \frac{\Gamma(50)\Gamma(100)}{\Gamma(150)}\] \[\text{≈ } \frac{49! \cdot 99!}{149!} \text{ (Overflow-Problem!)}\] \[\text{Log-Beta-Berechnung: } \ln B(50,100) = \ln \Gamma(50) + \ln \Gamma(100) - \ln \Gamma(150)\] \[\text{≈ } 148.48 + 363.74 - 605.02 = -92.80\] \[\text{Daher: } B(50,100) = e^{-92.80} \approx 1.37 \times 10^{-41}\]

Vorteil: Numerisch stabile Berechnung ohne Overflow

📝 Beispiel 2: Dirichlet-Verteilung

Aufgabe: Log-Likelihood der Dirichlet-Verteilung
Dichte: f(x|α) = [1/B(α)] ∏ᵢ xᵢ^(αᵢ-1)
Berechnung:

\[\text{Dirichlet-Verteilung für } k \text{ Komponenten:}\] \[f(\mathbf{x}|\boldsymbol{\alpha}) = \frac{1}{B(\boldsymbol{\alpha})} \prod_{i=1}^k x_i^{\alpha_i - 1}\] \[\text{wobei } B(\boldsymbol{\alpha}) = \frac{\prod_{i=1}^k \Gamma(\alpha_i)}{\Gamma(\sum_{i=1}^k \alpha_i)}\] \[\text{Log-Likelihood für } n \text{ Beobachtungen:}\] \[\ell(\boldsymbol{\alpha}) = -n \ln B(\boldsymbol{\alpha}) + \sum_{i=1}^k (\alpha_i - 1) \sum_{j=1}^n \ln x_{ji}\] \[= -n \left[\sum_{i=1}^k \ln \Gamma(\alpha_i) - \ln \Gamma\left(\sum_{i=1}^k \alpha_i\right)\right] + \ldots\]

Wichtigkeit: Log-Beta ist essentiell für Maximum-Likelihood-Schätzung

📝 Beispiel 3: Bayesianische Konjugation

Aufgabe: Beta-Binomial-Modell mit Log-Beta
Prior: Beta(α,β), Likelihood: Binomial
Berechnung:

\[\text{Prior: } p \sim \text{Beta}(\alpha, \beta)\] \[\text{Likelihood: } X|p \sim \text{Binomial}(n, p)\] \[\text{Posterior: } p|X \sim \text{Beta}(\alpha + x, \beta + n - x)\] \[\text{Log-Marginal-Likelihood:}\] \[\ln p(x) = \ln B(\alpha + x, \beta + n - x) - \ln B(\alpha, \beta) + \ln \binom{n}{x}\] \[= [\ln \Gamma(\alpha + x) + \ln \Gamma(\beta + n - x) - \ln \Gamma(\alpha + \beta + n)]\] \[- [\ln \Gamma(\alpha) + \ln \Gamma(\beta) - \ln \Gamma(\alpha + \beta)] + \ln \binom{n}{x}\]

Anwendung: Model Selection, Bayes Factors

✅ Vorteile der Log-Beta-Funktion

Numerische Vorteile gegenüber der regulären Beta-Funktion:

\[\text{✓ Keine Overflow-Probleme bei großen Parametern}\] \[\text{✓ Keine Underflow-Probleme bei kleinen Beta-Werten}\] \[\text{✓ Additive Eigenschaften in Log-Likelihood-Funktionen}\] \[\text{✓ Bessere numerische Konditionierung}\] \[\text{✓ Direkte Berechenbarkeit über Log-Gamma}\] \[\text{✓ Symmetrieeigenschaften bleiben erhalten}\]

⚠️ Berechnungsaspekte

Wichtige Implementierungsdetails:

\[\text{⚠ Genauigkeit hängt von Log-Gamma-Implementation ab}\] \[\text{⚠ Für sehr kleine Parameter können Log-Gamma-Werte sehr negativ werden}\] \[\text{⚠ Rekursionsformeln müssen sorgfältig implementiert werden}\] \[\text{⚠ Numerische Ableitung für Gradienten kann instabil sein}\]

📊 Log-Beta Werte

💻 Code-Implementierungen

Effiziente Implementierung der Log-Beta-Funktion:

Python (SciPy):
from scipy.special import betaln, loggamma
import numpy as np

# Log-Beta-Funktion
result = betaln(a, b) # ln(B(a,b))

# Eigene Implementation
def log_beta(a, b):
  """Log-Beta-Funktion über Log-Gamma"""
  return loggamma(a) + loggamma(b) - loggamma(a + b)

# Vectorized version
def log_beta_vec(a, b):
  """Vektorisierte Log-Beta-Funktion"""
  a, b = np.asarray(a), np.asarray(b)
  return loggamma(a) + loggamma(b) - loggamma(a + b)

R:
result <- lbeta(a, b) # Log-Beta
# Oder über lgamma
result <- lgamma(a) + lgamma(b) - lgamma(a + b)

MATLAB:
result = betaln(a, b); % Log-Beta
% Oder über gammaln
result = gammaln(a) + gammaln(b) - gammaln(a + b);

🎯 Statistische Anwendung

Log-Beta in der Bayesianischen Statistik:

Dirichlet-Verteilung Log-Likelihood:
def dirichlet_log_likelihood(data, alpha):
  """Log-Likelihood für Dirichlet-Verteilung"""
  n, k = data.shape
  alpha = np.asarray(alpha)
  
  # Log-Normalisierungskonstante
  log_norm = (loggamma(alpha.sum()) -
              loggamma(alpha).sum())
  
  # Log-Likelihood
  log_lik = (n * log_norm +
            ((alpha - 1) * np.log(data).sum(axis=0)).sum())
  
  return log_lik

Beta-Binomial-Modell:
def beta_binomial_log_pmf(k, n, alpha, beta):
  """Log-PMF der Beta-Binomial-Verteilung"""
  from scipy.special import gammaln
  
  return (gammaln(n + 1) - gammaln(k + 1) - gammaln(n - k + 1) +
         gammaln(k + alpha) + gammaln(n - k + beta) - gammaln(n + alpha + beta) +
         gammaln(alpha + beta) - gammaln(alpha) - gammaln(beta))

Posterior Update:
def beta_posterior_update(prior_alpha, prior_beta, successes, failures):
  """Update Beta-Prior und berechne Log-Evidence"""
  post_alpha = prior_alpha + successes
  post_beta = prior_beta + failures
  
  # Log-Marginal-Likelihood (Evidence)
  log_evidence = (betaln(post_alpha, post_beta) -
                 betaln(prior_alpha, prior_beta))
  
  return post_alpha, post_beta, log_evidence

🎯 Hochperformante Implementation

C++ Implementation für kritische Anwendungen:

C++ (Numerisch optimiert):
#include <cmath>
#include <stdexcept>

double log_beta(double a, double b) {
  if (a <= 0 || b <= 0) {
    throw std::domain_error("Log-Beta: arguments must be positive");
  }
  
  // Verwende lgamma für numerische Stabilität
  return lgamma(a) + lgamma(b) - lgamma(a + b);
}

// Vektorisierte Version
void log_beta_array(const double* a, const double* b,
                     double* result, size_t n) {
  for (size_t i = 0; i < n; ++i) {
    result[i] = log_beta(a[i], b[i]);
  }
}

CUDA (GPU-Beschleunigung):
__device__ double cuda_log_beta(double a, double b) {
  return lgamma(a) + lgamma(b) - lgamma(a + b);
}

__global__ void log_beta_kernel(const double* a, const double* b,
                                 double* result, int n) {
  int idx = blockIdx.x * blockDim.x + threadIdx.x;
  if (idx < n) {
    result[idx] = cuda_log_beta(a[idx], b[idx]);
  }
}