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