Guide du développeur Random Forest : 5 façons de l'implémenter en Python

Random Forest, un ensemble d'arbres de décision, est l'une des méthodes les plus populaires en monde de l'apprentissage automatique et est souvent utilisé pour faire des prédictions. Dans cet article, nous discutons de 5 paquets Python différents avec lesquels vous pouvez implémenter Random Forest.

Commençons par voir comment mettre en œuvre une forêt aléatoire en Python sans utiliser de paquets.

Implémentation d'une forêt aléatoire en Python

Une forêt aléatoire consiste en une collection d'arbres de décision. L'algorithme sélectionne aléatoirement des échantillons des données de formation et des variables et crée un arbre de décision à partir de chaque échantillon. La prédiction s'effectue en faisant la moyenne ou en rapprochant les prédictions de chaque arbre.

Le présent exemple de code met en œuvre l'algorithme Random Forest en Python. L'objectif de l'algorithme est de générer un ensemble d'arbres de décision et d'augmenter la précision de la prédiction en agrégeant leurs prédictions.

Implémentation en Python pur d'une forêt aléatoire

Le code commence par importer les bibliothèques nécessaires, à savoir numpy et collections. Le module d'enregistrement Scikit Learn est également importé afin de pouvoir utiliser la fonction make_classification() qui génère un ensemble de données artificielles sur lequel l'algorithme peut être entraîné et testé.

Ensuite, une classe Nœud pour représenter les nœuds de l'arbre décisionnel. Chaque nœud possède plusieurs attributs tels que feature_idx, threshold, left, right, et valeur.

La classe RandomForest est la classe principale qui implémente l'algorithme. Elle a plusieurs paramètres comme n_trees, max_depth et min_samples_split. Le site fit()-La fonction de prédiction de l'arbre décisionnel prend des ensembles de données comme entrées et génère des arbres décisionnels par sélection aléatoire répétée afin d'établir une prédiction.

La fonction build_tree() crée un arbre de décision en divisant les données de manière récursive. Si la profondeur maximale est atteinte, s'il n'y a qu'une seule classe ou si la taille minimale de l'échantillon n'est pas atteinte, un nœud de feuille est créé avec l'étiquette la plus fréquente. Dans le cas contraire, une caractéristique aléatoire est sélectionnée, le meilleur seuil de division est calculé et les données sont divisées en conséquence. Ensuite, ce processus est appliqué de manière récursive aux deux sous-arbres jusqu'à ce que les conditions d'interruption soient remplies.

Le site predict()-La fonction de prédiction génère des prédictions pour de nouvelles données en agrégeant les prédictions de tous les arbres de décision. La fonction predict_tree()-La fonction prend une décision sur la base des données et de l'arbre de décision actuel.

La fonction best_split() sélectionne la meilleure fonction et le meilleur seuil pour une séparation des nœuds de décision en calculant le gain d'information. Le site information_gain()-La fonction "Gain" calcule le gain d'information sur la base du seuil actuel, tandis que la fonction "Gain" calcule le gain d'information sur la base de la valeur de seuil actuelle. entropy() calcule l'entropie d'un nœud. Le site split()La fonction de décision divise les données en deux sous-ensembles, un pour chaque branche de l'arbre de décision. La fonction most_common_label() renvoie l'étiquette la plus fréquente.

Dans l'ensemble, il s'agit d'un exemple de code robuste qui représente une implémentation claire de l'algorithme Random Forest en Python. Il utilise différentes techniques telles que le bootstrapping, l'échantillonnage de caractéristiques et les calculs d'entropie afin d'obtenir une prédiction précise.

Exemple de code Random Forest

Voici un exemple de code pour implémenter une forêt aléatoire en Python :

import numpy as np
from collections import Counter
from sklearn.datasets import make_classification
class Node :
    def __init__(self, feature_idx=None, threshold=None, left=None, right=None, value=None) :
        self.feature_idx = feature_idx
        self.threshold = seuil
        self.left = left
        self.right = droite
        self.value = valeur
class RandomForest :
    def __init__(self, n_trees=10, max_depth=5, min_samples_split=5) :
        self.n_trees = n_trees
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.trees = []
    def fit(self, X, y) :
        n_samples, n_features = X.shape
        for i in range(self.n_trees) :
            sample_idxs = np.random.choice(n_samples, n_samples, replace=True)
            X_bootstrap = X[sample_idxs]
            y_bootstrap = y[sample_idxs]
            tree = self.build_tree(X_bootstrap, y_bootstrap, 0)
            self.trees.append(arbre)
    def build_tree(self, X, y, depth) :
        n_samples, n_features = X.shape
        n_labels = len(np.unique(y))
        if depth == self.max_depth or n_labels == 1 or n_samples < self.min_samples_split :
            leaf_value = self.most_common_label(y)
            return Node(valeur=leaf_value)
        feature_idxs = np.random.choice(n_features, int(np.sqrt(n_features)), replace=False)
        best_feature_idx, best_threshold = self.best_split(X, y, feature_idxs)
        left_idxs, right_idxs = self.split(X[ :, best_feature_idx], best_threshold)
        left = self.build_tree(X[left_idxs, :], y[left_idxs], depth+1)
        right = self.build_tree(X[right_idxs, :], y[right_idxs], depth+1)
        return Node(best_feature_idx, best_threshold, left, right)
    def predict(self, X) :
        predictions = np.zeros((X.shape[0], len(self.trees)))
        for i, tree in enumerate(self.trees) :
            predictions[ :, i] = self.predict_tree(X, tree)
        return np.round(np.mean(predictions, axis=1))
    def predict_tree(self, X, tree) :
        if tree.value is not None :
            return tree.value
        if X[tree.feature_idx]  best_gain :
                best_gain = gain
                split_idx = feature_idx
                split_threshold = seuil
    return split_idx, split_threshold
def information_gain(self, y, X_column, split_threshold) :
    parent_entropy = self.entropy(y)
    left_idxs, right_idxs = self.split(X_column, split_threshold)
    if len(left_idxs) == 0 or len(right_idxs) == 0 :
        return 0
    n = len(y)
    n_l, n_r = len(left_idxs), len(right_idxs)
    e_l, e_r = self.entropy(y[left_idxs]), self.entropy(y[right_idxs])
    child_entropy = (n_l/n)*e_l + (n_r/n)*e_r
    ig = parent_entropy - child_entropy
    return ig
def entropy(self, y) :
    _, counts = np.unique(y, return_counts=True)
    probabilités = counts / len(y)
    entropy = sum(probabilities * -np.log2(probabilities))
    return entropy
def split(self, X_column, threshold) :
    left_idxs = np.argwhere(X_column  threshold).flatten()
    return left_idxs, right_idxs
def most_common_label(self, y) :
    counter = Counter(y)
    most_common = counter.most_common(1)
    return most_common[0][0]

Générer des données et adapter le modèle RandomForest

X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
rf = RandomForest(n_trees=10, max_depth=5, min_samples_split=5) rf.fit(X, y)

Faire des prédictions

X_test = np.random.randn(10, 10)
predictions = rf.predict(X_test)

Il s'agit d'une implémentation très simple de l'algorithme Random Forest en Python. Cependant, comme vous pouvez le constater, elle est très compliquée et nécessite de prendre en compte de nombreuses choses. Par exemple, la vérification que la profondeur de l'arbre est atteinte, l'utilisation d'arbres de décision et la réconciliation des prédictions.

C'est pourquoi, dans la pratique, on utilise souvent des paquets pour implémenter une Random Forest. Vous trouverez ci-dessous cinq paquets Python différents qui vous permettront d'implémenter Random Forest.

Random Forest avec Scikit-Learn

Scikit-Learn est un package très populaire dans le monde de l'apprentissage automatique et offre de nombreux algorithmes et fonctionnalités. Avec Scikit-Learn, vous pouvez implémenter des forêts aléatoires avec seulement quelques lignes de code.

Voici un exemple de code :

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
# Création des données et adaptation du modèle RandomForest
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
rf = RandomForestClassifier(n_estimators=10, max_depth=5, min_samples_split=5, random_state=42)
rf.fit(X, y)
# Faire des prédictions
X_test = np.random.randn(10, 10)
predictions = rf.predict(X_test)
print(predictions)

Forêt aléatoire dans XGBoost

XGBoostiest un package spécialement conçu pour être utilisé dans les arbres de décision et les algorithmes de boosting de gradient.

a été développé. Il est rapide et offre de nombreuses options pour la personnalisation des modèles. XGBoost supporte également les modèles de forêts aléatoires.

Voici un exemple de code :

import xgboost as xgb
from sklearn.datasets import make_classification
# Générer des données
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
# Créer une structure de données XGBoost
dtrain = xgb.DMatrix(X, label=y)
# Définir les hyperparamètres
params = {
    "objective" : "multi:softprob",
    "eval_metric" : "mlogloss",
    "num_class" : len(np.unique(y)),
    "max_depth" : 5,
    "subsample" : 0.8,
    "colsample_bytree" : 0.8,
    "seed" : 42
}
# Personnaliser le modèle
num_round = 10
bst = xgb.train(params, dtrain, num_round)
# Faire des prédictions
X_test = np.random.randn(10, 10)
dtest = xgb.DMatrix(X_test)
predictions = bst.predict(dtest)
print(predictions)

Implémenter des arbres de décision dans LightGBM

LightGBM est un autre package rapide pour les arbres de décision et les algorithmes de boosting de gradient. Il offre également une option pour les modèles de forêts aléatoires.

Voici un exemple de code :

import lightgbm as lgb
from sklearn.datasets import make_classification
# Générer des données
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
# Créer une structure de données LightGBM
lgb_train = lgb.Dataset(X, y)
# Définir les hyperparamètres
params = {
    "objective" : "multiclass",
    "num_class" : len(np.unique(y)),
    "max_depth" : 5,
    "subsample" : 0.8,
    "colsample_bytree" : 0.8,
    "seed" : 42
}
# Personnaliser le modèle
num_round = 10
bst = lgb.train(params, lgb_train, num_round)
# Faire des prédictions
X_test = np.random.randn(10, 10)
predictions = bst.predict(X_test)
print(predictions)

RandomForestRegressor et RandomForestClassifier dans les modèles de stats

Statsmodels est un paquet spécialisé dans la modélisation et l'analyse statistiques. Il offre également des options pour les modèles de forêts aléatoires.

Voici un exemple de code pour RandomForestRegressor :

import statsmodels.api as sm
from sklearn.datasets import make_regression
# Générer des données
X, y = make_regression(n_samples=100, n_features=10, random_state=42)
# Ajuster le modèle
rf = sm.OLS(y, X)
result = rf.fit()
# Faire des prédictions
X_test = np.random.randn(10, 10)
predictions = result.predict(X_test)
print(predictions)

Voici un exemple de code pour RandomForestClassifier :

import statsmodels.api as sm
from sklearn.datasets import make_classification
# Générer des données
X, y = make_classification(n_samples=100, n_features=10, random_state=42)
# Ajuster le modèle
rf = sm.discrete_model.RandomForest(y, X)
result = rf.fit()
# Faire des prédictions
X_test = np.random.randn(10, 10)
predictions = result.predict(X_test)
print(predictions)

Conclusion

Random Forest est un site populaire Algorithme dans le monde de l'apprentissage automatique et est souvent utilisé pour faire des prédictions. Il existe de nombreux paquets en Python qui facilitent l'implémentation de modèles de forêts aléatoires, comme Scikit-Learn, XGBoost, LightGBM et Statsmodels. En fonction de vos besoins et de la quantité de données, vous pouvez choisir le paquet qui vous convient le mieux.

"
"
Avatar de Florian Zyprian

Derniers articles