IA para Científicos Sociales

Sesión 2.1: Métodos de clasificación

Danilo Freire

danilofreire@gmail.com

Department of Data and Decision Sciences
Emory University

Día 2: Aprendizaje supervisado

Repaso del Día 1

La IA busca crear sistemas capaces de realizar tareas que requieren inteligencia humana
Tres tipos de aprendizaje: supervisado, no supervisado y por refuerzo
El flujo de trabajo de ML: recoger, preprocesar, dividir, entrenar, evaluar
Sobreajuste (overfitting): memorizar en lugar de aprender
La exactitud (accuracy) no es suficiente: necesitamos precisión, recall y otras métricas
Ayer hicimos nuestros primeros modelos con tidymodels, una interfaz unificada para ML en R

Agenda de la sesión

Regresión logística (profundización)
Árboles de decisión
Random Forests
Interpretación de importancia de variables
Ajuste de hiperparámetros (tuning)
Gradient Boosting (XGBoost)
Comparación sistemática de modelos
Aplicaciones

Regresión logística

Regresión logística: profundización

Regresión logística: predice la probabilidad de pertenecer a una clase
Usa la función sigmoide para transformar una combinación lineal en una probabilidad entre 0 y 1:

\[P(y = 1 | x) = \frac{1}{1 + e^{-(w_0 + w_1 x_1 + \ldots + w_n x_n)}}\]

Los coeficientes (\(w\)) indican la dirección (positivo o negativo) y la fuerza del efecto
Interpretable: “por cada año adicional de educación, las chances de votar aumentan un X%”

La función sigmoide transforma valores lineales en probabilidades

Fuente: Wikipedia

¿Cuándo usar regresión logística?

Ventajas

Simple e interpretable: los coeficientes tienen significado claro
Rápida de entrenar, funciona bien con pocos datos
Produce probabilidades, no solo clases
Buena línea base (baseline) antes de probar modelos más complejos

Limitaciones

Asume relaciones lineales entre predictores y log-odds
No captura interacciones complejas ni patrones no lineales automáticamente

Usos comunes en ciencias sociales

Comportamiento electoral: ¿qué predice si alguien vota por un candidato?
Conflicto: ¿qué factores predicen un conflicto armado?
Pobreza: ¿qué variables predicen si un hogar está por debajo de la línea de pobreza?
Migración: ¿qué factores predicen la intención de emigrar?

La interpretabilidad es clave para informar políticas públicas, aunque a veces sacrifiquemos capacidad predictiva

Ejemplo: Apoyo a la democracia en Uruguay

Pregunta de investigación: ¿qué factores predicen si un uruguayo apoya la democracia? Datos del Latinobarómetro para Uruguay (simulados)

Variables: edad, educación, ingreso, confianza en instituciones, percepción económica, zona, género

Variable de respuesta: apoya_democracia (sí/no)

La regresión logística nos dice qué factores aumentan o disminuyen la probabilidad de apoyo, y en qué magnitud

R> ajuste_log <- logistic_reg() |>
+   set_engine("glm") |>
+   set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)

Resultados (datos simulados, n = 1125):

Código

R> broom::tidy(ajuste_log) |>
+   dplyr::mutate(
+     odds_ratio = exp(estimate),
+     sig = dplyr::case_when(
+       p.value < 0.001 ~ "***",
+       p.value < 0.01  ~ "**",
+       p.value < 0.05  ~ "*",
+       TRUE            ~ ""
+     ),
+     term = dplyr::recode(term,
+       `(Intercept)` = "Intercept",
+       `zonaurbano`  = "zona_urbano"
+     )
+   ) |>
+   dplyr::select(Variable = term,
+                 Coef = estimate,
+                 `Odds Ratio` = odds_ratio,
+                 ` ` = sig) |>
+   knitr::kable(digits = 2, align = c("l", "r", "r", "l"))

Variable	Coef	Odds Ratio
Intercept	-4.40	0.01	***
edad	0.01	1.01	**
educacion_anos	0.09	1.09	***
ingreso_log	0.21	1.23	**
confianza_gobierno	0.23	1.25	***
percepcion_economia	0.31	1.36	***
zona_urbano	-0.11	0.90
generomasculino	-0.08	0.92

*** p < 0.001, ** p < 0.01, * p < 0.05

Pregunta: ¿qué significa un OR de 1.25 para confianza en el gobierno?

Odds ratios: interpretación práctica

Los coeficientes de regresión logística están en escala log-odds
Para interpretarlos, usamos el odds ratio = \(e^{\beta}\)

Interpretación del odds ratio:

OR = 1: sin efecto
OR > 1: aumenta las chances (odds)
OR < 1: disminuye las chances

Ejemplo: OR = 1.25 para confianza en el gobierno

Por cada punto adicional de confianza (escala 1-10), las chances de apoyar la democracia se multiplican por 1.25
Es decir, aumentan un 25%

Cálculo en R:

R> tidy(ajuste_log) |>
+   mutate(
+     OR     = exp(estimate),
+     IC_inf = exp(estimate - 1.96 * std.error),
+     IC_sup = exp(estimate + 1.96 * std.error)
+   ) |>
+   select(term, OR, IC_inf, IC_sup) |>
+   knitr::kable(digits = 2)

term	OR	IC_inf	IC_sup
(Intercept)	0.01	0.00	0.05
edad	1.01	1.00	1.02
educacion_anos	1.09	1.05	1.13
ingreso_log	1.23	1.07	1.42
confianza_gobierno	1.25	1.19	1.32
percepcion_economia	1.36	1.23	1.51
zonaurbano	0.90	0.61	1.31
generomasculino	0.92	0.70	1.22

Siempre reportar intervalos de confianza para los odds ratios

Árboles de decisión

¿Qué es un árbol de decisión?

Un árbol de decisión aprende una jerarquía de preguntas de sí/no
Cada nodo divide los datos según una variable
Cada hoja contiene una predicción
Ejemplo: “Si la educación > 12 años Y la edad > 30, entonces predecir: votó”
Puede capturar relaciones no lineales
Muy fácil de interpretar: se visualiza como un diagrama de flujo que cualquiera entiende, incluso sin formación técnica

Fuente: Medium

¿Cómo se construye un árbol?

Empezar con todos los datos en la raíz
Buscar la variable y el punto de corte que mejor separen las clases
- Se usa un criterio como Gini o entropía (miden la “impureza” del nodo)
Dividir los datos en dos grupos según esa regla
Repetir recursivamente para cada grupo
Parar cuando se cumple un criterio:
- Profundidad máxima
- Mínimo de observaciones en un nodo
- Sin mejora significativa

El algoritmo es codicioso (greedy): en cada paso busca la mejor división local, sin mirar el panorama global

Ejemplo paso a paso

Datos: 500 personas, 265 votaron

Paso 1: ¿edad > 35?
  ├── Sí (300 personas, 200 votaron)
  │   Paso 2: ¿educación > 12?
  │   ├── Sí → Predecir: VOTÓ ✅
  │   └── No → Predecir: NO VOTÓ ❌
  └── No (200 personas, 65 votaron)
      Paso 2: ¿interés_política > 3?
      ├── Sí → Predecir: VOTÓ ✅
      └── No → Predecir: NO VOTÓ ❌

Cada pregunta busca la "mejor"
separación posible

Ventajas y problemas de los árboles

Ventajas

Muy interpretables: se pueden visualizar y explicar
Capturan interacciones entre variables automáticamente
No requieren escalado de variables (funcionan con valores originales)
Manejan variables numéricas y categóricas sin transformación
Pueden capturar relaciones no lineales

Problemas

Sobreajuste severo: los árboles profundos memorizan los datos
Alta varianza: un pequeño cambio en los datos puede producir un árbol completamente diferente
Inestabilidad: muy sensibles a la muestra de entrenamiento
Solución: en lugar de un solo árbol, usar muchos árboles
Eso nos lleva a los Random Forests

Árboles de decisión en R

Con tidymodels, solo necesitamos cambiar la especificación del modelo:

R> # Ajustar un árbol de decisión (spec + fit en una sola pipeline)
R> ajuste_arbol <- decision_tree(tree_depth = 5, min_n = 10) |>
+   set_engine("rpart") |>
+   set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> 
R> # Evaluar: accuracy y ROC-AUC en test
R> pred_arbol <- augment(ajuste_arbol, datos_test)
R> pred_arbol |> accuracy(truth = apoya_democracia, estimate = .pred_class)

# A tibble: 1 × 3
  .metric  .estimator .estimate
  <chr>    <chr>          <dbl>
1 accuracy binary         0.709

R> pred_arbol |> roc_auc(truth = apoya_democracia, .pred_si, event_level = "second")

# A tibble: 1 × 3
  .metric .estimator .estimate
  <chr>   <chr>          <dbl>
1 roc_auc binary         0.613

Noten que la interfaz es idéntica: solo cambiamos logistic_reg() por decision_tree(), ¡la misma sintaxis para todos los modelos!
tree_depth y min_n son hiperparámetros: controlan la complejidad del modelo
augment() agrega las predicciones al test set; una sola llamada da todo lo necesario para cualquier métrica de yardstick

Visualizar un árbol de decisión

Una de las grandes ventajas de los árboles es que se pueden visualizar
Con el paquete rpart.plot:

R> library(rpart.plot)
R> 
R> # Extraer el modelo rpart del ajuste tidymodels
R> arbol_rpart <- extract_fit_engine(ajuste_arbol)
R> 
R> # type=4: muestra reglas en todos los nodos
R> # extra=104: clase predicha + % de observaciones
R> # roundint=FALSE: evita warning con predictores
R> # no enteros
R> rpart.plot(arbol_rpart,
+            type     = 4,
+            extra    = 104,
+            roundint = FALSE)

Árbol ajustado a nuestros datos:

¡Cualquier persona puede entender este modelo, incluso sin formación técnica!

Poda (pruning): controlando la complejidad

Un árbol sin restricciones crece hasta memorizar los datos
La poda (pruning) reduce su complejidad: pre-poda (frenar el crecimiento antes) o post-poda (recortar ramas que no mejoran)
En tidymodels se controla con hiperparámetros: tree_depth (profundidad máxima), min_n (mínimo por nodo) y cost_complexity (penalización por complejidad)

El trade-off (con nuestros datos):

Código

R> profs <- c(1, 2, 3, 5, 7, 10, 15, 20)
R> err <- purrr::map_dfr(profs, function(d) {
+   fit <- rpart(apoya_democracia ~ .,
+                data    = datos_train,
+                control = rpart.control(maxdepth  = d,
+                                        minsplit  = 2,
+                                        minbucket = 1,
+                                        cp        = 0))
+   tibble::tibble(
+     profundidad = d,
+     train = mean(predict(fit, datos_train, type = "class") !=
+                  datos_train$apoya_democracia),
+     test  = mean(predict(fit, datos_test,  type = "class") !=
+                  datos_test$apoya_democracia)
+   )
+ })
R> 
R> err |>
+   tidyr::pivot_longer(c(train, test),
+                       names_to = "conjunto", values_to = "error") |>
+   ggplot(aes(profundidad, error, colour = conjunto)) +
+   geom_line(linewidth = 1) +
+   geom_point(size = 2) +
+   scale_colour_manual(values = c(train = "#1f77b4", test = "#d62728"),
+                       labels = c(train = "Entrenamiento", test = "Test")) +
+   labs(x = "Profundidad del árbol", y = "Error de clasificación",
+        colour = NULL) +
+   theme_minimal(base_size = 13) +
+   theme(legend.position = "bottom")

A partir de cierta profundidad, el error en test empeora mientras el error en train sigue bajando: la poda previene el sobreajuste

Random Forests

La idea detrás de Random Forest

Un solo árbol es inestable y propenso al sobreajuste
Solución: combinar muchos árboles y promediar sus predicciones
Random Forest (Breiman, 2001) = un conjunto de árboles de decisión
Dos fuentes de aleatoriedad:
1. Bootstrap: cada árbol entrena con una muestra diferente de los datos (con reemplazo)
2. Subconjunto de variables: en cada división, cada árbol solo considera un subconjunto aleatorio de variables
El resultado: árboles diversos cuyos errores se cancelan al promediar, y la predicción mejora
Así, RF reduce la varianza sin aumentar mucho el sesgo, y suele funcionar bien sin mucha afinación de hiperparámetros

Random Forest con 500 árboles:

Árbol 1: muestra 1, variables {A,C,F}
  → Predicción: VOTÓ

Árbol 2: muestra 2, variables {B,D,E}
  → Predicción: NO VOTÓ

Árbol 3: muestra 3, variables {A,D,G}
  → Predicción: VOTÓ

...

Árbol 500: muestra 500, variables {C,E,F}
  → Predicción: VOTÓ

Predicción final: VOTÓ
(mayoría de votos entre los 500 árboles)

La sabiduría de la multitud: ¡muchos modelos “mediocres” juntos hacen un modelo excelente!

Random Forest en R

De nuevo, con tidymodels solo cambiamos la especificación:

R> # Ajustar Random Forest (importance = "permutation" lo usamos después en VIP)
R> ajuste_rf <- rand_forest(trees = 2000, mtry = 2, min_n = 5) |>
+   set_engine("ranger", seed = 1, importance = "permutation") |>
+   set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> 
R> # Evaluar: accuracy y ROC-AUC en test
R> pred_rf <- augment(ajuste_rf, datos_test)
R> pred_rf |> accuracy(truth = apoya_democracia, estimate = .pred_class)

# A tibble: 1 × 3
  .metric  .estimator .estimate
  <chr>    <chr>          <dbl>
1 accuracy binary         0.715

R> pred_rf |> roc_auc(truth = apoya_democracia, .pred_si, event_level = "second")

# A tibble: 1 × 3
  .metric .estimator .estimate
  <chr>   <chr>          <dbl>
1 roc_auc binary         0.676

ranger es una implementación rápida y eficiente de Random Forest en R

Hiperparámetros principales

Parámetro	Descripción
`trees`	Número de árboles (más = mejor, pero más lento)
`mtry`	Variables a considerar en cada división
`min_n`	Mínimo de observaciones por nodo

mtry \(= \sqrt{p}\) (clasificación) o \(p/3\) (regresión); restringir las variables por división fuerza a los árboles a ser diferentes. En la práctica, los valores por defecto funcionan bien

Importancia de variables

Los Random Forests no son tan interpretables como un solo árbol o una regresión logística
Pero podemos medir la importancia de cada variable
¿Cómo? Medir cuánto empeora la predicción si permutamos (mezclamos) los valores de una variable
- Si mezclar edad hace que el modelo sea mucho peor, entonces edad es importante
- Si mezclar zona no cambia nada, entonces zona no aporta mucho
Esto nos da un ranking de variables por su contribución al modelo
Útil para entender qué factores importan, aunque no nos diga la dirección del efecto

R> vip(ajuste_rf, num_features = 7)

Usamos importancia por permutación (robusta); existen otras como Gini (rápida pero sesgada hacia variables con muchas categorías) y SHAP (más detallada, más avanzada). Para profundizar: Molnar, Interpretable ML

Gráficos de dependencia parcial (PDP)

La importancia nos dice qué variables importan
Los Partial Dependence Plots (PDP) nos dicen cómo afectan
Muestran el efecto marginal de una variable sobre la predicción
Útiles para entender relaciones no lineales

R> library(pdp)
R> 
R> ajuste_rf |>
+   partial(pred.var    = "confianza_gobierno",
+           which.class = "si",
+           prob        = TRUE,
+           train       = datos_train) |>
+   autoplot()

PDP: confianza en el gobierno → P(apoya democracia)

Interpretación: la probabilidad de apoyar la democracia crece con la confianza en el gobierno, pero el efecto se acelera a partir de un valor moderado. Esto es algo que la regresión logística asume lineal por construcción

Ajuste de hiperparámetros (tuning)

Los hiperparámetros (ej. mtry, min_n) se fijan antes de entrenar; los valores por defecto suelen servir, pero no siempre son óptimos
El tuning prueba muchas combinaciones y elige la mejor por validación cruzada (nunca con los datos de test)
El patrón en tidymodels:
1. marcar parámetros con tune()
2. definir una grilla de valores
3. evaluar cada combinación con tune_grid() sobre los folds (resamples = folds, grid = grilla)
4. select_best() + finalize_model() para el ajuste final

R> # 1. Hiperparámetros a ajustar con tune()
R> modelo_rf_tune <- rand_forest(mtry = tune(), min_n = tune()) |>
+   set_engine("ranger", seed = 1) |>
+   set_mode("classification")
R> 
R> # 2. Grilla de valores + folds de validación cruzada
R> grilla <- grid_regular(mtry(range = c(2, 10)),
+                        min_n(range = c(5, 20)), levels = 4)
R> folds  <- vfold_cv(datos_train, v = 5,
+                    strata = apoya_democracia)
R> 
R> # 3. Probar cada combinación con CV
R> resultados <- tune_grid(modelo_rf_tune,
+   apoya_democracia ~ ., resamples = folds,
+   grid = grilla, metrics = metric_set(roc_auc))
R> 
R> # 4. Elegir la mejor y entrenar el modelo final
R> mejor <- select_best(resultados, metric = "roc_auc")
R> ajuste_final <- finalize_model(modelo_rf_tune, mejor) |>
+   fit(apoya_democracia ~ ., data = datos_train)

El tuning mejora el rendimiento pero toma tiempo. Lo ejecutan paso a paso en el laboratorio

Gradient Boosting

Más allá de Random Forest: Gradient Boosting

Random Forest entrena muchos árboles en paralelo y promedia
Gradient Boosting los entrena en secuencia: cada árbol nuevo intenta corregir los errores del anterior
Suele dar muy buen rendimiento, pero tiene muchos hiperparámetros (número de árboles, profundidad, tasa de aprendizaje), así que el tuning que acabamos de ver se vuelve esencial
Implementaciones populares:
- XGBoost: muy usado en competencias de Kaggle
- LightGBM: rápido para datasets grandes
- CatBoost: bueno con variables categóricas

Random Forest vs. Gradient Boosting:

	RF	Boosting
Entrenamiento	Paralelo	Secuencial
Hiperparámetros	Pocos	Muchos
Riesgo de sobreajuste	Bajo	Más alto
Velocidad	Rápido	Variable
Rendimiento típico	Muy bueno	Excelente

En tidymodels, la misma interfaz de siempre:

R> modelo_xgb <- boost_tree(
+   trees      = 500,
+   tree_depth = 3,
+   learn_rate = 0.05,
+   min_n      = 10
+ ) |>
+   set_engine("xgboost") |>
+   set_mode("classification")

Comparación de modelos

Comparando los cuatro modelos

Como los cuatro ajustes comparten la misma estructura, podemos compararlos en una métrica común (ROC-AUC en test):

R> # Los cuatro ajustes de esta sesión (misma estructura, distinta spec)
R> ajuste_log <- logistic_reg() |> set_engine("glm") |> set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> ajuste_arbol <- decision_tree(tree_depth = 5, min_n = 10) |> set_engine("rpart") |> set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> ajuste_rf <- rand_forest(trees = 2000, mtry = 2, min_n = 5) |> set_engine("ranger", seed = 1, importance = "permutation") |> set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> ajuste_xgb <- boost_tree(trees = 500, tree_depth = 3, learn_rate = 0.05, min_n = 10) |> set_engine("xgboost", seed = 1) |> set_mode("classification") |>
+   fit(apoya_democracia ~ ., data = datos_train)
R> 
R> # Métrica: ROC-AUC en test
R> tibble(
+   Modelo = c("Logística", "Árbol", "Random Forest", "XGBoost"),
+   `ROC-AUC` = c(
+     augment(ajuste_log,   datos_test) |> roc_auc(apoya_democracia, .pred_si, event_level = "second") |> pull(.estimate),
+     augment(ajuste_arbol, datos_test) |> roc_auc(apoya_democracia, .pred_si, event_level = "second") |> pull(.estimate),
+     augment(ajuste_rf,    datos_test) |> roc_auc(apoya_democracia, .pred_si, event_level = "second") |> pull(.estimate),
+     augment(ajuste_xgb,   datos_test) |> roc_auc(apoya_democracia, .pred_si, event_level = "second") |> pull(.estimate)
+   )
+ ) |> knitr::kable(digits = 3)

Modelo	ROC-AUC
Logística	0.707
Árbol	0.613
Random Forest	0.676
XGBoost	0.687

Acá gana la regresión logística, y ni el Random Forest ni el XGBoost la superan. No es casualidad: estos datos se generaron con relaciones lineales, y ningún modelo complejo puede encontrar una estructura no lineal que no existe
Más complejo no es sinónimo de mejor. Con datos reales, más ruidosos y no lineales, el orden suele invertirse. Por eso siempre hay que comparar antes de elegir

¿Qué modelo elegir?

Criterio	Reg. logística	Árbol	Random Forest	XGBoost
Interpretabilidad	Alta	Alta (visual)	Baja	Baja
Capacidad predictiva	Moderada	Moderada-baja	Alta	Alta
Riesgo de sobreajuste	Bajo	Alto	Bajo	Medio-alto
Velocidad	Muy rápida	Rápida	Moderada	Moderada
Relaciones no lineales	No	Sí	Sí	Sí
Hiperparámetros	Ninguno	Pocos	Pocos	Muchos

Si necesitan entender por qué el modelo predice algo: regresión logística
Si necesitan explicar la lógica a no técnicos: árbol de decisión
Si necesitan la mejor predicción posible: Random Forest o Gradient Boosting, pero solo si los datos tienen estructura no lineal que aprovechar
En ciencias sociales, la elección depende de si el objetivo es explicar o predecir

Resumen de la sesión

Lo que vimos hoy:

Cuatro modelos, del más interpretable al más predictivo: regresión logística, árboles de decisión, Random Forests y Gradient Boosting
Importancia de variables y dependencia parcial para interpretar modelos de caja negra
Tuning de hiperparámetros con validación cruzada y comparación de modelos en tidymodels
El modelo más complejo no siempre gana: cuando la relación es lineal, la regresión logística es difícil de superar

Para explorar:

LightGBM y CatBoost, otras variantes de boosting, y SHAP para interpretar modelos de caja negra

La elección del modelo depende del objetivo: ¿explicar o predecir?

Próximos pasos

Próxima sesión (2.2): Regresión y regularización
- Predicción vs. explicación
- LASSO, Ridge, Elastic Net
- Selección automática de variables
Laboratorios (2.3 y 2.4):
- Clasificación con datos de Latinobarómetro
- Regresión con datos socioeconómicos
- Tuning, comparación e interpretación

¡Nos vemos después del descanso!

Apéndices

Apéndice 1: La matemática detrás de los árboles

El árbol busca la división que minimice la impureza de los nodos resultantes
La medida más común es el índice de Gini:

\[\text{Gini}(t) = 1 - \sum_{k=1}^{K} p_k^2\]

donde \(p_k\) es la proporción de la clase \(k\) en el nodo \(t\)

Nodo puro (una sola clase): \(\text{Gini} = 0\)
Nodo 50/50 (máxima mezcla): \(\text{Gini} = 0.5\)
El algoritmo evalúa cada variable y cada punto de corte posible, y elige la división con menor Gini ponderado:

\[\text{Gini}_{\text{split}} = \frac{n_L}{n} \text{Gini}(t_L) + \frac{n_R}{n} \text{Gini}(t_R)\]

Ejemplo con nuestros datos (apoyo a la democracia)

Nodo	Sí	No	Gini
Raíz	804	321	0.408
confianza_gobierno < 3.5	186	152	0.495
confianza_gobierno ≥ 3.5	618	169	0.337

\(\text{Gini}_{\text{split}} = \tfrac{338}{1125}(0.495) + \tfrac{787}{1125}(0.337) = 0.385\)

Como \(0.385 < 0.408\), esta división mejora la separación de las clases.

Apéndice 2: Aplicaciones en ciencias sociales

Muchlinski et al. (2016): Predicción de guerras civiles

Compararon regresión logística con Random Forest
RF tuvo mejor rendimiento predictivo
Wang (2019) replicó y encontró errores, pero la lección se mantiene
RF captura interacciones complejas que la regresión no capta

Jean et al. (2016): Pobreza desde el espacio

Predijeron pobreza en África usando imágenes satelitales
Random Forest + redes neuronales
Aplicable a contextos donde los censos son poco frecuentes o poco confiables

Otros ejemplos en ciencias sociales:

Predicción de deserción escolar: identificar estudiantes en riesgo antes de que abandonen
Scoring crediticio alternativo: las fintech como Nubank usan ML para evaluar clientes sin historial bancario
Detección de fraude electoral: análisis de patrones anómalos en resultados
Predicción de violencia: modelos para anticipar zonas de riesgo
Análisis de opinión pública: clasificación de textos sobre políticas públicas

En todos estos casos, RF es un punto de partida común

Nos vemos en la próxima sesión 🤓