Exemple d'algorithme de forêt aléatoire en Python

Random Forest est un algorithme d'apprentissage d'ensemble qui améliore la précision et la robustesse en combinant les résultats de prédiction de plusieurs arbres de décision. Les forêts aléatoires sont largement utilisées dans divers domaines, tels que la finance, les soins médicaux, le commerce électronique, etc.

Cet article expliquera comment implémenter un classificateur de forêt aléatoire à l'aide de Python et le tester à l'aide de l'ensemble de données de fleurs d'iris.

1. Ensemble de données Iris

L'ensemble de données Iris est un ensemble de données classique en apprentissage automatique. Il contient 150 enregistrements, chaque enregistrement comporte 4 fonctionnalités et 1 étiquette de catégorie. Les quatre caractéristiques sont la longueur des sépales, la largeur des sépales, la longueur des pétales et la largeur des pétales, et l'étiquette de catégorie représente l'une des trois variétés d'iris (Iris des montagnes, Iris versicolor, Iris virginia).

En Python, nous pouvons utiliser scikit-learn, une puissante bibliothèque d'apprentissage automatique, pour charger l'ensemble de données iris. Les opérations spécifiques sont les suivantes :

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
y = iris.target

2. Construire un classificateur de forêt aléatoire

Il est très simple de construire un classificateur de forêt aléatoire en utilisant scikit-learn. Tout d'abord, nous devons importer la classe RandomForestClassifier depuis sklearn.ensemble et instancier un objet :

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=10)

Parmi eux, le paramètre n_estimators spécifie le nombre d'arbres de décision inclus dans la forêt aléatoire. Ici, nous fixons le nombre d'arbres de décision dans la forêt aléatoire à 10.

Ensuite, nous devons diviser l'ensemble de données sur l'iris en données d'entraînement et données de test. Utilisez la fonction train_test_split pour diviser aléatoirement l'ensemble de données en un ensemble d'entraînement et un ensemble de test :

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

Parmi eux, le paramètre test_size spécifie la proportion de l'ensemble de test et le paramètre random_state spécifie la graine du générateur de nombres pseudo-aléatoires. pour garantir que le même résultat est obtenu à chaque fois que le programme est exécuté.

Ensuite, nous pouvons utiliser les données d'entraînement pour entraîner le classificateur de forêt aléatoire :

rfc.fit(X_train, y_train)

3. Testez le classificateur de forêt aléatoire

Une fois le classificateur formé, nous pouvons utiliser les données de test pour tester ses performances. Utilisez la fonction prédire pour faire des prédictions sur l'ensemble de test et la fonction précision_score pour calculer la précision du modèle :

from sklearn.metrics import accuracy_score

y_pred = rfc.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

Enfin, nous pouvons utiliser la bibliothèque matplotlib pour visualiser les limites de décision du classificateur afin de mieux comprendre le comportement du classificateur :

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
z_min, z_max = X[:, 2].min() - .5, X[:, 2].max() + .5
xx, yy, zz = np.meshgrid(np.arange(x_min, x_max, 0.2), np.arange(y_min, y_max, 0.2), np.arange(z_min, z_max, 0.2))

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

Z = rfc.predict(np.c_[xx.ravel(), yy.ravel(), zz.ravel()])
Z = Z.reshape(xx.shape)
ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y)
ax.set_xlabel('Sepal length')
ax.set_ylabel('Sepal width')
ax.set_zlabel('Petal length')
ax.set_title('Decision Boundary')

ax.view_init(elev=30, azim=120)
ax.plot_surface(xx, yy, zz, alpha=0.3, facecolors='blue')

plt.show()

Le code ci-dessus produira une image tridimensionnelle dans laquelle la couleur des points de données représente la variété de l'iris et la limite de décision est représentée par une surface bleue translucide.

4. Résumé

Cet article explique comment utiliser Python pour implémenter un classificateur de forêt aléatoire et utiliser l'ensemble de données de fleurs d'iris à des fins de tests. En raison de la robustesse et de la précision de l’algorithme de forêt aléatoire, il présente de larges perspectives d’application dans des applications pratiques. Si cet algorithme vous intéresse, il est recommandé de pratiquer davantage et de lire la littérature pertinente.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!