Como usar algoritmos baseados em árvore para aprendizado de máquina

Por

como isso funciona

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 packages
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

%matplotlib inline

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler, MinMaxScaler
import pandas_profiling

from matplotlib import rcParams
import warnings

warnings.filterwarnings("ignore")

# figure size in inches
rcParams["figure.figsize"] = 10, 6
np.random.seed(42)

Conjunto de dados

Em seguida, carregue o conjunto de dados do diretório de dados:

# Load dataset
data = pd.read_csv("../data/pima_indians_diabetes.csv")

Agora podemos observar a amostra do conjunto de dados.


# show sample of the dataset
data.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 columns
data.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 dataset
scaler = 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 set
X_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 classifier
classifier = RandomForestClassifier(n_estimators=100)

# Train the model using the training sets
classifier.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 set
y_pred = classifier.predict(X_test)

Em seguida, verificamos a precisão usando valores reais e previstos dos dados de teste.

# Calculate Model Accuracy
print("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 features
feature_importances_df = pd.DataFrame(
    {"feature": list(X.columns), "importance": classifier.feature_importances_}
).sort_values("importance", ascending=False)

# Display
feature_importances_df

Caracteristicas importantes

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 plot
sns.barplot(x=feature_importances_df.feature, y=feature_importances_df.importance)
# Add labels to your

plt.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 features
X = data.drop(["class", "triceps_skinfold_thickness"], axis=1)
y = data["class"]

# standardize the dataset
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# split into train and test set
X_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 Classifier
clf = RandomForestClassifier(n_estimators=100)

# Train the model using the training sets
clf.fit(X_train, y_train)

# prediction on test set
y_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