Random Forest é um algoritmo popular de aprendizado de máquina que pertence à técnica de aprendizado supervisionado. Ele pode ser usado para problemas de classificação e regressão em ML. É baseado no conceito de aprendizagem em conjunto, que é um processo de combinar vários classificadores para resolver um problema complexo e melhorar o desempenho do modelo.

Como o nome sugere, 'Random Forest é um classificador que contém uma série de árvores de decisão em vários subconjuntos de um determinado conjunto de dados e calcula a média para melhorar a precisão preditiva desse conjunto de dados.' Em vez de depender de uma árvore de decisão, a floresta aleatória pega a previsão de cada árvore e com base na maioria dos votos das previsões, e prevê o resultado final.

O maior número de árvores na floresta leva a uma maior precisão e evita o problema de overfitting.

bash se condição

O diagrama abaixo explica o funcionamento do algoritmo Random Forest:

Nota: Para entender melhor o Algoritmo Random Forest, você deve ter conhecimento do Algoritmo Árvore de Decisão.

Suposições para Floresta Aleatória

Como a floresta aleatória combina múltiplas árvores para prever a classe do conjunto de dados, é possível que algumas árvores de decisão prevejam a saída correta, enquanto outras não. Mas juntas, todas as árvores predizem o resultado correto. Portanto, abaixo estão duas suposições para um melhor classificador de floresta aleatória:

• Deve haver alguns valores reais na variável de recurso do conjunto de dados para que o classificador possa prever resultados precisos em vez de um resultado adivinhado.
• As previsões de cada árvore devem ter correlações muito baixas.

Por que usar a Floresta Aleatória?

Abaixo estão alguns pontos que explicam porque devemos usar o algoritmo Random Forest:

• Leva menos tempo de treinamento em comparação com outros algoritmos.
• Ele prevê a saída com alta precisão, mesmo para o grande conjunto de dados que executa com eficiência.
• Ele também pode manter a precisão quando uma grande proporção de dados estiver faltando.

Como funciona o algoritmo Random Forest?

A Random Forest funciona em duas fases: a primeira é criar a floresta aleatória combinando N árvores de decisão e a segunda é fazer previsões para cada árvore criada na primeira fase.

O processo de trabalho pode ser explicado nas etapas e no diagrama abaixo:

Passo 1: Selecione K pontos de dados aleatórios do conjunto de treinamento.

Passo 2: Construa as árvores de decisão associadas aos pontos de dados selecionados (subconjuntos).

média entorpecida

Etapa 3: Escolha o número N para as árvores de decisão que você deseja construir.

Passo 4: Repita as etapas 1 e 2.

Etapa 5: Para novos pontos de dados, encontre as previsões de cada árvore de decisão e atribua os novos pontos de dados à categoria que obtiver a maioria dos votos.

O funcionamento do algoritmo pode ser melhor compreendido pelo exemplo abaixo:

Exemplo: Suponha que haja um conjunto de dados que contenha várias imagens de frutas. Portanto, este conjunto de dados é fornecido ao classificador de floresta Random. O conjunto de dados é dividido em subconjuntos e fornecido a cada árvore de decisão. Durante a fase de treinamento, cada árvore de decisão produz um resultado de previsão e, quando ocorre um novo ponto de dados, com base na maioria dos resultados, o classificador Random Forest prevê a decisão final. Considere a imagem abaixo:

javascript mais próximo

Aplicações de Floresta Aleatória

Existem principalmente quatro setores onde a floresta aleatória é usada principalmente:

Bancário:O setor bancário utiliza principalmente este algoritmo para a identificação do risco de empréstimo.Medicamento:Com a ajuda deste algoritmo, as tendências e os riscos da doença podem ser identificados.Uso da terra:Podemos identificar as áreas de uso semelhante da terra por este algoritmo.Marketing:Tendências de marketing podem ser identificadas usando este algoritmo.

Vantagens da Floresta Aleatória

• Random Forest é capaz de realizar tarefas de classificação e regressão.
• É capaz de lidar com grandes conjuntos de dados com alta dimensionalidade.
• Aumenta a precisão do modelo e evita o problema de overfitting.

Desvantagens da Floresta Aleatória

• Embora a floresta aleatória possa ser usada para tarefas de classificação e regressão, ela não é mais adequada para tarefas de regressão.

Implementação Python do algoritmo de floresta aleatória

Agora implementaremos a árvore do algoritmo Random Forest usando Python. Para isso, utilizaremos o mesmo conjunto de dados 'user_data.csv', que utilizamos em modelos de classificação anteriores. Usando o mesmo conjunto de dados, podemos comparar o classificador Random Forest com outros modelos de classificação, como Classificador de árvore de decisão, KNN, SVM, regressão logística, etc.

As etapas de implementação são fornecidas abaixo:

• Etapa de pré-processamento de dados
• Ajustando o algoritmo Random Forest ao conjunto de treinamento
• Prevendo o resultado do teste
• Teste a precisão do resultado (matriz de criação de confusão)
• Visualizando o resultado do conjunto de testes.

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 o algoritmo Random Forest ao conjunto de treinamento:

Agora ajustaremos o algoritmo Random Forest ao conjunto de treinamento. Para ajustá-lo, importaremos o RandomForestClassificador aula do sklearn.ensemble biblioteca. O código é fornecido abaixo:

 #Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train) 

No código acima, o objeto classificador leva os parâmetros abaixo:

n_estimadores=O número necessário de árvores na Floresta Aleatória. O valor padrão é 10. Podemos escolher qualquer número, mas precisamos cuidar do problema de sobreajuste.critério=É uma função para analisar a precisão da divisão. Aqui consideramos 'entropia' o ganho de informação.

Saída:

 RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', 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=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False) 

3. Prever o resultado do conjunto de testes

Como nosso modelo está ajustado ao conjunto de treinamento, agora podemos prever o resultado do teste. Para previsão, 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:

wolverine vs texugo

O vetor de predição é dado como:

Ao verificar o vetor de predição acima e o vetor real do conjunto de teste, podemos determinar as previsões incorretas feitas pelo classificador.

4. Criando a Matriz de Confusão

Agora criaremos a matriz de confusão para determinar as previsões corretas e incorretas. 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:

converter string como int

Como podemos ver na matriz acima, existem 4+4= 8 previsões incorretas e 64+28= 92 previsões corretas.

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 floresta Random. 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:

 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()) for i, 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('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

A imagem acima é o resultado da visualização do classificador Random Forest trabalhando com o resultado do conjunto de treinamento. É muito semelhante ao classificador de árvore de decisão. Cada ponto de dados corresponde a cada usuário do user_data, e as regiões roxa e verde são as regiões de previsão. A região roxa é classificada para os usuários que não adquiriram o carro SUV, e a região verde é para os usuários que adquiriram o SUV.

Assim, no classificador Random Forest, pegamos 10 árvores que previram Sim ou NÃO para a variável Comprada. O classificador pegou a maioria das previsões e forneceu o resultado.

6. Visualizando o resultado do conjunto de testes

Agora visualizaremos o resultado do conjunto de testes. Abaixo está o código para isso:

 #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()) for i, 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('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

A imagem acima é o resultado da visualização do conjunto de teste. Podemos verificar que existe um número mínimo de previsões incorretas (8) sem o problema de Overfitting. Obteremos resultados diferentes alterando o número de árvores no classificador.