IA para Científicos Sociales

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

Danilo Freire

Departament 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 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

Primera parte

  • Regresión logística (profundización)
  • Árboles de decisión
  • Random Forests
  • Interpretación de importancia de variables

Segunda parte

  • Ajuste de hiperparámetros (tuning)
  • Comparación sistemática de modelos
  • Aplicaciones

Regresión logística

Regresión logística: profundización

  • Ayer usamos logistic_reg() en nuestro primer modelo. Hoy vamos a entenderla mejor
  • 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\)) nos dicen la dirección y fuerza de la relación:
    • Positivo: aumenta la probabilidad
    • Negativo: disminuye la probabilidad
  • Interpretable: podemos decir “por cada año adicional de educación, la probabilidad de votar aumenta 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
  • Familiar para investigadores de ciencias sociales

Limitaciones

  • Asume relaciones lineales entre predictores y log-odds
  • No captura interacciones complejas entre variables automáticamente
  • Puede ser insuficiente cuando los datos tienen patrones no lineales

Ejemplo en ciencias sociales

¿Qué predice si una persona
vota en la última elección?

Predictores:
  - Edad
  - Años de educación
  - Ingreso del hogar
  - Confianza en el gobierno
  - Zona (urbana/rural)

Outcome: voto (sí/no)

El modelo nos dice qué factores
aumentan o disminuyen la probabilidad
de votar, y en qué magnitud.

Regresión logística en la práctica

  • En ciencias sociales, la regresión logística se usa mucho para:
    • Comportamiento electoral: ¿qué predice si alguien vota por un candidato?
    • Conflicto: ¿qué factores predicen la ocurrencia de un conflicto armado? (Muchlinski et al., 2016)
    • 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
  • Pero a veces sacrificamos capacidad predictiva por interpretabilidad
  • ¿Podemos hacer las dos cosas? Veamos los árboles de decisión

Regresión logística en R (tidymodels)

# Ya lo vimos ayer:
modelo_log <- logistic_reg() |>
  set_engine("glm") |>
  set_mode("classification")

ajuste <- fit(modelo_log,
  voto ~ edad + educacion + ingreso,
  data = datos_train)

# Los coeficientes:
tidy(ajuste)

# Resultado:
# edad:       0.023 (más edad → más voto)
# educacion:  0.085 (más edu → más voto)
# ingreso:    0.041 (más ingreso → más voto)

Ejemplo: Apoyo a la democracia en Uruguay

Pregunta de investigación:

¿Qué factores predicen si un uruguayo apoya la democracia como forma de gobierno?

Datos: Latinobarómetro Uruguay (simulados)

Variables predictoras:

  • Edad, educación, ingreso
  • Confianza en instituciones (gobierno, congreso, justicia)
  • Percepción económica
  • Zona (urbano/rural), género

Variable objetivo: apoya_democracia (sí/no)

La regresión logística nos dice qué factores aumentan o disminuyen la probabilidad de apoyo.

Resultados típicos:

Variable              Coef    Odds Ratio
─────────────────────────────────────────
Intercept            -1.20    0.30
edad                  0.02    1.02
educacion_anos        0.08    1.08 ***
ingreso_log           0.15    1.16 *
confianza_gobierno    0.25    1.28 ***
percepcion_economia   0.18    1.20 **
zona_urbano           0.12    1.13

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

Pregunta: ¿Qué significa un OR de 1.28 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 la probabilidad
  • OR < 1: disminuye la probabilidad

Ejemplo: OR = 1.28 para confianza en el gobierno

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

Cálculo en R:

# Obtener coeficientes
coefs <- tidy(ajuste)

# Calcular odds ratios
coefs |>
  mutate(
    odds_ratio = exp(estimate),
    # Intervalo de confianza
    or_lower = exp(estimate - 1.96*std.error),
    or_upper = exp(estimate + 1.96*std.error)
  )


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 puede visualizar como un diagrama de flujo
  • Cualquiera puede entender la lógica del modelo, incluyendo personas sin formación técnica

Estructura de un árbol de decisión

Fuente: Medium

¿Cómo se construye un árbol?

  1. Empezar con todos los datos en la raíz
  2. 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)
  3. Dividir los datos en dos grupos según esa regla
  4. Repetir recursivamente para cada grupo
  5. 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.

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 datos de votación

Nodo Votó No votó Gini
Raíz 265 235 0.497
Edad > 35 200 100 0.444
Edad ≤ 35 65 135 0.442

\(\text{Gini}_{\text{split}} = \frac{300}{500}(0.444) + \frac{200}{500}(0.442)\)

\(= 0.267 + 0.177 = 0.443\)

Como \(0.443 < 0.497\), esta división mejora la separación de las clases

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:

# Especificar un árbol de decisión
modelo_arbol <- decision_tree(
  tree_depth = 5,       # profundidad máxima
  min_n = 10            # mínimo de observaciones por nodo
) |>
  set_engine("rpart") |>
  set_mode("classification")

# Ajustar (exactamente igual que antes)
ajuste_arbol <- fit(modelo_arbol, voto ~ ., data = datos_train)

# Predecir (exactamente igual que antes)
pred_arbol <- predict(ajuste_arbol, datos_test) |>
  bind_cols(datos_test)
  • Noten que la interfaz es idéntica: solo cambiamos logistic_reg() por decision_tree()
  • tree_depth y min_n son hiperparámetros: controlan la complejidad del modelo
  • Esta es la gran ventaja de tidymodels: misma sintaxis para todos los modelos

Visualizar un árbol de decisión

  • Una de las grandes ventajas de los árboles es que se pueden visualizar
  • Con el paquete rpart.plot:
# install.packages("rpart.plot")
library(rpart.plot)

# Extraer el modelo rpart del ajuste
arbol_rpart <- extract_fit_engine(ajuste_arbol)

# Visualizar
# type=4: muestra reglas en todos los nodos
# extra=104: clase predicha + % de observaciones
# roundint=FALSE: evita warning con predictores 
# no enteros
rpart.plot(arbol_rpart,
           type = 4,
           extra = 104,
           roundint = FALSE)

Ejemplo de visualización:

                [voto]
               /      \
         edad < 35   edad >= 35
           /              \
      [no votó]      educacion < 12
       65%              /        \
                  [no votó]    [votó]
                    55%         78%

Cualquier persona puede entender este modelo, incluso sin conocimientos técnicos.

Es ideal para comunicar resultados a tomadores de decisiones.

Poda (pruning): controlando la complejidad

  • Un árbol sin restricciones crece hasta memorizar los datos
  • Poda (pruning): técnica para reducir la complejidad del árbol
  • Dos estrategias:
    • Pre-poda: detener el crecimiento antes (limitar profundidad, mínimo de observaciones)
    • Post-poda: dejar crecer el árbol completo y luego recortar ramas que no mejoran
  • En tidymodels, usamos hiperparámetros para pre-poda:
    • tree_depth: profundidad máxima
    • min_n: mínimo de observaciones por nodo
    • cost_complexity: penalización por complejidad

El trade-off:

Profundidad     Error train    Error test
─────────────────────────────────────────
1               0.35           0.36
3               0.22           0.25
5               0.15           0.23
10              0.08           0.28  ←
15              0.03           0.35  ←
20              0.01           0.42  ←

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 ensemble (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 que cometen errores diferentes
  • Al promediar, los errores se cancelan y la predicción mejora
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.

¿Por qué funciona Random Forest?

  • Reduce la varianza sin aumentar mucho el sesgo
  • Cada árbol individual sobreajusta, pero al promediar, el sobreajuste se diluye
  • Analogía: si les piden a 500 personas que estimen el peso de un buey, el promedio será sorprendentemente cercano al valor real
  • Funciona bien sin mucha afinación de hiperparámetros
  • Resistente frente a outliers y ruido
  • Es uno de los modelos más usados en la práctica por su combinación de rendimiento y simplicidad

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
  • Más árboles casi siempre mejoran, pero con rendimientos decrecientes
  • mtry = \(\sqrt{p}\) para clasificación (donde \(p\) = número de variables)
    • Restringir variables por split fuerza a los árboles a ser diferentes. Si todos ven todas las variables, eligen las mismas divisiones
    • ¿Por qué \(\sqrt{p}\)? Compromiso empírico (Breiman, 2001): pocas variables → árboles débiles; muchas → árboles demasiado similares. Para regresión se usa \(p/3\)
  • En la práctica, los valores por defecto suelen funcionar bien

Random Forest en R

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

# Especificar Random Forest
modelo_rf <- rand_forest(
  trees = 500,    # 500 árboles
  mtry = 3,       # 3 variables por división
  min_n = 5       # mínimo 5 observaciones por nodo
) |>
  set_engine("ranger") |>       # ranger es una implementación rápida
  set_mode("classification")

# Ajustar
ajuste_rf <- fit(modelo_rf, voto ~ ., data = datos_train)

# Predecir
pred_rf <- predict(ajuste_rf, datos_test) |>
  bind_cols(datos_test)

# Evaluar
metrics(pred_rf, truth = voto, estimate = .pred_class)
  • ranger es una implementación rápida y eficiente de Random Forest en R
  • La interfaz de tidymodels permite comparar modelos fácilmente: misma estructura para logística, árbol y RF

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
# Con tidymodels + vip
library(tidymodels)
library(vip) # Variable Importance Plots

rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger",
             importance = "permutation") |>
  set_mode("classification")

rf_fit <- rf_spec |>
  fit(voto ~ ., data = datos_train)

# Ver importancia
rf_fit |>
  vip(num_features = 10)

# edad                 ████████████ 0.042
# educacion_anios      ██████████   0.038
# interes_politica     ████████     0.031
# ingreso_hogar        ██████       0.025
# confianza_gobierno   █████        0.019

Tipos de importancia de variables

Importancia por permutación

  • Mezclar los valores de una variable y ver cuánto empeora el modelo
  • Independiente del modelo: se puede usar con cualquier algoritmo
  • Más confiable pero más lenta
  • Es la que usamos con importance = "permutation"

Importancia por impureza (Gini)

  • Suma de las reducciones de impureza en todos los nodos donde se usa la variable
  • Rápida pero puede ser sesgada hacia variables con muchas categorías
  • Es la opción por defecto en muchas implementaciones

SHAP values (más avanzado)

  • SHapley Additive exPlanations
  • Basado en teoría de juegos cooperativos
  • Mide la contribución de cada variable para cada predicción individual
  • Permite ver no solo qué variables importan, sino cómo afectan cada caso
  • Disponible en R con los paquetes shapr o fastshap


Para este curso usaremos importancia por permutación, que es la más robusta.

:::

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
library(pdp)

ajuste_rf |>
  partial(pred.var = "edad") |>
  autoplot()

Ejemplo de PDP:

  • Interpretación: La probabilidad de votar aumenta con la edad, pero se estabiliza después de los 50 años.

  • Esto es algo que la regresión logística no captura automáticamente.

Ajuste de hiperparámetros (tuning)

¿Por qué ajustar hiperparámetros?

  • Los hiperparámetros son decisiones que tomamos antes de entrenar
  • Ejemplos:
    • Árbol: tree_depth, min_n
    • Random Forest: trees, mtry, min_n
  • Los valores por defecto suelen funcionar, pero no siempre son óptimos
  • El tuning busca la mejor combinación de hiperparámetros
  • Nunca usar datos de test para tuning: usamos validación cruzada (vfold_cv())
  • tune() es la función de tidymodels para marcar qué parámetros queremos ajustar
  • grid_regular() o grid_random() nos ayudan a crear combinaciones de valores para probar
  • tune_grid() hace el proceso de ajuste y evaluación automáticamente

El proceso:

1. Definir grilla de valores a probar
   mtry: [2, 3, 4, 5]
   min_n: [5, 10, 20]

2. Para cada combinación:
   - Validación cruzada (5 folds)
   - Calcular métrica promedio

3. Elegir la mejor combinación

4. Entrenar modelo final con
   todos los datos de train

Este proceso se llama “grid search”.

Tuning con tidymodels

# 1. Especificar modelo con parámetros a ajustar (tune())
modelo_rf_tune <- rand_forest(
  trees = 500,
  mtry = tune(),      # <- ajustar este

  min_n = tune()      # <- y este
) |>
  set_engine("ranger") |>
  set_mode("classification")

# 2. Crear grilla de valores
grilla <- grid_regular(      # grid_regular: combinaciones sistemáticas 
  mtry(range = c(2, 6)),
  min_n(range = c(5, 20)),
  levels = 4
)

# 3. Validación cruzada
folds <- vfold_cv(datos_train, v = 5, strata = voto) # estratificar por voto para mantener proporciones

# 4. Ajustar
resultados <- tune_grid(   # ajusta el modelo para cada combinación y fold
  modelo_rf_tune,
  voto ~ .,
  resamples = folds,
  grid = grilla,
  metrics = metric_set(accuracy, roc_auc)
)

# 5. Ver mejores combinaciones
show_best(resultados, metric = "roc_auc")

Seleccionar y finalizar el modelo

# Seleccionar la mejor combinación
mejor <- select_best(resultados, metric = "roc_auc")
mejor

# Finalizar el modelo con los mejores hiperparámetros
modelo_final <- finalize_model(modelo_rf_tune, mejor)

# Entrenar con todos los datos de entrenamiento
ajuste_final <- fit(modelo_final, voto ~ ., data = datos_train)

# Evaluar en datos de test
pred_final <- predict(ajuste_final, datos_test) |>
  bind_cols(datos_test)

metrics(pred_final, truth = voto, estimate = .pred_class)
  • El tuning puede mejorar significativamente el rendimiento
  • Pero también toma tiempo: con muchas combinaciones y folds, puede ser lento
  • En la práctica, empezar con valores por defecto y hacer tuning si es necesario
  • select_best() nos muestra la mejor combinación según la métrica que elijamos (accuracy, AUC, etc.)
  • finalize_model() fija los hiperparámetros en el modelo para el entrenamiento final

Comparación de modelos

El poder de parsnip: misma interfaz, diferentes modelos

La gran ventaja de tidymodels es que cambiar de modelo es trivial:

# Modelo 1: Regresión logística
modelo_1 <- logistic_reg() |> set_engine("glm") |> set_mode("classification")

# Modelo 2: Árbol de decisión
modelo_2 <- decision_tree(tree_depth = 5) |> set_engine("rpart") |> set_mode("classification")

# Modelo 3: Random Forest
modelo_3 <- rand_forest(trees = 500) |> set_engine("ranger") |> set_mode("classification")

# Todos se ajustan y evalúan con la misma sintaxis:
ajuste_1 <- fit(modelo_1, voto ~ ., data = datos_train)
ajuste_2 <- fit(modelo_2, voto ~ ., data = datos_train)
ajuste_3 <- fit(modelo_3, voto ~ ., data = datos_train)

# Y se comparan con las mismas métricas
  • No hay que aprender una API diferente para cada modelo
  • Esto facilita la experimentación y la comparación
  • En la práctica, siempre hay que comparar varios modelos antes de elegir uno

¿Qué modelo elegir?

Criterio Reg. logística Árbol de decisión Random Forest
Interpretabilidad Alta (coeficientes) Alta (visual) Baja (caja negra)
Capacidad predictiva Moderada Moderada-baja Alta
Riesgo de sobreajuste Bajo Alto Bajo
Velocidad Muy rápida Rápida Moderada
Relaciones no lineales No
Datos necesarios Pocos Pocos Moderados
  • 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 modelos aún más complejos)
  • En ciencias sociales, la elección depende de si el objetivo es explicar o predecir

Más allá de Random Forest: Gradient Boosting

  • Random Forest es un ensemble (muchos modelos juntos)
  • Otra familia de ensembles: Gradient Boosting
  • En lugar de entrenar árboles en paralelo, los entrena secuencialmente
  • Cada árbol nuevo intenta corregir los errores del anterior
  • Implementaciones populares:
    • XGBoost: muy usado en competencias de Kaggle
    • LightGBM: rápido para datasets grandes
    • CatBoost: bueno con variables categóricas

Suele tener mejor rendimiento que RF, pero es más difícil de ajustar.

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:

modelo_xgb <- boost_tree() |>
  set_engine("xgboost") |>
  set_mode("classification")

Lo veremos con más detalle en los laboratorios.

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: 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.

Resumen de la sesión

Modelos de clasificación:

  • Regresión logística: interpretable, produce probabilidades, ideal para entender relaciones
  • Árboles de decisión: intuitivos, visualizables, pero sobreajustan
  • Random Forests: combinan muchos árboles, excelente rendimiento, menos interpretables
  • Gradient Boosting: aún mejor rendimiento, más difícil de ajustar

Herramientas aprendidas:

  • Importancia de variables: permutación, Gini, SHAP
  • Gráficos de dependencia parcial: entender el efecto de cada variable
  • Tuning de hiperparámetros: grid search con validación cruzada
  • Comparación de modelos: misma interfaz para todos en tidymodels


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!

Nos vemos en la próxima sesión