Bootstrapping y Remuestreo en Python: Automatización Práctica

Clase 19 de 22 • Curso de Estadística Inferencial para Data Science e Inteligencia Artificial

Resumen

¿Qué es el bootstrapping en Python?

El bootstrapping en Python es una técnica estadística ampliamente utilizada para obtener estimaciones precisas a partir de muestras de datos. Esta técnica de remuestreo permite dividir la población inicial en múltiples submuestras, lo que ayuda a mitigar el sesgo de los resultados y evita problemas comunes como el sobreajuste. A continuación, exploraremos cómo implementar esta técnica de manera automatizada utilizando Python.

¿Cómo prepararse para el bootstrapping?

Para comenzar con la técnica de bootstrapping, es esencial configurar un entorno adecuado que permita la manipulación y el análisis de datos. Te recomiendo el uso de un notebook de Python, como Google Colab, para seguir este proceso.

Importación de librerías necesarias: Es crucial cargar las bibliotecas requeridas para el análisis de datos. En este caso, usaremos:
- pandas para manipulación de datos.
- numpy para cálculos numéricos.
- random para generar muestras aleatorias.
```
import pandas as pd
import numpy as np
import random
```
Generación de datos aleatorios: A continuación, generamos un conjunto de datos aleatorios que simulen una población con un promedio específico.
```
data = np.random.normal(loc=34, size=10000)
```

¿Cómo validar los datos generados?

Validar que los datos generados se ajustan a la media deseada es un paso crucial. Esto nos asegura que la población inicial se ha creado correctamente y que está lista para ser dividida en submuestras.

np.mean(data)  # Validar que la media es aproximadamente 34

¿Cómo implementar el bootstrapping?

Una vez que tengamos una población de datos bien definida, podemos proceder con el bootstrapping para calcular múltiples promedios de submuestras. Este proceso se puede lograr creando un bucle que genera y calcula el promedio de cada submuestra.

Iniciación de bootstrapping: Comenzamos definiendo el número de muestras y el tamaño de cada muestra.
```
numero_muestras = 40
tamaño_muestra = 5
promedios = []
```

Generación de submuestras y cálculo de promedios: Utilizamos un bucle para extraer muestras aleatorias y calcular sus promedios.

for _ in range(numero_muestras):
    muestra = np.random.choice(data, tamaño_muestra)
    promedio_muestra = np.mean(muestra)
    promedios.append(promedio_muestra)

Cálculo del promedio general a partir de muestras: Finalmente, calculamos el promedio de todos los promedios de las submuestras para estimar el promedio de la población entera.
```
promedio_final = np.mean(promedios)
print(promedio_final)
```

¿Por qué el bootstrapping es útil?

El bootstrapping es invaluable para evitar sesgos en los resultados y protegerse contra el overfitting (sobreajuste) al estimar tendencias poblacionales. Esta técnica es especialmente útil en datos de ciencia e inteligencia artificial, donde es común trabajar con conjuntos de datos limitados.

Te animo a practicar este enfoque ampliando el número y tamaño de las muestras, lo cual te ofrecerá más precisiones y te permitirá experimentar el impacto de las variaciones poblacionales.

Hugo Montoya Diaz

student•

Juan R. Vergara M.

student•

Buen aporte.

Uriel Alfonso Velandia Donado

student•

Gracias por compartir este recurso

Carlos Mazzaroli

student•

Aca les dejo mi ejemplo de como hacer un Bootstrapping así que:

Vamos por partes como dijo Jack el Destripador.

Paso 1) Tener una muestra de datos

# población
data = np.random.normal(loc=34, size=10000)
# muestra
sample = random.sample(data.tolist(),40)

Paso 2) hacer un dataset de remuestreo desde un dataset de muestra original

# remuestreo
resample = np.random.choice(sample, size=len(sample))

Si quieres comprobar que los valores del remuestreo no son los mismos de la muestra podes probar estas líneas debajo

print('largo de la muestra:',len(sample))
print('largo del remuestreo:',len(resample))
print('valores únicos del remuestreo:',len(np.unique(resample)))
print('comparar muestra con remuestreo:' ,sample == resample)

Paso 3) Calcular algo del remuestreo ( en este caso la media )

mean_resample = resample.mean()

Paso 4) Trackear los datos que calculamos

tracker = []
tracker.append(mean_resample)

Paso 5) Repetir varias veces el paso 2 al 4

sample = random.sample(data.tolist(),40)
tracker = []

# repetimos 40 veces el paso 2 y 4
for i in range(40):
    # el largo del remuestreo debe ser igual que la muestra (se pueden repetir los datos)
    resample = np.random.choice(sample, size=len(sample))
    
    # calculamos la media del remuestreo
    mean_resample = resample.mean()
    
    # guardamos la media que calculamos
    tracker.append(mean_resample)

Paso 6) Graficar

sns.histplot(tracker)
plt.title(f'mean: {np.mean(tracker)}')

Rubén Cuello

student•

Reto completado!

Yonatan Efraín Jara Boza

student•

Leyendo/viendo videos que comparte la comunidad para entender, la imagen que comparte Hugo Montoya (el aporte que esta en cabecera) representa mejor este tema. La explicación de la clase simplifica demasiado dejando pasar pasos importantes para entender el concepto.

Me refiero a: No se debió sacar las remuestras de una gran población cuando se habia explicado que es para conjuntos pequeños, y que no se considero una forma de resetear los datos de la muestra original (repacement).

Con random.sample no se puede hacer replacement, pero sí con numpy.random.choice.

Antonio Demarco Bonino

student•

Funciona de maravillas:

Jason Francisco Macas Mora

student•

Es posible simplificar el código de los promedios:

promedio = [np.mean(random.sample(data.tolist(), 5))  for i in range(40) ]

Jhon Freddy Tavera Blandon

student•

En Python, se puede realizar bootstrapping utilizando la librería "numpy" y "random". A continuación te muestro un ejemplo de cómo se podría realizar bootstrapping para estimar la media de una muestra de datos:

import numpy as np
import random

# muestra de datos
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# número de iteraciones para el bootstrapping
n_iter = 1000

# almacenar las medias de cada muestra generada
means = []

for i in range(n_iter):
    # generar una nueva muestra con reemplazo
    sample = np.random.choice(data, size=len(data), replace=True)
    # calcular la media de la nueva muestra
    mean = np.mean(sample)
    # almacenar la media
    means.append(mean)

# estimar la incertidumbre de la media original
mean_original = np.mean(data)
std_original = np.std(means)

# imprimir resultados
print("Media original: ", mean_original)
print("Desviacion estandar de las medias de las muestras generadas: ", std_original)

En este ejemplo, se generaron 1000 muestras con reemplazo de los datos originales y se calcularon las medias de cada una de las muestras. La desviación estándar de las medias de las muestras generadas es una estimación de la incertidumbre de la media original.

Es importante mencionar que el número de iteraciones que se utilice para bootstrapping dependerá de los datos y del propósito del análisis. Generalmente, se sugiere utilizar al menos 1000 iteraciones para obtener una buena estimación de la incertidumbre.

Thomas Gonzalez Rodrigues

student•

reto y código

sample_list = []
samples = 40
sample_size = 5

for i in range(samples):
  sample = data.sample(sample_size)
  sample_list.append(sample.mean())

sns.histplot(data = sample_list);

Javier Luis Ricaurte Peña

student•

Seguí este procedimiento para realizar una muestra de la muestra que hicimos en clase.

Primero la muestra que hizo la profe:

promedio = []
for i in range(100):
  muestra = random.sample(data.tolist(), 20)
  prom = np.mean(muestra)
  promedio.append(prom)

np.mean(promedio)

Ahora realicé una segunda muestra basándome en la primera:

promedio2 = []
for i in range(20):
  muestra2 = random.sample(muestra, 5)
  prom2 = np.mean(muestra2)
  promedio2.append(prom2)

np.mean(promedio2)

Es correcto este procedimiento que hice, o por el contrario me equivoqué al repetir el proceso? Agradezco el feedback.

Federico Mario

student•

Hola Javier! Hasta donde tengo yo entendido, el bootstrap se refiere mas a lo que hiciste vos que a lo que hizo la profesora, ya que vos hiciste un remuestreo de la muestra original que es en lo que se basa la idea del bootstrap y en cambio la profe solo saco 40 muestras de la población original y no de una muestra. Recomiendo muchisimo para complementar el curso la lectura del libro Practical Statistics for Data Scientists (si se lo busca se lo encuentra ;)) Saludos!!

William Camilo Correa Sandoval

student•

Reto: Haciendo Bootstrapping para determinar la Desviación estandar de la muestra

Hay un error en la toma de las muestras. Según ChatGPT:

En el bootstrapping generalmente se toman muestras con reemplazo del mismo tamaño que la muestra original. Esto se debe a que el objetivo del bootstrapping es simular el proceso de muestreo repetido de la población original, permitiendo que los mismos elementos se seleccionen varias veces. Cuando tomas muestras del mismo tamaño que la muestra original y con reemplazo, estás imitando la variabilidad que se observa en los datos originales. Cada muestra bootstrap es una "fotocopia" de la muestra original, pero debido al reemplazo, puede contener duplicados y elementos que no estaban en la muestra original.

Tomando las muestras con la misma longitud de los datos y siguiendo muestreo con reemplazo

std = []

for i in range(1000):
  std_i = random.choices(data, k = len(data))
  std.append(np.std(std_i))

np.mean(std)

0.993307735107782

Graficamos los resultados:

sns.histplot(std)
plt.axvline(x = np.std(data), color='r', linestyle='--', label='Std data')
plt.axvline(x = np.mean(std), color='b', linestyle='-.', label='Mean std bootstrapping')
plt.legend();

print("Standard deviation data original: {}".format(np.std(data)), "\n",
      "Standard deviation with bootstrapping: {}".format(np.mean(std)))

Standard deviation data original: 0.993526117939529 Standard deviation with bootstrapping: 0.993307735107782

Jeinfferson Bernal G

student•

Gran aporte. Mucho mejor entendido que lo explicado por la profe 👍🏻

Marcela Villa Marulanda

student•

El ejemplo de la profesora es en realidad una demostración del Teorema del Límite Central: muestra que si se toman muchas muestras de una población, la distribución de las medias de esas muestras tenderá a ser normal y su promedio se acercará al promedio de la población.

Santiago Ahumada Lozano

student•

Una pregunta. Yo estoy intentando cambiar el "Tomar 40 muestras de a 5" Por "tomar una muestra de 200 y tomar 40 muestras de a 5" Y la verdad obtengo resultados malos: 33.2, 33.6 pero nunca 33.9 o 34 ¿Es porque los remuestreos deben ser tomados sobre el conjunto completo? ¿O por lo que al hacer muestras sobre una muestra se repiten datos y eso provoca un sesgo? Aquí el código

def bootstrapp2(data, sample_size, sub_sample_size):
  sample_means = []
  data_list = data.tolist()
  sample = random.sample(data_list, sample_size)
  for i in range(sample_size // sub_sample_size):
    sample = random.sample(sample, sub_sample_size)
    sample_mean = np.mean(sample)
    sample_means.append(sample_mean)
  return np.mean(sample_means)

sample_size = 384
subsample_size = 3  # Must be a divisor of the sample size
mean_bs = bootstrapp2(data, sample_size, subsample_size)
print('The approximated mean via bootstrapping is: ', mean_bs)

Cuyo resultado en mi caso es The approximated mean via bootstrapping is: 33.24292454654546

Yonatan Efraín Jara Boza

student•

Tus pasos son los correctos! Tu segunda pregunta revela el problema mas o menos: Estas remuestreando sin repetición cuando deberías hacerlo con repetición porque tu muestra es pequeña (40). Mira este video; https://youtu.be/Xz0x-8-cgaQ

O sea en vez de usar random.sample(...) debes usar numpy.random.choice(..., replace=True). Revisa la documentación de estos 2 métodos.

Ricardo Gomez

student•

Alfonso Andres Zapata Guzman

student•

def generador_data(media, largo):
    data = np.random.normal(loc = media, size = largo)
    return data


mi_data = generador_data(300, 100000)
mi_data.mean()

def bootstrapping(data, iteraciones):
    promedio = []
    for i in range(iteraciones):
        muestra = random.sample(data.tolist(), 5)
        prom = np.mean(muestra)
        promedio.append(prom)
    return f'El promedio de mi data usando el metodo bootstrapping es: {np.mean(promedio):.2f}'

bootstrapping(mi_data, 350)

Gabriel Obregón

student•

🧾Bootstrapping en Python

🔹 ¿Qué es?

📊 Técnica de remuestreo que:

🔄 Crea submuestras de una población inicial.
🛡️ Reduce sesgos en los resultados.
🚫 Evita el sobreajuste (overfitting).
🎯 Mejora estimaciones poblacionales.

🔹 Preparación del entorno

👉 Usa un notebook de Python (ej. Google Colab).

📦 Librerías necesarias:

🐼 pandas → manipulación de datos.
🔢 numpy → cálculos numéricos.
🎲 random → generación de muestras.

import pandas as pd

import numpy as np

import random

🔹 Generación de datos

🎲 Crear una población simulada con media ~34:

data = np.random.normal(loc=34, size=10000)

✅ Validar media:

np.mean(data) # ~34

🔹 Pasos del Bootstrapping

1️⃣ Definir parámetros

📝 Número de muestras y tamaño de cada muestra:

numero_muestras = 40

tamaño_muestra = 5

promedios = []

2️⃣ Crear submuestras + promedio

🔄 Extraer submuestras y calcular su media:

for _ in range(numero_muestras):

muestra = np.random.choice(data, tamaño_muestra)

promedio_muestra = np.mean(muestra)

promedios.append(promedio_muestra)

3️⃣ Calcular promedio general

📈 Promedio de promedios = estimación poblacional:

promedio_final = np.mean(promedios)

print(promedio_final)

🔹 ¿Por qué es útil?

✨ Ventajas principales:

📉 Reduce sesgos.
🛡️ Previene el sobreajuste.
🤖 Muy usado en ciencia de datos e IA cuando hay pocos datos.

🔹 Recomendación práctica

🧪 Para experimentar:

🔢 Aumenta el número de muestras.
📏 Cambia el tamaño de cada muestra.
👀 Observa cómo varían los resultados.

💡 Tip extra: Añade gráficos (ej. histogramas) para visualizar distribuciones y entender mejor los resultados del bootstrapping.

Matías Collado

student•

Entonces la muestra limitada de la que dispondremos serán 10.000 datos?

De ellos sacaremos 40 muestras de 5 elementos.
Calcularemos la media para los 40 conjuntos.
Finalmente calculamos la media de las 40 medias calculadas.

¿Así?

Bryan Castano

student•

Genial cuando Ella ha dicho - ' Es por esto que queremos hacer una Muestra de la Muestra, =' vayah Luego asi es como Yo he entendido finalmente boostraping.

Eugenio Schiavoni

student•

Dejo un codigo de Bootstrapping para que puedan experimentar y ver las diferencias en el numero de muestras,.

import numpy as np
import random

data = np.random.normal(loc=34, size=10000)
print("=====" * 30)
print("Promedio de datos de poblacion" )
print(data.mean().round(4))
print("Mediana de datos de poblacion")
print(np.median(data).round(4))
print("=====" * 30)
def boot_straper(cant):
    boot_strap = np.array([])
    for i in range(0, cant):
        boot_strap = np.append(boot_strap, data[random.randint(0, 9999)])
    return boot_strap

###En esta linea de abajo donde esta el 100 representa el numero de muestras que quiero tomar, notese
#que a medida que subo el numero se aproxima mas a los valores "reales" o de la poblacion. Lo que seria lo mismo
#que crear muchos grupos. Con este simple algoritmo espero que les sirva para entender lo que no se entendio en clases!
#tambien se comprueba el teorema del limite central repitiendo el experimento varias veces
resultado = boot_straper(100000)
print("=====" * 30)
print("Promedio de datos de muestra realizada con boot_strap" )
print(resultado.mean().round(4))
print("Mediana de datos de muestra realizada con boot_strap" )
print(np.median(resultado).round(4))
print("=====" * 30)

print("Diferencia entre el promedio y la mediana de la poblacion y de las muestras realizadas por boot_strap" )

print("Diferencia de promedio: ",abs(data.mean().round(4)
                                     - resultado.mean().round(4)).round(4),
      "es la diferencia entre el promedio real y el calculado con la muestra aleatoria" )

print("Diferencias de medianas: ", abs(np.median(data).round(4) -
                                       np.median(resultado).round(4)).round(4),
                                    " es la diferencia entre la mediana real y el calculado con la muestra aleatoria")

Jorge Ricardo Chambilla Araca

student•

Reto cumplido

data1 = np.random.normal(loc=42, size = 110000)
data1
data1.mean()
promedio2 = []
for i in range(70):   #generamos 70 muestras o grupos de la población total = 110000
  muestra = random.sample(data1.tolist(),8)    # generamos 70 muestras de 8 integrantes
  prom= np.mean(muestra)      # de cada muestra generamos un promedio de edad
  promedio2.append(prom)      # y agreagmos a la lista promedio2[], obtendremos un total de 70 promedios
# de los 70 promedios, sacamos un promedio general, el resultado se aproxima a la etiqueta de edad promedio = 42, 
np.mean(promedio2)