Floresta aleatória em código com Scikit-learn

Posts Relacionados:

Conjuntos de treinamento e teste em machine learning

Árvore de decisão em machine learning

Scikit-learn – a melhor escolha para machine learning

16.07.24

Floresta aleatória combina várias árvores de decisão para fazer previsões em machine learning com excelente precisão. Aprenda como implementá-la facilmente com Scikit-learn.

Receba nossa newsletter

Floresta aleatória para uma tarefa de classificação

Floresta aleatória é um algoritmo excelente de machine learning com inúmeras aplicações importantes. Uma floresta aleatória combina múltiplas árvores de decisão para obter predições precisas. Mas essa não é a única vantagem das florestas aleatórias. Florestas aleatórias são simples de implementar, costumam ter execução rápida em comparação a outras técnicas como redes neurais e não precisam de ajustes extensos de hiperparâmetros. Elas também conseguem informar quais características de um conjunto de dados são mais importantes para gerar uma classificação. Essa interpretabilidade torna esse algoritmo bastante atraente para projetos em produção, onde é importante explicar para clientes ou usuários como o algoritmo realiza decisões.

Em código, florestas aleatórias são facilmente implementadas com a biblioteca Scikit-learn, como será ilustrado nesse post.

O Conjunto de Dados

Usaremos um conjunto de dados retirados daqui. Para acompanhar o post, baixe os dados e descompacte o arquivo. O conjunto de dados contém informações retiradas de imagens de 13.611 grãos de 7 diferentes feijões. Cada tipo de grão possui um total de 16 recursos. Portanto, esse é um problema de classificação envolvendo múltiplas classes.

Início do Código

Para criar nosso classificador, num código Python, importamos os pacotes que serão usados. Além da biblioteca Scikit-learn usaremos Pandas e NumPy.

				
					import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import LabelEncoder, MinMaxScaler

Em seguida, abrimos os dados:

				
					filename = 'LOCAL_DOS_SEUS_DADOS/Dry_Bean_Dataset.xlsx'
df = pd.read_excel(filename)

A criação dos conjuntos de atributos (X) e rótulos (y_init) é o passo seguinte:

				
					cols = df.columns
X = cols[0:-1]
y_init = cols[-1]

Pré-Processamento

Os atributos do conjunto de dados não possuem dados categóricos. Todos os atributos são numéricos. Portanto, o pré-processamento que faremos será uma normalização simples.

				
					scaler = MinMaxScaler()
X = np.reshape(X, (X.shape[0], 1))
X = np.squeeze(X)

Depois, fazemos uma randomização dos dados usando Pandas e NumPy. Isso garante uma boa distribuição dos dados para o treinamento.

				
					dfNorm = pd.DataFrame(df)
indices = np.array(dfNorm.index)
np.random.shuffle(indices) 
X = dfNorm.reindex(indices)[X]
y_init = dfNorm.reindex(indices)[y_init]
y_init = np.array(y_init).astype(object)

Também precisamos converter os rótulos para valores numéricos e garantir que o conjunto X contendo os atributos esteja no formato correto.

				
					le = LabelEncoder()
y = le.fit_transform(y_init)

X = np.array(X).astype(np.float32)

Conjuntos de Treinamento e Teste

A etapa seguinte é separar os dados em conjuntos de treinamento e conjuntos de testes, o que é feito com o auxílio da biblioteca Scikit-learn.

				
					X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Definição do Classificador

O classificador que utilizaremos, obviamente, será uma floresta aleatória. Ele é inicializado com o comando mostrado abaixo:

				
					rf_classifier = RandomForestClassifier(n_estimators=100)

Neste trecho, definimos nossa floresta aleatória contendo 100 modelos estimadores. Leia mais sobre isso aqui ou na documentação oficial do Scikit-learn. A documentação oficial conta também com uma lista de parâmetros opcionais que podem ser usados.

Treinamento e Validação

As últimas etapas da implementação do modelo consistem em seu treinamento e validação. O treinamento é feito com o comando mostrado abaixo.

				
					rf_classifier.fit(X_train, y_train)

Para a validação do modelo implementado, usamos os conjuntos de teste para calcular sua acurácia.

				
					y_pred = rf_classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Precisão: {accuracy:.2f}")
# Resultado: Precisão: 0.93

Nosso modelo tem acurácia em torno de 0.93 (esse resultado pode variar devido à aleatoriedade da implementação), evidenciando o excelente desempenho da floresta aleatória. Evidentemente, esse resultado pode subir ainda mais com um ajuste mais aprofundado de hiperparâmetros usando, por exemplo, grid search.

Interpretabilidade

Para terminar, exploraremos um pouco a capacidade do algoritmo floresta aleatória de apontar quais atributos ele definiu como mais importantes para gerar suas predições. Isso é feito como mostrado abaixo.

				
					feature_importance = rf_classifier.feature_importances_
for i, importance in enumerate(feature_importance):
    print(f"Feature {i+1} importance: {importance:.4f}")

# Resultados:
# Feature 1 importance: 0.0641
# Feature 2 importance: 0.0888
# Feature 3 importance: 0.0786
# Feature 4 importance: 0.0784
# Feature 5 importance: 0.0655
# Feature 6 importance: 0.0565
# Feature 7 importance: 0.0724
# Feature 8 importance: 0.0601
# Feature 9 importance: 0.0111
# Feature 10 importance: 0.0191
# Feature 11 importance: 0.0559
# Feature 12 importance: 0.0969
# Feature 13 importance: 0.0904
# Feature 14 importance: 0.0345
# Feature 15 importance: 0.0958
# Feature 16 importance: 0.0321

Como mostrado acima, o algoritmo da floresta aleatória do Scikit-learn indica a importância de cada atributo para suas predições. Com essa informação, o algoritmo fica mais interpretável, o que o torna particularmente atraente para ser usado em produção. Melhor ainda, esses dados são facilmente plotados com Matplotlib, tornando sua interpretação ainda mais evidente.

				
					import matplotlib.pyplot as plt

escala = np.arange(1, 17)
plt.subplot(1,1,1)
plt.bar(escala, feature_importance, color="cornflowerblue")
plt.ylabel('Importance')
plt.xlabel('Feature')
plt.show()

Na figura acima, fica bastante evidente quais atributos são mais ou menos importantes para as previsões do modelo treinado. Isso permite que possíveis clientes utilizem os resultados do modelo para fazer decisões informadas.