Modelos basados en árboles: árboles de decisión y bosques aleatorios
Cree y ajuste modelos de árboles de decisión y bosques de ensamble.
Modelos basados en árboles: árboles de decisión y bosques aleatorios es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.
Conceptos de árboles de decisión
Un árbol de decisión divide los datos en subconjuntos formulando una secuencia de preguntas binarias. Cada nodo interno representa un umbral de una característica; cada hoja representa una predicción.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print("Depth:", model.get_depth())
print("Leaves:", model.get_n_leaves())DecisionTreeClassifier
Hiperparámetros clave: max_depth, min_samples_split y min_samples_leaf. Los árboles más profundos tienden al sobreajuste; los más poco profundos, al subajuste.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=5)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))DecisionTreeRegressor
Los árboles de decisión también permiten hacer regresión: predicen el valor medio del objetivo en cada hoja.
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
X, y = make_regression(noise=15, random_state=0)
model = DecisionTreeRegressor(max_depth=4).fit(X, y)
print("RMSE:", mean_squared_error(y, model.predict(X))**0.5)Importancia de las características
model.feature_importances_ proporciona la importancia relativa de cada característica, basada en la reducción de la impureza.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
model = DecisionTreeClassifier().fit(X, y)
for name, imp in sorted(zip(feature_names, model.feature_importances_), key=lambda x: -x[1]):
print(f"{name}: {imp:.3f}")Descripción general de Random Forest
Un Random Forest entrena muchos árboles de decisión no correlacionados con muestras bootstrap y promedia sus predicciones, lo que reduce la varianza sin aumentar el sesgo.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))RandomForestRegressor
Los Random Forest también funcionan igual de bien para la regresión.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import r2_score
X, y = make_regression(noise=10, random_state=0)
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)
print("R²:", r2_score(y, model.predict(X)))Puntuación out-of-bag
Establezca oob_score=True para obtener una puntuación de validación gratuita usando las muestras que no están en el bootstrap de cada árbol (sin necesidad de un conjunto de prueba independiente).
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(random_state=0)
model = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=0).fit(X, y)
print("OOB score:", model.oob_score_)Boosting de gradiente
El boosting de gradiente (GBM) entrena los árboles secuencialmente, de modo que cada uno corrige los errores del anterior. A menudo es más preciso que Random Forest, pero tarda más en entrenarse.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = GradientBoostingClassifier(n_estimators=100).fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))XGBoost / LightGBM
XGBoost y LightGBM son bibliotecas optimizadas de boosting de gradiente: son más rápidas, escalables y, a menudo, más precisas que el GBM de sklearn.
# pip install xgboost lightgbm
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
xgb = XGBClassifier(n_estimators=100, eval_metric="logloss").fit(X_tr, y_tr)
print("XGB acc:", xgb.score(X_te, y_te))Ajuste de n_estimators
Usar más árboles en un Random Forest reduce la varianza (hasta cierto punto) sin provocar sobreajuste. Use una curva de validación para encontrar la cantidad óptima.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(random_state=0)
for n in [10, 50, 100, 200]:
scores = cross_val_score(RandomForestClassifier(n_estimators=n, random_state=0), X, y, cv=5)
print(f"n={n}: {scores.mean():.3f}")Visualización de un árbol de decisión
Use sklearn.tree.plot_tree o export_text para examinar lo que ha aprendido el árbol.
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=2).fit(X, y)
print(export_text(model, feature_names=load_iris().feature_names.tolist()))Comprobación rápida
¿Cómo reduce un Random Forest el sobreajuste en comparación con un único árbol de decisión?
Resumen
Los árboles de decisión dividen los datos según umbrales de las características y predicen usando los valores de las hojas. Ajuste max_depth para controlar el sobreajuste. Los Random Forest promedian muchos árboles para reducir la varianza. El boosting de gradiente entrena árboles secuencialmente para lograr una alta precisión. En producción, prefiera XGBoost o LightGBM.
Preguntas frecuentes
¿La lección «Modelos basados en árboles: árboles de decisión y bosques aleatorios» es gratis?
Sí — el texto completo de «Modelos basados en árboles: árboles de decisión y bosques aleatorios» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Modelos basados en árboles: árboles de decisión y bosques aleatorios»?
Cree y ajuste modelos de árboles de decisión y bosques de ensamble. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Python Academy?
No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Modelos basados en árboles: árboles de decisión y bosques aleatorios»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Python Academy?
Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- La API de scikit-learn: fit, transform y predict
- Modelos lineales: regresión y clasificación
- Modelos basados en árboles: árboles de decisión y bosques aleatorios
- Evaluación de modelos y validación cruzada