Classificação com Random Forest
O algoritmo Random Forest (Floresta Aleatória) é um poderoso método de aprendizado de máquina que é usado principalmente para tarefas de classificação e regressão. Ele é uma extensão do algoritmo de árvore de decisão e é conhecido por sua capacidade de lidar com uma variedade de problemas de forma robusta e eficaz. A ideia central por trás do Random Forest é combinar várias árvores de decisão individuais para criar um modelo mais robusto e preciso.
⚙️Funcionamento do Random Forest
📌Votação por Maioria: Quando você deseja fazer uma previsão com um modelo Random Forest, cada árvore na floresta faz sua própria previsão com base nos dados de entrada. Em um problema de classificação, cada árvore vota na classe mais provável, e em um problema de regressão, cada árvore faz uma previsão numérica. A previsão final do Random Forest é determinada pela votação por maioria (no caso da classificação) ou pela média das previsões (no caso da regressão) de todas as árvores.
📌Redução da Variância e Overfitting: Uma das principais vantagens do Random Forest é sua capacidade de reduzir a variância e combater o overfitting. Como as árvores são treinadas com diferentes subconjuntos de dados e características, elas tendem a ser menos suscetíveis a ajustar-se demais ao conjunto de treinamento. A combinação de várias árvores ajuda a suavizar as previsões e a produzir um modelo mais estável e geral.
🤖Previsão com Random Forest
1) Importação das bibliotecas necessárias e dos dados:
# Importação das bibliotecas import pandas as pd from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from sklearn.metrics import confusion_matrix from sklearn.ensemble import RandomForestClassifier # importação do dataset dataset = pd.read_csv('../Data/credit-approval.csv') dataset
➜ Nosso dataset possui 16 colunas, sendo 15 atributos e 1 classe, Para entender mais sobre o dataset, segue o link: Dataset
2) Verificando se há dados nulos:
dataset.isnull().sum()
Saída:
A1 12 A2 12 A3 0 A4 6 A5 6 A6 9 A7 9 A8 0 A9 0 A10 0 A11 0 A12 0 A13 0 A14 13 A15 0 class 0 dtype: int64
➜ O dataset possui dados nulos(NaN).
➜ É preciso remover os dados nulos, pois o algoritmo random forest não suporta o mesmo.
2.1) removendo os valores nulos:
# Apagando linhas com NaN dataset = dataset.dropna() dataset.isnull().sum()
Saída:
A1 0 A2 0 A3 0 A4 0 A5 0 A6 0 A7 0 A8 0 A9 0 A10 0 A11 0 A12 0 A13 0 A14 0 A15 0 class 0 dtype: int64
3) Criação das variáveis previsores e classe:
# Criação dos previsores e da classe previsores = dataset.iloc[:,0:15].values classe = dataset.iloc[:,15].values
➜ Previsores são os valores que usaremos para treinar o modelo.
➜ Classe é o valor que iremos classificar, 1 e 0. Crédito aprovado ou Não aprovado respectivamente.
4) Codificando os valores categóricos:
# Transformação dos atributos categóricos em atributos numéricos, passando o índice de cada atributo categórico labelencoder = LabelEncoder() previsores[:,0] = labelencoder.fit_transform(previsores[:,0]) previsores[:,3] = labelencoder.fit_transform(previsores[:,3]) previsores[:, 4] = labelencoder.fit_transform(previsores[:, 4]) previsores[:, 5] = labelencoder.fit_transform(previsores[:, 5]) previsores[:, 6] = labelencoder.fit_transform(previsores[:, 6]) previsores[:, 8] = labelencoder.fit_transform(previsores[:, 8]) previsores[:, 9] = labelencoder.fit_transform(previsores[:, 9]) previsores[:, 11] = labelencoder.fit_transform(previsores[:, 11]) previsores[:, 12] = labelencoder.fit_transform(previsores[:, 12]) # Transformação da classe em atributo numérico classe = labelencoder.fit_transform(classe)
➜ Alguns algoritmos não suportam valores categóricos, como é o caso do random forest
➜ Nossa classe também é categórica por isso também vamos codifica-la.
5) Divisão dos nossos dados em treino e teste no modelo Hold-Out:
# Divisão da base de dados entre treinamento e teste (30% para testar e 70% para treinar) X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(previsores, classe, test_size = 0.3, random_state = 0)
➜ Text_size = 0.3 significa que 30% dos dados serão usados para teste.
6) Criação e treinamento do modelo:
# Criação do modelo e treinamento # Funciona por meio de votação, ou seja, a classe que tiver mais votos é a classe que o modelo vai escolher floresta = RandomForestClassifier(n_estimators = 100) floresta.fit(X_treinamento, y_treinamento)
➜ n_estimators = Número de árvores que serão criadas.
7) Previsão:
previsoes = floresta.predict(X_teste) previsoes
Saída:
array([0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0])
8) Criando um array com os valores percentuais de ocorrência do valor 1(True):
# Os valores percentuais da previsão # predict_proba retorna a probabilidade de cada classe, o primeiro valor é a probabilidade de ser 0 e o segundo de ser 1 previsoes_percent = floresta.predict_proba(X_teste) # As probabilidades de 1, usaremos para a função ROC previsoes_percent = previsoes_percent[:,1] previsoes_percent
Saída:
array([0.22, 0.23, 0.07, 0.76, 0.51, 0.06, 0.91, 0.23, 0.87, 0.18, 0.1 , 0.9 , 0.96, 0.01, 0.49, 0.88, 0.02, 0.43, 0.93, 0.2 , 0.99, 1. , 0.97, 0.92, 0.82, 0.86, 0.94, 0.54, 0.53, 0.81, 0.76, 0.39, 0.88, 0.91, 0.16, 0.86, 0.93, 0.99, 0.82, 0.92, 0.2 , 0.44, 0.8 , 0.96, 0.85, 0.85, 0.52, 0.97, 0.78, 0.07, 0.07, 0.75, 0.19, 0.62, 0.46, 0.01, 0.95, 0.36, 0.05, 0.26, 0.95, 0.49, 0.86, 0.1 , 0.78, 0.29, 0.85, 0.41, 0.68, 0.98, 0.71, 0.48, 0.91, 0.06, 0.53, 0.91, 0.97, 0.12, 0.19, 0.87, 0.38, 0.15, 0.9 , 0.06, 0.93, 0.93, 0.86, 0.93, 0.77, 0.1 , 0.1 , 0.65, 0.12, 0.06, 0.98, 0.42, 0.98, 0.03, 0.92, 0.27, 0.02, 0.87, 0.99, 0.1 , 0.3 , 0.84, 0.04, 0.04, 1. , 0.04, 0.14, 0.94, 0.64, 0.17, 0.72, 0.81, 0.01, 0.68, 0.55, 0.96, 0.96, 0.86, 1. , 0.91, 0.04, 0.77, 0.12, 0.28, 0.13, 0.05, 0.48, 0.88, 0.98, 0.11, 0.88, 0.21, 0.11, 0.56, 0.81, 0.84, 0.21, 0.11, 0.88, 0.74, 0.21, 0.87, 0.33, 0.47, 0.49, 0.81, 0.99, 0.09, 0.95, 0.1 , 0.89, 0.88, 0.22, 0.21, 0.23, 0.37, 0.97, 0.97, 0.09, 0.25, 0.78, 0.96, 0.02, 0.72, 0.49, 0.94, 0.87, 0.09, 0.76, 0.97, 0.23, 0.18, 0.99, 0.34, 0.02, 0.86, 0.55, 0.93, 0.41, 0.84, 0.14, 0.92, 0.78, 0.71, 0.41, 0.13, 0.11, 0.03, 0.98, 0.78, 0.49, 0.19])
➜ Será usado como parâmetro da métrica ROC.
📊Avaliando o Modelo
1) Matriz de confusão:
# Matriz de confusão matriz_confusao = confusion_matrix(y_teste, previsoes) matriz_confusao
Saída:
array([[79, 8], [10, 99]], dtype=int64)
➜ A Matriz demonstra um ótimo desempenho do nosso modelo.
➜ A partir da matriz de confusão podemos gerar outras métricas.
2) Métricas de avaliação
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix # Acurácia accuracy = accuracy_score(y_teste, previsoes) print("Acurácia:", accuracy) # Precisão precision = precision_score(y_teste, previsoes) print("Precisão:", precision) # Recall recall = recall_score(y_teste, previsoes) print("Recall:", recall) # Especificidade. tn, fp, fn, tp = confusion_matrix(y_teste, previsoes).ravel() specificity = tn / (tn + fp) print("Especificidade:", specificity) # F1 Score f1 = f1_score(y_teste, previsoes) print("F1 Score:", f1) # ROC AUC Score (necessita das probabilidades de classe em vez de previsões). # Para calcular a ROC AUC é necessário passar a probabilidade de ser 1. roc_auc = roc_auc_score(y_teste, previsoes_percent) print("ROC AUC Score:", roc_auc)
Saída:
Acurácia: 0.9081632653061225 Precisão: 0.9252336448598131 Recall: 0.908256880733945 Especificidade: 0.9080459770114943 F1 Score: 0.9166666666666666 ROC AUC Score: 0.9570810924812823
➜ A acurácia mostra um grande percentual de acertos!
➜ O F1 Score demonstra que há um equilíbrio entre a Precisão e o Recall.
➜ A métrica ROC varia entre 0 e 1 e quanto mais próximo de 1 melhor será o modelo.
📄 Segue o link para acessar o código na integra: Código
Comentários
Postar um comentário