- A árvore de decisão é uma Técnica de aprendizagem supervisionada que pode ser usado tanto para problemas de classificação quanto de regressão, mas é principalmente preferido para resolver problemas de classificação. É um classificador estruturado em árvore, onde nós internos representam os recursos de um conjunto de dados, ramificações representam as regras de decisão e cada nó folha representa o resultado.
- Em uma árvore de decisão, existem dois nós, que são os Nó de decisão e Nó da folha. Os nós de decisão são usados para tomar qualquer decisão e possuem múltiplas ramificações, enquanto os nós Folha são a saída dessas decisões e não contêm quaisquer ramificações adicionais.
- As decisões ou o teste são realizados com base nas características de um determinado conjunto de dados.
- É chamada de árvore de decisão porque, semelhante a uma árvore, começa com o nó raiz, que se expande em ramos adicionais e constrói uma estrutura semelhante a uma árvore.
- Para construir uma árvore, usamos o Algoritmo CART, que significa Algoritmo de árvore de classificação e regressão.
- Uma árvore de decisão simplesmente faz uma pergunta e, com base na resposta (Sim/Não), divide ainda mais a árvore em subárvores.
- O diagrama abaixo explica a estrutura geral de uma árvore de decisão:
Nota: Uma árvore de decisão pode conter dados categóricos (SIM/NÃO), bem como dados numéricos.
Por que usar árvores de decisão?
Existem vários algoritmos em aprendizado de máquina, portanto, escolher o melhor algoritmo para um determinado conjunto de dados e problema é o ponto principal a ser lembrado ao criar um modelo de aprendizado de máquina. Abaixo estão os dois motivos para usar a árvore de decisão:
- As árvores de decisão geralmente imitam a capacidade de pensamento humano ao tomar uma decisão, por isso são fáceis de entender.
- A lógica por trás da árvore de decisão pode ser facilmente compreendida porque mostra uma estrutura semelhante a uma árvore.
Terminologias de Árvore de Decisão
Como funciona o algoritmo da árvore de decisão?
Em uma árvore de decisão, para prever a classe de um determinado conjunto de dados, o algoritmo começa no nó raiz da árvore. Este algoritmo compara os valores do atributo raiz com o atributo registro (conjunto de dados real) e, com base na comparação, segue o ramo e salta para o próximo nó.
como encontrar números bloqueados no Android
Para o próximo nó, o algoritmo compara novamente o valor do atributo com os outros subnós e avança. Ele continua o processo até atingir o nó folha da árvore. O processo completo pode ser melhor compreendido usando o algoritmo abaixo:
Exemplo: Suponha que haja um candidato que tenha uma oferta de emprego e queira decidir se deve aceitá-la ou não. Assim, para resolver este problema, a árvore de decisão começa com o nó raiz (atributo Salário por ASM). O nó raiz se divide no próximo nó de decisão (distância do escritório) e em um nó folha com base nos rótulos correspondentes. O próximo nó de decisão é dividido em um nó de decisão (recurso Cab) e um nó folha. Finalmente, o nó de decisão se divide em dois nós folha (ofertas aceitas e oferta recusada). Considere o diagrama abaixo:
Medidas de seleção de atributos
Ao implementar uma árvore de decisão, surge a questão principal: como selecionar o melhor atributo para o nó raiz e para os subnós. Então, para resolver tais problemas existe uma técnica chamada Medida de seleção de atributos ou ASM. Por esta medida, podemos facilmente selecionar o melhor atributo para os nós da árvore. Existem duas técnicas populares para ASM, que são:
1. Ganho de informação:
- O ganho de informação é a medição das mudanças na entropia após a segmentação de um conjunto de dados com base em um atributo.
- Ele calcula quanta informação um recurso nos fornece sobre uma classe.
- De acordo com o valor do ganho de informação, dividimos o nó e construímos a árvore de decisão.
- Um algoritmo de árvore de decisão sempre tenta maximizar o valor do ganho de informação, e um nó/atributo com o maior ganho de informação é dividido primeiro. Pode ser calculado usando a fórmula abaixo:
Information Gain= Entropy(S)- [(Weighted Avg) *Entropy(each feature)
Entropia: Entropia é uma métrica para medir a impureza em um determinado atributo. Ele especifica aleatoriedade nos dados. A entropia pode ser calculada como:
Entropy(s)= -P(yes)log2 P(yes)- P(no) log2 P(no)
Onde,
2. Índice de Gini:
- O índice de Gini é uma medida de impureza ou pureza usada ao criar uma árvore de decisão no algoritmo CART (Árvore de Classificação e Regressão).
- Um atributo com índice de Gini baixo deve ser preferido em comparação com o índice de Gini alto.
- Ele cria apenas divisões binárias e o algoritmo CART usa o índice de Gini para criar divisões binárias.
- O índice de Gini pode ser calculado usando a fórmula abaixo:
Gini Index= 1- ∑<sub>j</sub>P<sub>j</sub><sup>2</sup>
Poda: Obtendo uma árvore de decisão ideal
A poda é um processo de exclusão de nós desnecessários de uma árvore para obter a árvore de decisão ideal.
o que é um sistema de arquivos Linux
Uma árvore muito grande aumenta o risco de overfitting e uma árvore pequena pode não capturar todos os recursos importantes do conjunto de dados. Portanto, uma técnica que diminui o tamanho da árvore de aprendizagem sem reduzir a precisão é conhecida como Poda. Existem basicamente dois tipos de árvores poda tecnologia utilizada:
Vantagens da Árvore de Decisão
- É simples de entender, pois segue o mesmo processo que um ser humano segue ao tomar qualquer decisão na vida real.
- Pode ser muito útil para resolver problemas relacionados a decisões.
- Ajuda pensar sobre todos os resultados possíveis para um problema.
- Há menos requisitos de limpeza de dados em comparação com outros algoritmos.
Desvantagens da Árvore de Decisão
- A árvore de decisão contém muitas camadas, o que a torna complexa.
- Pode haver um problema de overfitting, que pode ser resolvido usando o Algoritmo de floresta aleatória.
- Para mais rótulos de classe, a complexidade computacional da árvore de decisão pode aumentar.
Implementação Python da árvore de decisão
Agora implementaremos a árvore de decisão usando Python. Para isso, usaremos o conjunto de dados ' dados_do_usuário.csv ,' que usamos em modelos de classificação anteriores. Usando o mesmo conjunto de dados, podemos comparar o classificador de árvore de decisão com outros modelos de classificação, como KNN SVM, Regressão Logística, etc.
As etapas também permanecerão as mesmas, fornecidas a seguir:
1. Etapa de pré-processamento de dados:
Abaixo está o código para a etapa de pré-processamento:
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
No código acima, pré-processamos os dados. Onde carregamos o conjunto de dados, que é fornecido como:
2. Ajustando um algoritmo de árvore de decisão ao conjunto de treinamento
Agora ajustaremos o modelo ao conjunto de treinamento. Para isso, importaremos o DecisionTreeClassificador aula de sklearn.tree biblioteca. Abaixo está o código para isso:
#Fitting Decision Tree classifier to the training set From sklearn.tree import DecisionTreeClassifier classifier= DecisionTreeClassifier(criterion='entropy', random_state=0) classifier.fit(x_train, y_train)
No código acima, criamos um objeto classificador, no qual passamos dois parâmetros principais;
Abaixo está a saída para isso:
diferença entre $ e $$
Out[8]: DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None, max_features=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, presort=False, random_state=0, splitter='best')
3. Prever o resultado do teste
Agora vamos prever o resultado do conjunto de testes. Criaremos um novo vetor de previsão y_pred. Abaixo está o código para isso:
#Predicting the test set result y_pred= classifier.predict(x_test)
Saída:
Na imagem de saída abaixo, a saída prevista e a saída do teste real são fornecidas. Podemos ver claramente que existem alguns valores no vetor de predição que são diferentes dos valores reais do vetor. Esses são erros de previsão.
4. Teste a precisão do resultado (matriz de criação de confusão)
Na saída acima, vimos que houve algumas previsões incorretas, portanto, se quisermos saber o número de previsões corretas e incorretas, precisamos usar a matriz de confusão. Abaixo está o código para isso:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Saída:
Na imagem de saída acima, podemos ver a matriz de confusão, que tem 6+3= 9 previsões incorretas e 62+29=91 previsões corretas. Portanto, podemos dizer que comparado a outros modelos de classificação, o classificador Árvore de Decisão fez uma boa previsão.
5. Visualizando o resultado do conjunto de treinamento:
Aqui visualizaremos o resultado do conjunto de treinamento. Para visualizar o resultado do conjunto de treinamento, traçaremos um gráfico para o classificador de árvore de decisão. O classificador irá prever sim ou Não para os usuários que compraram ou não o carro SUV, como fizemos na regressão logística. Abaixo está o código para isso:
#Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Saída:
A saída acima é completamente diferente dos demais modelos de classificação. Possui linhas verticais e horizontais que dividem o conjunto de dados de acordo com a idade e a variável salário estimado.
Como podemos ver, a árvore está tentando capturar cada conjunto de dados, o que é o caso do overfitting.
programa java
6. Visualizando o resultado do conjunto de testes:
A visualização do resultado do conjunto de teste será semelhante à visualização do conjunto de treinamento, exceto que o conjunto de treinamento será substituído pelo conjunto de teste.
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) fori, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Decision Tree Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Saída:
Como podemos ver na imagem acima, existem alguns pontos de dados verdes na região roxa e vice-versa. Portanto, essas são as previsões incorretas que discutimos na matriz de confusão.