LazyPredict : une bibliothèque Python utilitaire

Table des matières

Introduction
Installation du module LazyPredict
Implémentation de LazyPredict dans un modèle de classification
Implémentation de LazyPredict dans un modèle de régression
Conclusion

Introduction

Le développement de modèles d’apprentissage automatique est révolutionné par le package Python de pointe connu sous le nom de LazyPredict. En utilisant LazyPredict, nous pouvons créer rapidement une variété de modèles fondamentaux avec peu ou pas de code, libérant ainsi notre temps pour choisir le modèle qui fonctionnerait le mieux avec nos données.

La sélection de modèles peut être facilitée à l’aide de la bibliothèque sans nécessiter un ajustement considérable des paramètres, ce qui est l’un de ses principaux avantages. LazyPredict offre un moyen rapide et efficace de trouver et d’adapter les meilleurs modèles à nos données.

Explorons et apprenons plus sur l’utilisation de cette bibliothèque dans cet article.

Installation du module LazyPredict

L’installation de la bibliothèque LazyPredict est une tâche assez simple. Nous n’avons besoin d’utiliser qu’une seule ligne de code comme nous le faisons habituellement pour installer n’importe quelle autre bibliothèque Python :

Implémentation de LazyPredict dans un modèle de classification

Nous utiliserons l’ensemble de données sur le cancer du sein du package Sklearn dans cet exemple.

Maintenant, chargeons les données :

from sklearn.datasets import load_breast_cancer
from lazypredict.Supervised import LazyClassifier

data = load_breast_cancer()
X = data.data
y= data.target

Pour choisir le meilleur modèle de classificateur, déployons maintenant l’algorithme « LazyClassifier ». Ces caractéristiques et paramètres d’entrée s’appliquent à la classe :

LazyClassifier(
    verbose=0,
    ignore_warnings=True,
    custom_metric=None,
    predictions=False,
    random_state=42,
    classifiers="all",
)

Appliquons-le maintenant à nos données et adaptons-le :

from lazypredict.Supervised import LazyClassifier
from sklearn.model_selection import train_test_split

# split the data
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.3,random_state =0)

# build the lazyclassifier
clf = LazyClassifier(verbose=0,ignore_warnings=True, custom_metric=None)

# fit it
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

# print the best models
print(models)

Le code ci-dessus affiche :

Ensuite, nous pouvons procéder comme suit pour examiner les détails individuels de ces modèles :

model_dictionary = clf.provide_models(X_train,X_test,y_train,y_test)

Ensuite, utilisez le nom du modèle qui nous intéresse (choisissons le meilleur modèle) pour déterminer précisément quelles étapes ont été utilisées :

model_dictionary['LGBMClassifier']

Ici, nous pouvons voir qu’un SimpleImputer a été utilisé sur l’ensemble des données, suivi d’un StandardScaler sur les caractéristiques numériques. Il n’y a pas d’entités catégorielles ou ordinales dans cet ensemble de données, mais s’il y en avait, OneHotEncoder et OrdinalEncoder auraient été utilisés, respectivement. Le LGBMClassifier le modèle reçoit les données après transformation et imputation.

LazyClassifier’s les modèles internes d’apprentissage automatique sont évalués et ajustés à l’aide de la boîte à outils sci-kit-learn. Le LazyClassifier La fonction construit et adapte automatiquement une variété de modèles, y compris des arbres de décision, des forêts aléatoires, des machines à vecteurs de support et autres, sur nos données lorsqu’elle est appelée. Un ensemble de critères de performance, tels que la précision, le rappel ou le score F1, que vous fournissez sont ensuite utilisés pour évaluer les modèles. L’ensemble d’apprentissage est utilisé pour l’ajustement, tandis que l’ensemble de test est utilisé pour l’évaluation.

Suite à l’évaluation et à l’ajustement des modèles, LazyClassifier propose un résumé des résultats (le tableau ci-dessus), ainsi qu’une liste des meilleurs modèles et des mesures de performance pour chaque modèle. Sans avoir besoin de peaufinage manuel ou de sélection de modèle, vous pouvez évaluer rapidement et simplement les performances de nombreux modèles et choisir le meilleur pour nos données.

Implémentation de LazyPredict dans un modèle de régression

En utilisant la fonction « LazyRegressor », nous pouvons, encore une fois, accomplir la même chose pour les modèles de régression.

Importons un jeu de données qui conviendra à une tâche de régression (ici, nous pouvons utiliser le jeu de données de Boston).

Ajustons maintenant nos données au LazyRegressor En l’utilisant:

from lazypredict.Supervised import LazyRegressor
from sklearn import datasets
from sklearn.utils import shuffle
import numpy as np

# load the data
boston = datasets.load_boston()
X, y = shuffle(boston.data, boston.target, random_state=0)
X = X.astype(np.float32)

# split the data
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.3,random_state =0)

# fit the lazy object
reg = LazyRegressor(verbose=0, ignore_warnings=False, custom_metric=None)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

# print the results in a table
print(models)

Le code ci-dessus affiche :

Voici un examen détaillé du meilleur modèle de régression :

model_dictionary = reg.provide_models(X_train,X_test,y_train,y_test)
model_dictionary['ExtraTreesRegressor']

Ici, nous pouvons voir qu’un SimpleImputer a été utilisé sur l’ensemble des données, suivi d’un StandardScaler sur les caractéristiques numériques. Il n’y a pas d’entités catégorielles ou ordinales dans cet ensemble de données, mais s’il y en avait, OneHotEncoder et OrdinalEncoder auraient été utilisés, respectivement. Le ExtraTreesRegressor le modèle reçoit les données après transformation et imputation.

Conclusion

La bibliothèque LazyPredict est une ressource utile pour toute personne impliquée dans l’industrie de l’apprentissage automatique. LazyPredict permet d’économiser du temps et des efforts en automatisant le processus de création et d’évaluation des modèles, ce qui améliore considérablement l’efficacité du processus de sélection des modèles. LazyPredict offre une méthode simple et rapide pour comparer l’efficacité de plusieurs modèles et déterminer quelle famille de modèles est la meilleure pour nos données et notre problème en raison de sa capacité à ajuster et à évaluer plusieurs modèles simultanément.

Le lien suivant contient tous les exemples de programmation téléchargés sur le référentiel GitHub afin que vous puissiez jouer avec les codes en fonction de vos besoins.

J’espère que vous avez maintenant une compréhension intuitive de la bibliothèque LazyPredict, et que ces concepts vous aideront à construire des projets vraiment précieux.