Métodos Bootstrap para el Desvío Estándar

Bootstrap: la revolución estadística de la era computacional

El remuestreo bootstrap es una técnica estadística sumamente poderosa que estima la distribución muestral de cualquier estadístico mediante el remuestreo repetido de los datos observados. Introducido por Bradley Efron en 1979, revolucionó la inferencia estadística al permitir el análisis de estadísticos complejos sin depender de fórmulas matemáticas ni supuestos distribucionales.

La idea central del bootstrap es elegantemente simple: tu muestra es la mejor estimación que tenés de la población. Al remuestrear de tu muestra (con reemplazo), simulás lo que ocurriría si pudieras tomar muestras repetidamente de la población. Este enfoque es particularmente valioso para el desvío estándar, donde las fórmulas tradicionales de intervalos de confianza suponen normalidad, un supuesto que frecuentemente no se cumple en la práctica.

El bootstrap se convirtió en una herramienta esencial en la ciencia de datos moderna porque funciona con cualquier estadístico (mediana, correlación, coeficientes de regresión, pesos de redes neuronales) y no hace supuestos sobre la distribución subyacente de los datos.

¿Por qué bootstrap para el desvío estándar?

Los intervalos de confianza tradicionales para el desvío estándar asumen que los datos provienen de una distribución normal. Cuando este supuesto falla (algo bastante común), estos intervalos pueden ser extremadamente imprecisos. El bootstrap ofrece una alternativa libre de supuestos distribucionales.

Ventajas clave del bootstrap para el desvío estándar:

• Sin supuestos distribucionales: funciona igualmente bien con datos normales, asimétricos o de colas pesadas
• Buen rendimiento con muestras pequeñas: frecuentemente más preciso que los métodos paramétricos cuando n < 30
• Maneja estadísticos complejos: el mismo enfoque sirve para el DE recortado, MAD o medidas de variabilidad personalizadas
• Intuición visual: la distribución bootstrap te muestra lo que está ocurriendo, no solo números finales

El procedimiento bootstrap

El algoritmo bootstrap es notablemente directo. A partir de tu muestra original de n observaciones:

¿Cuántas muestras bootstrap? B = 1.000 suele ser suficiente para estimaciones aproximadas y pruebas de hipótesis. Para intervalos de confianza, B = 10.000 proporciona percentiles estables. Para intervalos BCa de calidad publicable, se recomienda B = 15.000 o más.

Métodos de intervalos de confianza bootstrap

Existen varios métodos para construir intervalos de confianza a partir de muestras bootstrap, cada uno con sus ventajas y desventajas:

1. Método de percentiles (el más simple)

El enfoque más intuitivo: tomá los percentiles de la distribución bootstrap directamente.

Para 10.000 muestras bootstrap, esto corresponde al valor ordenado número 250 y al 9.750. Es simple, pero puede tener sesgo cuando la distribución bootstrap es asimétrica.

2. Bootstrap básico (pivotal)

Utiliza la relación entre el estadístico muestral y los estadísticos bootstrap:

Donde θ̂ es el DE de la muestra original. Este método “refleja” el intervalo de percentiles alrededor de la estimación muestral.

3. BCa (corregido por sesgo y acelerado)

El estándar de referencia en precisión. BCa ajusta tanto el sesgo de la distribución bootstrap como la aceleración (cómo cambia el error estándar con el valor del parámetro). Es más complejo de calcular, pero proporciona intervalos con precisión de segundo orden.

Ejemplo resuelto: datos no normales

Considerá 15 mediciones de tiempos de respuesta (en ms): 245, 312, 287, 456, 234, 298, 267, 523, 289, 301, 278, 645, 256, 289, 312. Estos datos presentan asimetría positiva (algunos tiempos de respuesta muy lentos).

El IC bootstrap es asimétrico (más amplio en el lado alto), reflejando la asimetría positiva de los datos. El IC chi-cuadrado no captura esta asimetría.

Implementación en Python

Implementación completa del bootstrap con múltiples métodos de IC:

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