Árboles de decisión: teoría e implementación
Impureza de Gini, ganancia de información, profundidad del árbol y sobreajuste: sklearn DecisionTreeClassifier.
Árboles de decisión: teoría e implementación es una lección gratuita de Learn AI with Python en CoddyKit. Esta es la lección 1 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 Learn AI with Python, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn AI with Python incluye 4 lecciones en total.
Qué es un árbol de decisión
Un árbol de decisión divide los datos en ramas según los valores de las características y formula preguntas de sí o no hasta llegar a una predicción en un nodo hoja.
Cada nodo interno comprueba una característica, cada rama representa un resultado y cada hoja asigna una clase. Los árboles son fáciles de interpretar porque puede seguir la ruta de las decisiones.
Impureza de Gini
La impureza de Gini mide hasta qué punto están mezcladas las clases en un nodo. Un nodo puro, formado por una sola clase, tiene un valor de Gini de 0.
La fórmula es Gini = 1 - sum(p_i^2), donde p_i es la proporción de la clase i. El árbol elige las divisiones que más reducen la impureza.
import numpy as np
def gini(labels):
classes, counts = np.unique(labels, return_counts=True)
probs = counts / counts.sum()
return 1 - np.sum(probs ** 2)
print(gini([0, 0, 1, 1])) # 0.5 (max mix)
print(gini([0, 0, 0, 0])) # 0.0 (pure)Ganancia de información y entropía
Otro criterio de división es la ganancia de información, basada en la entropía. La entropía es -sum(p_i * log2(p_i)).
Ganancia de información = entropía del padre - entropía ponderada de los hijos. Tanto Gini como la entropía suelen producir árboles similares; Gini se calcula ligeramente más rápido.
import numpy as np
def entropy(labels):
_, counts = np.unique(labels, return_counts=True)
p = counts / counts.sum()
return -np.sum(p * np.log2(p))
print(entropy([0, 0, 1, 1])) # 1.0
print(entropy([0, 0, 0, 1])) # ~0.81Entrenar un DecisionTreeClassifier
Scikit-learn proporciona DecisionTreeClassifier. Puede elegir el criterio de división con el parámetro criterion (gini o entropy).
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)
clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))Sobreajuste y max_depth
Un árbol sin restricciones crece hasta que todas las hojas son puras y memoriza el ruido. Esto produce sobreajuste.
El parámetro max_depth limita la profundidad máxima del árbol y le obliga a generalizar. Menor profundidad = modelo más sencillo = menos sobreajuste.
from sklearn.tree import DecisionTreeClassifier
shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training setOtros parámetros de poda previa
Además de max_depth, puede controlar el crecimiento con:
min_samples_split: número mínimo de muestras para dividir un nodomin_samples_leaf: número mínimo de muestras en una hojamax_leaf_nodes: límite del número total de hojas
Todos ellos reducen la varianza y combaten el sobreajuste.
from sklearn.tree import DecisionTreeClassifier
clf = DecisionTreeClassifier(
max_depth=5,
min_samples_split=10,
min_samples_leaf=5,
random_state=0,
)Visualización con plot_tree
plot_tree dibuja el árbol completo para que pueda leer cada división, el valor de Gini y la distribución de clases en cada nodo.
import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)
plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()Importancia de las características
Después del ajuste, feature_importances_ indica cuánto redujo cada característica la impureza en todas las divisiones. Los valores suman 1.0.
Es una forma rápida de ordenar las entradas más importantes para el modelo.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)
for name, imp in zip(data.feature_names, clf.feature_importances_):
print(f"{name}: {imp:.3f}")Poda de complejidad de costes (ccp_alpha)
La poda posterior hace crecer un árbol completo y después recorta las ramas débiles. El parámetro ccp_alpha controla la intensidad de la poda: un alpha mayor elimina más nodos.
Use cost_complexity_pruning_path para encontrar valores alpha candidatos.
from sklearn.tree import DecisionTreeClassifier
base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas
pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)Elegir el mejor Alpha
Para elegir ccp_alpha, entrene un árbol por cada valor alpha candidato y compare la exactitud en validación. El mejor alpha equilibra la exactitud y la sencillez.
from sklearn.tree import DecisionTreeClassifier
scores = []
for a in alphas:
t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
t.fit(Xtr, ytr)
scores.append((a, t.score(Xte, yte)))
best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])Ventajas y desventajas
Ventajas: interpretables, no necesitan escalado, gestionan fronteras no lineales y tipos de datos mixtos.
Desventajas: alta varianza, ya que pequeños cambios en los datos pueden cambiar el árbol; son propensos al sobreajuste y solo realizan divisiones alineadas con los ejes. Estas limitaciones motivan el uso de ensembles como los bosques aleatorios.
Comprobación rápida
Compruebe su comprensión de los conceptos de los árboles de decisión.
Resumen
Resumen: los árboles de decisión dividen los datos mediante la impureza de Gini o la ganancia de información. Controle el sobreajuste con poda previa (max_depth, min_samples_leaf) o poda posterior (ccp_alpha). Examine los modelos con plot_tree y feature_importances_. Su alta varianza motiva el uso de métodos de ensemble.
Preguntas frecuentes
¿La lección «Árboles de decisión: teoría e implementación» es gratis?
Sí — el texto completo de «Árboles de decisión: teoría e implementación» 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 Learn AI with Python, actualiza a CoddyKit PRO. El curso de Learn AI with Python incluye 4 lecciones en total.
¿Qué aprenderé en «Árboles de decisión: teoría e implementación»?
Impureza de Gini, ganancia de información, profundidad del árbol y sobreajuste: sklearn DecisionTreeClassifier. Practicas Learn AI with Python 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 Learn AI with Python?
No se requiere experiencia previa. Learn AI with Python 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 1 de 4.
¿Cuánto tiempo toma la lección «Árboles de decisión: teoría e implementación»?
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 Learn AI with Python?
Sí. Cada lección de Learn AI with Python 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
- Árboles de decisión: teoría e implementación
- Random Forests y bagging
- Gradient boosting: GBM y XGBoost
- LightGBM y CatBoost