En utilisant la bibliothèque Lazy Predict, nous pouvons comparer les algorithmes de classification et de régression les plus performants sans effort. Cette bibliothèque a été rédigée par «Shankar Rao Pandala» et voici le lien vers la documentation.

Nous allons utiliser l'ensemble de données sur le cancer du sein pour comparer les algorithmes de classification et l'ensemble de données sur le logement de Boston pour comparer les algorithmes de régression avec seulement quelques lignes de code pour chaque tâche utilisant cette bibliothèque.

Tâche de classification:

Installation de la bibliothèque:

! pip installer lazypredict

Utilisez la commande ci-dessus pour installer la bibliothèque lazypredict

Importation des bibliothèques nécessaires et des données sur le cancer du sein:

# Importer les bibliothèques
importer lazypredict
depuis lazypredict.Supervised importer LazyClassifier
depuis sklearn.datasets importer load_breast_cancer
depuis sklearn.model_selection importer train_test_split

# Charger le jeu de
données data = load_breast_cancer ()
X = data.data
y = data.target

Maintenant, nous allons diviser les données en rapport 80/20:

# Données fractionnées
X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = .2, random_state = 100)

Attribution de lazyclassifier:

# Définit et construit le lazyclassifier
clf = LazyClassifier (verbose = 0, ignore_warnings = True, custom_metric = None)
models_train, predictions_train = clf.fit (X_train, X_train, y_train, y_train)
models_test, predictions_test = clf.fit (X_test y_train, y_test)

Performances des données du train:

# Imprime les performances du modèle sur l'ensemble d'entraînement
models_train

Tester les performances des données:

# Imprime les performances du modèle sur le jeu de données de test
models_test

À partir des images ci-dessus, nous pouvons comprendre comment différents algorithmes de classification (environ 28 modèles) sont construits et nous pouvons comparer leurs précisions, les scores ROC AUC et F1 ainsi que leur temps de construction.

Créons un diagramme à barres pour comparer ces modèles à l'aide des bibliothèques seaborn et matplot.

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure (figsize = (5, 10))
sns.set_theme (style = ”whitegrid”)
ax = sns.barplot (y = models_train.index, x = ”Précision”, data = models_train)

À partir du diagramme à barres ci-dessus, nous pouvons décider quel algorithme convient le mieux à notre énoncé de problème et l'ajuster davantage pour de meilleures performances.

Tâche de régression:

# Chargement de l'ensemble de données du logement
boston boston = datasets.load_boston ()
X, y = shuffle (boston.data, boston.target, random_state = 42)

Maintenant, nous allons diviser les données en rapport 80/20:

# Données fractionnées
X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = .2, random_state = 42)

Attribution de lazyregressor:

# Définit et construit le lazyclassifier
reg = LazyRegressor (verbose = 0, ignore_warnings = False, custom_metric = None)
models_train, predictions_train = reg.fit (X_train, X_train, y_train, y_train)
models_test, predictions_test = reg.fit (X_test y_train, y_test)

Performances des données du train:

# Imprime les performances du modèle sur le jeu de données d'entraînement
models_train

Tester les performances des données:

# Imprime les performances du modèle sur le jeu de données de test
models_test

À partir des images ci-dessus, nous pouvons comprendre comment divers algorithmes de régression (environ 36 modèles) sont construits et nous pouvons comparer leurs valeurs R-carré, RMSE avec leur temps de construction.

Créons un diagramme à barres pour comparer ces modèles à l'aide des bibliothèques seaborn et matplot.

import matplotlib.pyplot as plt
import seaborn as sns

models_train [“R-Squared”] = [0 if i <0 else i for i in models_train.iloc [:, 0]]

plt.figure (figsize = (5, 10))
sns.set_theme (style = ”whitegrid”)
ax = sns.barplot (y = models_train.index, x = ”R-Squared”, data = models_train)
ax.set ( xlim = (0, 1))

Il s'agit d'un moyen simple de créer plusieurs modèles d'apprentissage automatique en utilisant seulement quelques lignes de code. Si nous essayons de construire manuellement ces modèles de ML individuellement, cela prendrait beaucoup de temps entre l'importation des bibliothèques respectives, leur construction individuelle et l'agrégation de leurs résultats de prédiction. À partir du diagramme à barres ci-dessus, nous pouvons arriver à une conclusion concernant l'algorithme qui fonctionne bien et décider de le peaufiner davantage pour de meilleures performances.

Remarque :

La bibliothèque LazyPredict nous permet de construire les modèles avec leurs paramètres par défaut. Nous ne pouvons pas optimiser les paramètres mais il construira ces modèles avec leurs paramètres par défaut, ce qui est toujours bon puisque nous avons pu les construire rapidement et une fois que nous avons identifié quel modèle est le meilleur, nous pouvons concentrer nos efforts sur la réalisation d'une optimisation d'hyper paramètres pour ce ML algorithme.

Alors qu'en pensez-vous les gars? Je serai intéressé de savoir ce que vous en pensez. J'espère vous avoir donné une brève idée sur la façon de créer rapidement des modèles ML en utilisant seulement quelques lignes de code. Donnez-lui un 💚, si vous aimez cet article pour une motivation supplémentaire. Je suis toujours ouvert à vos suggestions et questions.