Random Forest est un algorithme d'apprentissage automatique populaire qui appartient à la technique d'apprentissage supervisé. Il peut être utilisé pour les problèmes de classification et de régression en ML. Il est basé sur la notion de apprentissage d'ensemble, qui est un processus de combiner plusieurs classificateurs pour résoudre un problème complexe et améliorer les performances du modèle.
Comme le nom le suggère, 'Random Forest est un classificateur qui contient un certain nombre d'arbres de décision sur divers sous-ensembles de l'ensemble de données donné et prend la moyenne pour améliorer la précision prédictive de cet ensemble de données.' Au lieu de s'appuyer sur un seul arbre de décision, la forêt aléatoire prend la prédiction de chaque arbre et sur la base des votes majoritaires des prédictions, et prédit le résultat final.
Le plus grand nombre d’arbres dans la forêt conduit à une plus grande précision et évite le problème du surajustement.
java comment remplacer
Le diagramme ci-dessous explique le fonctionnement de l'algorithme Random Forest :
Remarque : Pour mieux comprendre l'algorithme de forêt aléatoire, vous devez connaître l'algorithme d'arbre de décision.
Hypothèses pour la forêt aléatoire
Étant donné que la forêt aléatoire combine plusieurs arbres pour prédire la classe de l'ensemble de données, il est possible que certains arbres de décision prédisent le résultat correct, tandis que d'autres ne le peuvent pas. Mais ensemble, tous les arbres prédisent le résultat correct. Par conséquent, vous trouverez ci-dessous deux hypothèses pour un meilleur classificateur de forêt aléatoire :
- Il doit y avoir des valeurs réelles dans la variable caractéristique de l'ensemble de données afin que le classificateur puisse prédire des résultats précis plutôt qu'un résultat deviné.
- Les prédictions de chaque arbre doivent avoir de très faibles corrélations.
Pourquoi utiliser Random Forest ?
Voici quelques points qui expliquent pourquoi nous devrions utiliser l’algorithme Random Forest :
- Cela prend moins de temps de formation par rapport à d’autres algorithmes.
- Il prédit les résultats avec une grande précision, même pour le vaste ensemble de données qu'il gère efficacement.
- Il peut également maintenir l’exactitude lorsqu’une grande proportion de données est manquante.
Comment fonctionne l’algorithme Random Forest ?
Random Forest fonctionne en deux phases : la première consiste à créer la forêt aléatoire en combinant N arbres de décision, et la deuxième consiste à faire des prédictions pour chaque arbre créé dans la première phase.
Le processus de travail peut être expliqué dans les étapes et le diagramme ci-dessous :
Étape 1: Sélectionnez des points de données K aléatoires dans l’ensemble d’entraînement.
Étape 2: Construisez les arbres de décision associés aux points de données sélectionnés (sous-ensembles).
tableau c chaîne
Étape 3: Choisissez le numéro N pour les arbres de décision que vous souhaitez construire.
Étape 4: Répétez les étapes 1 et 2.
Étape 5 : Pour les nouveaux points de données, recherchez les prédictions de chaque arbre de décision et attribuez les nouveaux points de données à la catégorie qui remporte les votes majoritaires.
Le fonctionnement de l'algorithme peut être mieux compris par l'exemple ci-dessous :
Exemple: Supposons qu'il existe un ensemble de données contenant plusieurs images de fruits. Ainsi, cet ensemble de données est transmis au classificateur de forêt aléatoire. L'ensemble de données est divisé en sous-ensembles et attribué à chaque arbre de décision. Pendant la phase de formation, chaque arbre de décision produit un résultat de prédiction, et lorsqu'un nouveau point de données apparaît, alors sur la base de la majorité des résultats, le classificateur Random Forest prédit la décision finale. Considérez l'image ci-dessous :
Go contre Mo
Applications de la forêt aléatoire
Il existe principalement quatre secteurs dans lesquels Random Forest est principalement utilisé :
Avantages de la forêt aléatoire
- Random Forest est capable d'effectuer à la fois des tâches de classification et de régression.
- Il est capable de gérer de grands ensembles de données avec une dimensionnalité élevée.
- Cela améliore la précision du modèle et évite le problème de surapprentissage.
Inconvénients de la forêt aléatoire
- Bien que la forêt aléatoire puisse être utilisée à la fois pour les tâches de classification et de régression, elle n'est pas plus adaptée aux tâches de régression.
Implémentation Python de l'algorithme de forêt aléatoire
Nous allons maintenant implémenter l’arborescence Random Forest Algorithm en utilisant Python. Pour cela, nous utiliserons le même ensemble de données « user_data.csv » que celui que nous avons utilisé dans les modèles de classification précédents. En utilisant le même ensemble de données, nous pouvons comparer le classificateur Random Forest avec d'autres modèles de classification tels que Classificateur d'arbre de décision, KNN, SVM, régression logistique, etc.
Les étapes de mise en œuvre sont indiquées ci-dessous :
- Étape de prétraitement des données
- Ajustement de l'algorithme de forêt aléatoire à l'ensemble d'entraînement
- Prédire le résultat du test
- Test de précision du résultat (Création de matrice de confusion)
- Visualisation du résultat de l'ensemble de test.
1.Étape de prétraitement des données :
Vous trouverez ci-dessous le code de l'étape de pré-traitement :
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Dans le code ci-dessus, nous avons prétraité les données. Où nous avons chargé l'ensemble de données, qui est donné comme suit :
2. Ajustement de l'algorithme Random Forest à l'ensemble d'entraînement :
Nous allons maintenant adapter l'algorithme de forêt aléatoire à l'ensemble d'entraînement. Pour l'adapter, nous importerons le RandomForestClassificateur classe de la sklearn.ensemble bibliothèque. Le code est donné ci-dessous :
#Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train)
Dans le code ci-dessus, l'objet classificateur prend les paramètres ci-dessous :
Sortir:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)
3. Prédire le résultat de l'ensemble de tests
Puisque notre modèle est adapté à l’ensemble d’entraînement, nous pouvons désormais prédire le résultat du test. Pour la prédiction, nous allons créer un nouveau vecteur de prédiction y_pred. Ci-dessous le code correspondant :
#Predicting the test set result y_pred= classifier.predict(x_test)
Sortir:
opérateurs javascript
Le vecteur de prédiction est donné comme suit :
En vérifiant le vecteur de prédiction ci-dessus et le vecteur réel de l'ensemble de test, nous pouvons déterminer les prédictions incorrectes effectuées par le classificateur.
4. Création de la matrice de confusion
Nous allons maintenant créer la matrice de confusion pour déterminer les prédictions correctes et incorrectes. Ci-dessous le code correspondant :
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Sortir:
générer un nombre aléatoire en Java
Comme nous pouvons le voir dans la matrice ci-dessus, il y a 4+4= 8 prédictions incorrectes et 64+28= 92 prédictions correctes.
5. Visualiser le résultat de l'ensemble d'entraînement
Ici, nous allons visualiser le résultat de l’ensemble de formation. Pour visualiser le résultat de l'ensemble d'entraînement, nous tracerons un graphique pour le classificateur de forêt aléatoire. Le classificateur prédira oui ou non pour les utilisateurs qui ont acheté ou non la voiture SUV, comme nous l'avons fait dans la régression logistique. Ci-dessous le code correspondant :
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Sortir:
L'image ci-dessus est le résultat de visualisation du classificateur Random Forest fonctionnant avec le résultat de l'ensemble d'entraînement. Il est très similaire au classificateur d'arbre de décision. Chaque point de données correspond à chaque utilisateur de user_data, et les régions violettes et vertes sont les régions de prédiction. La région violette est classée pour les utilisateurs qui n'ont pas acheté la voiture SUV, et la région verte est pour les utilisateurs qui ont acheté le SUV.
Ainsi, dans le classificateur Random Forest, nous avons pris 10 arbres qui ont prédit Oui ou NON pour la variable Acheté. Le classificateur a pris la majorité des prédictions et a fourni le résultat.
6. Visualisation du résultat de l'ensemble de test
Nous allons maintenant visualiser le résultat de l'ensemble de test. Ci-dessous le code correspondant :
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Sortir:
L'image ci-dessus est le résultat de visualisation de l'ensemble de test. Nous pouvons vérifier qu'il existe un nombre minimum de prédictions incorrectes (8) sans problème de surajustement. Nous obtiendrons des résultats différents en modifiant le nombre d'arbres dans le classificateur.