Bootstrap-metoder til standardafvigelse

Bootstrap: Den computerbaserede statistiske revolution

Bootstrap-resampling er en kraftfuld statistisk teknik, der estimerer stikprøvefordelingen for enhver statistik ved gentagne gange at udtage nye stikprøver fra de observerede data. Metoden blev introduceret af Bradley Efron i 1979 og revolutionerede statistisk inferens ved at muliggøre analyse af komplekse statistikker uden at være afhængig af matematiske formler eller fordelingsmæssige antagelser.

Den grundlæggende idé bag bootstrap er elegant i sin enkelthed: din stikprøve er dit bedste estimat af populationen. Ved at udtage nye stikprøver fra din stikprøve (med tilbagelægning) simulerer du, hvad der ville ske, hvis du gentagne gange kunne udtage stikprøver fra populationen. Denne tilgang er særligt værdifuld for standardafvigelse, hvor traditionelle konfidensintervalformler forudsætter normalfordeling – en antagelse, der ofte ikke holder i praksis.

Bootstrap er blevet uundværlig inden for moderne datavidenskab, fordi den fungerer med enhver statistik (median, korrelation, regressionskoefficienter, neurale netværksvægte) og ikke kræver antagelser om den underliggende fordeling af dine data.

Hvorfor bootstrap til standardafvigelse?

Traditionelle konfidensintervaller for standardafvigelse forudsætter, at dine data stammer fra en normalfordeling. Når denne antagelse ikke holder (hvilket er almindeligt), kan disse intervaller være stærkt upræcise. Bootstrap giver et fordelingsfrit alternativ.

Centrale fordele ved bootstrap til standardafvigelse:

• Ingen fordelingsantagelser: Fungerer lige godt med normalfordelte, skæve eller tunghalede data
• God præstation ved små stikprøver: Ofte mere præcis end parametriske metoder ved n < 30
• Håndterer komplekse statistikker: Samme fremgangsmåde virker for trimmet SA, MAD eller tilpassede spredningsmål
• Visuel indsigt: Bootstrap-fordelingen viser dig, hvad der foregår – ikke kun de endelige tal

Bootstrap-proceduren

Bootstrap-algoritmen er bemærkelsesværdigt ligetil. Fra din oprindelige stikprøve med n observationer:

Hvor mange bootstrap-stikprøver? B = 1.000 er ofte tilstrækkeligt til grove estimater og hypotesetest. Til konfidensintervaller giver B = 10.000 stabile percentiler. Til publikationskvalitets BCa-intervaller anbefales B = 15.000+.

Bootstrap-konfidensintervalmetoder

Der findes flere metoder til at konstruere konfidensintervaller fra bootstrap-stikprøver, hver med sine fordele og ulemper:

1. Percentilmetoden (enkleste)

Den mest intuitive tilgang: tag percentilerne af bootstrap-fordelingen direkte.

Ved 10.000 bootstrap-stikprøver er dette den 250. og 9.750. ordnede værdi. Simpelt, men kan være skævt, når bootstrap-fordelingen er asymmetrisk.

2. Basal (pivotal) bootstrap

Bruger forholdet mellem stikprøvestatistikken og bootstrap-statistikkerne:

Hvor θ̂ er den oprindelige stikprøves SA. Dette “spejler” percentilintervallet omkring stikprøveestimatet.

3. BCa (Bias-Corrected and Accelerated)

Guldstandarden for nøjagtighed. BCa justerer for både bias i bootstrap-fordelingen og acceleration (hvordan standardfejlen ændres med parameterværdien). Mere kompleks at beregne, men giver andenordens nøjagtige intervaller.

Gennemregnet eksempel: Ikke-normalfordelte data

Betragt 15 målinger af responstider (i ms): 245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312. Disse data er højreskæve (nogle meget langsomme svar).

Bootstrap-KI’et er asymmetrisk (bredere i den høje ende), hvilket afspejler den højreskæve karakter af dataene. Chi-kvadrat-KI’et fanger ikke denne asymmetri.

Python-implementering

Komplet bootstrap-implementering med flere KI-metoder:

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}]")