Métodos Bootstrap para la Desviación Estándar

Bootstrap: La Revolución Estadística de la Era Computacional

El remuestreo bootstrap es una técnica estadística poderosa que estima la distribución muestral de cualquier estadístico mediante el muestreo repetido a partir 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 clave detrás del bootstrap es elegantemente simple: tu muestra es la mejor estimación de la población. Al remuestrear de tu muestra (con reemplazo), simulas lo que ocurriría si pudieras tomar muestras repetidamente de la población. Este enfoque es particularmente valioso para la desviación estándar, donde las fórmulas tradicionales de intervalos de confianza asumen normalidad, un supuesto que frecuentemente falla en la práctica.

El bootstrap se ha vuelto 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 requiere supuestos sobre la distribución subyacente de los datos.

¿Por qué usar Bootstrap para la Desviación Estándar?

Los intervalos de confianza tradicionales para la desviación estándar asumen que los datos provienen de una distribución normal. Cuando este supuesto no se cumple (lo cual es frecuente), estos intervalos pueden ser enormemente imprecisos. El bootstrap ofrece una alternativa libre de distribución.

Ventajas clave del bootstrap para la desviación estándar:

• Sin supuestos distribucionales: Funciona igualmente bien con datos normales, asimétricos o de colas pesadas
• Buen desempeño con muestras pequeñas: Frecuentemente más preciso que los métodos paramétricos cuando n < 30
• Manejo de estadísticos complejos: El mismo enfoque funciona para DE recortada, MAD u otras medidas de variabilidad personalizadas
• Perspectiva visual: La distribución bootstrap muestra lo que está ocurriendo, no solo números finales

El Procedimiento Bootstrap

El algoritmo bootstrap es notablemente sencillo. 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 para publicación, se recomiendan 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: tomar directamente los percentiles de la distribución bootstrap.

Para 10,000 muestras bootstrap, estos son los valores ordenados en las posiciones 250 y 9,750. 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 la 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. El método BCa ajusta tanto por el sesgo en la distribución bootstrap como por 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

Consideremos 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 tienen asimetría positiva (algunas respuestas muy lentas).

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

Implementación en Python

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

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