Poda de Árvores de Decisão

Introdução

Em aprendizagem de máquina, árvores de decisão são modelos comumente utilizados. No entanto, as árvores de decisão tendem a sobreajustar os dados de treino, o que pode levar a um desempenho fraco nos dados de teste. Uma forma de prevenir o sobreajuste é através da poda da árvore de decisão. A poda por complexidade de custo é um método popular para podar árvores de decisão. Neste laboratório, utilizaremos o scikit-learn para demonstrar a poda por complexidade de custo para árvores de decisão.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Às vezes, pode ser necessário esperar alguns segundos para que o Jupyter Notebook termine de carregar. A validação de operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Carregar os Dados

Utilizaremos o conjunto de dados de cancro da mama do scikit-learn. Este conjunto de dados possui 30 características e uma variável alvo binária que indica se um paciente tem cancro maligno ou benigno.

from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

Dividir os Dados

Dividiremos os dados em conjuntos de treino e teste.

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 os Valores Adequados de Alpha

Queremos determinar os valores apropriados de alpha a utilizar para podar a árvore de decisão. Podemos fazer isto representando a impureza total das folhas versus os alphas efectivos da árvore podada.

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 das folhas")
ax.set_title("Impureza Total vs alpha efectivo para o conjunto de treino")

Treinar as Árvores de Decisão

Em seguida, treinaremos uma árvore de decisão usando cada um dos valores de alpha efectivos. O último valor em ccp_alphas é o valor de alpha que poda toda a árvore, deixando a árvore apenas com um nó.

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 nós na última árvore é: {} com ccp_alpha: {}".format(
        clfs[-1].tree_.node_count, ccp_alphas[-1]
    )
)

Remover Árvores Triviais

Vamos remover a árvore trivial com apenas um nó da lista de árvores de decisão.

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

Plotar o Número de Nós e a Profundidade da Árvore

Vamos plotar o número de nós e a profundidade da árvore à medida que o alpha aumenta.

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 nós")
ax[0].set_title("Número de nós vs alpha")
ax[1].plot(ccp_alphas, depth, marker="o", drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("profundidade da árvore")
ax[1].set_title("Profundidade vs alpha")
fig.tight_layout()

Determinar o Melhor Valor de Alpha

Queremos determinar o melhor valor de alpha a utilizar para podar a árvore de decisão. Podemos fazer isso plotando a precisão versus alpha para os conjuntos de treino e teste.

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("precisão")
ax.set_title("Precisão vs alpha para os conjuntos de treino e teste")
ax.plot(ccp_alphas, train_scores, marker="o", label="treino", drawstyle="steps-post")
ax.plot(ccp_alphas, test_scores, marker="o", label="teste", drawstyle="steps-post")
ax.legend()
plt.show()

Resumo

Neste laboratório, demonstramos como utilizar o scikit-learn para realizar a poda por complexidade de custo em árvores de decisão. Dividimos os dados em conjuntos de treino e teste, determinámos os valores apropriados de alpha para a poda, treinámos árvores de decisão utilizando os valores eficazes de alpha, plotámos o número de nós e a profundidade da árvore, e determinámos o melhor valor de alpha a utilizar para a poda com base na precisão dos conjuntos de treino e teste.