Machine Learning — Módulo 6: Random Forest — la sabiduría de muchos árboles

En el Módulo 5 conocimos el árbol de decisión: transparente, no-lineal y fácil de leer — pero con dos defectos serios. Es inestable (cambia entero si cambias unos datos) y débil (un árbol solo suele predecir con poca precisión). Terminamos con una promesa: la solución no es hacer un árbol mejor, es hacer muchos y ponerlos a votar. Este módulo cumple esa promesa. Vas a ver cómo cientos de árboles mediocres, combinados con inteligencia, forman uno de los modelos más robustos y confiables que existen para datos tabulares: el Random Forest.

La tesis del módulo

Un árbol solo se equivoca por su lado; muchos árboles distintos se equivocan por lados que se cancelan. Esa es toda la magia del Random Forest: entrenar un bosque de árboles, cada uno mirando datos y variables ligeramente distintos, y promediar sus votos. El resultado generaliza muchísimo mejor que cualquier árbol individual.

Ensemble: la sabiduría de la multitud

Un ensemble (glosamos: combinar varios modelos y juntar sus predicciones en una sola) parte de una idea vieja y muy humana: un grupo diverso de opiniones, promediado, suele acertar más que el mejor experto individual. Si le preguntas a mil personas cuántas monedas hay en un frasco, el promedio de sus respuestas queda asombrosamente cerca del número real — mejor que casi cualquier respuesta suelta.

Para que esto funcione hay una condición: los modelos tienen que ser diversos. Si los mil árboles fueran idénticos, votarían lo mismo y no ganarías nada. El arte está en fabricar árboles que se equivoquen de formas distintas, para que sus errores se cancelen entre sí en vez de sumarse.

Bagging: cómo se fabrican árboles distintos

La técnica que genera esa diversidad se llama bagging (glosamos: de bootstrap aggregating — entrenar cada modelo sobre una muestra aleatoria distinta de los datos y luego agregar, o sea promediar/votar, sus predicciones).

Funciona así:

1. Tomas tu dataset de, digamos, 1.000 filas.
2. Para cada árbol, sacas una muestra con reemplazo (bootstrap): eliges 1.000 filas al azar, pero permitiendo repetir. Algunas filas salen varias veces, otras no salen. Cada árbol ve un dataset parecido pero no igual.
3. Entrenas un árbol por cada muestra. Como cada uno vio datos distintos, cada uno sale distinto.
4. Para predecir, votan: en clasificación gana la clase más votada; en regresión se promedia el número.

Random Forest le agrega un segundo toque de azar: en cada corte, cada árbol solo puede elegir entre un subconjunto aleatorio de variables, no todas. Esto evita que todos los árboles usen siempre la misma variable dominante y los hace todavía más diversos.

             DATOS (1.000 filas)
                    │
      ┌─────────────┼─────────────┐
      ▼             ▼             ▼
 ┌─────────┐   ┌─────────┐   ┌─────────┐
 │ muestra │   │ muestra │   │ muestra │  ... cientos
 │    1    │   │    2    │   │    3    │
 └────┬────┘   └────┬────┘   └────┬────┘
      ▼             ▼             ▼
 ┌─────────┐   ┌─────────┐   ┌─────────┐
 │ árbol 1 │   │ árbol 2 │   │ árbol 3 │  ... cientos
 └────┬────┘   └────┬────┘   └────┬────┘
      │             │             │
      └─────────────┼─────────────┘
                    ▼
          ┌───────────────────┐
          │  voto / promedio  │
          └─────────┬─────────┘
                    ▼
               PREDICCIÓN

El efecto sobre el overfitting es notable: un árbol solo memoriza el ruido de sus datos; pero el ruido es distinto en cada muestra, así que al promediar cientos de árboles, el ruido se cancela y queda la señal. Por eso un Random Forest se sobreajusta muchísimo menos que un árbol individual, aun sin podar cada árbol.

Random Forest en código

En scikit-learn es RandomForestClassifier (o RandomForestRegressor). Misma API de siempre.

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

bosque = RandomForestClassifier(
    n_estimators=300,   # cuántos árboles en el bosque
    max_depth=None,     # cada árbol puede crecer: el bagging lo controla
    max_features="sqrt",# variables candidatas por corte (el 2do azar)
    n_jobs=-1,          # usa todos los núcleos: los árboles son paralelos
    random_state=42,
)
bosque.fit(X_train, y_train)

print("test:", accuracy_score(y_test, bosque.predict(X_test)))

# feature importance: qué variables pesaron más en las decisiones
import numpy as np
nombres = load_breast_cancer().feature_names
importancias = bosque.feature_importances_
orden = np.argsort(importancias)[::-1]   # de mayor a menor

for i in orden[:5]:                       # top 5 variables
    print(f"{nombres[i]:25s} {importancias[i]:.3f}")

Nota n_jobs=-1: como los árboles son independientes, se entrenan en paralelo en todos tus núcleos. Es una de las razones prácticas por las que el Random Forest es tan cómodo de usar.

Feature importance: qué variables mandan

Una ventaja que rescatamos del árbol, aunque en forma agregada, es el feature importance (glosamos: un puntaje por variable que dice cuánto contribuyó, en promedio sobre todo el bosque, a mejorar la pureza de los cortes — o sea, qué variables pesan más en las decisiones del modelo).

El atributo feature_importances_ te da un número por variable; suman 1 en total. Sirve muchísimo para entender tu problema: te dice qué mide de verdad tu modelo. Ese código de arriba imprime el top 5.

Ojo: el feature importance por defecto (basado en impureza) infla las variables con muchos valores distintos. Si vas a tomar decisiones serias con esto, complementa con permutation importance (sklearn.inspection.permutation_importance), que es más honesto porque mide cuánto empeora el modelo al barajar cada variable.

Árbol solo vs Random Forest

	Árbol de decisión	Random Forest
Precisión	Baja/media (“débil”)	Alta y robusta
Overfitting	Alto si no se poda	Bajo (el bagging lo amortigua)
Estabilidad	Frágil ante cambios	Estable
Interpretabilidad	Total: se dibuja entero	Limitada: solo importancias
Velocidad	Muy rápido	Más lento (cientos de árboles)
Escalar variables	No hace falta	No hace falta
Tuning	Poco	Poco: anda bien casi sin tocar

El costo: adiós a la transparencia total

No todo es gratis. El árbol solo tenía una virtud enorme que aquí perdemos: podías dibujarlo entero y auditar cada decisión. Un Random Forest son cientos de árboles votando; ya no puedes seguir su lógica con el dedo. Ganaste robustez y precisión, pero pasaste de un modelo transparente a uno semi-caja-negra. El feature importance te da una idea de qué mira, pero no el “por qué” exacto de una predicción concreta.

Este trade-off — precisión versus interpretabilidad — te va a perseguir todo el machine learning. No hay respuesta universal: en un modelo médico que un doctor debe justificar, la transparencia puede pesar más; en un detector de fraude, quizás manda la precisión.

Errores comunes

• Poner pocos árboles. Con n_estimators=10 no aprovechas el ensemble. Parte en 100–300; más árboles nunca empeora (solo tarda más).
• Podar agresivamente cada árbol como en el módulo 5. En Random Forest los árboles individuales pueden crecer profundos; el bagging ya controla el overfitting. Podar de más le quita fuerza.
• Leer el feature importance por defecto como verdad absoluta. Está sesgado hacia variables de alta cardinalidad. Usa permutation importance para decisiones importantes.
• Esperar que interprete como un árbol. No: cambiaste transparencia por robustez. Si necesitas explicar cada predicción, mira herramientas como SHAP o vuelve a un árbol.
• Escalar las variables. Sigue sin hacer falta, igual que con un árbol solo.

La frase para llevarse

“Un árbol se equivoca solo; un bosque de árboles diversos se equivoca en direcciones que se cancelan. La multitud diversa vence al experto individual.”

Qué viene

El Random Forest entrena sus árboles en paralelo y los promedia — todos son iguales de importantes. Pero existe otra forma de combinar árboles, casi opuesta: entrenarlos en secuencia, donde cada árbol nuevo se dedica a corregir los errores del anterior. Esa idea, el boosting, es todavía más potente. En el Módulo 7: Gradient Boosting conoceremos a XGBoost y LightGBM, los modelos que dominan el machine learning tabular y ganan competencias de Kaggle.

Material relacionado

• Glosario de Machine Learning
• Machine Learning — Módulo 5: árboles de decisión
• Machine Learning — Módulo 7: Gradient Boosting — XGBoost y LightGBM
• Redes — Módulo 7: overfitting y regularización