Bootstrap-Methoden für die Standardabweichung

Bootstrap: Die statistische Revolution des Computerzeitalters

Bootstrap-Resampling ist ein leistungsfähiges statistisches Verfahren, das die Stichprobenverteilung einer beliebigen Statistik durch wiederholtes Ziehen aus den beobachteten Daten schätzt. Die 1979 von Bradley Efron eingeführte Methode revolutionierte die statistische Inferenz, indem sie die Analyse komplexer Statistiken ermöglichte — ohne auf mathematische Formeln oder Verteilungsannahmen angewiesen zu sein.

Die zentrale Idee hinter dem Bootstrap ist elegant einfach: Ihre Stichprobe ist die beste Schätzung der Population. Durch wiederholtes Ziehen aus Ihrer Stichprobe (mit Zurücklegen) simulieren Sie, was geschehen würde, wenn Sie wiederholt aus der Population ziehen könnten. Dieser Ansatz ist besonders wertvoll für die Standardabweichung, da klassische Konfidenzintervall-Formeln Normalverteilung voraussetzen — eine Annahme, die in der Praxis häufig verletzt wird.

Bootstrap ist in der modernen Datenwissenschaft unverzichtbar geworden, weil es mit jeder Statistik funktioniert (Median, Korrelation, Regressionskoeffizienten, neuronale Netzwerk-Gewichte) und keine Annahmen über die zugrundeliegende Verteilung Ihrer Daten erfordert.

Warum Bootstrap für die Standardabweichung?

Klassische Konfidenzintervalle für die Standardabweichung setzen voraus, dass Ihre Daten aus einer Normalverteilung stammen. Wenn diese Annahme nicht erfüllt ist (was häufig vorkommt), können diese Intervalle stark verfälscht sein. Bootstrap bietet eine verteilungsfreie Alternative.

Wesentliche Vorteile des Bootstrap für die Standardabweichung:

• Keine Verteilungsannahmen: Funktioniert gleich gut mit normalen, schiefen oder schwerschwänzigen Daten
• Leistung bei kleinen Stichproben: Oft genauer als parametrische Methoden bei n < 30
• Handhabt komplexe Statistiken: Der gleiche Ansatz funktioniert für getrimmte SD, MAD oder eigene Streuungsmaße
• Visueller Einblick: Die Bootstrap-Verteilung zeigt Ihnen, was passiert — nicht nur Endergebnisse

Das Bootstrap-Verfahren

Der Bootstrap-Algorithmus ist bemerkenswert geradlinig. Ausgehend von Ihrer ursprünglichen Stichprobe mit n Beobachtungen:

Wie viele Bootstrap-Stichproben? B = 1.000 genügt oft für grobe Schätzungen und Hypothesentests. Für Konfidenzintervalle liefert B = 10.000 stabile Perzentile. Für publikationsreife BCa-Intervalle werden B = 15.000+ empfohlen.

Bootstrap-Konfidenzintervall-Methoden

Es existieren mehrere Methoden zur Konstruktion von Konfidenzintervallen aus Bootstrap-Stichproben, jeweils mit eigenen Vor- und Nachteilen:

1. Perzentil-Methode (einfachste)

Der intuitivste Ansatz: Die Perzentile der Bootstrap-Verteilung werden direkt verwendet.

Bei 10.000 Bootstrap-Stichproben sind dies der 250. und der 9.750. geordnete Wert. Einfach, aber bei schiefer Bootstrap-Verteilung möglicherweise verzerrt.

2. Basis-Bootstrap (Pivotal-Methode)

Nutzt die Beziehung zwischen der Stichprobenstatistik und den Bootstrap-Statistiken:

Dabei ist θ̂ die ursprüngliche Stichproben-SD. Diese Methode "spiegelt" das Perzentil-Intervall um die Stichprobenschätzung.

3. BCa (verzerrungskorrigiert und beschleunigt)

Der Goldstandard für Genauigkeit. BCa korrigiert sowohl die Verzerrung in der Bootstrap-Verteilung als auch die Beschleunigung (wie sich der Standardfehler mit dem Parameterwert ändert). Rechenintensiver, liefert aber Intervalle zweiter Ordnung.

Rechenbeispiel: Nicht-normalverteilte Daten

Betrachten Sie 15 Messungen von Reaktionszeiten (in ms): 245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312. Diese Daten sind rechtsschief (einige sehr langsame Reaktionen).

Das Bootstrap-KI ist asymmetrisch (breiter auf der oberen Seite) und spiegelt die Rechtsschiefe der Daten wider. Das Chi-Quadrat-KI erfasst diese Asymmetrie nicht.

Python-Implementierung

Vollständige Bootstrap-Implementierung mit mehreren KI-Methoden:

import numpy as np
from scipy import stats

def bootstrap_sd_ci(data, n_bootstrap=10000, ci=0.95, method='percentile'):
    """
    Bootstrap confidence interval for standard deviation.

    Parameters:
    -----------
    data : array-like - Original sample
    n_bootstrap : int - Number of bootstrap samples
    ci : float - Confidence level (e.g., 0.95)
    method : str - 'percentile', 'basic', or 'bca'

    Returns:
    --------
    tuple : (lower_bound, upper_bound, bootstrap_sds)
    """
    data = np.array(data)
    n = len(data)
    original_sd = np.std(data, ddof=1)

    # Generate bootstrap samples and calculate SDs
    bootstrap_sds = np.array([
        np.std(np.random.choice(data, size=n, replace=True), ddof=1)
        for _ in range(n_bootstrap)
    ])

    alpha = 1 - ci

    if method == 'percentile':
        lower = np.percentile(bootstrap_sds, 100 * alpha/2)
        upper = np.percentile(bootstrap_sds, 100 * (1 - alpha/2))

    elif method == 'basic':
        lower = 2*original_sd - np.percentile(bootstrap_sds, 100*(1-alpha/2))
        upper = 2*original_sd - np.percentile(bootstrap_sds, 100*alpha/2)

    elif method == 'bca':
        # Bias correction
        prop_less = np.mean(bootstrap_sds < original_sd)
        z0 = stats.norm.ppf(prop_less)

        # Acceleration (jackknife estimate)
        jackknife_sds = np.array([
            np.std(np.delete(data, i), ddof=1) for i in range(n)
        ])
        jack_mean = jackknife_sds.mean()
        a = np.sum((jack_mean - jackknife_sds)**3) / \
            (6 * np.sum((jack_mean - jackknife_sds)**2)**1.5)

        # Adjusted percentiles
        z_alpha = stats.norm.ppf([alpha/2, 1-alpha/2])
        adj_percentiles = stats.norm.cdf(
            z0 + (z0 + z_alpha) / (1 - a*(z0 + z_alpha))
        ) * 100
        lower = np.percentile(bootstrap_sds, adj_percentiles[0])
        upper = np.percentile(bootstrap_sds, adj_percentiles[1])

    return lower, upper, bootstrap_sds

# Example usage
response_times = [245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312]

for method in ['percentile', 'basic', 'bca']:
    lower, upper, _ = bootstrap_sd_ci(response_times, method=method)
    print(f"{method.upper():12s} 95% CI: [{lower:.1f}, {upper:.1f}]")