Bootstrapmethoden voor standaardafwijking

Bootstrap: de statistische revolutie van het computertijdperk

Bootstrap-resampling is een krachtige statistische techniek die de steekproefverdeling van elke statistiek schat door herhaaldelijk opnieuw te trekken uit uw waargenomen gegevens. Geïntroduceerd door Bradley Efron in 1979, revolutioneerde het de statistische inferentie door analyse van complexe statistieken mogelijk te maken zonder afhankelijkheid van wiskundige formules of verdelingsaannames.

Het kernidee achter bootstrap is elegant eenvoudig: uw steekproef is uw beste schatting van de populatie. Door opnieuw te trekken uit uw steekproef (met terugleggen) simuleert u wat er zou gebeuren als u herhaaldelijk uit de populatie kon trekken. Deze benadering is bijzonder waardevol voor standaardafwijking, waar traditionele betrouwbaarheidsintervalformules normaliteit aannemen—een aanname die in de praktijk vaak niet klopt.

Bootstrap is essentieel geworden in moderne data science omdat het werkt met elke statistiek (mediaan, correlatie, regressiecoëfficiënten, gewichten van neurale netwerken) en geen aannames doet over de onderliggende verdeling van uw gegevens.

Waarom bootstrap voor standaardafwijking?

Traditionele betrouwbaarheidsintervallen voor standaardafwijking nemen aan dat uw gegevens uit een normale verdeling komen. Wanneer deze aanname niet klopt (wat veel voorkomt), kunnen deze intervallen flink onjuist zijn. Bootstrap biedt een verdelingsvrij alternatief.

Belangrijkste voordelen van bootstrap voor standaardafwijking:

• Geen verdelingsaannames: Werkt even goed met normale, scheve of zwaartstaartgegevens
• Prestatie bij kleine steekproeven: Vaak nauwkeuriger dan parametrische methoden met n < 30
• Behandelt complexe statistieken: Dezelfde aanpak werkt voor getrimde SD, MAD of aangepaste variabiliteitsmaten
• Visueel inzicht: De bootstrapverdeling laat u zien wat er gebeurt, niet alleen eindcijfers

De bootstrapprocedure

Het bootstrap-algoritme is opmerkelijk eenvoudig. Vanuit uw oorspronkelijke steekproef van n waarnemingen:

Hoeveel bootstrapsteekproeven? B = 1.000 is vaak voldoende voor ruwe schattingen en hypothesetoetsen. Voor betrouwbaarheidsintervallen biedt B = 10.000 stabiele percentielen. Voor publicatiekwaliteit BCa-intervallen wordt B = 15.000+ aanbevolen.

Bootstrap-betrouwbaarheidsintervalmethoden

Er bestaan verschillende methoden voor het construeren van betrouwbaarheidsintervallen uit bootstrapsteekproeven, elk met afwegingen:

1. Percentielmethode (eenvoudigst)

De meest intuïtieve benadering: neem de percentielen van de bootstrapverdeling direct.

Bij 10.000 bootstrapsteekproeven zijn dit de 250e en 9.750e geordende waarden. Eenvoudig maar kan vertekend zijn wanneer de bootstrapverdeling scheef is.

2. Basis (pivotale) bootstrap

Gebruikt de relatie tussen de steekproefstatistiek en bootstrapstatistieken:

Waarbij θ̂ de oorspronkelijke steekproef-SD is. Dit “spiegelt” het percentielinterval rond de steekproefschatting.

3. BCa (Bias-gecorrigeerd en versneld)

De gouden standaard voor nauwkeurigheid. BCa corrigeert voor zowel vertekening in de bootstrapverdeling als versnelling (hoe de standaardfout verandert met de parameterwaarde). Complexer om te berekenen maar levert tweede-orde nauwkeurige intervallen.

Uitgewerkt voorbeeld: niet-normale gegevens

Beschouw 15 metingen van reactietijden (in ms): 245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312. Deze gegevens zijn rechtsscheef (sommige zeer trage reacties).

Het bootstrap-BI is asymmetrisch (breder aan de hoge kant), wat de rechtsscheve aard van de gegevens weerspiegelt. Het chi-kwadraat BI vangt deze asymmetrie niet.

Python-implementatie

Volledige bootstrap-implementatie met meerdere BI-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}]")