Haciendo un bootstrapping a un modelo

Curso de Estadística Inferencial con R

Teoría

Qué aprenderás y qué es Estadística Inferencial

Valor esperado condicional

Muestras y poblaciones

Muestreo

Estimadores y parámetros

Casos paramétricos y no paramétricos

El espacio de parámetros

Estimación puntual

Estimación por intervalo

Tamaño muestral

Sesgo y varianza

Teoría no paramétrica

Estimación funcional: una sola variable

Estimación funcional: valor esperado condicional

Bootstrapping

Validación cruzada

Introducción a las pruebas de hipótesis

Pruebas de hipótesis

Simulación

Teorías formales

Instalación de R

Explorando datos simulados

Simulando estimadores puntuales

Simulando intervalos de confianza

Observando el comportamiento del tamaño muestral

Estimando distribuciones simuladas

Red neuronal vs. regresión lineal

Examinando el sesgo y la varianza

Haciendo un bootstrapping a un modelo

Hagamos la validación cruzada

Revisemos la potencia de una prueba

Proyecto

Estimación de parámetros con datos reales

Estimación por intervalo de parámetros con datos reales

Red neuronal de pronóstico con datos reales

Validación cruzada de nuestra red neuronal

Calculando el tamaño óptimo de la muestra

Contextualización de la red neuronal

Conclusiones

¿Qué más sigue?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Qué es el bootstrapping y cómo se implementa en R?

El bootstrapping es una técnica de remuestreo que permite estimar la distribución de un estadístico mediante la creación de múltiples subconjuntos de los datos originales. En una muestra aleatoria, el proceso se repite varias veces con reemplazo, lo que significa que algunos elementos pueden seleccionarse más de una vez.

En R, el bootstrapping comúnmente se utiliza en la estadística inferencial para estimar intervalos de confianza, especialmente en situaciones donde no se pueden aplicar fórmulas teóricas debido a la estructura compleja de los datos.

¿Cómo se prepara el entorno de trabajo?

Para comenzar a implementar bootstrapping en R, se establece primero el tamaño de la muestra. En el ejemplo se utiliza un tamaño muy pequeño de muestra, solo 23, pero se enfatiza el uso de un gran número de iteraciones para mejorar la precisión de los resultados.

n <- 23 # Tamaño muestral pequeño
iteraciones <- 1000 # Número de iteraciones

# Valores para beta0 y beta1
beta0 <- 1
beta1 <- -0.3

# Desviación estándar del error
desviacion_error <- 0.5

¿Cómo se generan las variables independientes y dependientes?

Para la generación de datos, se definen funciones que simulan la variable independiente X y la dependiente Y, basadas en la relación lineal preestablecida. La función generaX produce valores X entre -3 y 3, mientras que generaY crea Y usando los valores predeterminados de los betas y sumando un error aleatorio.

generaX <- function(n) {
  seq(-3, 3, length.out = n)
}

generaY <- function(x, beta0, beta1, desviacion) {
  y <- beta1 * x + beta0 + rnorm(length(x), mean = 0, sd = desviacion)
  return(y)
}

# Generación de datos
datosX <- generaX(n)
datosY <- generaY(datosX, beta0, beta1, desviacion_error)

¿Cómo se realiza la regresión lineal y el cálculo de los coeficientes?

La regresión lineal en R se lleva a cabo utilizando el modelo LM. Los coeficientes resultantes del modelo se extraen para su análisis.

modelo <- lm(datosY ~ datosX)
coeficientes_muestrales <- coef(modelo)

¿Qué pasos se siguen para el remuestreo en bootstrapping?

Para realizar el remuestreo, se ejecuta un ciclo for para iterar sobre el número de veces deseadas. En cada iteración, se toma una nueva muestra con reemplazo, se ejecuta la regresión sobre esta muestra y se almacenan los coeficientes. Este proceso se repite densas veces, lo que da como resultado una comparación robusta de los intervalos de confianza.

beta0_est <- numeric(iteraciones)
beta1_est <- numeric(iteraciones)

for (i in 1:iteraciones) {
  muestra_indices <- sample(1:n, n, replace = TRUE)
  muestraX <- datosX[muestra_indices]
  muestraY <- datosY[muestra_indices]
  
  modelo_muestra <- lm(muestraY ~ muestraX)
  coef_muestra <- coef(modelo_muestra)

  beta0_est[i] <- coef_muestra[1]
  beta1_est[i] <- coef_muestra[2]
}

# Cálculo de los intervalos de confianza con bootstrapping
intervalo_beta0 <- quantile(beta0_est, c(0.025, 0.975))
intervalo_beta1 <- quantile(beta1_est, c(0.025, 0.975))

¿Cómo se visualizan los resultados del bootstrapping?

Finalmente, se realiza un gráfico utilizando las funciones de plot y points, mostrando los diferentes estimadores obtenidos mediante bootstrapping y destacando los intervalos de confianza.

plot(beta0_est, beta1_est, xlab = "Beta 0", ylab = "Beta 1", main = "Distribución de Betas via Bootstrap")
abline(v = intervalo_beta0, col = "blue", lty = 2)
abline(h = intervalo_beta1, col = "red", lty = 2)

El bootstrapping, como se ha descrito, ofrece flexibilidad ante la falta de supuestos teóricos al proporcionar una forma empírica de estimar la dispersión estadística y confiar en los resultados, permitiéndonos abordar modelos estadísticos complejos sin depender de criterios normales. ¡Es una herramienta poderosa para tus proyectos de análisis de datos!

Aportes 8

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

rusbel bermúdez rivera

hace 5 años

Agrego mi código con comentarios, espero sea de utilidad,


# Hacemos un bootstrapping para nuestra regresión lineal. -----------------


# Bootstrapping -----------------------------------------------------------


tamano_muestral <- 23
iteraciones <- 1000
beta_0 <- 1
beta_1 <- -0.3
desv_est_error <- 0.5

genera_x <- function(n) seq(-3, 3, length.out = n)

genera_y <- function(x, beta_0, beta_1){
  beta_1*x + beta_0 + rnorm(length(x), 0, desv_est_error)
}

#los datos se vuelven fijos para el ejercicio
datos_x <- geno_muestral)
datos_y <- genera_y(datos_x, beta_0, beta_1)

#hacemos la regresion con lm (linear model)
lm(datos_y ~ datos_x) -> modelo
coefficients(modelo) -> coeficientes_muestrales

# obtenemos intervalos de confianza con confint
confint(modelo)


#inicializamos vectores
beta_0_estimado <- beta_1_estimado <- vector()


for(i in seq_len(iteraciones)){
  # Tomamos una muesta con sample(numeros, tamaño, reemplazo(datos repetidos)
  muestra <- sample(seq_along(datos_x), length(datos_x), replace = TRUE)
  
  # Usando los valores aleatorios y repetitivos de la variable "muestra" 
  # como indices tomamos una muestra datos de la variable "datos_x"
  muestra_x <- datos_x[muestra]

  # Repetimos el procedimiento para muestra_y
  muestra_y <- datos_y[muestra]
  
  # Hacemos un modelo lineal de con las submuestras
  lm(muestra_y ~ muestra_x) -> modelo
  
  # Obtenemos sus coeficientes
  coeficientes <- coefficients(modelo)
  
  # Guardamos los coeficientes estimados
  beta_0_estimado[i] <- coeficientes[1]
  beta_1_estimado[i] <- coeficientes[2]
}


# Creamos un DataFrame con los datos

data.frame(
  limite = c("inferior", "superior"),
  beta_0 = quantile(beta_0_estimado, c(0.025, 0.975)),
  beta_1 = quantile(beta_1_estimado, c(0.025, 0.975))
) -> intervalo_bootstrapping

intervalo_bootstrapping

# Hacemos el plot
plot(beta_0, beta_1)

points(beta_0_estimado, beta_1_estimado)
points(coeficientes_muestrales[1], coeficientes_muestrales[2], pch = 20, col = 4, cex = 3)
points(beta_0, beta_1, pch = 20, col = 2, cex = 3)
# Graficamos un rectangolo (nuestro intervalo de confianza)
rect(
  intervalo_bootstrapping$beta_0[1], 
  intervalo_bootstrapping$beta_1[1],
  intervalo_bootstrapping$beta_0[2],
  intervalo_bootstrapping$beta_1[2],
  border = 4, lwd = 2)

rusbel bermúdez rivera

hace 5 años

Dejo esta lectura complementaria sobre el metodo de minimos cuadrados donde se toca el tema de regresion lineal y porque agregamos el error normal a la funcion genera_y

https://grisalazar.wordpress.com/2014/05/01/regresion-lineal/

Martin DAVILA

hace 4 años



# Hacemos un bootstrapping para nuestra regresión lineal. -----------------


# Bootstrapping -----------------------------------------------------------


tamano_muestral <- 23
iteraciones <- 1000
beta_0 <- 1
beta_1 <- -0.3
desv_est_error <- 0.5

genera_x <- function(n) seq(-3, 3, length.out = n)

genera_y <- function(x, beta_0, beta_1){
  beta_1*x + beta_0 + rnorm(length(x), 0, desv_est_error)
}

datos_x <- genera_x(tamano_muestral)
datos_y <- genera_y(datos_x, beta_0, beta_1)


lm(datos_y ~ datos_x) -> modelo
coefficients(modelo) -> coeficientes_muestrales
summary(modelo)
confint(modelo)

beta_0_estimado <- beta_1_estimado <- vector()

for(i in seq_len(iteraciones)){
  muestra <- sample(seq_along(datos_x), length(datos_x), replace = TRUE)
  muestra_x <- datos_x[muestra]
  muestra_y <- datos_y[muestra]
  lm(muestra_y ~ muestra_x) -> modelo
  coeficientes <- coefficients(modelo)
  beta_0_estimado[i] <- coeficientes[1]
  beta_1_estimado[i] <- coeficientes[2]
}


data.frame(
  limite = c("LI", "LS"),
  beta_0 = quantile(beta_0_estimado, c(0.025, 0.975)),
  beta_1 = quantile(beta_1_estimado, c(0.025, 0.975))
) -> intervalo_bootstrapping

intervalo_bootstrapping



plot(beta_0, beta_1)

points(beta_0_estimado, beta_1_estimado)
points(coeficientes_muestrales[1], coeficientes_muestrales[2], pch = 20, col = 4, cex = 3)
points(beta_0, beta_1, pch = 20, col = 2, cex = 3)
rect(
  intervalo_bootstrapping$beta_0[1], 
  intervalo_bootstrapping$beta_1[1],
  intervalo_bootstrapping$beta_0[2],
  intervalo_bootstrapping$beta_1[2],
  border = 4, lwd = 2)


# Tidy approach -----------------------------------------------------------

# Paquetes ----------------------------------------------------------------


library("dplyr")
library("purrr")
library("tidyr", exclude = c("extract"))
library("ggplot2")
library("magrittr")

colores_platzi <- c("#78D92A", "#002E4E", "#058ECD", "#ED2B05", "#F4F7F4")

tamano_muestral <- 23
iteraciones <- 1000
beta_0 <- 1
beta_1 <- -0.3
desv_est_error <- 0.5

genera_x <- function(n) seq(-3, 3, length.out = n)

genera_y <- function(x, beta_0, beta_1){
  beta_1*x + beta_0 + rnorm(length(x), 0, desv_est_error)
}

datos_simulados <- tibble(
  x = genera_x(tamano_muestral),
  y = genera_y(datos_x, beta_0, beta_1)
)


lm(y ~ x, data = datos_simulados) -> modelo
coefficients(modelo) -> coeficientes_muestrales
summary(modelo)
confint(modelo)

tibble(
  muestras = replicate(iteraciones, sample_n(datos_simulados, nrow(datos_simulados), replace = TRUE), simplify = FALSE),
  modelos = map(muestras, function(muestra){lm(y~x, data = muestra)}),
  beta_0_estimado = map(modelos, coef) %>% map_dbl(extract, 1),
  beta_1_estimado = map(modelos, coef) %>% map_dbl(extract, 2)
) -> coeficientes

coeficientes %>% 
  select(beta_0_estimado, beta_1_estimado) %>% 
    gather(key = coeficiente, value = valor) %>%
    group_by(coeficiente) %>%
    summarise(
      LI = quantile(valor, 0.025),
      LS = quantile(valor, 0.975)
    ) -> intervalo_bootstrap

coeficientes %>% 
  select(beta_0_estimado, beta_1_estimado) %>% 
  gather(key = coeficiente, value = valor) %>% 
  ggplot +
  aes(x = valor) + 
  geom_density(fill = "#78D92A", alpha = 0.5, colour = "#78D92A") +
  facet_wrap(~coeficiente, nrow = 4,  scales = "free") + 
  theme_minimal()

ggplot() +
  geom_point(
    data = coeficientes, 
    mapping = aes(x = beta_0_estimado, y = beta_1_estimado)
    ) +
  geom_rect(
    data = intervalo_bootstrap, 
    mapping = aes(xmin = LI[[1]], ymin = LI[[2]], xmax = LS[[1]], ymax = LS[[2]]),
    fill = colores_platzi[1],
    alpha = 0.2
    ) +
  annotate("point",x = beta_0, y = beta_1, colour = colores_platzi[4], size = 5) +
  annotate("point",x = coeficientes_muestrales[1], y = coeficientes_muestrales[2], colour = colores_platzi[3], size = 5) +
  theme_minimal()```

Miguel Angel Velazquez Romero

hace 4 años

¿Qué es Bootstrapping?

El bootstrapping (o bootstrap) es un método de remuestreo propuesto por Bradley Efron en 1979. Se utiliza para aproximar la distribución en el muestreo de un estadístico. Se usa frecuentemente para aproximar el sesgo o la varianza de un análisis estadístico, así como para construir intervalos de confianza o realizar contrastes de hipótesis sobre parámetros de interés. En la mayor parte de los casos no pueden obtenerse expresiones cerradas para las aproximaciones bootstrap y por lo tanto es necesario obtener remuestras en un ordenador para poner a prueba el método. La enorme potencia de cálculo de los ordenadores actuales facilita considerablemente la aplicabilidad de este método tan costoso computacionalmente.

¿Para que sirve?

La idea básica de bootstrap es que la inferencia sobre una población a partir de datos de muestra, (muestra → población), puede ser modelada mediante un nuevo muestreo de los datos de la muestra y realizando la inferencia sobre una muestra a partir de datos remuestreados. Como la población es desconocida, el verdadero error en una muestra estadística contra su valor poblacional es desconocido. En las re-muestras de bootstrap, la ‘población’ es de hecho la muestra, y esto se conoce; por lo tanto, se puede medir la calidad de la inferencia de la muestra “verdadera” a partir de datos remuestreados, (muestra re-muestreada).

Bibliografía:

colaboradores de Wikipedia. (2020, 11 junio). Bootstrapping (estadística). Wikipedia, la enciclopedia libre. https://es.wikipedia.org/wiki/Bootstrapping_(estadística)

Cesar Augusto Morales Godoy

hace 4 años

Comparto mi Notebook:
https://colab.research.google.com/drive/153qmu4054QSANbNO5ezW4XireGD1RtqU?usp=sharing
😀

JHON FREDDY TAVERA BLANDON

hace 5 meses

![](https://static.platzi.com/media/user_upload/image-998a2bfc-f0e2-4f9c-b8cd-973fd4d0991d.jpg) El **bootstrapping** es una técnica de remuestreo que utiliza muestras aleatorias con reemplazo para estimar propiedades de una distribución, como el error estándar, intervalos de confianza, y estabilidad de modelos. En el contexto de un modelo, permite evaluar su desempeño o estabilidad a partir de múltiples muestras generadas desde los datos originales.

César Jesús Estrada Haernánandez

hace 8 meses

Tengo una duda, no estoy seguro si usando la funcion summary directamente al modelo; es decir summary(nombre del lm) nos da los datos de las estimaciones y los limites de las betas sin tener que hacer un codigo para obtenerlas.

Byron José López Mayorga

hace 4 años

Agrego mi código pero el plot no me sale igual, talvez alguien se da cuenta del error…

tamano_muestral <- 23
iteraciones <- 1000
beta_0 <- 1
beta_1 <- -0.3
desv_est_error <- 0.5
genera_x <- function(n) seq(-3, 3, length.out = n)

genera_y <- function(x, beta_0, beta_1){
beta_1*x + beta_0 + rnorm(length(x), 0, desv_est_error)}

datos_x <- genera_x(tamano_muestral)

datos_y <- genera_y(datos_x, beta_0, beta_1)

lm(datos_y ~ datos_x) -> modelo
coefficients(modelo) -> coeficientes_muestrales
confint(modelo)

beta_0_estimado <- beta_1_estimado <- vector()

for(i in seq_len(iteraciones)){
muestra <- sample(seq_along(datos_x), length(datos_x), replace = TRUE)
muestra_x <- datos_x[muestra]
muestra_y <- datos_y[muestra]
lm(muestra_y ~ muestra_x) -> modelo
coeficientes <- coefficients(modelo)
beta_0_estimado[i] <- coeficientes[1]
beta_1_estimado[i] <- coeficientes[2]

}

data.frame(
limite = c(“LI”, “LS”),
beta_0 = quantile(beta_0_estimado, c(0.025, 0.975)),
beta_1 = quantile(beta_1_estimado, c(0.025, 0.975))
) -> intervalo_bootstrapping

intervalo_bootstrapping

plot(beta_0, beta_1)

points(coeficientes_muestrales[1], coeficientes_muestrales[2])
points(beta_0_estimado, beta_1_estimado)
points(beta_0, beta_1, pch = 20, col = 2, cex = 3)
rect(
intervalo_bootstrapping$beta_0[1],
intervalo_bootstrapping$beta_1[1],
intervalo_bootstrapping$beta_0[2],
intervalo_bootstrapping$beta_1[2],
border = 4,
lwd = 4
)