Didacticiel Random Forest Classifier: Comment utiliser des algorithmes basés sur des arbres pour l'apprentissage automatique

Les algorithmes basés sur des arbres sont des méthodes d'apprentissage automatique populaires utilisées pour résoudre des problèmes d'apprentissage supervisé. Ces algorithmes sont flexibles et peuvent résoudre tout type de problème (classification ou régression).

Les algorithmes basés sur des arbres ont tendance à utiliser la moyenne pour les entités continues ou le mode pour les caractéristiques catégorielles lors de la réalisation de prédictions sur des échantillons d'apprentissage dans les régions auxquelles ils appartiennent. Ils produisent également des prédictions avec une grande précision , stabilité et facilité d'interprétation .

Exemples d'algorithmes basés sur des arbres

Il existe différents algorithmes basés sur des arbres que vous pouvez utiliser, tels que

  • Arbres de décision
  • Forêt aléatoire
  • Augmentation du dégradé
  • Ensachage (agrégation Bootstrap)

Ainsi, chaque data scientist devrait apprendre ces algorithmes et les utiliser dans leurs projets d'apprentissage automatique.

Dans cet article, vous en apprendrez plus sur l'algorithme de forêt aléatoire. Après avoir terminé cet article, vous devez maîtriser l'utilisation de l'algorithme de forêt aléatoire pour résoudre et créer des modèles prédictifs pour les problèmes de classification avec scikit-learn.

Qu'est-ce que Random Forest?

Random forest est l'un des algorithmes d'apprentissage supervisé basé sur les arbres les plus populaires. C'est aussi le plus flexible et le plus facile à utiliser.

L'algorithme peut être utilisé pour résoudre à la fois des problèmes de classification et de régression. La forêt aléatoire a tendance à combiner des centaines dearbres de décisionpuis entraîne chaque arbre de décision sur un échantillon différent des observations.

Les prédictions finales de la forêt aléatoire sont faites en faisant la moyenne des prédictions de chaque arbre individuel.

Les avantages des forêts aléatoires sont nombreux. Les arbres de décision individuels ont tendance à surajuster les données d'apprentissage, mais la forêt aléatoire peut atténuer ce problème en faisant la moyenne des résultats de prédiction de différents arbres. Cela donne aux forêts aléatoires une précision prédictive plus élevée qu'un arbre de décision unique.

L'algorithme de forêt aléatoire peut également vous aider à trouver des entités importantes dans votre jeu de données. Il se trouve à la base de l'algorithme de Boruta, qui sélectionne les caractéristiques importantes d'un ensemble de données.

La forêt aléatoire a été utilisée dans diverses applications, par exemple pour fournir des recommandations de différents produits aux clients du commerce électronique.

En médecine, un algorithme de forêt aléatoire peut être utilisé pour identifier la maladie du patient en analysant le dossier médical du patient.

Toujours dans le secteur bancaire, il peut être utilisé pour déterminer facilement si le client est frauduleux ou légitime.

Comment fonctionne l'algorithme Random Forest?

L'algorithme de forêt aléatoire fonctionne en effectuant les étapes suivantes:

Étape 1 : L'algorithme sélectionne des échantillons aléatoires dans l'ensemble de données fourni.

Étape 2: L'algorithme créera un arbre de décision pour chaque échantillon sélectionné. Ensuite, il obtiendra un résultat de prédiction à partir de chaque arbre de décision créé.

Étape 3: Le vote sera alors effectué pour chaque résultat prévu. Pour un problème de classification, il utilisera le mode , et pour un problème de régression, il utilisera la moyenne .

Étape 4 : Et enfin, l'algorithme sélectionnera le résultat de prédiction le plus voté comme prédiction finale.

Random Forest en pratique

Maintenant que vous connaissez les tenants et les aboutissants de l'algorithme de forêt aléatoire, construisons un classificateur de forêt aléatoire.

Nous allons construire un classificateur de forêt aléatoire à l'aide de l'ensemble de données Pima Indians Diabetes. L'ensemble de données sur le diabète des Indiens Pima consiste à prédire l'apparition du diabète dans les 5 ans sur la base des détails médicaux fournis. Il s'agit d'un problème de classification binaire.

Notre tâche est d'analyser et de créer un modèle sur l'ensemble de données Pima Indian Diabetes pour prédire si un patient particulier est à risque de développer un diabète, compte tenu d'autres facteurs indépendants.

Nous commencerons par importer des packages importants que nous utiliserons pour charger l'ensemble de données et créer un classificateur de forêt aléatoire. Nous utiliserons la bibliothèque scikit-learn pour charger et utiliser l'algorithme de forêt aléatoire.

# 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)

Base de données

Chargez ensuite l'ensemble de données à partir du répertoire de données:

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

Nous pouvons maintenant observer l'échantillon de l'ensemble de données.

 # show sample of the dataset data.sample(5)

Comme vous pouvez le voir, dans notre ensemble de données, nous avons différentes fonctionnalités avec des valeurs numériques.

Comprenons la liste des fonctionnalités que nous avons dans cet ensemble de données.

# show columns data.columns

Dans cet ensemble de données, il y a 8 entités d'entrée et 1 entité de sortie / cible. On pense que les valeurs manquantes sont codées avec des valeurs nulles. La signification des noms de variables est la suivante (de la première à la dernière caractéristique):

  • Nombre de fois enceinte.
  • Concentration de glucose plasmatique a 2 heures dans un test oral de tolérance au glucose.
  • Tension artérielle diastolique (mm Hg).
  • Épaisseur du pli cutané du triceps (mm).
  • Insuline sérique 2 heures (mu U / ml).
  • Indice de masse corporelle (poids en kg / (taille en m) ^ 2).
  • Fonction généalogique du diabète.
  • Années d'âge).
  • Variable de classe (0 ou 1).

Ensuite, nous divisons l'ensemble de données en entités indépendantes et en entité cible. Notre fonction cible pour cet ensemble de données est appelée classe.

# split data into input and taget variable(s) X = data.drop("class", axis=1) y = data["class"]

Prétraitement de l'ensemble de données

Before we create a model we need to standardize our independent features by using the standardScaler method from scikit-learn.

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

You can learn more on how and why to standardize your data from this article by clicking here.

Splitting the dataset into Training and Test data

We now split our processed dataset into training and test data. The test data will be 10% of the entire processed dataset.

# 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 )

Building the Random Forest Classifier

Now is time to create our random forest classifier and then train it on the train set. We will also pass the number of trees (100) in the forest we want to use through theparameter called n_estimators.

# create the classifier classifier = RandomForestClassifier(n_estimators=100) # Train the model using the training sets classifier.fit(X_train, y_train)

The above output shows different parameter values of the random forest classifier used during the training process on the train data.

After training we can perform prediction on the test data.

# predictin on the test set y_pred = classifier.predict(X_test)

Then we check the accuracy using actual and predicted values from the test data.

# Calculate Model Accuracy print("Accuracy:", accuracy_score(y_test, y_pred))

Accuracy: 0.8051948051948052

Our accuracy is around 80.5% which is good. But we can always make it better.

Identify Important Features

As I said before, we can also check the important features by using the feature_importances_ variable from the random forest algorithm in 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

The figure above shows the relative importance of features and their contribution to the model. We can also visualize these features and their  scores using the seaborn and matplotlib libraries.

# 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()

From the figure above, you can see the triceps_skinfold_thickness feature has low importance and does not contribute much to the prediction.

This means that we can remove this feature and train our random forest classifier again and then see if it can improve its performance on the test data.

# 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 )

We will train the random forest algorithm with the selected processed features from our dataset, perform predictions, and then find the accuracy of the model.

# 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))

Accuracy: 0.8181818181818182

Now the model accuracy has increased from 80.5% to 81.8% after we removed the least important feature called triceps_skinfold_thickness.

This suggests that it is very important to check important features and see if you can remove the least important features to increase your model's performance.

Wrapping up

Tree-based algorithms are really important for every data scientist to learn. In this article, you've learned the basics of tree-based algorithms and how to create a classification model by using the random forest algorithm.

I also recommend you try other types of tree-based algorithms such as the Extra-trees algorithm.

You can download the dataset and notebook used in this article here: //github.com/Davisy/Random-Forest-classification-Tutorial

Congratulations, you have made it to the end of this article!

If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! I can also be reached on Twitter @Davis_McDavid