ARG

Análisis de encuestas ENIF y ENAFIN

Tue, 02 Jun 2026 06:00:00 GMT

Introducción

Las encuestas oficiales son una de las fuentes más importantes para analizar fenómenos sociales y económicos, pero trabajar con ellas requiere más que solo abrir una base de datos y directamente calcular promedios. En este tutorial usaremos dos encuestas del Instituto Nacional de Estadística y Geografía (INEGI) relacionadas con el sistema financiero: la Encuesta Nacional de Inclusión Financiera (ENIF) y la Encuesta Nacional de Financiamiento de las Empresas (ENAFIN). A partir de ellas veremos cómo descargar sus datos abiertos, leer archivos CSV en R, construir variables de análisis, respetar el diseño muestral de una encuesta compleja con {survey} y {srvyr} y crear visualizaciones que comuniquen los resultados de forma clara.

Descarga de datos

Antes de sumergirnos en el código, primero debemos obtener los datos. A continuación, te guiaré a través de los pasos para descargarlos del sitio oficial del INEGI. Cabe destacar que, en este tutorial, utilizaremos solamente las versiones de 2021 de ambas encuestas; sin embargo, el procedimiento es casi el mismo para cualquier edición de las mismas.

En primer lugar, debemos ir al sitio web del INEGI y buscar las encuestas ENIF y ENAFIN. Para ello, podemos utilizar el buscador que aparece en la página principal o simplemente hacer clic en los siguientes enlaces:

Una vez que hayamos ingresado a la sección de Datos abiertos de cada encuesta, debemos cliquear estos botones que resalté con rectángulos rojos para iniciar las respectivas descargas:

Ya completadas las descargas, encontraremos los archivos de ambas encuestas en nuestra computadora. Dichos archivos deben de verse así:

Los dos archivos vienen en formato comprimido (.zip). Para poder utilizar los datos, necesitamos descomprimirlos primero. Para ello, en Windows, podemos hacer clic derecho sobre cada archivo y seleccionar la opción Extraer aquí; en macOS solo basta con dar doble clic en cada uno de ellos. Al haber hecho esto, veremos que se crearán dos carpetas nuevas, una para cada encuesta, que contienen los archivos de datos, los diccionarios de variables y los modelos entidad-relación de las mismas:

Con los datos descomprimidos listos, el siguiente paso es cargarlos en R y empezar a trabajar con ellos.

Procesamiento de datos

Para empezar con el código, debemos crear un nuevo archivo de R Markdown o Quarto. En RStudio, podemos ir a File > New File > R Markdown… o File > New File > Quarto Document…, según el formato que prefiramos. Para mantener las cosas simples, conviene guardar ese archivo en la misma carpeta donde descomprimimos los datos de ambas encuestas. De esta manera, R podrá encontrar los archivos usando rutas relativas, sin necesidad de escribir la ruta completa de nuestra computadora.

En lo que sigue asumiré que las carpetas descomprimidas conservan los nombres que vimos en las capturas de pantalla anteriores: conjunto_de_datos_enif_2021_csv para la ENIF y enafin_2019_2021_csv para la ENAFIN. Si tu computadora descomprimió los archivos de forma ligeramente distinta, solo tendrás que ajustar esas primeras partes de las rutas.

En este tutorial utilizaremos siete paquetes. Los primeros nos servirán para leer archivos, manipular datos y hacer gráficas. Los dos últimos, {survey} y {srvyr}, son especialmente importantes porque nos permiten trabajar correctamente con encuestas que tienen diseño muestral complejo:

# Si aún no los tienes instalados, puedes usar:
# install.packages(c("readr", "dplyr", "tidyr", "ggplot2", "scales", "survey", "srvyr"))

library(readr) # para leer archivos CSV
library(dplyr) # para manipular datos
library(tidyr) # para transformar bases de datos
library(ggplot2) # para crear gráficas
library(scales) # para formatear porcentajes en las gráficas
library(survey) # para trabajar con diseños muestrales complejos
library(srvyr) # para usar survey con sintaxis parecida a dplyr

La diferencia entre {survey} y {srvyr} no está en el objetivo, sino en la forma de escribir el código. {survey} es el paquete clásico para analizar encuestas complejas en R; {srvyr} construye sobre {survey} y permite escribir muchas de las mismas operaciones con una sintaxis más parecida a {dplyr}. En la práctica, conviene conocer ambos: {survey} es más general y muy usado en documentación técnica, mientras que {srvyr} resulta más cómodo cuando ya trabajamos con tuberías (|> o %>%), group_by() y summarize().

Lectura de la ENIF

Comenzaremos con la ENIF. Dentro de los archivos descomprimidos hay varias tablas, pero para este ejemplo trabajaremos con la tabla del módulo principal, llamada conjunto_de_datos_tmodulo_enif_2021.csv. La podemos leer de la siguiente manera:

ruta_enif <- paste0(
  "conjunto_de_datos_enif_2021_csv/",
  "conjunto_de_datos_tmodulo_enif_2021/",
  "conjunto_de_datos/",
  "conjunto_de_datos_tmodulo_enif_2021.csv"
)

enif_tmodulo <- read_csv(
  ruta_enif,
  guess_max = Inf,
  show_col_types = FALSE
)

En este caso usamos guess_max = Inf para que R revise todas las filas antes de decidir el tipo de cada columna. Esto evita que algunas variables codificadas con números se lean por error como variables lógicas (TRUE/FALSE). También usamos show_col_types = FALSE únicamente para ocultar el mensaje técnico que {readr} imprime al terminar la lectura.

Una vez importada la tabla, podemos revisar rápidamente su tamaño, sus primeras filas y los nombres de algunas variables:

dim(enif_tmodulo)

[1] 13554   382

enif_tmodulo |>
  select(FOLIO, VIV_SEL, HOGAR, N_REN, REGION, SEXO, EDAD, FAC_ELE) |>
  head()

# A tibble: 6 × 8
  FOLIO VIV_SEL HOGAR N_REN REGION  SEXO  EDAD FAC_ELE
              
1 00001 01          1 01         3     2    83    3807
2 00002 02          1 01         3     2    33    1903
3 00003 03          1 04         3     1    30    8897
4 00004 04          1 01         3     2    64    5710
5 00005 05          1 01         3     1    70   14236
6 00006 01          1 04         3     2    20    5264

names(enif_tmodulo)[1:30]

 [1] "FOLIO"   "VIV_SEL" "HOGAR"   "N_REN"   "P3_1_1"  "P3_1_2"  "P3_2"   
 [8] "P3_3"    "P3_4"    "P3_5"    "P3_6"    "P3_7"    "P3_8A"   "P3_8B"  
[15] "P3_9"    "P3_10"   "P3_11"   "P4_1"    "P4_2_1"  "P4_2_2"  "P4_2_3" 
[22] "P4_2_4"  "P4_2_5"  "P4_3"    "P4_4_1"  "P4_4_2"  "P4_4_3"  "P4_4_4" 
[29] "P4_4_5"  "P4_4_6"

Las salidas nos confirman que el archivo fue importado correctamente. También nos permiten observar que la ENIF no es una base pequeña, pero tampoco es inmanejable. En esta tabla cada fila corresponde a una persona entrevistada y las columnas contienen tanto sus respuestas como variables necesarias para expandir correctamente los resultados a la población total. Para este primer ejemplo nos interesa construir una variable sencilla: si la persona tiene al menos una cuenta o producto financiero de los enlistados en las preguntas P5_4_1 a P5_4_9.

Estas variables preguntan, por ejemplo, si la persona tiene cuenta o tarjeta de nómina, cuenta de pensión, cuenta para recibir apoyos de gobierno, cuenta de ahorro, cuenta de cheques, depósito a plazo fijo, fondo de inversión, cuenta contratada por internet o alguna otra cuenta. Como todas usan el código 1 para “Sí” y 2 para “No”, podemos crear una variable indicadora que valga 1 si la persona respondió “Sí” en al menos una de ellas y 0 en caso contrario.

Además, en el mismo bloque recodificaremos dos variables que usaremos para describir los resultados: REGION y SEXO. En la base original estas variables vienen como códigos numéricos; por ejemplo, SEXO usa 1 para hombres y 2 para mujeres. Para que las tablas y gráficas sean más fáciles de leer, las convertiremos a variables categóricas con etiquetas:

enif_tmodulo <- enif_tmodulo |>
  mutate(
    tiene_cuenta = as.numeric(
      if_any(
        starts_with("P5_4_"),
        ~ coalesce(.x == 1, FALSE)
      )
    ),
    region = factor(
      REGION,
      levels = 1:6,
      labels = c(
        "Noroeste",
        "Noreste",
        "Occidente y Bajío",
        "Ciudad de México",
        "Centro Sur y Oriente",
        "Sur"
      )
    ),
    sexo = factor(
      SEXO,
      levels = 1:2,
      labels = c("Hombre", "Mujer")
    )
  )

Después de crear tiene_cuenta y de recodificar variables de región y de sexo, podemos revisar algunas filas y columnas para comprobar que los cambios fueron aplicados como esperamos.

enif_tmodulo |>
  select(region, sexo, P5_4_1, P5_4_2, P5_4_3, tiene_cuenta) |>
  head(8)

# A tibble: 8 × 6
  region            sexo   P5_4_1 P5_4_2 P5_4_3 tiene_cuenta
                              
1 Occidente y Bajío Mujer       2      2      1            1
2 Occidente y Bajío Mujer       2      2      1            1
3 Occidente y Bajío Hombre      2      2      2            0
4 Occidente y Bajío Mujer       2      2      2            0
5 Occidente y Bajío Hombre      2      2      1            1
6 Occidente y Bajío Mujer       1      2      2            1
7 Occidente y Bajío Mujer       2      1      2            1
8 Occidente y Bajío Hombre      2      2      2            0

La variable tiene_cuenta queda codificada como una variable binaria: 1 si la persona tiene al menos una cuenta y 0 si no. Esto es útil porque el promedio de una variable binaria puede interpretarse como una proporción. Por ejemplo, si el promedio ponderado de tiene_cuenta fuera 0.55, eso significaría que aproximadamente 55% de la población tiene al menos una cuenta.

Diseño muestral: pesos, estratos y unidades primarias

Antes de calcular cualquier porcentaje, hay un punto metodológico importante. Las encuestas nacionales como la ENIF no suelen ser muestras aleatorias simples. De acuerdo con el diseño muestral de la ENIF 2021, la muestra fue probabilística, trietápica, estratificada y por conglomerados, donde la unidad última de selección fueron las personas de 18 años y más. En términos prácticos, esto significa que primero se seleccionan unidades primarias de muestreo, después viviendas y finalmente una persona adulta dentro de la vivienda seleccionada. Por eso no basta con calcular promedios simples usando mean().

En la ENIF, tres variables son centrales para respetar ese diseño:

FAC_ELE: factor de expansión para la población de 18 años y más.
UPM_DIS: unidad primaria de muestreo.
EST_DIS: estrato de diseño.

El factor de expansión indica cuántas personas de la población representa cada persona entrevistada. La intuición básica de un peso muestral parte de la probabilidad de inclusión: si es la probabilidad de inclusión de la persona en la muestra, un peso base puede escribirse como:

Así, una persona con peso representa aproximadamente a 800 personas con características similares en la población. En la práctica, el factor final publicado por INEGI no se queda necesariamente en ese peso base: también puede incorporar ajustes por no respuesta y por proyección poblacional. Aun así, para estimar una proporción poblacional, la idea operativa sigue siendo la misma: no usamos el promedio simple de una variable binaria, sino una media ponderada:

donde vale 1 si la persona tiene la característica de interés y 0 si no la tiene. En nuestro caso, será la variable tiene_cuenta.

La unidad primaria de muestreo (UPM_DIS) identifica los conglomerados que fueron seleccionados en la primera etapa del muestreo. En la documentación de INEGI, las UPM son agrupaciones de viviendas formadas de manera distinta según el ámbito urbano o rural. Esto importa porque las personas dentro de una misma unidad primaria pueden parecerse más entre sí que personas seleccionadas en lugares distintos. Si ignoramos esa dependencia, los errores estándar pueden quedar mal estimados.

El estrato de diseño (EST_DIS) identifica grupos dentro de los cuales se seleccionaron unidades bajo condiciones similares. Incluir los estratos permite que R calcule la varianza de los estimadores de acuerdo con el diseño usado en la encuesta. En términos prácticos, los pesos entran tanto en las estimaciones puntuales como en el cálculo de la varianza; las unidades primarias y los estratos, por su parte, son indispensables para que los errores estándar, los intervalos de confianza y las pruebas estadísticas reflejen la estructura real del muestreo.

Esta es la lógica general detrás del análisis de encuestas complejas con software especializado, como documenta Thomas Lumley en el paquete {survey} y en su artículo sobre el análisis de muestras complejas en R.

Idea clave

Si usamos mean(tiene_cuenta), tratamos a la ENIF como si fuera una muestra aleatoria simple y como si todas las personas entrevistadas representaran lo mismo. Si usamos el diseño muestral con FAC_ELE, UPM_DIS y EST_DIS, tratamos a la encuesta como lo que realmente es: una muestra compleja diseñada para representar a la población.

Estimaciones con el paquete survey

Antes de realizar cualquier cálculo, configuraremos una opción preventiva de {survey} para indicar cómo tratar estratos que tienen una sola unidad primaria de muestreo. En este ejemplo puede no ser indispensable, pero es una regla útil cuando después hacemos estimaciones para subgrupos o cortes específicos, donde sí podrían aparecer estratos con una sola UPM. La opción quedará activa durante toda la sesión de trabajo en R:

options(survey.lonely.psu = "adjust") # regla preventiva para estratos con una sola UPM

Con {survey}, necesitamos crear un objeto de diseño muestral para comenzar a trabajar. Este objeto le dice a R cuáles son los pesos, las unidades primarias y los estratos que debe usar en las estimaciones. Aunque el diseño completo de la ENIF es trietápico, en este tutorial declaramos la UPM de diseño que INEGI publica en los microdatos, que es una aproximación común cuando se analizan microdatos oficiales con variables de diseño:

diseno_enif <- svydesign(
  ids = ~UPM_DIS,
  strata = ~EST_DIS,
  weights = ~FAC_ELE,
  data = enif_tmodulo,
  nest = TRUE
)

El argumento nest = TRUE es útil cuando los identificadores de las unidades primarias pueden repetirse entre estratos. Con esto, R interpreta las unidades primarias como anidadas dentro de cada estrato. Asimismo, vale la pena notar el uso del símbolo ~ antes de UPM_DIS, EST_DIS y FAC_ELE. En este caso, ~ no significa “aproximadamente”; es la sintaxis de fórmulas de R. Si, por ejemplo, escribiéramos weights = FAC_ELE, R intentaría encontrar un objeto llamado FAC_ELE fuera de la base de datos y el código fallaría. En cambio, al escribir weights = ~FAC_ELE, le indicamos a {survey} que debe buscar esa variable dentro de data = enif_tmodulo. Lo mismo ocurre con ids = ~UPM_DIS y strata = ~EST_DIS.

Ahora podemos estimar el porcentaje nacional de personas con al menos una cuenta:

svymean(~tiene_cuenta, diseno_enif, na.rm = TRUE)

                mean     SE
tiene_cuenta 0.50339 0.0073

El resultado nos devuelve la proporción estimada y, de manera predeterminada, su error estándar. En este caso, la estimación nacional es cercana a 50.3%, con un error estándar de 0.73%. También podemos calcular la misma estimación por región con svyby():

cuentas_region_survey <- svyby(
  formula = ~tiene_cuenta,
  by = ~region,
  design = diseno_enif,
  FUN = svymean,
  na.rm = TRUE,
  vartype = "se"
) |>
  as.data.frame() |>
  mutate(
    porcentaje = tiene_cuenta * 100,
    error_estandar = se * 100
  )

cuentas_region_survey

                                   region tiene_cuenta         se porcentaje
Noroeste                         Noroeste    0.5839476 0.01424968   58.39476
Noreste                           Noreste    0.5764684 0.01181391   57.64684
Occidente y Bajío       Occidente y Bajío    0.5059088 0.01838211   50.59088
Ciudad de México         Ciudad de México    0.6156021 0.01993839   61.56021
Centro Sur y Oriente Centro Sur y Oriente    0.4421749 0.01605186   44.21749
Sur                                   Sur    0.4390515 0.01654713   43.90515
                     error_estandar
Noroeste                   1.424968
Noreste                    1.181391
Occidente y Bajío          1.838211
Ciudad de México           1.993839
Centro Sur y Oriente       1.605186
Sur                        1.654713

La salida de svyby() nos devuelve una fila por región. La columna tiene_cuenta contiene la proporción estimada, se contiene el error estándar y las dos últimas columnas expresan esos mismos valores en porcentaje.

Este resultado ya es una tabla mucho más útil: contiene una estimación por región y, además, el error estándar correspondiente. Esa diferencia es importante porque no solo queremos saber cuál es el porcentaje estimado, sino también qué tan precisa es esa estimación.

La misma estimación con srvyr

Ahora hagamos el mismo cálculo usando {srvyr}. La ventaja es que la sintaxis se parece más al flujo normal de {dplyr}. Primero declararemos el diseño, luego agruparemos y resumiremos.

diseno_enif_srvyr <- enif_tmodulo |>
  as_survey_design(
    ids = UPM_DIS,
    strata = EST_DIS,
    weights = FAC_ELE,
    nest = TRUE
  )

Una vez creado el diseño, podemos estimar el porcentaje por región con group_by() y summarize():

cuentas_region <- diseno_enif_srvyr |>
  group_by(region) |>
  summarize(
    prop_cuenta = survey_mean(
      tiene_cuenta,
      vartype = "se",
      na.rm = TRUE
    )
  ) |>
  mutate(
    porcentaje = prop_cuenta * 100,
    error_estandar = prop_cuenta_se * 100
  )

cuentas_region

# A tibble: 6 × 5
  region               prop_cuenta prop_cuenta_se porcentaje error_estandar
                                                  
1 Noroeste                   0.584         0.0142       58.4           1.42
2 Noreste                    0.576         0.0118       57.6           1.18
3 Occidente y Bajío          0.506         0.0184       50.6           1.84
4 Ciudad de México           0.616         0.0199       61.6           1.99
5 Centro Sur y Oriente       0.442         0.0161       44.2           1.61
6 Sur                        0.439         0.0165       43.9           1.65

La salida de {srvyr}, como podemos observar, es más compacta y conserva el formato de tibble.

El resultado es equivalente al que obtuvimos con {survey}, pero escrito de una forma más cercana a la que solemos usar para manipular datos con {dplyr}. Para construir una visualización un poco más informativa, ahora repetiremos la estimación separando por región y sexo. Además del porcentaje estimado, le pediremos a {srvyr} que calcule intervalos de confianza de 95%, en lugar del error estándar:

cuentas_region_sexo <- diseno_enif_srvyr |>
  group_by(region, sexo) |>
  summarize(
    prop_cuenta = survey_mean(
      tiene_cuenta,
      vartype = "ci",
      level = 0.95,
      na.rm = TRUE
    )
  ) |>
  mutate(
    porcentaje = prop_cuenta * 100,
    intervalo_inf = prop_cuenta_low * 100,
    intervalo_sup = prop_cuenta_upp * 100
  ) |>
  ungroup()

cuentas_region_sexo

# A tibble: 12 × 8
   region           sexo  prop_cuenta prop_cuenta_low prop_cuenta_upp porcentaje
                                                  
 1 Noroeste         Homb…       0.646           0.605           0.687       64.6
 2 Noroeste         Mujer       0.525           0.492           0.558       52.5
 3 Noreste          Homb…       0.647           0.612           0.683       64.7
 4 Noreste          Mujer       0.509           0.478           0.541       50.9
 5 Occidente y Baj… Homb…       0.579           0.527           0.631       57.9
 6 Occidente y Baj… Mujer       0.438           0.400           0.476       43.8
 7 Ciudad de México Homb…       0.631           0.572           0.689       63.1
 8 Ciudad de México Mujer       0.603           0.551           0.655       60.3
 9 Centro Sur y Or… Homb…       0.545           0.502           0.588       54.5
10 Centro Sur y Or… Mujer       0.354           0.317           0.390       35.4
11 Sur              Homb…       0.468           0.430           0.506       46.8
12 Sur              Mujer       0.414           0.375           0.453       41.4
# ℹ 2 more variables: intervalo_inf , intervalo_sup

Con esta tabla ya podemos construir una gráfica de barras por región y sexo. Para facilitar la lectura, ordenaremos las regiones de acuerdo con el subgrupo que tenga el mayor porcentaje estimado dentro de cada región. Las etiquetas al final de cada barra muestran el porcentaje estimado, mientras que las barras de error muestran el intervalo de confianza de 95%:

posicion_barras <- position_dodge(width = 0.75)

limite_grafica_enif <- max(cuentas_region_sexo$intervalo_sup, na.rm = TRUE) + 7

orden_regiones <- cuentas_region_sexo |>
  group_by(region) |>
  summarize(
    max_porcentaje = max(porcentaje, na.rm = TRUE),
    .groups = "drop"
  ) |>
  arrange(max_porcentaje) |>
  pull(region)

cuentas_region_sexo_ordenado <- cuentas_region_sexo |>
  mutate(
    region_ordenada = factor(region, levels = orden_regiones)
  )

caption_enif <- paste(
  "Fuente: Elaboración propia con datos de la ENIF 2021, INEGI.",
  paste(
    strwrap(
      "Nota: Se considera que una persona tiene cuenta si reporta al menos una cuenta o tarjeta de nómina, pensión, apoyos de gobierno, ahorro, cheques, depósito a plazo fijo, fondo de inversión, cuenta digital u otro producto similar (P5_4_1 a P5_4_9).",
      width = 95), collapse = "\n"), sep = "\n")

grafica_enif <- ggplot(
  cuentas_region_sexo_ordenado,
  aes(x = region_ordenada, y = porcentaje, fill = sexo)
  ) +
  geom_col(position = posicion_barras, width = 0.68) +
  geom_errorbar(
    aes(ymin = intervalo_inf, ymax = intervalo_sup),
    position = posicion_barras,
    width = 0.25,
    linewidth = 0.5
  ) +
  geom_text(
    aes(
      y = intervalo_sup + 1.0,
      label = label_number(accuracy = 0.1, suffix = "%")(porcentaje)
    ),
    position = posicion_barras,
    hjust = 0,
    size = 3
  ) +
  coord_flip() +
  scale_y_continuous(
    labels = label_number(suffix = "%"),
    limits = c(0, limite_grafica_enif),
    breaks = c(0, 20, 40, 60)
  ) +
  scale_fill_manual(
    values = c(
      "Hombre" = "#1A6F7A",
      "Mujer" = "#D96C4A"
    ),
    breaks = c("Mujer", "Hombre")
  ) +
  labs(
    title = "Personas con al menos una cuenta en una institución financiera\npor región y por sexo",
    subtitle = "ENIF 2021",
    x = NULL,
    y = "Porcentaje estimado",
    fill = NULL,
    caption = caption_enif
  ) +
  theme_minimal() +
  theme(
    plot.title = element_text(face = "bold"),
    plot.title.position = "plot",
    plot.caption = element_text(hjust = 0, size = 8, lineheight = 1.1),
    plot.caption.position = "plot",
    axis.text.y = element_text(margin = margin(r = -200)),
    axis.title.x = element_text(size = 11),
    axis.ticks.y = element_blank(),
    panel.grid.major.y = element_blank(),
    legend.position = "bottom"
  )

grafica_enif

La lectura de la gráfica anterior es directa: las barras más largas indican un mayor porcentaje estimado de personas con al menos una cuenta. Al separar por sexo, también podemos observar diferencias dentro de cada región. Lo importante es que esta gráfica no se construyó con conteos simples de la muestra, sino con estimaciones ponderadas que toman en cuenta el diseño muestral de la ENIF y que además muestran la incertidumbre de cada estimación mediante barras de error.

Análisis de la ENAFIN

Pasemos ahora a la ENAFIN 2021. Aquí conviene hacer una distinción importante: el archivo de datos abiertos de esta encuesta no está organizado igual que el de la ENIF. Mientras que en la ENIF trabajamos con microdatos de personas entrevistadas, en la ENAFIN el archivo disponible contiene información ya agregada por dominios de estudio: tamaño de empresa, sector de actividad y tamaño de localidad.

De igual manera, es importante tener claro el universo al que se refiere esta encuesta. La ENAFIN 2021 no representa a todas las empresas del país, sino a empresas con seis o más personas ocupadas en los sectores de construcción, manufacturas, comercio y servicios privados no financieros, ubicadas en localidades de 50,000 habitantes o más. Por lo tanto, las conclusiones de esta sección deben leerse dentro de ese universo específico.

En esta parte no vamos a crear un objeto de diseño muestral con {survey} o {srvyr}. No porque los pesos no importen, sino porque el archivo que estamos usando ya contiene estimaciones agregadas. En este caso, nuestro trabajo consiste más bien en seleccionar las columnas relevantes, calcular porcentajes a partir de los totales disponibles y visualizar los resultados.

Leemos primero el archivo CSV de la ENAFIN:

ruta_enafin <- paste0(
  "enafin_2019_2021_csv/",
  "conjunto_de_datos/",
  "enafin_2019_2021.csv"
)

enafin <- read_csv(
  ruta_enafin,
  na = c("", "NA", "*"),
  show_col_types = FALSE
)

enafin |>
  select(DOMINIO_ESTUDIO, C_1, D_8, Q_8, AD_8)

# A tibble: 11 × 5
   DOMINIO_ESTUDIO                              C_1    D_8    Q_8   AD_8
                                               
 1 total                                    280489. 93562. 88306. 98621.
 2 grande                                    14219.  2057.  4382.  7779.
 3 mediana                                   19329.  3855.  7404.  8070.
 4 pequeña                                   98917. 32036. 34582. 32298.
 5 micro                                    148024. 55613. 41937. 50473.
 6 construcción                              11652.  3806.  3959.  3887.
 7 manufacturas                              44708. 14564. 14199. 15946.
 8 comercio                                  76181. 21180. 24995. 30006.
 9 servicios                                147948. 54012. 45154. 48782.
10 Localidad de 500,000 y más habitantes    156861. 52427. 47028. 57406.
11 Localidad de 50,000 a 499,999 habitantes 123628. 41135. 41278. 41215.

Aquí usamos na = c("", "NA", "*") porque en este archivo algunos valores no disponibles aparecen marcados con asterisco (*). Al indicarle eso a R desde la lectura, evitamos que columnas numéricas se interpreten como texto. Como salida, R nos muestra una tabla con el dominio de estudio y las variables que usaremos más adelante. Esta vista seleccionada evita imprimir todas las columnas del archivo, lo cual sería poco práctico para este tutorial.

En el siguiente ejemplo analizaremos qué tanto afectó la falta de financiamiento a la operación de las empresas, comparando por el tamaño de las mismas. De acuerdo con el diccionario de datos, usaremos estas variables:

C_1: total de empresas en el dominio de estudio.
D_8: número de empresas a las que la falta de financiamiento afectó mucho.
Q_8: número de empresas a las que la falta de financiamiento afectó poco.
AD_8: número de empresas a las que la falta de financiamiento no afectó.

Primero filtramos los dominios de tamaño de empresa y transformamos los conteos en porcentajes:

afectacion_financiamiento <- enafin |>
  filter(DOMINIO_ESTUDIO %in% c("micro", "pequeña", "mediana", "grande")) |>
  transmute(
    tamano = factor(
      DOMINIO_ESTUDIO,
      levels = c("micro", "pequeña", "mediana", "grande"),
      labels = c("Micro", "Pequeña", "Mediana", "Grande")
    ),
    "Afectó mucho" = D_8 / C_1 * 100,
    "Afectó poco" = Q_8 / C_1 * 100,
    "No afectó" = AD_8 / C_1 * 100
  ) |>
  pivot_longer(
    cols = -tamano,
    names_to = "respuesta",
    values_to = "porcentaje"
  ) |>
  mutate(
    respuesta = factor(
      respuesta,
      levels = c("Afectó mucho", "Afectó poco", "No afectó")
    )
  )

afectacion_financiamiento

# A tibble: 12 × 3
   tamano  respuesta    porcentaje
                   
 1 Grande  Afectó mucho       14.5
 2 Grande  Afectó poco        30.8
 3 Grande  No afectó          54.7
 4 Mediana Afectó mucho       19.9
 5 Mediana Afectó poco        38.3
 6 Mediana No afectó          41.8
 7 Pequeña Afectó mucho       32.4
 8 Pequeña Afectó poco        35.0
 9 Pequeña No afectó          32.7
10 Micro   Afectó mucho       37.6
11 Micro   Afectó poco        28.3
12 Micro   No afectó          34.1

El resultado queda en formato largo: una fila por combinación de tamaño de empresa y respuesta. Ahora podemos construir una gráfica de barras apiladas para comparar la distribución de respuestas por tamaño de empresa:

grafica_enafin <- ggplot(
  afectacion_financiamiento,
  aes(x = tamano, y = porcentaje, fill = respuesta)
  ) +
  geom_col(width = 0.75, color = "white") +
  geom_text(
    aes(
      label = label_number(accuracy = 0.1, suffix = "%")(porcentaje)
    ),
    position = position_stack(vjust = 0.5),
    color = "white",
    fontface = "bold",
    size = 3
  ) +
  scale_y_continuous(
    labels = label_number(suffix = "%"),
    limits = c(0, 100)
  ) +
  scale_fill_manual(
    values = c(
      "Afectó mucho" = "#9B2226",
      "Afectó poco" = "#EE9B00",
      "No afectó" = "#0A9396"
    )
  ) +
  labs(
    title = "Afectación por falta de financiamiento según tamaño de empresa",
    subtitle = "ENAFIN 2021",
    x = "Tamaño de empresa",
    y = "Porcentaje de empresas",
    fill = NULL,
    caption = "Fuente: Elaboración propia con datos de la ENAFIN 2021, INEGI.\nNota: Universo de empresas con seis o más personas ocupadas en localidades de 50,000 habitantes o más."
  ) +
  theme_minimal() +
  theme(
    plot.title = element_text(face = "bold"),
    plot.title.position = "plot",
    plot.caption = element_text(hjust = 0, size = 8),
    plot.caption.position = "plot",
    legend.position = "bottom"
  )

grafica_enafin

La gráfica anterior ofrece una comparación descriptiva de las respuestas según el tamaño de la empresa. En particular, dentro del universo de la ENAFIN, las empresas micro y pequeñas muestran una proporción mayor en la categoría “Afectó mucho”, mientras que las empresas grandes concentran una mayor proporción en “No afectó”. Esta lectura es útil como primera exploración, pero no debe interpretarse como una prueba formal de diferencias entre grupos, ya que aquí estamos trabajando con tabulados agregados y no con intervalos de confianza o errores estándar para estas estimaciones.

Guardar las gráficas

Finalmente, si queremos guardar las gráficas que construimos con {ggplot2}, podemos usar ggsave(). Por ejemplo, para guardar la gráfica de la ENIF:

ggsave(
  filename = "enif_cuentas_region.png",
  plot = grafica_enif,
  width = 7,
  height = 5,
  dpi = 300,
  bg = "white"
)

Y para guardar la gráfica de la ENAFIN:

ggsave(
  filename = "enafin_financiamiento_tamano.png",
  plot = grafica_enafin,
  width = 7,
  height = 5,
  dpi = 300,
  bg = "white"
)

En ambos casos, width y height controlan el tamaño de la imagen, mientras que dpi controla la resolución. Un valor de 300 suele ser suficiente para una imagen de buena calidad en pantalla y en documentos.

Conclusión

En este tutorial vimos cómo descargar, leer y analizar información de la ENIF y la ENAFIN usando R. Con la ENIF trabajamos con microdatos, por lo que fue necesario declarar el diseño operativo con las variables públicas de diseño: pesos, estratos y unidades primarias de muestreo. También vimos dos formas de hacerlo: con {survey}, usando la sintaxis clásica, y con {srvyr}, usando una sintaxis más cercana a {dplyr}. Con la ENAFIN, en cambio, trabajamos con un archivo de datos agregados por dominios de estudio. Por eso el procesamiento fue distinto: únicamente seleccionamos las columnas en las que estabamos interesados, calculamos porcentajes y visualizamos diferencias por tamaño de empresa.

La idea central es que no todas las encuestas se procesan igual. Cuando tenemos microdatos con diseño muestral, debemos incorporar pesos, estratos y conglomerados para obtener estimaciones adecuadas. En ambos casos, R nos permite construir un flujo de trabajo claro: leer datos, entender su estructura, transformar variables y comunicar resultados mediante visualizaciones.

R como SIG: Shapefiles, GeoPackages y mapas coropléticos de México

Fri, 13 Mar 2026 06:00:00 GMT

Introducción

Si nunca has trabajado con mapas en R, es completamente normal que términos como SIG, Shapefile, GeoPackage, geometría o sistema de coordenadas suenen un poco intimidantes. La buena noticia es que, una vez comprendamos las ideas básicas, gran parte del trabajo se parece bastante a lo que ya hacemos normalmente en R: leer archivos, limpiar datos, unir tablas y hacer visualizaciones.

Primero entenderemos qué es un SIG y qué tipo de datos utiliza. Después veremos dos de los formatos vectoriales más comunes: el Shapefile y el GeoPackage. Finalmente, construiremos mapas coropléticos de México por estado; es decir, mapas donde cada estado se colorea de acuerdo con el valor de una variable.

Nota

En los SIG existen dos grandes tipos de datos espaciales:

Vectoriales: Representan puntos, líneas y polígonos.
Raster: Representan celdas o pixeles, como una imagen satelital o un modelo de elevación.

En este tutorial trabajaremos con datos vectoriales, porque los estados de México pueden representarse como polígonos.

¿Qué es un SIG?

Un Sistema de Información Geográfica (SIG) es un conjunto de herramientas que permite almacenar, organizar, analizar y visualizar datos que tienen una ubicación en el espacio. En palabras más simples, un SIG nos ayuda a trabajar con datos que viven en un mapa. Por ejemplo, con un SIG podríamos responder (visualmente) a preguntas como estas:

¿En qué estados hay mayor acceso a internet?
¿Qué municipios cuentan con mayor número de sucursales bancarias?
¿Cómo cambian ciertos indicadores entre regiones del país?

Tradicionalmente, estas tareas se realizan con programas especializados como QGIS o ArcGIS. Sin embargo, R también puede funcionar como un SIG muy potente, especialmente cuando queremos combinar análisis estadístico, limpieza de datos y visualización dentro del mismo flujo de trabajo.

R como SIG

Cuando usamos R como SIG, normalmente trabajamos con objetos espaciales que guardan dos cosas al mismo tiempo:

un conjunto de atributos, es decir, información como nombres, claves o indicadores y
una geometría, a saber, la forma y la ubicación espacial de cada observación.

El paquete más importante para esto hoy en día es {sf}. Las siglas vienen de simple features, un estándar moderno para representar datos espaciales vectoriales. Una de sus ventajas es que un objeto sf se comporta de manera muy parecida a un data frame, así que muchas operaciones con {dplyr} funcionan de manera natural.

Shapefiles y GeoPackages

Antes de dibujar nuestro primer mapa, vale la pena entender los formatos en los que suelen venir los datos espaciales.

Shapefile

El Shapefile es el formato más conocido en la comunidad geoespacial. Fue desarrollado por ESRI y durante muchos años ha sido el formato clásico para compartir y trabajar con capas vectoriales. Sin embargo, hay algo importante que suele confundir a quienes empiezan: un Shapefile no es realmente un solo archivo. En realidad, es un conjunto de archivos que trabajan juntos.

Los archivos más comunes son estos:

.shp: guarda la geometría;
.shx: guarda un índice de la geometría;
.dbf: guarda los atributos asociados en formato de tabla;
.prj: guarda el sistema de coordenadas.

En términos estrictos, para que un shapefile funcione correctamente y conserve tanto la geometría como los atributos, al menos deben estar presentes los archivos .shp, .shx y .dbf. Sin embargo, en la práctica también conviene que esté presente el archivo .prj, porque sin él perdemos la referencia espacial del objeto y después pueden surgir problemas al intentar superponer esa capa con otras.

Es decir, cuando alguien te comparte un shapefile, normalmente en realidad te está compartiendo varios archivos al mismo tiempo. Si falta alguno de los esenciales, es muy probable que la capa no pueda abrirse correctamente o que se abra con información incompleta.

GeoPackage

El GeoPackage o GPKG es un formato más moderno. Internamente está basado en SQLite y fue diseñado como un estándar abierto para almacenar información geoespacial. Su principal ventaja es que todo queda guardado en un solo archivo con extensión .gpkg. Además, suele manejar mejor los nombres largos de variables, la codificación de texto y el almacenamiento de varias capas dentro del mismo archivo.

¿Cuál conviene usar?

Si necesitas máxima compatibilidad con software antiguo, el Shapefile sigue siendo útil. Empero, si estás empezando hoy y puedes elegir, el GeoPackage suele ser una mejor opción.

Preparación del Entorno de trabajo

Para este tutorial podríamos utilizar como fuente de información geoespacial directamente el Marco Geoestadístico 2025 del INEGI, que es la fuente oficial de referencia para la cartografía geoestadística de México. Sin embargo, para un primer acercamiento considero que esa descarga puede resultar algo pesada (245 MB), especialmente si nuestro objetivo inicial es simplemente aprender a leer una capa vectorial, entender su estructura y construir un mapa coroplético por entidad federativa. Por esa razón, en este tutorial utilizaremos una alternativa también oficial: la capa de División política estatal 1:250000. 2010 de CONABIO. Esta capa es mucho más ligera y suficiente para fines didácticos como los nuestros: el recurso en formato Shapefile (coordenadas geográficas) tiene un tamaño de 8.8 MB comprimido, lo cual la vuelve una opción mucho más manejable para aprender.

Ahora bien, nuestra variable de interés para el mapa coroplético será la pobreza por estado, definida de acuerdo con la tercera edición de la Metodología para la medición multidimensional de la pobreza del extinto Consejo Nacional de Evaluación de la Política de Desarrollo Social (CONEVAL). El anexo estadístico 2016 - 2022 proporciona los datos de porcentaje de población en pobreza (moderada y extrema) por entidad federativa, que serán los que utilizaremos para nuestros mapas. Para obtener esta información, podemos ir a la página del anexo antes mencionado y simplemente darle clic al botón llamado Anexo entidades federativas, lo cual descargará un archivo AE_estatal_2022.zip que contiene un archivo Excel llamado Anexo estad”stico entidades 2022.xlsx.

Una vez que ya tenemos claro qué información utilizaremos y de dónde obtendremos tanto la cartografía como la variable de interés, el siguiente paso es preparar nuestro entorno de trabajo en R. Para este tutorial utilizaremos seis paquetes principales:

library(sf) # para trabajar con datos espaciales
library(dplyr) # para manipular datos en general
library(tidyr) # para transformar estructuras de datos
library(stringi) # para manipular texto
library(ggplot2) # para crear gráficos
library(readxl) # para leer nuestro archivo Excel

El siguiente paso es importar los archivos que vamos a utilizar. Para simplificar el proceso, asumiré que tanto la carpeta que contiene el Shapefile extraída de AE_estatal_2022.zip llamada dest_2010gw, como el archivo de Excel se encuentran en la misma carpeta que el archivo .R, .Rmd o .qmd desde el cual estamos trabajando. Esta forma de organizar el proyecto es bastante útil cuando apenas estamos comenzando, porque nos permite leer los archivos directamente por su nombre, sin necesidad de escribir rutas más largas o complejas. Si quisiéramos organizar nuestro proyecto de una manera más estructurada, podríamos crear subcarpetas como data para guardar nuestros archivos de datos, y entonces la ruta para leer el Shapefile sería algo así como data/dest_2010gw/dest_2010gw.shp, y para el Excel sería data/Anexo estadístico entidades 2022.xlsx. Sin embargo, para este tutorial mantendremos las cosas simples y asumiremos que ambos archivos están en la raíz del proyecto.

Primero comenzaremos importando el Shapefile. Como ya se mencionó antes, aunque un Shapefile está compuesto por varios archivos, para leerlo en R basta con indicar la ruta del archivo .shp, siempre y cuando los demás componentes esenciales se encuentren en la misma carpeta. En nuestro caso, como la carpeta dest_2010gw está en la raíz del proyecto, podemos importarlo de la siguiente manera:

mapa_mexico <- st_read("dest_2010gw/dest_2010gw.shp")

Reading layer `dest_2010gw' from data source 
  `/Users/ale_romero/Library/CloudStorage/OneDrive-CIDE/R/AlejandroRomeroG.github.io/blog/RComoSIG-Mapa/dest_2010gw/dest_2010gw.shp' 
  using driver `ESRI Shapefile'
Simple feature collection with 1212 features and 8 fields
Geometry type: POLYGON
Dimension:     XY
Bounding box:  xmin: -118.3665 ymin: 14.53496 xmax: -86.71074 ymax: 32.71873
Geodetic CRS:  WGS 84

Si todo salió bien, R nos mostrará en la consola un breve resumen del objeto espacial que acabamos de importar: el número de observaciones (features), el número de variables (fields), el tipo de geometría, la extensión espacial del objeto y el sistema de referencia de coordenadas. En este caso, veremos que la capa se encuentra en el sistema WGS 84, uno de los más comunes para trabajar con información geográfica. Para inspeccionar con más detalle el objeto importado y sus atributos, basta con escribir su nombre:

mapa_mexico

Simple feature collection with 1212 features and 8 fields
Geometry type: POLYGON
Dimension:     XY
Bounding box:  xmin: -118.3665 ymin: 14.53496 xmax: -86.71074 ymax: 32.71873
Geodetic CRS:  WGS 84
First 10 features:
           AREA    PERIMETER COV_ COV_ID         ENTIDAD    CAPITAL RASGO_GEOG
1  7.171369e+10 2273088.5899    2      1 BAJA CALIFORNIA   Mexicali       
2  4.778415e+05    3517.5845    3      2 BAJA CALIFORNIA              ISLA
3  4.242857e+04     916.2356    4      3 BAJA CALIFORNIA              ISLA
4  1.297501e+05    2259.5981    5      4 BAJA CALIFORNIA              ISLA
5  1.479776e+06    7917.4943    6      5 BAJA CALIFORNIA              ISLA
6  1.792021e+11 3759999.3858    7      6          SONORA Hermosillo       
7  1.341048e+08   70456.4252    8      7 BAJA CALIFORNIA              ISLA
8  1.617167e+07   18779.8250    9      8 BAJA CALIFORNIA              ISLA
9  2.469928e+11 3119522.9908   10      9       CHIHUAHUA  Chihuahua       
10 1.498113e+05    1522.8309   11     10 BAJA CALIFORNIA              ISLA
   NUM_EDO                       geometry
1       02 POLYGON ((-117.0825 32.3816...
2       02 POLYGON ((-117.2944 32.4341...
3       02 POLYGON ((-117.2629 32.4233...
4       02 POLYGON ((-117.2595 32.4148...
5       02 POLYGON ((-117.2396 32.3907...
6       26 POLYGON ((-114.8133 32.4925...
7       02 POLYGON ((-114.7069 31.7452...
8       02 POLYGON ((-114.6085 31.7284...
9       08 POLYGON ((-108.7544 31.3346...
10      02 POLYGON ((-116.0428 30.7120...

En este punto conviene detenernos un momento a observar qué acabamos de importar. Como puede verse, mapa_mexico no es un data frame cualquiera, sino un objeto de clase sf. Esto significa que, además de los atributos de cada entidad federativa, también contiene la geometría correspondiente a cada una de ellas. Entre las variables disponibles, la más importante para nuestros propósitos será ENTIDAD, ya que contiene el nombre de cada estado y nos servirá más adelante para unir la cartografía con la base de pobreza.

Si queremos echar un primer vistazo visual a la cartografía, podemos graficar únicamente la geometría:

plot(st_geometry(mapa_mexico))

Este gráfico todavía es muy básico, pero nos permite comprobar rápidamente que la capa se importó correctamente y que la geometría de las entidades federativas luce razonable. El siguiente paso es importar el archivo de Excel que contiene la información de pobreza. Antes de leerlo, conviene revisar qué hojas contiene:

excel_sheets("Anexo estad”stico entidades 2022.xlsx")

 [1] "Contenido"                       "Estados Unidos Mexicanos"       
 [3] "Aguascalientes"                  "Baja California"                
 [5] "Baja California Sur"             "Campeche"                       
 [7] "Coahuila de Zaragoza"            "Colima"                         
 [9] "Chiapas"                         "Chihuahua"                      
[11] "Ciudad de México"                "Durango"                        
[13] "Guanajuato"                      "Guerrero"                       
[15] "Hidalgo"                         "Jalisco"                        
[17] "México"                          "Michoacán de Ocampo"            
[19] "Morelos"                         "Nayarit"                        
[21] "Nuevo León"                      "Oaxaca"                         
[23] "Puebla"                          "Querétaro"                      
[25] "Quintana Roo"                    "San Luis Potosí"                
[27] "Sinaloa"                         "Sonora"                         
[29] "Tabasco"                         "Tamaulipas"                     
[31] "Tlaxcala"                        "Veracruz de Ignacio de la Llave"
[33] "Yucatán"                         "Zacatecas"

Al hacer esto veremos que el archivo no contiene una sola tabla con toda la información junta, sino varias hojas: una de contenido, una para el total nacional y una hoja para cada entidad federativa. Esta estructura no es tan cómoda como una base rectangular tradicional, pero sigue siendo perfectamente utilizable. De hecho, nos permitirá construir nosotros mismos una pequeña base de datos estatal a partir de cada hoja. Para entender mejor cómo está organizado el archivo, podemos importar primero una sola hoja, por ejemplo la de Aguascalientes:

aguascalientes_raw <- read_excel(
  "Anexo estad”stico entidades 2022.xlsx",
  sheet = "Aguascalientes",
  col_names = FALSE
)

aguascalientes_raw

# A tibble: 28 × 17
   ...1       ...2  ...3  ...4      ...5    ...6 ...7  ...8  ...9   ...10  ...11
                         
 1 Medición … NA          NA       NA      NA        NA     NA  
 2 Porcentaj… NA          NA       NA      NA        NA     NA  
 3        NA    Indi… Porc…   NA       NA      NA    Mile…   NA     NA  
 4        NA      2016  2018     2020    2022… NA    2016  2018   2020  
 5        NA    Pobr…     NA       NA      NA        NA     NA  
 6        NA    Pobl… 28.9…   26.3     27.6  23.7… NA    381.…  361.   396. 
 7        NA    Pobl… 26.7…   25.3     25.2  21.9… NA    352.…  347.   362. 
 8        NA    Pobl… 2.21…    0.988    2.42 1.75… NA    29.2…   13.6   34.7
 9        NA    Pobl… 25.1…   25.5     25.6  29.8… NA    330.…  351.   367. 
10        NA    Pobl… 11.5…   12.0     11.1  9.25… NA    152.…  165.   159. 
# ℹ 18 more rows
# ℹ 6 more variables: ...12 , ...13 , ...14 , ...15 ,
#   ...16 , ...17

Si observamos esta hoja con cuidado, notaremos que la fila que nos interesa es la correspondiente a Población en situación de pobreza, mientras que las columnas que nos interesan son las de los años 2016, 2018, 2020 y 2022 dentro del bloque de porcentajes. Es decir, lo que haremos a continuación será repetir esta misma extracción para cada una de las hojas estatales. Primero obtenemos los nombres de todas las hojas y descartamos aquellas que no representan una entidad federativa:

hojas <- excel_sheets("Anexo estad”stico entidades 2022.xlsx")

hojas_estados <- hojas[!(hojas %in% c("Contenido", "Estados Unidos Mexicanos"))]

hojas_estados

 [1] "Aguascalientes"                  "Baja California"                
 [3] "Baja California Sur"             "Campeche"                       
 [5] "Coahuila de Zaragoza"            "Colima"                         
 [7] "Chiapas"                         "Chihuahua"                      
 [9] "Ciudad de México"                "Durango"                        
[11] "Guanajuato"                      "Guerrero"                       
[13] "Hidalgo"                         "Jalisco"                        
[15] "México"                          "Michoacán de Ocampo"            
[17] "Morelos"                         "Nayarit"                        
[19] "Nuevo León"                      "Oaxaca"                         
[21] "Puebla"                          "Querétaro"                      
[23] "Quintana Roo"                    "San Luis Potosí"                
[25] "Sinaloa"                         "Sonora"                         
[27] "Tabasco"                         "Tamaulipas"                     
[29] "Tlaxcala"                        "Veracruz de Ignacio de la Llave"
[31] "Yucatán"                         "Zacatecas"

Ahora construiremos una pequeña función que lea cada hoja estatal, localice la fila de Población en situación de pobreza y extraiga el porcentaje correspondiente a 2016, 2018, 2020 y 2022, respectivamente. En este archivo, esa información se encuentra en la tercera columna para el nombre del indicador y en la cuarta, quinta, sexta y séptima columna para el porcentaje de los años ya mencionados.

extraer_pobreza <- function(hoja) {
  tabla <- read_excel(
    "Anexo estad”stico entidades 2022.xlsx",
    sheet = hoja,
    col_names = FALSE
  )
  
  fila_pobreza <- which(tabla[[3]] == "Población en situación de pobreza")[1]
  
  data.frame(
    ENTIDAD = hoja,
    pobreza_2016 = as.numeric(tabla[[4]][fila_pobreza]),
    pobreza_2018 = as.numeric(tabla[[5]][fila_pobreza]),
    pobreza_2020 = as.numeric(tabla[[6]][fila_pobreza]),
    pobreza_2022 = as.numeric(tabla[[7]][fila_pobreza])
  )
}

Con esa función lista, ya podemos aplicarla a todas las hojas estatales y reunir el resultado en una sola base:

pobreza_estados <- bind_rows(lapply(hojas_estados, extraer_pobreza))

pobreza_estados

                           ENTIDAD pobreza_2016 pobreza_2018 pobreza_2020
1                   Aguascalientes     28.94648     26.26541     27.62669
2                  Baja California     22.60487     23.59869     22.51012
3              Baja California Sur     22.88005     18.57216     27.60222
4                         Campeche     45.66019     48.96430     50.54915
5             Coahuila de Zaragoza     27.05571     25.50771     25.61704
6                           Colima     32.53320     30.41075     26.69353
7                          Chiapas     77.91276     77.99502     75.49129
8                        Chihuahua     30.70164     26.64279     25.30499
9                 Ciudad de México     26.59985     29.96781     32.60447
10                         Durango     37.19312     38.78717     38.69167
11                      Guanajuato     39.35110     41.48813     42.74239
12                        Guerrero     66.82816     67.89002     66.40571
13                         Hidalgo     56.90224     49.86971     50.75079
14                         Jalisco     30.46840     27.80150     31.41550
15                          México     46.64539     41.77450     48.86456
16             Michoacán de Ocampo     54.16250     46.21151     44.50929
17                         Morelos     46.69338     48.54414     50.94579
18                         Nayarit     38.10435     35.72054     30.40544
19                      Nuevo León     18.84034     19.38327     24.33040
20                          Oaxaca     67.97761     64.33596     61.66425
21                          Puebla     58.12609     58.00944     62.43210
22                       Querétaro     29.68809     26.37347     31.32530
23                    Quintana Roo     31.65285     30.19206     47.48029
24                 San Luis Potosí     44.13719     42.06817     42.84615
25                         Sinaloa     30.45804     30.98426     28.07140
26                          Sonora     27.00777     26.66402     29.92402
27                         Tabasco     53.84361     56.35136     54.47779
28                      Tamaulipas     32.04342     34.54683     34.94246
29                        Tlaxcala     55.93331     50.96552     59.28752
30 Veracruz de Ignacio de la Llave     60.49191     60.15534     58.60315
31                         Yucatán     45.50457     44.03003     49.48563
32                       Zacatecas     50.19457     49.23215     45.77076
   pobreza_2022
1      23.72232
2      13.37082
3      13.32903
4      45.12944
5      18.24332
6      20.54717
7      67.37083
8      17.57220
9      23.96761
10     34.31107
11     33.03430
12     60.35474
13     40.99902
14     21.83615
15     42.87551
16     41.73628
17     41.05589
18     29.31316
19     16.04045
20     58.44035
21     54.01727
22     21.69072
23     26.96601
24     35.52276
25     21.63881
26     21.69311
27     46.47409
28     26.82275
29     52.51998
30     51.73243
31     38.77263
32     44.21589

En este punto ya contamos con una base de datos mucho más cómoda para trabajar los datos de pobreza. pobreza_estados tiene una fila por entidad federativa y una columna para cada año de interés. A primera vista, podría parecer que ya estamos listos para unir esta tabla con la cartografía. Sin embargo, antes de hacerlo conviene verificar que los nombres de las entidades coincidan correctamente en ambas fuentes. Podemos revisar rápidamente los nombres únicos de cada base con las siguientes instrucciones:

sort(unique(mapa_mexico$ENTIDAD))

 [1] "AGUASCALIENTES"                  "BAJA CALIFORNIA"                
 [3] "BAJA CALIFORNIA SUR"             "CAMPECHE"                       
 [5] "CHIAPAS"                         "CHIHUAHUA"                      
 [7] "COAHUILA DE ZARAGOZA"            "COLIMA"                         
 [9] "DISTRITO FEDERAL"                "DURANGO"                        
[11] "GUANAJUATO"                      "GUERRERO"                       
[13] "HIDALGO"                         "JALISCO"                        
[15] "MEXICO"                          "MICHOACAN DE OCAMPO"            
[17] "MORELOS"                         "NAYARIT"                        
[19] "NUEVO LEON"                      "OAXACA"                         
[21] "PUEBLA"                          "QUERETARO DE ARTEAGA"           
[23] "QUINTANA ROO"                    "SAN LUIS POTOSI"                
[25] "SINALOA"                         "SONORA"                         
[27] "TABASCO"                         "TAMAULIPAS"                     
[29] "TLAXCALA"                        "VERACRUZ DE IGNACIO DE LA LLAVE"
[31] "YUCATAN"                         "ZACATECAS"

sort(unique(pobreza_estados$ENTIDAD))

 [1] "Aguascalientes"                  "Baja California"                
 [3] "Baja California Sur"             "Campeche"                       
 [5] "Chiapas"                         "Chihuahua"                      
 [7] "Ciudad de México"                "Coahuila de Zaragoza"           
 [9] "Colima"                          "Durango"                        
[11] "Guanajuato"                      "Guerrero"                       
[13] "Hidalgo"                         "Jalisco"                        
[15] "México"                          "Michoacán de Ocampo"            
[17] "Morelos"                         "Nayarit"                        
[19] "Nuevo León"                      "Oaxaca"                         
[21] "Puebla"                          "Querétaro"                      
[23] "Quintana Roo"                    "San Luis Potosí"                
[25] "Sinaloa"                         "Sonora"                         
[27] "Tabasco"                         "Tamaulipas"                     
[29] "Tlaxcala"                        "Veracruz de Ignacio de la Llave"
[31] "Yucatán"                         "Zacatecas"

Si observamos ambas salidas con cuidado, veremos que los nombres no coinciden de forma exacta. Esto ocurre porque la cartografía de CONABIO utiliza mayúsculas, omite algunos acentos y además conserva nombres administrativos más antiguos, como DISTRITO FEDERAL; mientras que el archivo de pobreza usa nombres más recientes, como Ciudad de México. Para resolver este problema, crearemos una pequeña función que estandarice los nombres de las entidades en ambas bases.

normalizar_entidad <- function(x) {
  x <- stri_trans_general(x, "Latin-ASCII") # Elimina acentos
  x <- toupper(x) # Convierte a mayúsculas
  x <- trimws(x) # Elimina espacios en blanco al inicio y al final
  
  x <- case_when( # Reemplaza nombres específicos
    x == "DISTRITO FEDERAL" ~ "CIUDAD DE MEXICO",
    x == "QUERETARO DE ARTEAGA" ~ "QUERETARO",
    TRUE ~ x
  )
  
  return(x)
}

Aplicamos ahora esta función tanto a la cartografía como a la base de pobreza:

mapa_mexico <- mapa_mexico |>
  mutate(ENTIDAD_STD = normalizar_entidad(ENTIDAD))

pobreza_estados <- pobreza_estados |>
  mutate(ENTIDAD_STD = normalizar_entidad(ENTIDAD))

Con esto ya podemos unir ambas fuentes de información utilizando la nueva variable ENTIDAD_STD como llave:

mapa_pobreza <- mapa_mexico |>
  left_join(
    pobreza_estados |>
      select(ENTIDAD_STD, pobreza_2016, pobreza_2018, pobreza_2020, pobreza_2022),
    by = "ENTIDAD_STD"
  )

Construcción de mapas coropléticos

Ahora pasemos a la parte más visual del tutorial. Como ya tenemos la geometría de cada entidad y el porcentaje de población en pobreza para varios años dentro de un mismo objeto sf, podemos comenzar construyendo un primer mapa para 2016. La lógica de {ggplot2} en este caso es bastante simple: usaremos geom_sf() para dibujar las entidades federativas y asignaremos la variable pobreza_2016 al argumento fill, que controla el color de relleno de cada polígono.

mapa_2016 <- ggplot(mapa_pobreza) +
  geom_sf(aes(fill = pobreza_2016), color = "white", linewidth = 0.2) +
  scale_fill_gradient(
    low = "#FDFBF7",
    high = "#9158A2",
    name = "Pobreza (%)"
  ) +
  labs(
    title = "Porcentaje de población en situación de pobreza por entidad federativa",
    subtitle = "México, 2016",
    caption = "Fuente: Elaboración propia con datos de CONEVAL y geometrías de CONABIO"
  ) +
  theme_void() +
  theme(
    plot.title = element_text(face = "bold", size = 14),
    plot.subtitle = element_text(size = 12),
    plot.caption = element_text(size = 10),
    legend.position = "right"
  )

mapa_2016

El resultado es ya un mapa coroplético funcional: cada estado aparece coloreado según su porcentaje de población en situación de pobreza. Los tonos más claros representan menores niveles de pobreza, mientras que los tonos más intensos corresponden a valores más altos. Una ventaja adicional de haber extraído los datos para más de un año es que podemos repetir este mismo procedimiento para 2018, 2020 o 2022, simplemente cambiando la variable utilizada en fill. Por ejemplo, para mapear 2022 bastaría con reemplazar pobreza_2016 por pobreza_2022 y cambiar el subtítulo:

mapa_2022 <- ggplot(mapa_pobreza) +
  geom_sf(aes(fill = pobreza_2022), color = "white", linewidth = 0.2) +
  scale_fill_gradient(
    low = "#FDFBF7",
    high = "#9158A2",
    name = "Pobreza (%)"
  ) +
  labs(
    title = "Porcentaje de población en situación de pobreza por entidad federativa",
    subtitle = "México, 2022",
    caption = "Fuente: Elaboración propia con datos de CONEVAL y geometrías de CONABIO"
  ) +
  theme_void() +
  theme(
    plot.title = element_text(face = "bold", size = 14),
    plot.subtitle = element_text(size = 12),
    plot.caption = element_text(size = 10),
    legend.position = "right"
  )

mapa_2022

A bote pronto, con fines de comparación, podríamos poner una imagen al lado de la otra en cualquier documento para sacar conclusiones. Sin embargo, estaríamos cometiendo un error común en la visualización de datos: comparar mapas coropléticos sin una escala de colores común. En el ejemplo anterior, cada mapa tiene su propia escala de colores, lo que puede llevar a interpretaciones erróneas. Por ejemplo, un estado que tenga el mismo porcentaje de población en situación de pobreza en ambos años podría aparecer con un color diferente si las escalas no son idénticas (los valores mínimos y máximos cambian), lo que podría hacer pensar que hubo un cambio cuando en realidad no lo hubo. Para evitar esto, es fundamental establecer una escala de colores común para todos los mapas que se quieran comparar.

Para resolver este problema, primero debemos calcular un rango común de valores que abarque todos los años que queremos comparar. De esta manera, cada color representará exactamente el mismo nivel de pobreza en todos los mapas.

limites_pobreza <- range(
  c(
    mapa_pobreza$pobreza_2016,
    mapa_pobreza$pobreza_2018,
    mapa_pobreza$pobreza_2020,
    mapa_pobreza$pobreza_2022
  ),
  na.rm = TRUE
)

limites_pobreza

[1] 13.32903 77.99502

En lugar de construir cada mapa por separado y luego intentar acomodarlos manualmente, una alternativa más elegante consiste en reorganizar la base de datos a un formato largo. Así, cada observación conservará su geometría, pero además tendrá una nueva variable que indique el año correspondiente. Esto nos permitirá utilizar facet_wrap() para generar los cuatro mapas dentro de una sola figura. Para esto, usaremos la función pivot_longer() del paquete {tidyr}:

mapa_pobreza_largo <- mapa_pobreza |>
  select(geometry, pobreza_2016, pobreza_2018, pobreza_2020, pobreza_2022) |>
  pivot_longer(
    cols = starts_with("pobreza_"),
    names_to = "anio",
    values_to = "pobreza"
  ) |>
  mutate(
    anio = factor(
      anio,
      levels = c("pobreza_2016", "pobreza_2018", "pobreza_2020", "pobreza_2022"),
      labels = c("2016", "2018", "2020", "2022")
    )
  ) |>
  st_as_sf()

Con esta nueva base ya podemos construir una sola imagen con los cuatro mapas en una disposición de 2 por 2: en la primera fila aparecerán 2016 y 2018, y en la segunda 2020 y 2022.

mapa_comparativo <- ggplot(mapa_pobreza_largo) +
  geom_sf(aes(fill = pobreza), color = "white", linewidth = 0.2) +
  scale_fill_gradient(
    low = "#FDFBF7",
    high = "#9158A2",
    limits = limites_pobreza,
    name = "Pobreza (%)"
  ) +
  facet_wrap(~anio, ncol = 2) +
  labs(
    title = "Porcentaje de población en situación de pobreza por entidad federativa",
    subtitle = "México, 2016-2022",
    caption = "Fuente: Elaboración propia con datos de CONEVAL y geometrías de CONABIO"
  ) +
  theme_void() +
  theme(
    strip.text = element_text(face = "bold", size = 11),
    plot.title = element_text(face = "bold", size = 14, hjust = 0.5),
    plot.subtitle = element_text(size = 12, hjust = 0.5),
    plot.caption = element_text(size = 10),
    legend.position = "bottom"
  )

mapa_comparativo

El resultado es una sola figura comparativa con una escala de colores común, una sola leyenda y un encabezado compartido. De esta manera, cualquier diferencia visual entre los paneles refleja cambios reales en la pobreza y no simples variaciones en la escala de color. Finalmente, para guardar la visualización como archivo de imagen utilizaremos la función ggsave(), que permite exportar objetos creados con {ggplot2} en distintos formatos:

ggsave(filename = "mapa.png", plot = mapa_comparativo,
       width = 7, height = 5, dpi = 300, bg = "white")

Si preferimos guardarla como JPG, basta con cambiar la extensión del archivo:

ggsave(filename = "mapa.jpg", plot = mapa_comparativo,
       width = 7, height = 5, dpi = 300, bg = "white")

En ambos casos, width y height controlan el tamaño de la imagen, mientras que dpi determina su resolución. Un valor de 300 en este último campo suele ser suficiente para obtener una imagen de buena calidad tanto en pantalla como en impresión.

Conclusión

A lo largo de este tutorial vimos que R puede utilizarse como un Sistema de Información Geográfica bastante potente. Primero entendimos qué es un SIG y repasamos la diferencia entre Shapefiles y GeoPackages, dos de los formatos vectoriales más comunes en el trabajo geoespacial. Después importamos una capa cartográfica, construimos una base de datos estatal de pobreza a partir de un archivo de Excel, estandarizamos nombres de entidades, unimos ambas fuentes y, finalmente, creamos un mapa coroplético comparativo para distintos años.

Más allá de los mapas en sí, lo más importante aquí fue el flujo de trabajo que aprendimos: importar datos espaciales, limpiar datos tabulares, unir ambas fuentes y visualizarlas correctamente. Una vez entendido este proceso, resulta relativamente sencillo repetirlo con otras variables, otras escalas geográficas o incluso otras fuentes de información. En ese sentido, R no solo sirve para hacer mapas, sino para integrar análisis espacial y análisis de datos dentro de un mismo entorno de trabajo.

Política de Drogas en Sin Filtro de N+

Sun, 04 Feb 2024 06:00:00 GMT

Ver Programa Completo

El 04 de febrero de 2024, tuve el honor de participar en el programa Sin Filtro de N+, conducido por Natalia Sánchez. El tema del programa fue la Política de Drogas y las problemáticas relacionadas con la regulación y la seguridad en México. En este episodio abordamos cuestiones cruciales como la regulación del fentanilo, la marihuana y los vapeadores.

Durante mi participación, presenté evidencia empírica y ofrecí perspectivas globales sobre estas sustancias. Además, realicé una revisión histórica del prohibicionismo en México, subrayando la importancia de adoptar un enfoque informado y basado en la reducción de daños para abordar estos complejos problemas. El panel estuvo compuesto por destacados jóvenes expertas y expertos, entre ellas Kinari Bustos, Jeter Peralta y José Ángel Bazán, quienes también compartieron sus valiosas opiniones y experiencias sobre el tema.

Puedes ver el episodio completo haciendo clic en el botón de arriba. Agradezco a Natalia Sánchez y a todo el equipo de Sin Filtro por la invitación y la oportunidad de participar en este importante programa. ¡Espero que disfrutes la discusión!

Implementación de los Autómatas Celulares de Wolfram en R

Tue, 23 Jan 2024 06:00:00 GMT

Introducción a los Autómatas Celulares (de Wolfram)

Los Autómatas Celulares (AC) son sistemas dinámicos discretos y abstractos con aplicaciones en numerosos campos científicos. Se componen de una red de células que cambian de estado según reglas determinadas, a menudo con base en el estado de las células vecinas. Esta sencilla premisa puede generar una sorprendente variedad de comportamientos: desde patrones estáticos, hasta dinámicas complejas y caóticas.

Los AC fueron introducidos por primera vez por el matemático John von Neumann y el físico Stanislaw Ulam en la década de 1960, pero fue el físico Stephen Wolfram quien popularizó su estudio en la década de 1980. Wolfram propuso una estructura unidimensional y un conjunto de reglas binarias simples para los AC, que se terminaron conociendo como los Autómatas Celulares de Wolfram (ACW). Este tipo de autómatas se han convertido en un modelo de referencia para el estudio de la complejidad y la emergencia de patrones en sistemas dinámicos.

Fundamentos Teóricos

En general, los AC basan su comportamiento en tres componentes principales:

Espacio de Células: Una matriz (en nuestro caso, un vector) donde cada elemento representa una célula.
Estados: Cada célula puede adoptar un estado de un conjunto finito de estados posibles. En este ejemplo, las células pueden estar activas (“”) o inactivas (“”).
Reglas de Evolución: Las células cambian de estado según reglas determinadas, habitualmente con base en el estado de las células vecinas. Para los ACW, las células cambian de estado basandose en su propio estado y el de las células que están a la izquierda y derecha de cada una de ellas mediante una regla binaria de 8 bits. Esta última se representa como un número entero entre 0 y 255.

Preparación del Entorno en R

Para comenzar nuestra exploración de los Autómatas Celulares de Wolfram en R, primero necesitamos configurar nuestro entorno de trabajo cargando algunas bibliotecas esenciales. Estas bibliotecas nos ayudarán en la manipulación de datos y en la visualización gráfica de los resultados.

# Instalalas si aún no las tienes utilizando:
# install.packages(c("dplyr", "ggplot2", "ggview"))

library(dplyr) # para la manipulación de datos
library(ggplot2) # para la creación de gráficos
library(ggview) # para visualizar los gráficos en el Viewer sin guardarlos

Definición de la Función para Reglas Binarias

Después de haber preparado nuestro entorno en R, el siguiente paso es definir cómo nuestro ACW interpretará las reglas que dictarán la evolución de sus células. Recordemos que en los ACW, estas reglas se aplican basándose en el estado actual de una célula y sus vecinos inmediatos a la izquierda y a la derecha.

Cada combinación de estos tres estados (el propio y los de sus dos vecinos) puede ser representada como un número binario de 3 dígitos, y para cada combinación posible, la regla del autómata define si la célula estará activa o inactiva en la siguiente generación. Dado que hay combinaciones posibles, una regla de autómata celular se puede representar como una secuencia de 8 bits, donde cada bit indica el estado resultante para una combinación específica de vecinos. Por lo tanto, hay un total de reglas posibles, numeradas del 0 al 255.

La función getBinaryRule que definiremos a continuación, toma un número entre 0 y 255 y lo convierte en su versión binaria de 8 bits. Aquí nos estamos aprovechando de que los números del 0 al 255 se representan en binario con 8 dígitos y a partir del 256 con 9 o más. Esto nos permitirá aplicar fácilmente la regla elegida a nuestro autómata:

getBinaryRule <- function(ruleNumber) {
  # Convierte el número en una secuencia de bits:
  ruleBinary <- intToBits(ruleNumber)[1:8]
  # Convierte la secuencia de bits en un vector de enteros:
  ruleBinary <- as.integer(rev(ruleBinary))
  return(ruleBinary)
}

Tras definir la función getBinaryRule, nuestro siguiente paso es establecer el escenario para la simulación de nuestro ACW. Esto implica inicializar las reglas que determinarán el comportamiento de las células y preparar la población inicial en nuestro modelo.

Inicialización de las Reglas y las Células

Comenzaremos eligiendo una regla específica para nuestro autómata. Recordemos que las reglas varían de 0 a 255, cada una produciendo patrones interesantes. Para este ejemplo, utilizaremos la regla 135:

# Selecciona la regla número 135:
ruleNumber <- 135
# Convierte la regla a su representación binaria:
ruleSet <- getBinaryRule(ruleNumber)
# Establece el número de células y generaciones para la simulación:
numCells <- 101
generations <- 101
# Crea una matriz para representar cada generación de células:
grid <- matrix(nrow = generations, ncol = numCells)

Configuración de la Población Inicial

Ahora, definiremos la población inicial de células. Para simplificar y visualizar claramente el efecto de la regla seleccionada, iniciaremos con una única célula activa en el centro de nuestra cuadrícula:

# Inicializa todas las células en estado inactivo (0):
cells <- rep(0, numCells)
# Activa la célula central:
cells[ceiling(numCells / 2)] <- 1
# Establece la configuración previa como la primera generación en nuestra matriz:
grid[1, ] <- cells

Así, estamos en posición de simular cómo estas células evolucionarán a lo largo de las generaciones bajo la regla seleccionada. Este es el núcleo de los ACW, donde las simples reglas locales conducen a patrones complejos y a menudo sorprendentes a lo largo del tiempo.

Aplicación de las Reglas para Dar Paso a Nuevas Generaciones

Para observar la evolución de nuestro autómata celular, aplicaremos las reglas definidas en cada célula y en cada generación. Recordemos que las reglas consideran el estado de una célula y sus vecinas inmediatas (izquierda y derecha) para determinar su nuevo estado. Este proceso se repite para cada célula en cada nueva generación:

# Bucle a través de cada generación, empezando por la segunda:
for (gen in 2:generations) {
  # Bucle a través de cada célula en la generación:
  for (i in 1:numCells) {
    # Calcula los índices de las vecinas izquierda y derecha, 
    # considerando condiciones de frontera periódicas
    # (si la célula está en el borde, la vecina es la primera o la última):
    left_index <- ifelse(i == 1, numCells, i - 1)
    right_index <- ifelse(i == numCells, 1, i + 1)

    # Obtiene los estados de las vecinas y de la célula central:
    left <- grid[gen - 1, left_index]
    center <- grid[gen - 1, i]
    right <- grid[gen - 1, right_index]

    # Calcula el patrón de vecindario en versión entera (nota más adelante):
    neighborhood <- left * 4 + center * 2 + right
    # Determina el nuevo estado basado en la respectiva regla:
    grid[gen, i] <- ruleSet[8 - neighborhood]
  }
}

Nota

El vecindario de una célula es una combinación de sus estados y los de sus dos vecinas. En los ACW, este vecindario se representa como un número binario de 3 dígitos. Por ejemplo, si la célula izquierda, la célula central y la célula derecha están en los estados 1 (activo), 0 (inactivo), y 1 (activo), respectivamente, el vecindario se representa como en binario.

Para convertir esta representación binaria del vecindario en algo que podamos usar para acceder a nuestra regla en versión binaria, necesitamos convertirla a un número entero que vaya del 0 al 7. Aquí es donde entran en juego las multiplicaciones por 4 y por 2:

El bit más a la izquierda (la vecina izquierda) se multiplica por 4 porque, en la representación binaria, este bit es equivalente a . Si este bit es 1, su contribución al número decimal total es 4.
El bit del medio (la célula misma) se multiplica por 2 porque corresponde a en binario. Si esta célula está activa, añade 2 al número decimal.
El bit más a la derecha (la vecina derecha) no se multiplica porque representa . Así, su estado (activo o inactivo) se añade tal cual al número decimal.

Este doble bucle, primero a través de las generaciones y luego a través de cada célula, es el corazón de nuestra simulación. En cada paso, estamos aplicando cada regla binaria para determinar el estado futuro de cada célula, basándonos en su estado actual y el de sus vecinas. Al final de este proceso, tendremos una representación completa de cómo las células evolucionan a lo largo del tiempo bajo la influencia de nuestra regla seleccionada.

Visualización de la Evolución de las Células

Para visualizar la evolución de nuestro ACW, primero necesitamos transformar nuestros datos de la matriz grid en un formato adecuado para {ggplot2}. Lo hacemos creando un data frame que represente cada célula y su estado en cada generación:

# Crea un data frame con todas las combinaciones de células y generaciones:
df <- expand.grid(x = 1:numCells, y = 1:generations)
# Asigna los valores de la cuadrícula al data frame, ajustando la estructura.
# La transposición cambia las filas por columnas y viceversa para que cada
# columna represente una generación y cada fila una célula.
# La función as.vector() convierte la matriz en un vector para que podamos ir
# asignando valores de generación en generación, como esta creado el data frame:
df$value <- as.vector(t(grid))
# Ajusta el eje y para que las generaciones se muestren en el orden correcto
# (de arriba a abajo):
df$y <- generations - df$y + 1

Ahora que tenemos nuestros datos en el formato correcto, podemos proceder a visualizarlos utilizando {ggplot2}. Esta herramienta nos permite crear una representación gráfica clara y atractiva de cómo cambian las células a lo largo del tiempo:

# Crea un gráfico con ggplot2:
plot_acw <- ggplot(df, aes(x = x, y = y, fill = factor(value))) +
  geom_tile() + # Crea un gráfico de mosaico
  scale_fill_manual(values = c("white", "black")) + # Define los colores
  theme(legend.position = "none", # Elimina la leyenda
        panel.grid = element_blank(), # Elimina las líneas de la cuadrícula
        axis.title = element_blank(), # Elimina los títulos de los ejes
        axis.text = element_blank(), # Elimina las etiquetas de los ejes
        axis.ticks = element_blank(), # Elimina las marcas de los ejes
        panel.background = element_blank(), # Elimina el fondo del panel
        panel.border = element_blank()) # Elimina el borde del panel

# Visualiza el gráfico en el Viewer de RStudio:
#ggview(plot_acw, width=10, height = 10, dpi = 500, units = "in")

# Guarda el gráfico como un archivo PNG:
#ggsave("acw_135.png", width=10, height = 10, dpi = 1000, units = "in")

El resultado de todo lo anterior es una visualización de la evolución de nuestro ACW bajo la regla 135:

Explorando el Espacio de Reglas

Ya que hemos visto cómo funciona un ACW bajo una regla específica, podemos explorar cómo cambia el comportamiento de nuestro sistema cuando cambiamos la regla. Para ello, a continuación y gracias a quarto-webr, podemos modificar y correr el siguiente chunk de código para explorar el espacio de reglas (0 a 255): solamente debemos cambiar el número de la regla dentro de la función ACW y darle clic a Run Code:

Conclusión y Reflexiones

Al concluir este viaje a través de los ACW en R, hemos explorado no solo un fascinante modelo matemático, sino también la profunda complejidad que puede surgir de reglas aparentemente simples. Los ACW nos ofrecen una ventana única hacia la naturaleza emergente de los sistemas complejos, un concepto que encuentra resonancia en campos tan variados como la biología, la informática, la física e incluso la economía, la sociología y demás ciencias sociales.

Lecciones Aprendidas

Simplicidad y Complejidad: Hemos visto cómo estructuras simples pueden dar lugar a patrones increíblemente complejos y variados. Esta es una poderosa metáfora de cómo sistemas simples pueden generar fenómenos emergentes en el mundo real. Por ejemplo, la complejidad de un individuo surge de la interacción y coevolución con otros individuos, su entorno socioeconómico-cultural y factores psicológicos y biológicos.
Exploración y Experimentación: La capacidad de experimentar con diferentes reglas y configuraciones nos recuerda la importancia de la exploración en la ciencia y la tecnología. Cada cambio en la regla puede revelar nuevos patrones y comportamientos, alentando una mentalidad de descubrimiento continuo. Además, logramos aprender cómo graficar celdas producto de una simulación, lo cual es una habilidad útil para trabajar con datos en general.

Referencias e Inspiración

Este artículo se basa en el trabajo de tres personas. Primero, el físico Stephen Wolfram, quien en 2002 publicó un libro titulado A New Kind of Science (Un Nuevo Tipo de Ciencia), en el cual introduce y explora los ACW y sus implicaciones en la ciencia y la tecnología. En segundo lugar, el economista y científico de la complejidad Gonzalo Castañeda, quien en 2021 publicó The Paradigm of Social Complexity (El Paradigma de la Complejidad Social): un libro que, en dos volúmenes, construye un marco teórico y práctico para el estudio de fenómenos socioeconómicos a través de conceptos como los Sistemas Adaptables Complejos, Autómatas Celulares y Modelos Basados en Agentes. Finalmente, al maestro Daniel Shiffman, quien con su canal de Youtube The Coding Train y su libro The Nature of Code (La Naturaleza del Código) me inspiró y ayudó a implementar este proyecto en R.

Espero sinceramente que hayas encontrado tanto valor como inspiración en el fascinante mundo de los Autómatas Celulares de Wolfram. Mi objetivo al compartir esta exploración en R no es solo presentar un tema interesante y complejo de manera accesible, sino también encender tu curiosidad y el deseo de experimentar más allá de lo que hemos explorado aquí. Animo a cada uno de ustedes a tomar lo que hemos aprendido y expandirlo, ya sea creando nuevas versiones, aplicando estos conceptos en diferentes contextos o explorando nuevas áreas que aún estén por descubrir. La belleza de la programación y la ciencia de datos radica en su naturaleza exploratoria, en cómo nos permite dar forma a nuestras ideas y teorías.

Presentaciones desde RStudio con {xaringan}

Tue, 14 Nov 2023 06:00:00 GMT

Primero, necesitamos instalar y cargar los paquetes necesarios:

install.packages(c("pagedown", "xaringan"), dependencies = TRUE)
library(pagedown)
library(xaringan)

Ahora, para generar nuestra primer presentación, pondremos la siguiente estructura en un archivo .Rmd vacío:

---
title: "Práctica 1"
subtitle: "Presentación hecha con {xaringan}"
author: "Alejandro Romero González"
date: "10/25/2021"
output:
    xaringan::moon_reader:
      css: ["default"]
      nature:
        highlightStyle: github
        highlighLine: true
        countIncrementalSlides: true
---

Al guardar dicho archivo y después darle clic a Knit, RStudio compilará un html con el siguiente contenido:

Podrás ver que la presentación está un poco fea. Para darle un mejor estilo podemos crear nuestro propio tema o utilizar los temas precargados. Estos últimos podemos visualizarlos escribiendo lo siguiente en la consola:

names(xaringan:::list_css())

Yo escogeré la fuente “tamu-fonts” y el tema “shinobi”. Se aplican en el .Rmd de la siguiente manera:

---
title: "Práctica 1"
subtitle: "Presentación hecha con {xaringan}"
author: "Alejandro Romero González"
date: "10/25/2021"
output:
    xaringan::moon_reader:
      css: ["default", "tamu-fonts", "shinobi"]
      nature:
        highlightStyle: github
        highlighLine: true
        countIncrementalSlides: true
---

Guardamos y compilamos de nuevo. El output ahora es este:

Ya se ve mejor. Sin embargo, está algo tedioso que una ventana adicional aparezca para poder visualizar la presentación. Es por ello que existe Infinite Moon Reader: éste addin nos permitirá visualizar la presentación en el viewer que está integrado a RStudio (como cuando visualizamos gráficas de {ggplot2}). Para activarlo solo es necesario darle clic al botón Addins que se encuentra en la parte superior de RStudio, buscar Infinite Moon Reader y oprimir clic de nuevo (si saltan avisos de que necesitamos instalar o actualizar algunos paquetes, les damos aceptar). Con esto, ya podremos visualizar la presentación desde Rstudio actualizándose en tiempo real (la mayor parte de las veces).

Nota

Si Infinite Moon Reader no aparece en Addins, reinstalen el paquete {xaringan}, pero ahora desde la repo oficial en Github:

remotes::install_github("yihui/xaringan")

Para crear nuevas diapositivas simplemente tenemos que escribir debajo del área donde definimos el título, subtítulo, etc., e ir separando diapositiva por diapositiva con tres guiones. Ejemplo:

---
title: "Práctica 1"
subtitle: "Presentación hecha con {xaringan}"
author: "Alejandro Romero González"
date: "10/25/2021"
output:
    xaringan::moon_reader:
      css: ["default", "tamu-fonts", "shinobi"]
      nature:
        highlightStyle: github
        highlighLine: true
        countIncrementalSlides: true
---

class: inverse

# Mi primera diapositiva

Esto es un texto
  - Elemento 1
  - Elemento 2
  
  1. Uno
  2. Dos
  3. Tres
  
---

# Mi segunda diapositiva

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Output:

Nota

El color de fondo predeterminado del tema que escogí es el blanco, sin embargo lo cambié al color inverso con “class: inverse”, como se puede ver en el código de arriba.

Para poner links a una página web dentro de una diapositiva podemos hacerlo de tres maneras:

---

# Diapositiva con links

- Simplemente poner el link: https://cran.r-project.org/

- Usar sintaxis de Rmarkdown: [link a CRAN](https://cran.r-project.org/)

<br/><br/><br/>

- Usar sintaxis de HTML
<a href="https://cran.r-project.org/">
  Link a CRAN con a href
</a>

Output:

Si queremos insertar código y gráficas de R simplemente tenemos que insertar un nuevo code chunk y escribir nuestras instrucciones:

---

# Diapositiva con código y gráficas de R

\```{r, out.width = "300px"}
library(ggplot2)

ggplot(mpg) +
    aes(cty, hwy) +
    geom_point() +
    ggtitle("Fuel efficiency!")
\```

Nota

En el bloque de código anterior, hemos utilizado un método especial para “escapar” el bloque de código interno de RMarkdown. Esto significa que hemos añadido barras invertidas (“\”) antes de las comillas invertidas que normalmente delimitan un bloque de código. Hacemos esto para que el bloque interno se muestre como un ejemplo de código en el documento, pero sin que se ejecute realmente como código R.

Output:

También podemos insertar imágenes (incluso pueden ser gifs) de dos maneras, estilo RMarkdown o estilo HTML:

---

# Diapositiva con imágenes

- Estilo Rmarkdown:
![Este es Tobías](Imagenes/tobi.png)

---

- Estilo HTML:

<div align="center">
<img src="Imagenes/tobi.png" width="650" height="500">
<br>
<br>
Este es Tobías
</div>

Output:

Nota

Preferiblemente hay que usar el estilo HTML debido a que no podemos cambiar el tamaño de la imagen de otro modo.

La imagen que inserté anteriormente estaba guardada en la memoria de mi computadora. Sin embargo, también podemos introducir imágenes que se encuentren en internet:

---

# Imagen desde internet

<br>
<div align="center">
<img src="https://media.giphy.com/media/Ihf1VjXyflOU6Mhh3l/giphy-downsized-large.gif" width="700" height="400">
<br>
<br>
Fractal de Mandelbrot
</div>

Output:

También podemos dividir cada diapositiva en dos partes e insertar ecuaciones LaTeX de la siguiente manera:

---

# Dividir la diapositiva en dos y agregar fórmulas en LaTeX

.pull-left[
<br><br>
<div align="center">
<img src="https://media.giphy.com/media/PkKzNQjwPy7GvxZbfe/giphy.gif" width="300" height="300">
<br><br>
Agujero negro
</div>

]

.pull-right[
<br><br><br><br><br><br><br><br><br>
Fórmula para hallar la temperatura de un agujero negro:

$$T = \frac{\hbar c^3}{8\pi kGM}$$

Output:

¡Fin!

Notas adicionales

Si quieres subir tu presentación a internet, te recomiendo seguir este otro tutorial: https://silviacanelon.com/blog/2021-03-16-deploying-xaringan-slides/.

El link de la presentación que cree en el presente tutorial es el siguiente: https://alejandroromerog.github.io/PracticaUnoXaringan/#1.