Introduction à AutoML : automatisation des flux de travail d'apprentissage automatique

AutoML est un outil conçu pour les experts techniques et non techniques. Cela simplifie le processus de formation des modèles d’apprentissage automatique. Tout ce que vous avez à faire est de lui fournir l’ensemble de données, et en retour, il vous fournira le modèle le plus performant pour votre cas d’utilisation. Vous n’avez pas besoin de coder pendant de longues heures ou d’expérimenter diverses techniques ; il fera tout tout seul pour vous.

Dans ce didacticiel, nous découvrirons AutoML et TPOT, un outil Python AutoML permettant de créer des pipelines d'apprentissage automatique. Nous apprendrons également à créer un classificateur d'apprentissage automatique, à enregistrer le modèle et à l'utiliser pour l'inférence de modèle.

Qu’est-ce qu’AutoML ?

AutoML, ou Automated Machine Learning, est un outil dans lequel vous fournissez un ensemble de données et il effectuera toutes les tâches en back-end pour vous fournir un modèle d'apprentissage automatique très performant. AutoML effectue diverses tâches telles que le prétraitement des données, la sélection des fonctionnalités, la sélection du modèle, le réglage des hyperparamètres, l'assemblage du modèle et l'évaluation du modèle. Même un utilisateur non technique peut créer un modèle d'apprentissage automatique très complexe à l'aide des outils AutoML.

En utilisant des algorithmes et des techniques avancés d'apprentissage automatique, les systèmes AutoML peuvent découvrir automatiquement les meilleurs modèles et configurations pour un ensemble de données donné, réduisant ainsi le temps et les efforts nécessaires au développement de modèles d'apprentissage automatique.

1. Premiers pas avec TPOT

TPOT (Tree-based Pipeline Optimization Tool) est l'outil AutoML le plus simple et le plus populaire qui utilise la programmation génétique pour optimiser les pipelines d'apprentissage automatique. Il explore automatiquement des centaines de pipelines potentiels pour identifier le modèle le plus efficace pour un ensemble de données donné.

Vous pouvez installer TPOT à l'aide de la commande suivante sur votre système.

!pip install tpot==0.12.2

Chargez les bibliothèques Python nécessaires pour charger et traiter les données et entraîner le modèle de classification.

import numpy as np
import pandas as pd
from tpot import TPOTClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer

2. Chargement des données

Pour ce tutoriel, nous utilisons le Mushroom Dataset de Kaggle qui contient 9 fonctionnalités pour déterminer si le champignon est toxique ou non.

Nous chargerons l'ensemble de données à l'aide de Pandas et sélectionnerons au hasard 1 000 échantillons dans l'ensemble de données.

data = pd.read_csv('mushroom_cleaned.csv')
data = data.sample(n=1000, random_state=55)
data.head()

3. Traitement des données

La colonne « classe » est notre variable cible, qui contient deux valeurs : 0 ou 1, où 0 fait référence à un produit non toxique et 1 à un produit toxique. Nous l'utiliserons pour créer des variables indépendantes et dépendantes. Après cela, nous le diviserons en un ensemble de données d'entraînement et de test.

X = data.drop('class', axis=1)
y = data['class'].values

# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=55)

4. Construction et installation du classificateur TPOT

Nous allons lancer le classificateur TPOT et le former à l'aide d'un ensemble de formation. Le modèle expérimentera divers modèles et techniques et renverra le modèle et le pipeline les plus performants.

# Initialize TPOTClassifier
tpot = TPOTClassifier(verbosity=2, generations=5, population_size=20, random_state=55)

# Fit the classifier to the training data
tpot.fit(X_train, y_train)

Nous avons obtenu différents scores pour différentes générations et le meilleur pipeline.

Évaluons notre meilleur pipeline sur l'ensemble de données de test en utilisant la fonction .score.

# Evaluate the model on the test set
print(tpot.score(X_test, y_test))

Je pense que nous avons un modèle assez stable et précis.

0.875

5. Enregistrement du pipeline et du modèle TPOT

Pour enregistrer le pipeline TPOT, nous utiliserons la fonction .export et lui fournirons le nom du fichier et l'extension .py.

tpot.export('tpot_mashroom_pipeline.py')

Le fichier sera enregistré sous forme de fichier Python avec le code contenant le meilleur pipeline. Pour exécuter le pipeline, vous devez apporter quelques modifications aux noms du répertoire, du séparateur et des colonnes cibles de l'ensemble de données.

tpot_mashroom_pipeline.py :

import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.feature_selection import SelectFromModel
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from tpot.export_utils import set_param_recursive

# NOTE: Make sure that the outcome column is labeled 'target' in the data file
tpot_data = pd.read_csv('PATH/TO/DATA/FILE', sep='COLUMN_SEPARATOR', dtype=np.float64)
features = tpot_data.drop('target', axis=1)
training_features, testing_features, training_target, testing_target = \
            train_test_split(features, tpot_data['target'], random_state=55)

# Average CV score on the training set was: 0.8800000000000001
exported_pipeline = make_pipeline(
    SelectFromModel(estimator=ExtraTreesClassifier(criterion="entropy", max_features=0.9000000000000001, n_estimators=100), threshold=0.1),
    ExtraTreesClassifier(bootstrap=False, criterion="gini", max_features=0.9500000000000001, min_samples_leaf=4, min_samples_split=2, n_estimators=100)
)

# Fix random state for all the steps in exported pipeline
set_param_recursive(exported_pipeline.steps, 'random_state', 55)

exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(testing_features)

Vous pouvez même enregistrer le modèle en utilisant la bibliothèque joblib en tant que fichier pickle. Ce fichier contient les poids du modèle et le code pour exécuter l'inférence du modèle.

import joblib

joblib.dump(tpot.fitted_pipeline_, 'tpot_mashroom_pipeline.pkl')

6. Chargement du pipeline TPOT et de l'inférence de modèle

Nous allons charger le modèle enregistré à l'aide de la fonction joblib.load et prédire les 10 meilleurs échantillons de l'ensemble de données de test.

model = joblib.load('tpot_mashroom_pipeline.pkl')

print(y_test[0:10])
print(model.predict(X_test[0:10]))

Notre modèle est précis car les étiquettes réelles sont similaires aux étiquettes prédites.

[1 1 1 1 1 1 0 1 0 1]
[1 1 1 1 1 1 0 1 0 1]

Résumé

Dans ce didacticiel, nous avons découvert AutoML et comment il peut être utilisé par n'importe qui, même par des utilisateurs non techniques. Nous avons également appris à utiliser TPOT, un outil AutoML Python qui effectue automatiquement le traitement des données, la sélection des fonctionnalités, la sélection du modèle, le réglage des hyperparamètres, l'assemblage de modèles et l'évaluation du modèle. A la fin de la formation du modèle, nous obtenons le modèle le plus performant et le pipeline en exécutant deux lignes de code. Nous pouvons même enregistrer le modèle et l'utiliser pour créer une application d'IA.