Entendendo Classificadores de Florestas Aleatórias em Python

Se ainda não está familiarizado com Modelos Baseados em Árvores no Aprendizado Mecânico, deve dar uma vista de olhos ao nosso curso de R sobre o assunto.

O Algoritmo de Florestas Aleatórias

Vamos compreender o algoritmo em termos de leigos. Suponha que quer fazer uma viagem e gostaria de viajar para um lugar de que vai gostar.

Então o que fazer para encontrar um lugar de que vai gostar? Pode pesquisar online, ler críticas em blogs e portais de viagens, ou pode também perguntar aos seus amigos.

P>Ponhamos que decidiu perguntar aos seus amigos, e falar com eles sobre a sua experiência de viagem passada a vários lugares. Receberá algumas recomendações de todos os seus amigos. Agora tem de fazer uma lista desses lugares recomendados. Depois, pede-lhes para votar (ou seleccionar um dos melhores lugares para a viagem) a partir da lista de lugares recomendados que fez. O lugar com o maior número de votos será a sua escolha final para a viagem.

No processo de decisão acima referido, existem duas partes. Primeiro, perguntar aos seus amigos sobre a sua experiência de viagem individual e obter uma recomendação a partir de vários lugares que visitaram. Esta parte é como utilizar o algoritmo da árvore de decisão. Aqui, cada amigo faz uma selecção dos lugares que visitou até agora.

A segunda parte, depois de recolher todas as recomendações, é o procedimento de votação para seleccionar o melhor lugar na lista de recomendações. Todo este processo de obter recomendações de amigos e votar neles para encontrar o melhor lugar é conhecido como o algoritmo das florestas aleatórias.

É tecnicamente um método de conjunto (baseado na abordagem dividir e conquistar) de árvores de decisão geradas num conjunto de dados divididos aleatoriamente. Esta colecção de classificadores de árvores de decisão é também conhecida como a floresta. As árvores de decisão individuais são geradas utilizando um indicador de selecção de atributos, tal como ganho de informação, rácio de ganho, e índice de Gini para cada atributo. Cada árvore depende de uma amostra aleatória independente. Num problema de classificação, cada árvore vota e a classe mais popular é escolhida como o resultado final. Em caso de regressão, a média de todos os resultados das árvores é considerada como o resultado final. É mais simples e mais potente em comparação com outros algoritmos de classificação não-lineares.

Como funciona o algoritmo?

Funciona em quatro passos:

1. Seleccionar amostras aleatórias de um dado conjunto de dados.
2. Construir uma árvore de decisão para cada amostra e obter um resultado de previsão de cada árvore de decisão.
3. Executar um voto para cada resultado previsto.
4. Seleccionar o resultado da previsão com o maior número de votos como a previsão final.

Vantagens:

• Florestas aleatórias é considerado como um método altamente preciso e robusto devido ao número de árvores de decisão que participam no processo.
• Não sofre do problema de sobreajustamento. A principal razão é que toma a média de todas as previsões, o que anula os vieses.
• O algoritmo pode ser utilizado tanto em problemas de classificação como de regressão.
• As florestas aleatórias também podem lidar com valores em falta. Há duas maneiras de lidar com estes: utilizando valores medianos para substituir variáveis contínuas, e calculando a média próxima ponderada dos valores em falta.
• Pode obter a importância relativa das características, o que ajuda na selecção das características que mais contribuem para o classificador.

Desvantagens:

• Florestas aleatórias é lento na geração de previsões porque tem múltiplas árvores de decisão. Sempre que faz uma previsão, todas as árvores da floresta têm de fazer uma previsão para o mesmo input dado e depois realizar uma votação sobre o mesmo. Todo este processo consome muito tempo.
• O modelo é difícil de interpretar em comparação com uma árvore de decisão, onde se pode facilmente tomar uma decisão seguindo o caminho na árvore.

Encontrar características importantes

Florestas aleatórias também oferece um bom indicador de selecção de características. Scikit-learn fornece uma variável extra com o modelo, que mostra a importância relativa ou contribuição de cada característica na previsão. Calcula automaticamente a pontuação de relevância de cada característica na fase de formação. Em seguida, escala a relevância para baixo para que a soma de todas as pontuações seja 1,

Esta pontuação irá ajudá-lo a escolher as características mais importantes e a largar as menos importantes para a construção do modelo.

Florestas aleatórias utilizam a importância do gini ou a diminuição média da impureza (MDI) para calcular a importância de cada característica. A importância do gini é também conhecida como a diminuição total da impureza do nó. Isto é o quanto o modelo se ajusta ou a precisão diminui quando se deixa cair uma variável. Quanto maior for o decréscimo, mais significativa é a variável. Aqui, o decréscimo médio é um parâmetro significativo para a selecção da variável. O índice de Gini pode descrever o poder explicativo global das variáveis.

Florestas aleatórias vs Árvores de decisão

• Florestas aleatórias é um conjunto de árvores de decisão múltipla.
• As árvores de decisão aleatória podem sofrer de sobreajustamento, mas as florestas aleatórias previnem o sobreajustamento criando árvores em subconjuntos aleatórios.
• As árvores de decisão são computacionalmente mais rápidas.
• As florestas aleatórias são difíceis de interpretar, enquanto que uma árvore de decisão é facilmente interpretável e pode ser convertida em regras.

Construir um Classificador usando Scikit-learn

Vais construir um modelo no conjunto de dados de flores da íris, que é um conjunto de classificação muito famoso. Compreende o comprimento da sépala, largura da sépala, comprimento das pétalas, largura das pétalas, e tipo de flores. Existem três espécies ou classes: setosa, versicolor, e virgínia. Constrói-se um modelo para classificar o tipo de flor. O conjunto de dados está disponível na biblioteca scikit-learn, ou pode descarregá-lo do Repositório de Aprendizagem da Máquina UCI.

p>Iniciar importando a biblioteca de conjuntos de dados de scikit-learn, e carregar o conjunto de dados da íris comload_iris().

#Import scikit-learn dataset libraryfrom sklearn import datasets#Load datasetiris = datasets.load_iris()

Pode imprimir o alvo e os nomes das características, para se certificar de que tem o conjunto de dados correcto, como tal:

# print the label species(setosa, versicolor,virginica)print(iris.target_names)# print the names of the four featuresprint(iris.feature_names)

É uma boa ideia explorar sempre um pouco os seus dados, para que saiba com o que está a trabalhar. Aqui, pode ver as primeiras cinco linhas do conjunto de dados impressas, assim como a variável alvo para todo o conjunto de dados.

# print the iris data (top 5 records)print(iris.data)# print the iris labels (0:setosa, 1:versicolor, 2:virginica)print(iris.target)

 ]

Aqui, pode criar uma DataFrame do conjunto de dados da íris da seguinte forma.

# Creating a DataFrame of given iris dataset.import pandas as pddata=pd.DataFrame({ 'sepal length':iris.data, 'sepal width':iris.data, 'petal length':iris.data, 'petal width':iris.data, 'species':iris.target})data.head()

First, separa-se as colunas em variáveis dependentes e independentes (ou características e rótulos). Em seguida, divide essas variáveis num conjunto de treino e teste.

# Import train_test_split functionfrom sklearn.model_selection import train_test_splitX=data] # Featuresy=data # Labels# Split dataset into training set and test setX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) # 70% training and 30% test

Após a divisão, irá treinar o modelo no conjunto de treino e realizar previsões no conjunto de teste.

#Import Random Forest Modelfrom sklearn.ensemble import RandomForestClassifier#Create a Gaussian Classifierclf=RandomForestClassifier(n_estimators=100)#Train the model using the training sets y_pred=clf.predict(X_test)clf.fit(X_train,y_train)y_pred=clf.predict(X_test)

Após o treino, verificar a precisão utilizando valores reais e previstos.

#Import scikit-learn metrics module for accuracy calculationfrom sklearn import metrics# Model Accuracy, how often is the classifier correct?print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

('Accuracy:', 0.93333333333333335)

Também se pode fazer uma previsão para um único item, por exemplo:

• comprimento do pé = 3
• largura do pé = 5
• comprimento do pé = 4
• largura do pé = 2

Agora é possível prever que tipo de flor é.

clf.predict(])

array()

Aqui, 2 indica o tipo de flor Virginica.

Finding Important Features in Scikit-learn

Aqui, está a encontrar características importantes ou a seleccionar características no conjunto de dados IRIS. Em scikit-learn, pode realizar esta tarefa nos seguintes passos:

• Primeiro, precisa de criar um modelo de florestas aleatórias.
• Segundo, use a variável de importância de características para ver as pontuações de importância de características.
• Terceiro, visualize estas pontuações usando a biblioteca do mar.

from sklearn.ensemble import RandomForestClassifier#Create a Gaussian Classifierclf=RandomForestClassifier(n_estimators=100)#Train the model using the training sets y_pred=clf.predict(X_test)clf.fit(X_train,y_train)

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini', max_depth=None, max_features='auto', 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, n_estimators=100, n_jobs=1, oob_score=False, random_state=None, verbose=0, warm_start=False)

import pandas as pdfeature_imp = pd.Series(clf.feature_importances_,index=iris.feature_names).sort_values(ascending=False)feature_imp

petal width (cm) 0.458607petal length (cm) 0.413859sepal length (cm) 0.103600sepal width (cm) 0.023933dtype: float64

P>Pode também visualizar a importância da característica. As visualizações são fáceis de compreender e interpretáveis.

Para a visualização, pode usar uma combinação de matplotlib e seaborn. Uma vez que o seaborn é construído em cima da matplotlib, oferece uma série de temas personalizados e fornece tipos de parcelas adicionais. O matplotlib é um super conjunto de seabornos e ambos são igualmente importantes para boas visualizações.

import matplotlib.pyplot as pltimport seaborn as sns%matplotlib inline# Creating a bar plotsns.barplot(x=feature_imp, y=feature_imp.index)# Add labels to your graphplt.xlabel('Feature Importance Score')plt.ylabel('Features')plt.title("Visualizing Important Features")plt.legend()plt.show()

Gerar o modelo em características seleccionadas

Aqui, pode remover a característica “largura sépala” porque tem uma importância muito baixa, e seleccionar as 3 características restantes.

# Import train_test_split functionfrom sklearn.cross_validation import train_test_split# Split dataset into features and labelsX=data] # Removed feature "sepal length"y=data # Split dataset into training set and test setX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.70, random_state=5) # 70% training and 30% test

Após a divisão, será gerado um modelo sobre as características seleccionadas do conjunto de treino, serão feitas previsões sobre as características seleccionadas do conjunto de teste, e comparar-se-ão os valores reais e previstos.

from sklearn.ensemble import RandomForestClassifier#Create a Gaussian Classifierclf=RandomForestClassifier(n_estimators=100)#Train the model using the training sets y_pred=clf.predict(X_test)clf.fit(X_train,y_train)# prediction on test sety_pred=clf.predict(X_test)#Import scikit-learn metrics module for accuracy calculationfrom sklearn import metrics# Model Accuracy, how often is the classifier correct?print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

('Accuracy:', 0.95238095238095233)

Vê-se que depois de remover as características menos importantes (comprimento sépala), a precisão aumentou. Isto deve-se ao facto de ter removido dados e ruído enganadores, resultando numa maior exactidão. Uma menor quantidade de características também reduz o tempo de treino.

Conclusão

Congratulações, chegou ao fim deste tutorial!

Neste tutorial, aprendeu o que são florestas aleatórias, como funciona, encontrando características importantes, a comparação entre florestas aleatórias e árvores de decisão, vantagens e desvantagens. Aprendeu também a construir modelos, a avaliar e a encontrar características importantes em scikit-learn. B

Se quiser aprender mais sobre a aprendizagem de máquinas, recomendo que dê uma vista de olhos à nossa aprendizagem supervisionada em R: Curso de classificação.