Qu’est-ce que la technique Random Forest en Python ?

Qu'est-ce que la technique Random Forest en Python ?

Random forest est un puissant algorithme d'apprentissage d'ensemble qui peut être appliqué à des problèmes tels que la classification et la régression. Il se compose de plusieurs arbres de décision pour améliorer la précision et la robustesse d’une manière collective. Les dépendances de la bibliothèque Python requises pour créer des forêts aléatoires incluent le package de forêt aléatoire utilisant scikit-learn (sklearn).

Qu'est-ce que Random Forest ?

Random forest est un modèle d'apprentissage supervisé qui prédit la valeur d'une variable de sortie par entraînement sur un ensemble de données. Il fonctionne avec des variables de sortie continues ou discrètes. La forêt aléatoire se compose de plusieurs arbres de décision. Il sélectionne aléatoirement des variables et des points de partage sur les points de partage construits.

Quels sont les avantages de la forêt aléatoire ?

Random Forest présente plusieurs avantages importants qui en font l'une des techniques de prédiction les plus populaires dans la science des données moderne :

1. Haute précision : Random Forest a généralement une précision plus élevée que les autres algorithmes d'apprentissage automatique. Il excelle dans la gestion des données manquantes et de l'incertitude.
2. Idéal pour les grands ensembles de données : les forêts aléatoires s'adaptent très bien aux grands problèmes de science des données, car elles consomment les ressources du système plus efficacement en raison de leur structure d'ensemble naturelle.
3. Peut gérer plusieurs types de variables : la forêt aléatoire n'est pas limitée par le type de données ou le type de variable.
4. Peut déterminer l'importance des fonctionnalités : une forêt aléatoire peut mesurer l'impact de chaque variable de l'ensemble de données sur le modèle et déduire les tendances et les modèles les plus importants dans les données en fonction de l'importance des variables.

Comment implémenter une forêt aléatoire en utilisant Python ?

L'implémentation de random forest nécessite l'installation de la bibliothèque Python scikit-learn (sklearn). Les étapes d'installation sont les suivantes :

pip install scikit-learn

Après l'installation, nous pouvons utiliser l'API fournie par la bibliothèque sklearn pour implémenter une forêt aléatoire.

Avant cela, vous devez charger les bibliothèques requises :

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

De manière générale, nous pouvons effectuer les quatre étapes suivantes pour entraîner un modèle de forêt aléatoire et l'utiliser pour faire des prédictions.

1. Chargement des données

Dans cet exemple de code, nous utilisons l'ensemble de données Iris intégré de scikit-learn :

def load_data():
    data = load_iris()
    return data.data, data.target

2. Construction du modèle

Dans cette étape, nous construisons un classificateur de forêt aléatoire à l'aide de la classe RandomForestClassifier. Le paramètre n_estimators définit le nombre d'arbres dans la forêt, où chaque arbre est formé avec des échantillons et des variables aléatoires. Le nombre recommandé d’arbres à choisir dépend de la taille du problème particulier. Dépasser ce nombre entraînera une augmentation du temps de formation, tandis qu'un nombre insuffisant d'arbres peut entraîner un surajustement du modèle : n_estimators参数定义了森林的树数量，其中每个树在随机的样本和变量下训练。建议选择的树数取决于特定问题的大小。超出此数量会导致训练时间增加，而过少的树数可能导致模型过度拟合：

def create_model():
    model = RandomForestClassifier(n_estimators=100,
                                   max_depth=3,
                                   random_state=0)
    return model

在本例中，我们选择树的数量为100，并根据数据集的大小选择深度。我们将max_depth设置为3，以避免过度拟合。

3. 拆分数据

在拟合和评估模型之前，我们需要将数据集拆分为训练集和测试集。在此示例中，我们将训练数据的70％用于训练模型，余下的30％用于评估模型：

def train_test_split_data(X, y, test_size=0.3):
    return train_test_split(X, y, test_size=test_size, random_state=0)

4. 训练与评估模型

在此步骤中，我们使用拆分的数据进行训练和测试。我们使用fit()

def train_model(model, X_train, y_train):
    model.fit(X_train, y_train)
    return model

def evaluate_model(model, X_test, y_test):
    accuracy = model.score(X_test, y_test)
    return accuracy

Dans cet exemple, nous choisissons le nombre d'arbres à 100 et la profondeur en fonction de la taille de l'ensemble de données. Nous définissons max_degree sur 3 pour éviter le surajustement.

Diviser les données

Avant d'ajuster et d'évaluer le modèle, nous devons diviser l'ensemble de données en un ensemble d'entraînement et un ensemble de test. Dans cet exemple, nous utilisons 70 % des données d'entraînement pour entraîner le modèle et les 30 % restants pour évaluer le modèle :

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

def load_data():
    data = load_iris()
    return data.data, data.target

def create_model():
    model = RandomForestClassifier(n_estimators=100,
                                    max_depth=3,
                                    random_state=0)
    return model

def train_test_split_data(X, y, test_size=0.3):
    return train_test_split(X, y, test_size=test_size, random_state=0)

def train_model(model, X_train, y_train):
    model.fit(X_train, y_train)
    return model

def evaluate_model(model, X_test, y_test):
    accuracy = model.score(X_test, y_test)
    return accuracy

if __name__ == "__main__":
    X, y = load_data()
    X_train, X_test, y_train, y_test = train_test_split_data(X, y)
    model = create_model()
    trained_model = train_model(model, X_train, y_train)
    accuracy = evaluate_model(trained_model, X_test, y_test)
    print("Accuracy:", accuracy)

🎜Formation et évaluation du modèle🎜🎜🎜Dans cette étape, nous Utilisez des données fractionnées pour la formation et les tests. Nous entraînons le modèle à l'aide de la méthode fit() et évaluons l'exactitude du modèle à l'aide de données de test : 🎜rrreee🎜Le code complet est le suivant : 🎜rrreee🎜Conclusion🎜🎜Les étapes pour implémenter la forêt aléatoire en Python incluent le chargement de données, la création de modèles, le fractionnement des données, l'entraînement et l'évaluation des modèles. Les modèles de forêt aléatoire peuvent être utilisés pour résoudre efficacement les problèmes de classification et de régression et prendre en charge le traitement de plusieurs types de variables. Les forêts aléatoires étant si flexibles, elles peuvent être utilisées dans un large éventail de scénarios d’application. 🎜

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!