Podado de árboles de decisión posterior

Introducción

En el aprendizaje automático, los árboles de decisión son modelos comúnmente utilizados. Sin embargo, los árboles de decisión tienen una tendencia a sobreajustarse a los datos de entrenamiento, lo que puede hacer que desempeñen mal en los datos de prueba. Una forma de prevenir el sobreajuste es a través de la poda del árbol de decisión. La poda por complejidad de coste es un método popular para la poda de árboles de decisión. En este laboratorio, usaremos scikit-learn para demostrar la poda por complejidad de coste para árboles de decisión.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Cargar los datos

Usaremos el conjunto de datos de cáncer de mama de scikit-learn. Este conjunto de datos tiene 30 características y una variable objetivo binaria que indica si un paciente tiene cáncer maligno o benigno.

from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

Dividir los datos

Dividiremos los datos en un conjunto de entrenamiento y un conjunto de prueba.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

Determinar los valores adecuados de alfa

Queremos determinar los valores adecuados de alfa para utilizar en la poda del árbol de decisión. Esto se puede hacer trazando la impureza total de las hojas en función de los alfas efectivos del árbol podado.

from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt

clf = DecisionTreeClassifier(random_state=0)
path = clf.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities

fig, ax = plt.subplots()
ax.plot(ccp_alphas[:-1], impurities[:-1], marker="o", drawstyle="steps-post")
ax.set_xlabel("alpha efectivo")
ax.set_ylabel("impureza total de las hojas")
ax.set_title("Impureza total vs alpha efectivo para el conjunto de entrenamiento")

Entrenar los árboles de decisión

A continuación, entrenaremos un árbol de decisión utilizando cada uno de los valores efectivos de alfa. El último valor en ccp_alphas es el valor de alfa que poda el árbol completo, dejando un árbol con un solo nodo.

clfs = []
for ccp_alpha in ccp_alphas:
    clf = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)
    clf.fit(X_train, y_train)
    clfs.append(clf)
print(
    "Número de nodos en el último árbol es: {} con ccp_alpha: {}".format(
        clfs[-1].tree_.node_count, ccp_alphas[-1]
    )
)

Eliminar árboles triviales

Eliminaremos el árbol trivial con un solo nodo de la lista de árboles de decisión.

clfs = clfs[:-1]
ccp_alphas = ccp_alphas[:-1]

Graficar el número de nodos y la profundidad del árbol

Graficaremos el número de nodos y la profundidad del árbol a medida que aumenta el alfa.

node_counts = [clf.tree_.node_count for clf in clfs]
depth = [clf.tree_.max_depth for clf in clfs]
fig, ax = plt.subplots(2, 1)
ax[0].plot(ccp_alphas, node_counts, marker="o", drawstyle="steps-post")
ax[0].set_xlabel("alpha")
ax[0].set_ylabel("número de nodos")
ax[0].set_title("Número de nodos vs alpha")
ax[1].plot(ccp_alphas, depth, marker="o", drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("profundidad del árbol")
ax[1].set_title("Profundidad vs alpha")
fig.tight_layout()

Determinar el mejor valor de alfa

Queremos determinar el mejor valor de alfa para utilizar en la poda del árbol de decisión. Esto se puede hacer trazando la precisión en función del alfa para los conjuntos de entrenamiento y prueba.

train_scores = [clf.score(X_train, y_train) for clf in clfs]
test_scores = [clf.score(X_test, y_test) for clf in clfs]

fig, ax = plt.subplots()
ax.set_xlabel("alpha")
ax.set_ylabel("precisión")
ax.set_title("Precisión vs alpha para los conjuntos de entrenamiento y prueba")
ax.plot(ccp_alphas, train_scores, marker="o", label="entrenamiento", drawstyle="steps-post")
ax.plot(ccp_alphas, test_scores, marker="o", label="prueba", drawstyle="steps-post")
ax.legend()
plt.show()

Resumen

En este laboratorio, demostramos cómo utilizar scikit-learn para realizar la poda de complejidad de coste para árboles de decisión. Dividimos los datos en un conjunto de entrenamiento y prueba, determinamos los valores adecuados de alfa para utilizar en la poda, entrenamos árboles de decisión utilizando los valores efectivos de alfa, graficamos el número de nodos y la profundidad del árbol y determinamos el mejor valor de alfa para utilizar en la poda basado en la precisión de los conjuntos de entrenamiento y prueba.