Algoritmos de classificação - árvore de decisão

Introdução à árvore de decisão

Em geral, a análise da árvore de decisão é uma ferramenta de modelagem preditiva que pode ser aplicada em muitas áreas. As árvores de decisão podem ser construídas por uma abordagem algorítmica que pode dividir o conjunto de dados de maneiras diferentes com base em condições diferentes. As árvores de decisão são os algoritmos mais poderosos que se enquadram na categoria de algoritmos supervisionados.

Eles podem ser usados ​​para tarefas de classificação e regressão. As duas principais entidades de uma árvore são os nós de decisão, onde os dados são divididos e saem, onde obtemos o resultado. O exemplo de uma árvore binária para prever se uma pessoa está em forma ou não, fornecendo várias informações como idade, hábitos alimentares e hábitos de exercício, é dado abaixo -

Na árvore de decisão acima, a questão são nós de decisão e os resultados finais são folhas. Temos os seguintes dois tipos de árvores de decisão -

  • Classification decision trees- Nesse tipo de árvore de decisão, a variável de decisão é categórica. A árvore de decisão acima é um exemplo de árvore de decisão de classificação.

  • Regression decision trees - Nesse tipo de árvore de decisão, a variável de decisão é contínua.

Implementando Algoritmo de Árvore de Decisão

Índice de Gini

É o nome da função de custo usada para avaliar as divisões binárias no conjunto de dados e funciona com a variável de destino categorial “Sucesso” ou “Falha”.

Quanto maior o valor do índice de Gini, maior a homogeneidade. Um valor de índice de Gini perfeito é 0 e o pior é 0,5 (para o problema de 2 classes). O índice de Gini para uma divisão pode ser calculado com a ajuda das seguintes etapas -

  • Primeiro, calcule o índice de Gini para subnós usando a fórmula p ^ 2 + q ^ 2, que é a soma do quadrado da probabilidade de sucesso e fracasso.

  • Em seguida, calcule o índice de Gini para divisão usando a pontuação de Gini ponderada de cada nó dessa divisão.

O algoritmo Classification and Regression Tree (CART) usa o método Gini para gerar divisões binárias.

Criação Dividida

Uma divisão consiste basicamente em incluir um atributo no conjunto de dados e um valor. Podemos criar uma divisão no conjunto de dados com a ajuda das três partes a seguir -

  • Part1: Calculating Gini Score - Acabamos de discutir essa parte na seção anterior.

  • Part2: Splitting a dataset- Pode ser definido como a separação de um conjunto de dados em duas listas de linhas com índice de um atributo e um valor de divisão desse atributo. Depois de obter os dois grupos - direito e esquerdo, do conjunto de dados, podemos calcular o valor da divisão usando a pontuação de Gini calculada na primeira parte. O valor dividido decidirá em qual grupo o atributo residirá.

  • Part3: Evaluating all splits- A próxima parte depois de encontrar a pontuação Gini e dividir o conjunto de dados é a avaliação de todas as divisões. Para isso, primeiro devemos verificar cada valor associado a cada atributo como uma divisão candidata. Em seguida, precisamos encontrar a melhor divisão possível avaliando o custo da divisão. A melhor divisão será usada como um nó na árvore de decisão.

Construindo uma árvore

Como sabemos, uma árvore possui nó raiz e nós terminais. Depois de criar o nó raiz, podemos construir a árvore seguindo duas partes -

Parte 1: Criação do nó terminal

Ao criar nós terminais da árvore de decisão, um ponto importante é decidir quando parar de aumentar a árvore ou criar outros nós terminais. Isso pode ser feito usando dois critérios, nomeadamente profundidade máxima da árvore e registros de nós mínimos, como segue -

  • Maximum Tree Depth- Como o nome sugere, este é o número máximo de nós em uma árvore após o nó raiz. Devemos parar de adicionar nós terminais uma vez que uma árvore atingiu a profundidade máxima, ou seja, quando uma árvore obteve o número máximo de nós terminais.

  • Minimum Node Records- Pode ser definido como o número mínimo de padrões de treinamento pelos quais um determinado nó é responsável. Devemos parar de adicionar nós terminais assim que a árvore atingir esses registros de nós mínimos ou abaixo desse mínimo.

O nó terminal é usado para fazer uma previsão final.

Parte 2: Divisão Recursiva

Como entendemos sobre quando criar nós terminais, agora podemos começar a construir nossa árvore. A divisão recursiva é um método para construir a árvore. Neste método, uma vez que um nó é criado, podemos criar os nós filhos (nós adicionados a um nó existente) recursivamente em cada grupo de dados, gerados pela divisão do conjunto de dados, chamando a mesma função repetidamente.

Predição

Depois de construir uma árvore de decisão, precisamos fazer uma previsão sobre ela. Basicamente, a previsão envolve navegar na árvore de decisão com a linha de dados especificamente fornecida.

Podemos fazer uma previsão com a ajuda da função recursiva, como fizemos acima. A mesma rotina de predição é chamada novamente com os nós esquerdo ou direito filho.

Suposições

A seguir estão algumas das suposições que fazemos ao criar a árvore de decisão -

  • Ao preparar árvores de decisão, o conjunto de treinamento é o nó raiz.

  • O classificador da árvore de decisão prefere que os valores dos recursos sejam categóricos. Caso deseje usar valores contínuos, eles devem ser discretizados antes da construção do modelo.

  • Com base nos valores do atributo, os registros são distribuídos recursivamente.

  • A abordagem estatística será usada para colocar atributos em qualquer posição de nó, como nó raiz ou nó interno.

Implementação em Python

Exemplo

No exemplo a seguir, vamos implementar o classificador de árvore de decisão no Diabetes Indiano Pima -

Primeiro, comece importando os pacotes Python necessários -

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

Em seguida, baixe o conjunto de dados iris de seu weblink da seguinte forma -

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
pima = pd.read_csv(r"C:\pima-indians-diabetes.csv", header=None, names=col_names)
pima.head()
pregnant    glucose  bp    skin  insulin  bmi   pedigree    age   label
0       6         148      72    35     0       33.6    0.627     50      1
1       1         85       66    29     0       26.6    0.351     31      0
2       8         183      64     0     0       23.3    0.672     32      1
3       1         89       66    23     94      28.1    0.167     21      0
4       0         137      40    35     168     43.1    2.288     33      1

Agora, divida o conjunto de dados em recursos e variável de destino da seguinte maneira -

feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

A seguir, dividiremos os dados em treinamento e divisão de teste. O código a seguir dividirá o conjunto de dados em 70% dos dados de treinamento e 30% dos dados de teste -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)

Em seguida, treine o modelo com a ajuda da classe DecisionTreeClassifier do sklearn da seguinte forma -

clf = DecisionTreeClassifier()
clf = clf.fit(X_train,y_train)

Por fim, precisamos fazer previsões. Isso pode ser feito com a ajuda do seguinte script -

y_pred = clf.predict(X_test)

Em seguida, podemos obter a pontuação de precisão, a matriz de confusão e o relatório de classificação da seguinte forma -

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
result = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:")
print(result)
result1 = classification_report(y_test, y_pred)
print("Classification Report:",)
print (result1)
result2 = accuracy_score(y_test,y_pred)
print("Accuracy:",result2)

Resultado

Confusion Matrix:
[[116 30]
[ 46 39]]
Classification Report:
            precision   recall   f1-score    support
      0       0.72      0.79       0.75     146
      1       0.57      0.46       0.51     85
micro avg     0.67      0.67       0.67     231
macro avg     0.64      0.63       0.63     231
weighted avg  0.66      0.67       0.66     231

Accuracy: 0.670995670995671

Visualizando Árvore de Decisão

A árvore de decisão acima pode ser visualizada com a ajuda do seguinte código -

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('Pima_diabetes_Tree.png')
Image(graph.create_png())