Existem diferentes algoritmos baseados em árvore que você pode usar, como
- Árvores de decisão
- Random Forest
- Reforço de gradiente
- Bagging (Agregação de Bootstrap)
Portanto, todo cientista de dados deve aprender esses algoritmos e usá-los em seus projetos de aprendizado de máquina.
Neste artigo, você aprenderá mais sobre o algoritmo de floresta aleatória. Depois de concluir este artigo, você deve usar o algoritmo de floresta aleatória para resolver e criar modelos preditivos para problemas de classificação com o scikit-learn.
A floresta aleatória é um dos algoritmos de aprendizado supervisionado baseados em árvore mais populares. É também o mais flexível e fácil de usar.
O algoritmo pode ser usado para resolver problemas de classificação e regressão. A floresta aleatória tende a combinar centenas de Árvores de decisão e depois treina cada árvore de decisão em uma amostra diferente das observações.
As previsões finais da floresta aleatória são feitas calculando a média das previsões de cada árvore individual.
Os benefícios de florestas aleatórias são numerosos. As árvores de decisão individuais tendem a sobreajuste aos dados do treinamento, mas a floresta aleatória pode atenuar esse problema média a previsão resulta de diferentes árvores. Isso fornece às florestas aleatórias uma maior precisão preditiva do que uma única árvore de decisão.
O algoritmo de floresta aleatória também pode ajudá-lo a encontrar recursos que são importante no seu conjunto de dados. Encontra-se na base do Algoritmo Boruta, que seleciona recursos importantes em um conjunto de dados.
A floresta aleatória tem sido usada em uma variedade de aplicações, por exemplo, para fornecer recomendações de diferentes produtos aos clientes no comércio eletrônico.
Na medicina, um algoritmo florestal aleatório pode ser usado para identificar a doença do paciente, analisando o prontuário médico do paciente.
Também no setor bancário, ele pode ser usado para determinar facilmente se o cliente é fraudulento ou legítimo.
O algoritmo de floresta aleatória funciona executando as seguintes etapas:
Passo 1: O algoritmo seleciona amostras aleatórias no conjunto de dados fornecido.
Passo 2: O algoritmo criará uma árvore de decisão para cada amostra selecionada. Em seguida, ele obterá um resultado de previsão de cada árvore de decisão criada.
Etapa 3: VA votação será realizada para cada resultado previsto. Para um problema de classificação, ele usará modoe, para um problema de regressão, ele usará significar.
Passo 4: E finalmente, o algoritmo selecionará o resultado da previsão mais votado como a previsão final.
Agora que você conhece os detalhes do algoritmo de floresta aleatória, vamos criar um classificador de floresta aleatório.
Vamos construir um classificador florestal aleatório usando o conjunto de dados de diabéticos dos índios Pima. O conjunto de dados de diabetes Pima Indians envolve prever o início do diabetes dentro de 5 anos, com base nos detalhes médicos fornecidos. Este é um problema de classificação binária.
Nossa tarefa é analisar e criar um modelo no conjunto de dados Pima Indian Diabetes para prever se um paciente em particular corre o risco de desenvolver diabetes, dados outros fatores independentes.
Começaremos importando pacotes importantes que usaremos para carregar o conjunto de dados e criar um classificador de floresta aleatório. Vamos usar o scikit-learn biblioteca para carregar e usar o algoritmo de floresta aleatória.
# import important packagesimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport seaborn as sns%matplotlib inlinefrom sklearn.model_selection import train_test_splitfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.metrics import accuracy_scorefrom sklearn.preprocessing import StandardScaler, MinMaxScalerimport pandas_profilingfrom matplotlib import rcParamsimport warningswarnings.filterwarnings("ignore")# figure size in inchesrcParams["figure.figsize"] = 10, 6np.random.seed(42)Conjunto de dados
Em seguida, carregue o conjunto de dados do diretório de dados:
# Load datasetdata = pd.read_csv("../data/pima_indians_diabetes.csv")Agora podemos observar a amostra do conjunto de dados.
# show sample of the datasetdata.sample(5)
Como você pode ver, em nosso conjunto de dados, temos recursos diferentes com valores numéricos.
Vamos entender a lista de recursos que temos neste conjunto de dados.
# show columnsdata.columns
Neste conjunto de dados, existem 8 recursos de entrada e 1 recurso de saída / destino. Acredita-se que os valores ausentes sejam codificados com valores zero. O significado dos nomes das variáveis é o seguinte (do primeiro ao último recurso):
- Número de vezes que está grávida.
- Concentração de glicose no plasma duas horas em um teste de tolerância à glicose por via oral.
- Pressão arterial diastólica (mm Hg).
- Prega cutânea tricipital (mm).
- Insulina sérica de 2 horas (mu U / ml).
- Índice de massa corporal (peso em kg / (altura em m) ^ 2).
- Função de pedigree de diabetes.
- Anos de idade).
- Variável de classe (0 ou 1).
Em seguida, dividimos o conjunto de dados em recursos independentes e de destino. Nosso recurso de destino para esse conjunto de dados é chamado classe.
# split data into input and taget variable(s)X = data.drop("class", axis=1)y = data["class"]Pré-processamento do Conjunto de Dados
Antes de criarmos um modelo, precisamos padronizar nossos recursos independentes usando o standardScaler método do scikit-learn.
# standardize the datasetscaler = StandardScaler()X_scaled = scaler.fit_transform(X)Você pode saber mais sobre como e por que padronizar seus dados neste artigo clicando em aqui.
Dividindo o conjunto de dados em dados de Treinamento e Teste
Agora, dividimos nosso conjunto de dados processado em dados de treinamento e teste. Os dados de teste serão 10% de todo o conjunto de dados processados.
# split into train and test setX_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42)Construindo o Classificador Aleatório de Floresta
Agora é hora de criar nosso classificador de floresta aleatório e treiná-lo no conjunto de trens. Também passaremos o número de árvores (100) na floresta que queremos usar através do parâmetro chamado n_estimators.
# create the classifierclassifier = RandomForestClassifier(n_estimators=100)# Train the model using the training setsclassifier.fit(X_train, y_train)
A saída acima mostra diferentes valores de parâmetros do classificador aleatório de floresta usado durante o processo de treinamento nos dados do trem.
Após o treinamento, podemos executar a previsão nos dados do teste.
# predictin on the test sety_pred = classifier.predict(X_test)Em seguida, verificamos a precisão usando valores reais e previstos dos dados de teste.
# Calculate Model Accuracyprint("Accuracy:", accuracy_score(y_test, y_pred))Precisão: 0.8051948051948052
Nossa precisão é de cerca de 80,5%, o que é bom. Mas sempre podemos melhorar.
Identificar recursos importantes
Como eu disse antes, também podemos verificar os recursos importantes usando o feature_importances_ variável do algoritmo de floresta aleatória no scikit-learn.
# check Important featuresfeature_importances_df = pd.DataFrame( {"feature": list(X.columns), "importance": classifier.feature_importances_}).sort_values("importance", ascending=False)# Displayfeature_importances_df
A figura acima mostra a importância relativa dos recursos e sua contribuição para o modelo. Também podemos visualizar esses recursos e suas pontuações usando as bibliotecas seaborn e matplotlib.
# visualize important featuers# Creating a bar plotsns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance)# Add labels to yourplt.xlabel("Feature Importance Score")plt.ylabel("Features")plt.title("Visualizing Important Features")plt.xticks( rotation=45, horizontalalignment="right", fontweight="light", fontsize="x-large")plt.show()
Na figura acima, você pode ver o recurso triceps_skinfold_thickness tem baixa importância e não contribui muito para a previsão.
Isso significa que podemos remover esse recurso e treinar nosso classificador aleatório de floresta novamente e, em seguida, ver se ele pode melhorar seu desempenho nos dados de teste.
# load data with selected featuresX = data.drop(["class", "triceps_skinfold_thickness"], axis=1)y = data["class"]# standardize the datasetscaler = StandardScaler()X_scaled = scaler.fit_transform(X)# split into train and test setX_train, X_test, y_train, y_test = train_test_split( X_scaled, y, stratify=y, test_size=0.10, random_state=42)Vamos treinar o algoritmo de floresta aleatória com os recursos processados selecionados do nosso conjunto de dados, executar previsões e, em seguida, encontrar a precisão do modelo.
# Create a Random Classifierclf = RandomForestClassifier(n_estimators=100)# Train the model using the training setsclf.fit(X_train, y_train)# prediction on test sety_pred = clf.predict(X_test)# Calculate Model Accuracy,print("Accuracy:", accuracy_score(y_test, y_pred))Precisão: 0.8181818181818182
Agora, a precisão do modelo aumentou de 80,5% para 81,8% depois que removemos o recurso menos importante chamado triceps_skinfold_thickness.
Isso sugere que é muito importante verificar recursos importantes e verificar se você pode remover os recursos menos importantes para aumentar o desempenho do seu modelo.
Algoritmos baseados em árvore são realmente importantes para todo cientista de dados aprender. Neste artigo, você aprendeu o básico de algoritmos baseados em árvore e como criar um modelo de classificação usando o algoritmo de floresta aleatória.
Também recomendo que você tente outros tipos de algoritmos baseados em árvore, como o Algoritmo extra-árvores.
Você pode baixar o conjunto de dados e o bloco de anotações usados neste artigo aqui: https://github.com/Davisy/Random-Forest-classification-Tutorial
Parabéns, você chegou ao final deste artigo!
Se você aprendeu algo novo ou gostou de ler este artigo, compartilhe-o para que outros possam vê-lo. Até lá, até o próximo post! Também posso ser encontrado no Twitter @Davis_McDavid
