Aprenda a classificação de árvore de decisão no Python

A partir deste capítulo, entramos na aprendizagem formal do algoritmo.

Primeiro, aprendemos o algoritmo de classificação eficaz e clássico: algoritmo de classificação de árvore de decisão.

1、algoritmo de árvore de decisão

A árvore de decisão usa a estrutura de árvore para classificar as propriedades das amostras, é o algoritmo de classificação mais intuitivo e também pode ser usado para regressão. No entanto, para algumas classificações lógicas especiais, pode haver dificuldades. Exemplos típicos incluem a lógica XOR, a árvore de decisão não é boa em resolver tais problemas.
A construção da árvore de decisão não é única, lamentavelmente, a construção da árvore de decisão ótima é um problema NP. Portanto, como construir uma árvore de decisão boa é o ponto focal da pesquisa.
J. Ross Quinlan no1975introduziu o conceito de entropia na construção da árvore de decisão, que é o famoso ID3algoritmo. Posteriormente, o C4.5, C5.0, CART e outros são melhorias para este método.

A entropia é o grau de 'desordem' e 'confusão'. Pode ser confuso ao primeiro contato com este conceito. Para entender rapidamente como usar o ganho de entropia para dividir propriedades, você pode referir-se ao artigo deste irmão: Algoritmo de árvore de decisão de aprendizado de máquina Python

Se ainda não entender, veja o exemplo a seguir.

Supondo que você precise construir uma árvore de decisão automática para escolher boas maçãs, para simplificar, deixarei que ele aprenda apenas o seguinte:4amostras:
Amostra　　Vermelha　　Grande　　Boa maçã　
0　　　　　　　 　1　　　　　　　 1　　　　　　　　 1　
1　　　　　　　 　1　　　　　　 　0　　　　　　　　 1　
2　　　　　　 　 0　　　　　 　 1　　　　　　　　 0　
3　　　　　　 　 0　　0　　0　

A amostra tem2propriedades, A0 representa se é uma maçã vermelha. A1representa se é uma maçã grande.

Portanto, a entropia da amostra antes da classificação é S = -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1.

A entropia é1representa o estado mais caótico e desorganizado atual.

Este exemplo apenas2propriedades. Portanto, naturalmente, pode haver apenas2árvores de decisão, conforme mostrado na figura a seguir:

Claramente, a árvore de decisão que usa A0 (vermelho) como critério de divisão no lado esquerdo é superior à árvore de decisão que usa A1A árvore de decisão baseada no critério de divisão (tamanho).
Claro, isso é uma percepção intuitiva. Para uma avaliação quantitativa, é necessário calcular o ganho de entropia de cada situação de divisão.
Primeiro, escolha A0 para a divisão, e a cálculo da entropia de cada sub-nó é conforme follows:
0,1Os nós folha têm2exemplos positivos, 0 exemplos negativos. A entropia é: e1 = -(2/2 * log(2/2) + 0/2 * log(0/2)) = 0。
2,3Os nós folha têm 0 exemplos positivos,2exemplos negativos. A entropia é: e2 = -(0/2 * log(0/2) + 2/2 * log(2/2)) = 0。

Portanto, a escolha da entropia de A0 após a divisão é a ponderação ponderada da proporcionalidade da entropia de cada sub-nó: E = e1*2/4 + e2*2/4 = 0。
Escolher A0 para dividir a增益 de entropia de informação G(S, A0) = S - E = 1 - 0 = 1.

Na verdade, os nós folha da árvore de decisão representam que todos pertencem à mesma classe, portanto, a entropia é sempre 0.

Da mesma forma, se escolher A1faz a divisão, e a entropia de cada nó subordinado é calculada conforme abaixo:
0,2os nós subordinados têm1exemplos positivos,1exemplos negativos. A entropia é: e1 = -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1.
1,3os nós subordinados têm1exemplos positivos,1exemplos negativos. A entropia é: e2 = -(1/2 * log(1/2) + 1/2 * log(1/2)) = 1.
Portanto, escolher A1A entropia da divisão após a divisão é o peso proporcional da entropia de cada nó subordinado somado: E = e1*2/4 + e2*2/4 = 1. Isso é como dividir e não dividir!
Escolher A1G(S, A) = S1）=S - E = 1 - 1 = 0.
Portanto, antes de cada divisão, precisamos calcular a divisão que maximiza a增益 de entropia de informação.

2Conjunto de dados

Para facilitar a explicação e compreensão, usamos um conjunto de dados de teste extremamente simples:
1.5 50 magro　
1.5 60 gordo　
1.6 40 magro　
1.6 60 gordo　
1.7 60 magro　
1.7 80 gordo　
1.8 60 magro　
1.8 90 gordo　
1.9 70 magro　
1.9 80 gordo　

Este conjunto de dados tem10exemplos, cada exemplo tem2características, respectivamente altura e peso, a terceira coluna é o rótulo de classe, representando 'gordo' ou 'magro'. Os dados são armazenados em1.txt.

Nossa tarefa é treinar um classificador de árvore de decisão, que, ao receber altura e peso, pode classificar se a pessoa é gorda ou magra.
(Os dados são uma especulação subjetiva do autor, com um certo lógico, mas ignore sua razoabilidade)

A árvore de decisão é bastante natural para a ramificação lógica binária de 'sim' ou 'não'. E no conjunto de dados deste exemplo, o que fazer com valores contínuos de altura e peso?

Embora um pouco complicado, isso não é um problema. Basta encontrar o ponto intermediário que divide esses valores contínuos em intervalos diferentes, e torna-se um problema lógico binário.
A tarefa do exemplo de árvore de decisão é encontrar alguns valores críticos de altura e peso, classificar os exemplos de acordo com a lógica maior ou menor que esses valores críticos, e construir a árvore de decisão de forma top-down.

Usar bibliotecas de aprendizado de máquina do Python, é bastante simples e elegante.

3Implementação em Python

Implementação em Python如下：

# -*- coding: utf-8 -*- 
import numpy como np 
import scipy como sp 
from sklearn import tree 
from sklearn.metrics import precision_recall_curve 
from sklearn.metrics import classification_report 
from sklearn.cross_validation import train_test_split 
''' Dados de leitura ''' 
data  = [] 
labels = [] 
com open("data\\1.txt) como ifile: 
    for line in ifile: 
      tokens = line.strip().split(' ') 
      data.append([float(tk) for tk in tokens[:-1]) 
      labels.append(tokens[-1] 
x = np.array(data) 
labels = np.array(labels) 
y = np.zeros(labels.shape) 
''''' 标签转换为0 '''/1 ''' 
y[labels=='gordo'] =1 
''''' 拆分训练数据与测试数据 ''' 
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.2) 
''''' 使用信息熵作为划分标准，对决策树进行训练 ''' 
clf = tree.DecisionTreeClassifier(criterion='entropy') 
print(clf) 
clf.fit(x_train, y_train) 
''''' 把决策树结构写入文件 ''' 
with open("tree.dot", 'w') as f: 
  f = tree.export_graphviz(clf, out_file=f) 
''''' 系数反映每个特征的影响力。越大表示该特征在分类中起到的作用越大 ''' 
print(clf.feature_importances_) 
'''''测试结果的打印''' 
answer = clf.predict(x_train) 
print(x_train) 
print(answer) 
print(y_train) 
print(np.mean(answer == y_train)) 
'''''准确率与召回率''' 
precision, recall, thresholds = precision_recall_curve(y_train, clf.predict(x_train)) 
answer = clf.predict_proba(x)[:1] 
print(classification_report(y, answer, target_names = ['magro', 'gordo'])) 

os resultados de saída são semelhantes aos seguintes:}
[ 0.2488562　 0.7511438]
array([[　 1.6,　 60. ],
　　　　　　 [　 1.7,　 60. ],
　　　　　　 [　 1.9,　 80. ],
　　　　　　 [　 1.5,　 50. ],
　　　　　　 [　 1.6,　 40. ],
　　　　　　 [　 1.7,　 80. ],
　　　　　　 [　 1.8,　 90. ],
　　　　　　 [　 1.5,　 60. ])
array([ 1.])　 1, 0., 0.,　 1,　 1,　 1taxa de precisão de thin é 0.
array([ 1.])　 1, 0., 0.,　 1,　 1,　 1taxa de precisão de thin é 0.
1.0
　　　　　　　　　　　　 precision　　　 recall　 f1-score　　 suporte
　　　　　　 thin　　　　　　 0.83　　　　　 1.00　　　　　 0.91　　　　　　　　 5
　　　　　　　 fat　　　　　　　 1.00　　　　　 0.80　　　　　 0.89　　　　　　　　 5
avg / total　　　　　　 1.00　　　　　 1.00　　　　　 1.00　　　　　　　　 8
array([ 0.,　 1.])　 1.])　 1.])　 1. 0., 0.])
array([ 0.,　 1.])　 1.])　 1.])　 1.])　 1taxa de precisão de thin é 0.

pode ver que a precisão da classificação dos dados treinados é100%. No entanto, ao testar todos os dados no final,会出现1amostras de teste foram classificadas incorretamente.
isso mostra que a árvore de decisão deste exemplo absorveu bem as regras do conjunto de treinamento, mas a predição é um pouco fraca.
há3pontos precisam ser mencionados, o que será usado em aprendizado de máquina posterior.

1e divisão dos dados de treinamento e teste.

Fazemos isso para facilitar a validação cruzada. A validação cruzada é usada para testar a estabilidade do classificador.
no código é 0.2representa a escolha aleatória20% dos dados foram usados como teste. O resto80% foram usados para treinar a árvore de decisão.
isto é,10amostras foram escolhidas aleatoriamente8treinamentos. Este conjunto de dados é pequeno, e o objetivo aqui é mostrar que, devido à escolha aleatória dos dados de treinamento, cada árvore de decisão construída é diferente.

2e diferentes fatores de influência das características.

A influência do peso das diferentes características dos amostras na classificação pode variar muito. Verificar a influência de cada amostra na classificação após a classificação também é muito importante.
Neste exemplo, o peso da altura é 0.25o peso é 0.75pode ver que a importância do peso é muito maior do que a da altura. Para a classificação de gordo e magro, isso também é logicamente correto.

3e precisão e taxa de recuperação.

este2um valor é um importante critério de avaliação da precisão da classificação. Por exemplo, no código final, todos10resultados de classificação de
resultados do teste: array([ 0.,　 1.])　 1.])　 1.])　 1. 0., 0.])
, 0.,　 1.])　 1.])　 1.])　 1.])　 1taxa de precisão de thin é 0.
. Isso é porque o classificador classificou83corretos6um thin, dos quais5um thin, dos quais5/6=0.83.
taxa de recuperação de thin é1.00. Isso é porque há5um thin, enquanto o classificador os classificou corretamente (apesar de dividir um fat em thin!), taxa de recuperação5/5=1.
taxa de precisão de fat é1.00. Não há mais o que dizer.
taxa de recuperação de fat é 0.80. Isso é porque há5fat, enquanto o classificador classificou apenas4um (dividiu um fat em thin!), taxa de recuperação4/5=0.80。
Muitas vezes, especialmente em situações de classificação de dados difíceis, a precisão e o recall frequentemente entram em conflito. Você pode precisar encontrar o melhor equilíbrio de acordo com suas necessidades.
Por exemplo, neste exemplo, seu objetivo é garantir que os gordos encontrados sejam realmente gordos (precisão) ou garantir que sejam encontrados tantos gordos quanto possível (recall).

O código também escreve a estrutura da árvore de decisão no tree.dot. Abra o arquivo, é fácil desenhar a árvore de decisão e ver mais informações de classificação da árvore de decisão.
O tree.dot deste artigo é como follows:

digraph Tree { 
0 [label="X[1] <= 55.0000\nentropy = 0.954434002925
samples = 8", shape="box"] ; 
1 [label="entropy = 0.0000\nsamples = 2
value = [ 2. 0.]", shape="box"] ; 
0 -> 1 ; 
2 [label="X[1] <= 70.0000\nentropy = 0.650022421648
samples = 6", shape="box"] ; 
0 -> 2 ; 
3 [label="X[0] <= 1.6500\nentropy = 0.918295834054
samples = 3", shape="box"] ; 
2 -> 3 ; 
4 [label="entropy = 0.0000\nsamples = 2
value = [ 0. 2]. shape="box"] ; 
3 -> 4 ; 
5 [label="entropy = 0.0000\nsamples = 1
value = [ 1. 0.]", shape="box"] ; 
3 -> 5 ; 
6 [label="entropy = 0.0000\nsamples = 3
value = [ 0. 3]. shape="box"] ; 
2 -> 6 ; 
} 

De acordo com essa informação, a árvore de decisão deve ser assim:

Isso é tudo o que há no artigo, espero que ajude no seu aprendizado e que você apóie o tutorial Yell.

Declaração: o conteúdo deste artigo é de origem na internet, pertence ao respectivo proprietário, é contribuído e carregado voluntariamente pelos usuários da internet, este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidade legal relevante. Se você encontrar conteúdo suspeito de infringência de direitos autorais, bem-vindo a enviar e-mail para: notice#oldtoolbag.com (ao enviar e-mail, substitua # por @ para denunciar, forneça provas relacionadas e, se confirmado, o site deletará imediatamente o conteúdo suspeito de infringência).