Tutorial de classificação de árvore de decisão em Python

O algoritmo de árvore de decisão

Uma árvore de decisão é uma estrutura de árvore semelhante a um fluxograma em que um nó interno representa um recurso (ou atributo), o ramo representa uma regra de decisão e cada nó folha representa o resultado.

O nó mais alto em uma árvore de decisão é conhecido como nó raiz. Ele aprende a particionar com base no valor do atributo. Ele particiona a árvore de forma recursiva, chamada de particionamento recursivo. Essa estrutura semelhante a um fluxograma ajuda você a tomar decisões. É uma visualização como um diagrama de fluxograma que imita facilmente o pensamento em nível humano. É por isso que as árvores de decisão são fáceis de entender e interpretar.

Imagem | Abid Ali Awan 

Uma árvore de decisão é um tipo de algoritmo de ML de caixa branca. Ele compartilha a lógica interna de tomada de decisões, que não está disponível nos algoritmos do tipo caixa preta, como em uma rede neural. Seu tempo de treinamento é mais rápido em comparação com o algoritmo de rede neural.

A complexidade de tempo das árvores de decisão é uma função do número de registros e atributos nos dados fornecidos. A árvore de decisão é um método sem distribuição ou não paramétrico que não depende de suposições de distribuição de probabilidade. As árvores de decisão podem lidar com dados de alta dimensão com boa precisão.

Como funciona o algoritmo de árvore de decisão?

A ideia básica por trás de qualquer algoritmo de árvore de decisão é a seguinte:

1. Selecione o melhor atributo usando Attribute Selection Measures (ASM) para dividir os registros.
2. Faça desse atributo um nó de decisão e divida o conjunto de dados em subconjuntos menores.
3. Inicie a construção da árvore repetindo esse processo recursivamente para cada filho até que uma das condições corresponda:
   • Todas as tuplas pertencem ao mesmo valor de atributo.
   • Não há mais atributos restantes.
   • Não há mais instâncias.

Medidas de seleção de atributos

A medida de seleção de atributos é uma heurística para selecionar o critério de divisão que particiona os dados da melhor maneira possível. Também é conhecido como regras de divisão porque nos ajuda a determinar pontos de interrupção para tuplas em um determinado nó. O ASM fornece uma classificação para cada recurso (ou atributo), explicando o conjunto de dados fornecido. O atributo com a melhor pontuação será selecionado como um atributo de divisão(Fonte). No caso de um atributo de valor contínuo, também é necessário definir pontos de divisão para as ramificações. As medidas de seleção mais populares são o ganho de informações, a relação de ganho e o índice de Gini.

Ganho de informações

Claude Shannon inventou o conceito de entropia, que mede a impureza do conjunto de entrada. Na física e na matemática, a entropia é chamada de aleatoriedade ou impureza em um sistema. Na teoria da informação, refere-se à impureza em um grupo de exemplos. O ganho de informações é a diminuição da entropia. O ganho de informações calcula a diferença entre a entropia antes da divisão e a entropia média após a divisão do conjunto de dados com base em determinados valores de atributos. O algoritmo de árvore de decisão ID3 (Iterative Dichotomiser) usa o ganho de informações.

Onde Pi é a probabilidade de uma tupla arbitrária em D pertencer à classe Ci.

Onde:

• Info(D) é a quantidade média de informações necessárias para identificar o rótulo de classe de uma tupla em D.
• |Dj|/|D| atua como o peso da j-ésima partição.
• InfoA(D) é a informação esperada necessária para classificar uma tupla de D com base no particionamento por A.

O atributo A com o maior ganho de informações, Gain(A), é escolhido como o atributo de divisão no nó N().

Relação de ganho

O ganho de informações é tendencioso para o atributo com muitos resultados. Isso significa que você prefere o atributo com um grande número de valores distintos. Por exemplo, considere um atributo com um identificador exclusivo, como customer_ID, que tem zero info(D) por causa da partição pura. Isso maximiza o ganho de informações e cria um particionamento inútil.

O C4.5, um aprimoramento do ID3, usa uma extensão do ganho de informações conhecida como taxa de ganho. A proporção de ganho lida com a questão da tendência normalizando o ganho de informações usando o Split Info. A implementação em Java do algoritmo C4.5 é conhecida como J48, que está disponível na ferramenta de mineração de dados WEKA.

Onde:

• |Dj|/|D| atua como o peso da j-ésima partição.
• v é o número de valores discretos no atributo A.

A taxa de ganho pode ser definida como

O atributo com a maior taxa de ganho é escolhido como o atributo de divisão(Fonte).

Índice de Gini

Outro algoritmo de árvore de decisão, o CART (Classification and Regression Tree), usa o método Gini para criar pontos de divisão.

Onde pi é a probabilidade de uma tupla em D pertencer à classe Ci.

O Índice de Gini considera uma divisão binária para cada atributo. Você pode calcular uma soma ponderada da impureza de cada partição. Se uma divisão binária no atributo A particiona os dados D em D1 e D2, o índice de Gini de D é:

No caso de um atributo de valor discreto, o subconjunto que fornece o índice de gini mínimo para o escolhido é selecionado como um atributo de divisão. No caso de atributos de valor contínuo, a estratégia é selecionar cada par de valores adjacentes como um possível ponto de divisão, e um ponto com um índice de gini menor é escolhido como o ponto de divisão.

O atributo com o índice Gini mínimo é escolhido como o atributo de divisão.

Criação de classificador de árvore de decisão no Scikit-learn

Importação de bibliotecas necessárias

Primeiro, vamos carregar as bibliotecas necessárias.

# Load libraries
import pandas as pd
from sklearn.tree import DecisionTreeClassifier # Import Decision Tree Classifier
from sklearn.model_selection import train_test_split # Import train_test_split function
from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation

Carregando dados

Primeiro, vamos carregar o conjunto de dados necessário do Pima Indian Diabetes usando a função read CSV do pandas. Você pode fazer o download do conjunto de dados do Kaggle para acompanhar o processo.

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
# load dataset
pima = pd.read_csv("diabetes.csv", header=None, names=col_names)

pima.head()

Seleção de recursos

Aqui, você precisa dividir as colunas fornecidas em dois tipos de variáveis: dependente (ou variável-alvo) e independente (ou variáveis de recursos).

#split dataset in features and target variable
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

Divisão de dados

Para entender o desempenho do modelo, dividir o conjunto de dados em um conjunto de treinamento e um conjunto de teste é uma boa estratégia.

Vamos dividir o conjunto de dados usando a função train_test_split(). Você precisa passar três parâmetros: recursos, alvo e tamanho do conjunto de teste.

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1) # 70% training and 30% test

Criação do modelo de árvore de decisão

Vamos criar um modelo de árvore de decisão usando o Scikit-learn.

# Create Decision Tree classifer object
clf = DecisionTreeClassifier()

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

Avaliação do modelo

Vamos estimar a precisão com que o classificador ou modelo pode prever o tipo de cultivares.

A precisão pode ser calculada comparando-se os valores reais do conjunto de testes e os valores previstos.

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.6753246753246753

Obtivemos uma taxa de classificação de 67,53%, que é considerada uma boa precisão. Você pode melhorar essa precisão ajustando os parâmetros no algoritmo da árvore de decisão.

Visualização de árvores de decisão

Você pode usar a função export_graphviz do Scikit-learn para exibir a árvore em um notebook Jupyter. Para plotar a árvore, você também precisa instalar o graphviz e o pydotplus.

pip install graphviz

pip install pydotplus

A função export_graphviz converte o classificador da árvore de decisão em um arquivo de pontos, e o pydotplus converte esse arquivo de pontos em png ou em um formato exibível no Jupyter.

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO  
from IPython.display import Image  
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
graph.write_png('diabetes.png')
Image(graph.create_png())

No gráfico da árvore de decisão, cada nó interno tem uma regra de decisão que divide os dados. O Gini, conhecido como índice de Gini, mede a impureza do nó. Você pode dizer que um nó é puro quando todos os seus registros pertencem à mesma classe, nós esses conhecidos como nó folha.

Aqui, a árvore resultante não é podada. Essa árvore não podada é inexplicável e não é fácil de entender. Na próxima seção, vamos otimizá-lo por meio da poda.

Otimização do desempenho da árvore de decisão

• criterion : opcional (padrão="gini") ou Escolha a medida de seleção de atributo. Esse parâmetro nos permite usar a medida de seleção de atributos diferentes-diferentes. Os critérios compatíveis são "gini" para o índice Gini e "entropia" para o ganho de informações.

• splitter : string, opcional (padrão="melhor") ou Split Strategy. Esse parâmetro nos permite escolher a estratégia de divisão. As estratégias compatíveis são "best" (melhor) para escolher a melhor divisão e "random" (aleatório) para escolher a melhor divisão aleatória.

• max_depth : int ou None, opcional (padrão=None) ou Profundidade máxima de uma árvore. A profundidade máxima da árvore. Se for None, os nós serão expandidos até que todas as folhas contenham menos do que min_samples_split samples. O valor mais alto da profundidade máxima causa sobreajuste, e um valor mais baixo causa subajuste(Fonte).

No Scikit-learn, a otimização do classificador de árvore de decisão é realizada apenas com a pré-poda. A profundidade máxima da árvore pode ser usada como uma variável de controle para a poda prévia. No exemplo a seguir, você pode plotar uma árvore de decisão nos mesmos dados com max_depth=3. Além dos parâmetros de pré-aproveitamento, você também pode tentar outra medida de seleção de atributos, como a entropia.

# Create Decision Tree classifer object
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.7705627705627706

Bem, a taxa de classificação aumentou para 77,05%, o que representa uma precisão melhor do que o modelo anterior.

Visualização de árvores de decisão

Vamos tornar nossa árvore de decisão um pouco mais fácil de entender usando o código a seguir: 

from six import StringIO from IPython.display import Image from sklearn.tree import export_graphviz import pydotplus dot_data = StringIO() export_graphviz(clf, out_file=dot_data, filled=True, rounded=True, special_characters=True, feature_names = feature_cols,class_names=['0','1']) graph = pydotplus.graph_from_dot_data(dot_data.getvalue()) graph.write_png('diabetes.png') Image(graph.create_png())

Aqui, concluímos as etapas a seguir: 

• Você importou as bibliotecas necessárias.
• Você criou um objeto StringIO chamado dot_data para manter a representação de texto da árvore de decisão.
• Você exportou a árvore de decisão para o formato dot usando a função export_graphviz e gravou a saída no buffer dot_data.
• Criou um objeto gráfico pydotplus a partir da representação em formato dot da árvore de decisão armazenada no buffer dot_data.
• Grave o gráfico gerado em um arquivo PNG chamado "diabetes.png".
• Exibiu a imagem PNG gerada da árvore de decisão usando o objeto Image do módulo IPython.display.

Como você pode ver, esse modelo podado é menos complexo, mais explicável e mais fácil de entender do que o modelo de árvore de decisão anterior.

Profissionais da árvore de decisão

• As árvores de decisão são fáceis de interpretar e visualizar.
• Ele pode capturar facilmente padrões não lineares.
• Requer menos pré-processamento de dados por parte do usuário, por exemplo, não há necessidade de normalizar colunas.
• Ele pode ser usado para a engenharia de recursos, como a previsão de valores ausentes, adequada para a seleção de variáveis.
• A árvore de decisão não tem suposições sobre a distribuição devido à natureza não paramétrica do algoritmo. (Fonte)

Árvore de decisão Contras

• Sensível a dados com ruídos. Ele pode se ajustar excessivamente a dados ruidosos.
• A pequena variação (ou variância) nos dados pode resultar em uma árvore de decisão diferente. Isso pode ser reduzido por meio de algoritmos de ensacamento e de reforço.
• As árvores de decisão são tendenciosas com conjuntos de dados desequilibrados, portanto, recomenda-se que você equilibre o conjunto de dados antes de criar a árvore de decisão.

Conclusão

Parabéns, você chegou ao final deste tutorial!

Neste tutorial, você abordou muitos detalhes sobre árvores de decisão; como elas funcionam, medidas de seleção de atributos, como Ganho de Informações, Razão de Ganho e Índice de Gini, construção de modelos de árvores de decisão, visualização e avaliação de um conjunto de dados de diabetes usando o pacote Scikit-learn do Python. Também discutimos seus prós e contras e como otimizar o desempenho da árvore de decisão usando o ajuste de parâmetros.

Esperamos que agora você possa utilizar o algoritmo de árvore de decisão para analisar seus próprios conjuntos de dados.

Se você quiser saber mais sobre Machine Learning em Python, faça o curso Machine Learning with Tree-Based Models in Python do DataCamp.

Confira nosso tutorial Kaggle: Seu primeiro modelo de aprendizado de máquina.