logo

Régression de forêt aléatoire en Python

Random Forest Regression est une technique polyvalente d’apprentissage automatique permettant de prédire des valeurs numériques. Il combine les prédictions de plusieurs arbres de décision pour réduire le surajustement et améliorer la précision. Python apprentissage automatique les bibliothèques facilitent la mise en œuvre et l’optimisation de cette approche.

Apprentissage d’ensemble

L'apprentissage d'ensemble est une technique d'apprentissage automatique qui combine les prédictions de plusieurs modèles pour créer une prédiction plus précise et plus stable. Il s'agit d'une approche qui exploite l'intelligence collective de plusieurs modèles pour améliorer les performances globales du système d'apprentissage.

Types de méthodes d'ensemble

Il existe différents types de méthodes d'apprentissage d'ensemble, notamment :



  1. Ensachage (agrégation Bootstrap) : Cette méthode implique la formation de plusieurs modèles sur des sous-ensembles aléatoires des données de formation. Les prédictions des modèles individuels sont ensuite combinées, généralement en faisant une moyenne.
  2. Booster : Cette méthode implique la formation d'une séquence de modèles, où chaque modèle suivant se concentre sur les erreurs commises par le modèle précédent. Les prédictions sont combinées à l’aide d’un système de vote pondéré.
  3. Empilage : Cette méthode consiste à utiliser les prédictions d'un ensemble de modèles comme caractéristiques d'entrée pour un autre modèle. La prédiction finale est réalisée par le modèle de deuxième niveau.

Forêt aléatoire

Une forêt aléatoire est une méthode d'apprentissage d'ensemble qui combine les prédictions de plusieurs arbres de décision pour produire une prédiction plus précise et plus stable. Il s'agit d'un type d'algorithme d'apprentissage supervisé qui peut être utilisé à la fois pour des tâches de classification et de régression.

Chaque arbre de décision a une variance élevée, mais lorsque nous les combinons tous en parallèle, la variance résultante est faible car chaque arbre de décision est parfaitement formé sur cet échantillon de données particulier, et donc la sortie ne dépend pas d'un arbre de décision mais de plusieurs arbres de décision. Dans le cas d'un problème de classification, le résultat final est obtenu en utilisant le classificateur de vote majoritaire. Dans le cas d’un problème de régression, le résultat final est la moyenne de tous les résultats. Cette partie s'appelle Agrégation .

Fonctionnement du modèle de régression de forêt aléatoire

Fonctionnement du modèle de régression de forêt aléatoire

Qu’est-ce que la régression de forêt aléatoire ?

La régression de forêt aléatoire dans l'apprentissage automatique est un ensemble technique capable d'effectuer les deux régression et classification tâches avec l'utilisation de plusieurs arbres de décision et d'une technique appelée Bootstrap et Agrégation, communément appelée ensachage . L'idée de base derrière cela est de combiner plusieurs arbres de décision pour déterminer le résultat final plutôt que de s'appuyer sur des arbres de décision individuels.

Random Forest dispose de plusieurs arbres de décision comme modèles d'apprentissage de base. Nous effectuons de manière aléatoire un échantillonnage de lignes et un échantillonnage de caractéristiques à partir de l'ensemble de données formant des exemples d'ensembles de données pour chaque modèle. Cette partie s'appelle Bootstrap.

Nous devons aborder la technique de régression Random Forest comme n’importe quelle autre apprentissage automatique technique.

  • Concevez une question ou des données spécifiques et obtenez la source pour déterminer les données requises.
  • Assurez-vous que les données sont dans un format accessible, sinon convertissez-les au format requis.
  • Spécifiez toutes les anomalies visibles et les points de données manquants qui peuvent être nécessaires pour obtenir les données requises.
  • Créez un modèle d'apprentissage automatique.
  • Définissez le modèle de base que vous souhaitez atteindre
  • Entraînez le modèle d’apprentissage automatique des données.
  • Fournir un aperçu du modèle avec des données de test
  • Comparez maintenant les mesures de performances des données de test et des données prédites du modèle.
  • Si cela ne répond pas à vos attentes, vous pouvez essayer d'améliorer votre modèle en conséquence, de dater vos données ou d'utiliser une autre technique de modélisation de données.
  • À ce stade, vous interprétez les données que vous avez obtenues et faites votre rapport en conséquence.

Régression de forêt aléatoire en Python

Nous utiliserons un exemple de technique similaire dans l'exemple ci-dessous. Vous trouverez ci-dessous un exemple d'implémentation étape par étape de Random Forest Regression, sur l'ensemble de données qui peut être téléchargé ici - https://bit.ly/417n3N5

Python les bibliothèques nous permettent de gérer très facilement les données et d'effectuer des tâches typiques et complexes avec une seule ligne de code.

  • Pandas – Cette bibliothèque permet de charger le bloc de données dans un format de tableau 2D et dispose de plusieurs fonctions pour effectuer des tâches d'analyse en une seule fois.
  • Numpy – Les tableaux Numpy sont très rapides et peuvent effectuer des calculs volumineux en très peu de temps.
  • Matplotlib / Né de la mer – Cette bibliothèque est utilisée pour dessiner des visualisations.
  • Sklearn – Ce module contient plusieurs bibliothèques ayant des fonctions pré-implémentées pour effectuer des tâches allant du prétraitement des données au développement et à l'évaluation de modèles.
  • RandomForestRegressor – Il s'agit du modèle de régression basé sur le modèle Random Forest ou sur l'apprentissage d'ensemble que nous utiliserons dans cet article en utilisant la bibliothèque sklearn.
  • apprendre : Cette bibliothèque est la bibliothèque principale d'apprentissage automatique en Python. Il fournit une large gamme d'outils pour le prétraitement, la modélisation, l'évaluation et le déploiement de modèles d'apprentissage automatique.
  • Encodeur d'étiquette : Cette classe est utilisée pour coder des données catégorielles en valeurs numériques.
  • KNNImputateur : Cette classe est utilisée pour imputer les valeurs manquantes dans un ensemble de données en utilisant une approche des k voisins les plus proches.
  • train_test_split : Cette fonction est utilisée pour diviser un ensemble de données en ensembles de formation et de test.
  • Échelle standard : Cette classe est utilisée pour normaliser les caractéristiques en supprimant la moyenne et en mettant à l'échelle la variance unitaire.
  • f1_score : Cette fonction est utilisée pour évaluer les performances d'un modèle de classification à l'aide du score F1.
  • RandomForestRégresseur : Cette classe est utilisée pour entraîner un modèle de régression forestière aléatoire.
  • cross_val_score : Cette fonction est utilisée pour effectuer une validation croisée k fois pour évaluer les performances d'un modèle

Étape 1 : Importer des bibliothèques

Ici, nous importons toutes les bibliothèques nécessaires requises.

Python3




import> pandas as pd> import> matplotlib.pyplot as plt> import> seaborn as sns> import> sklearn> import> warnings> from> sklearn.preprocessing>import> LabelEncoder> from> sklearn.impute>import> KNNImputer> from> sklearn.model_selection>import> train_test_split> from> sklearn.preprocessing>import> StandardScaler> from> sklearn.metrics>import> f1_score> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.model_selection>import> cross_val_score> warnings.filterwarnings(>'ignore'>)>

>

>

Étape 2 : Importer l'ensemble de données

Chargeons maintenant l'ensemble de données dans le bloc de données du panda. Pour une meilleure gestion des données et tirer parti des fonctions pratiques pour effectuer des tâches complexes en une seule fois.

liste de fléchettes

Python3




df>=> pd.read_csv(>'Salaries.csv'>)> print>(df)>

>

>

Sortir:

 Position Level Salary 0 Business Analyst 1 45000 1 Junior Consultant 2 50000 2 Senior Consultant 3 60000 3 Manager 4 80000 4 Country Manager 5 110000 5 Region Manager 6 150000 6 Partner 7 200000 7 Senior Partner 8 300000 8 C-level 9 500000 9 CEO 10 1000000>

Ici le.info()>La méthode fournit un aperçu rapide de la structure, des types de données et de l’utilisation de la mémoire de l’ensemble de données.

Python3




df.info()>

>

>

Sortir:

 RangeIndex: 10 entries, 0 to 9 Data columns (total 3 columns):  # Column Non-Null Count Dtype  --- ------ -------------- -----   0 Position 10 non-null object  1 Level 10 non-null int64   2 Salary 10 non-null int64  dtypes: int64(2), object(1) memory usage: 372.0+ bytes>

Étape 3: Préparation des données

Ici, le code extraira deux sous-ensembles de données de l'ensemble de données et les stockera dans des variables distinctes.

  • Fonctionnalités d'extraction : Il extrait les fonctionnalités du DataFrame et les stocke dans une variable nomméeX>.
  • Extraction de la variable cible : Il extrait la variable cible du DataFrame et la stocke dans une variable nomméey>.

Python3




# Assuming df is your DataFrame> X>=> df.iloc[:,>1>:>2>].values>#features> y>=> df.iloc[:,>2>].values># Target variable>

>

exemple de sous-chaîne Java

>

Étape 4 : Modèle de régresseur de forêt aléatoire

Le code traite les données catégorielles en les codant numériquement, combine les données traitées avec des données numériques et forme un modèle de régression forestière aléatoire à l'aide des données préparées.

Python3




import> pandas as pd> from> sklearn.ensemble>import> RandomForestRegressor> from> sklearn.preprocessing>import> LabelEncoder> >Check>for> and> handle categorical variables> label_encoder>=> LabelEncoder()> x_categorical>=> df.select_dtypes(include>=>[>'object'>]).>apply>(label_encoder.fit_transform)> x_numerical>=> df.select_dtypes(exclude>=>[>'object'>]).values> x>=> pd.concat([pd.DataFrame(x_numerical), x_categorical], axis>=>1>).values> # Fitting Random Forest Regression to the dataset> regressor>=> RandomForestRegressor(n_estimators>=>10>, random_state>=>0>, oob_score>=>True>)> # Fit the regressor with x and y data> regressor.fit(x, y)>

>

>

Étape 5 : Faire des prédictions et une évaluation

Le code évalue le modèle de régression de forêt aléatoire formé :

  • score out-of-bag (OOB), qui estime les performances de généralisation du modèle.
  • Effectue des prédictions à l’aide du modèle entraîné et les stocke dans le tableau « prédictions ».
  • Évalue les performances du modèle à l’aide des mesures d’erreur quadratique moyenne (MSE) et de R-carré (R2).

Score hors sac dans RandomForest

Score du sac ou Score OOB est le type de technique de validation qui est principalement utilisé dans les algorithmes d'ensachage pour valider l'algorithme d'ensachage. Ici, une petite partie des données de validation est extraite du courant dominant des données et les prédictions sur les données de validation particulières sont effectuées et comparées aux autres résultats.

Le principal avantage qu'offre le score OOB est qu'ici les données de validation ne sont pas vues par l'algorithme d'ensachage et c'est pourquoi les résultats sur le score OOB sont les vrais résultats qui indiquent les performances réelles de l'algorithme d'ensachage.

Pour obtenir le score OOB d'un algorithme Random Forest particulier, il faut définir la valeur True pour le paramètre OOB_Score dans l'algorithme.

Python3




# Evaluating the model> from> sklearn.metrics>import> mean_squared_error, r2_score> # Access the OOB Score> oob_score>=> regressor.oob_score_> print>(f>'Out-of-Bag Score: {oob_score}'>)> # Making predictions on the same data or new data> predictions>=> regressor.predict(x)> # Evaluating the model> mse>=> mean_squared_error(y, predictions)> print>(f>'Mean Squared Error: {mse}'>)> r2>=> r2_score(y, predictions)> print>(f>'R-squared: {r2}'>)>

>

>

qu'est-ce que la ROM

Sortir:

Out-of-Bag Score: 0.644879832593859 Mean Squared Error: 2647325000.0 R-squared: 0.9671801245316117>

Étape 6 : Visualisation

Visualisons maintenant les résultats obtenus en utilisant le modèle de régression RandomForest sur notre ensemble de données sur les salaires.

  • Crée une grille de points de prédiction couvrant la plage des valeurs des caractéristiques.
  • Trace les points de données réels sous forme de points de dispersion bleus.
  • Trace les valeurs prédites pour la grille de prédiction sous forme de ligne verte.
  • Ajoute des étiquettes et un titre à l'intrigue pour une meilleure compréhension.

Python3




import> numpy as np> X_grid>=> np.arange(>min>(X),>max>(X),>0.01>)> X_grid>=> X_grid.reshape(>len>(X_grid),>1>)> > plt.scatter(X,y, color>=>'blue'>)>#plotting real points> plt.plot(X_grid, regressor.predict(X_grid),color>=>'green'>)>#plotting for predict points> > plt.title(>'Random Forest Regression Results'>)> plt.xlabel(>'Position level'>)> plt.ylabel(>'Salary'>)> plt.show()>

>

>

Sortir:

Capture d'écran-2023-12-04-101235

Étape 7 : Visualisation d'un arbre de décision unique à partir du modèle de forêt aléatoire

Le code visualise l'un des arbres de décision du modèle Random Forest formé. Trace l'arbre de décision sélectionné, affichant le processus de prise de décision d'un seul arbre au sein de l'ensemble.

Python3




from> sklearn.tree>import> plot_tree> import> matplotlib.pyplot as plt> # Assuming regressor is your trained Random Forest model> # Pick one tree from the forest, e.g., the first tree (index 0)> tree_to_plot>=> regressor.estimators_[>0>]> # Plot the decision tree> plt.figure(figsize>=>(>20>,>10>))> plot_tree(tree_to_plot, feature_names>=>df.columns.tolist(), filled>=>True>, rounded>=>True>, fontsize>=>10>)> plt.title(>'Decision Tree from Random Forest'>)> plt.show()>

changer le nom du répertoire Linux

>

>

Sortir:

Capture d'écran-2023-12-05-111140 Applications de la régression forestière aléatoire

La régression de forêt aléatoire présente un large éventail de problèmes du monde réel, notamment :

  • Prédiction de valeurs numériques continues : Prédire les prix de l'immobilier, les cours des actions ou la valeur à vie du client.
  • Identifier les facteurs de risque : Détecter les facteurs de risque de maladies, de crises financières ou d’autres événements négatifs.
  • Gestion des données de grande dimension : Analyser des ensembles de données avec un grand nombre de fonctionnalités d'entrée.
  • Capturer des relations complexes : Modélisation de relations complexes entre les entités d'entrée et la variable cible.

Avantages de la régression de forêt aléatoire

  • Il est facile à utiliser et moins sensible aux données d’entraînement par rapport à l’arbre de décision.
  • C'est plus précis que le arbre de décision algorithme.
  • Il est efficace pour gérer de grands ensembles de données comportant de nombreux attributs.
  • Il peut gérer les données manquantes, valeurs aberrantes et des fonctionnalités bruyantes.

Inconvénients de la régression forestière aléatoire

  • Le modèle peut également être difficile à interpréter.
  • Cet algorithme peut nécessiter une certaine expertise du domaine pour choisir les paramètres appropriés tels que le nombre d'arbres de décision, la profondeur maximale de chaque arbre et le nombre de fonctionnalités à prendre en compte à chaque division.
  • Cela coûte cher en termes de calcul, en particulier pour les grands ensembles de données.
  • Il peut souffrir de surapprentissage si le modèle est trop complexe ou si le nombre d'arbres de décision est trop élevé.

Conclusion

Random Forest Regression est devenu un outil puissant pour les tâches de prédiction continue, présentant des avantages par rapport aux arbres de décision traditionnels. Sa capacité à gérer des données de grande dimension, à capturer des relations complexes et à réduire le surapprentissage en a fait un choix populaire pour une variété d'applications. La bibliothèque scikit-learn de Python permet la mise en œuvre, l'optimisation et l'évaluation de modèles de régression de forêt aléatoire, ce qui en fait une technique accessible et efficace pour les praticiens de l'apprentissage automatique.

Foire aux questions (FAQ)

1. Qu'est-ce que Python de régression de forêt aléatoire ?

Random Forest Regression Python est une méthode d'apprentissage d'ensemble qui utilise plusieurs arbres de décision pour faire des prédictions. Il s’agit d’un algorithme puissant et polyvalent bien adapté aux tâches de régression.

2. À quoi sert la régression forestière aléatoire ?

La régression forestière aléatoire peut être utilisée pour prédire diverses variables cibles, notamment les prix, les ventes, le taux de désabonnement des clients, etc. Il s’agit d’un algorithme robuste qui n’est pas facilement surajusté, ce qui en fait un bon choix pour les applications du monde réel.

3. Quelle est la différence entre la forêt aléatoire et la régression ?

Random Forest est une méthode d'apprentissage d'ensemble, tandis que la régression est un type d'algorithme d'apprentissage supervisé. Random Forest utilise plusieurs arbres de décision pour faire des prédictions, tandis que la régression utilise un seul modèle pour faire des prédictions.

4. Comment régler les hyperparamètres de Random Forest Regression ?

Il existe plusieurs méthodes pour régler les hyperparamètres de Random Forest Regression, telles que :

  • Recherche par grille : La recherche par grille implique d'essayer systématiquement différentes combinaisons de valeurs d'hyperparamètres pour trouver la meilleure combinaison.
  • Recherche aléatoire : La recherche aléatoire échantillonne de manière aléatoire différentes combinaisons de valeurs d'hyperparamètres pour trouver une bonne combinaison.

5. Pourquoi la forêt aléatoire est-elle meilleure que la régression ?

Random Forest est généralement plus précis et robuste que la régression. Il est également moins sujet au surajustement, ce qui signifie qu’il est plus susceptible de bien se généraliser aux nouvelles données.