AutoML dans Fabric (aperçu)

AutoML (Machine Learning automatisé) est une collection de méthodes et d’outils qui automatisent l’entraînement et l’optimisation des modèles Machine Learning avec peu d’implication humaine. L’objectif d’AutoML est de simplifier et d’accélérer le processus de choix du meilleur modèle Machine Learning et des hyperparamètres pour un jeu de données donné, ce qui demande généralement beaucoup de compétences et de puissance de calcul.

Important

Cette fonctionnalité est en version préliminaire.

Dans Fabric, les scientifiques des données peuvent utiliser flaml.AutoML pour automatiser leurs tâches d’apprentissage automatique.

AutoML peut aider les professionnels du ML et les développeurs de différents secteurs à :

• Créer des solutions ML avec un minimum de codage
• Réduire les délais et les coûts
• Appliquer les meilleures pratiques de la science des données
• Résoudre les problèmes rapidement et efficacement

Flux de travail AutoML

flaml.AutoML est une classe pour AutoML basée sur la tâche. Elle peut être utilisée comme un estimateur de type Scikit-learn avec les méthodes habituelles d’ajustement et de prédiction.

Pour démarrer un essai AutoML, les utilisateurs n’ont qu’à fournir les données d’entraînement et le type de tâche. Grâce aux expériences MLflow intégrées dans Fabric, les utilisateurs peuvent également examiner les différentes exécutions qui ont été tentées dans l’essai pour voir comment le modèle final a été choisi.

Données de formation

Dans Fabric, les utilisateurs peuvent transmettre les types d’entrée suivants à la fonction AutoML fit :

• Tableau Numpy : lorsque les données d’entrée sont stockées dans un tableau Numpy, elles sont transmises à fit() en tant que X_train et y_train.

• Dataframe Pandas : lorsque les données d’entrée sont stockées dans un dataframe Pandas, elles sont transmises à fit() soit sous forme de X_train et y_train, soit sous forme de dataframe et d’étiquette.

• Dataframe Pandas sur Spark : lorsque les données d’entrée sont stockées sous forme de dataframe Spark, elles peuvent être converties en dataframe Pandas sur Spark à l’aide de to_pandas_on_spark(), puis transmises à fit() sous forme de dataframe et d’étiquette.

  from flaml.automl.spark.utils import to_pandas_on_spark
  psdf = to_pandas_on_spark(sdf)
  automl.fit(dataframe=psdf, label='Bankrupt?', isUnbalance=True, **settings)
  

Problème d’apprentissage automatique

Les utilisateurs peuvent spécifier la tâche d’apprentissage automatique en utilisant l’argument task. Il existe une variété de tâches d’apprentissage automatique prises en charge, y compris :

• Classification : l’objectif principal des modèles de classification est de prédire les catégories dans lesquelles les nouvelles données sont classées, sur la base des apprentissages de leurs données d’entraînement. Les exemples de classification courants incluent la détection des fraudes, la reconnaissance de l’écriture manuscrite et la détection d’objets.
• Régression : les modèles de régression prédisent des valeurs de sortie numériques basées sur des prédicteurs indépendants. Dans une régression, l’objectif est d’aider à établir la relation entre ces variables de prédiction indépendantes en estimant l’impact d’une variable sur les autres. Par exemple, le coût de l’automobile basé sur des caractéristiques telles que la consommation de carburant, la cote de sécurité, etc.
• Prévision de série chronologique : cette tâche est utilisée pour prédire les valeurs futures sur la base de points de données historiques classés dans le temps. Dans une série chronologique, les données sont collectées et enregistrées à intervalles réguliers sur une période spécifique, par exemple quotidienne, hebdomadaire, mensuelle ou annuelle. L’objectif des prévisions de série chronologique est d’identifier les modèles, les tendances et la saisonnalité dans les données, puis d’utiliser ces informations pour faire des prédictions sur la valeur future.

Pour en savoir plus sur les autres tâches prises en charge par FLAML, vous pouvez consulter la documentation sur les tâches AutoML dans FLAML.

Entrées facultatives

Fournissez différentes contraintes et entrées pour configurer votre évaluation d’AutoML.

Contraintes

Lors de la création d’un essai AutoML, les utilisateurs peuvent également configurer des contraintes sur le processus AutoML, les arguments du constructeur des estimateurs potentiels, les types de modèles testés dans AutoML et même des contraintes sur les métriques de l’essai AutoML.

Par exemple, le code ci-dessous permet aux utilisateurs de spécifier une contrainte de métrique sur l’essai AutoML.

metric_constraints = [("train_loss", "<=", 0.1), ("val_loss", "<=", 0.1)]
automl.fit(X_train, y_train, max_iter=100, train_time_limit=1, metric_constraints=metric_constraints)

Pour en savoir plus sur ces configurations, vous pouvez consulter la documentation sur les configurations dans FLAML.

Métrique d’optimisation

Pendant l’entraînement, la fonction AutoML crée de nombreux essais qui testent différents algorithmes et paramètres. L’outil AutoML itère à travers les algorithmes ML et les hyperparamètres. Dans ce processus, chaque itération crée un modèle avec un score d’entraînement. Plus le score de la métrique que vous souhaitez optimiser est élevé, plus le modèle est considéré comme « adapté » à vos données. La métrique d’optimisation est spécifiée via l’argument metric. Il peut s’agir d’une chaîne de caractères faisant référence à une métrique prédéfinie ou d’une fonction définie par l’utilisateur.

Métriques d’optimisation AutoML

Réglage en parallèle

Dans certains cas, vous voudrez peut-être accélérer votre essai AutoML en utilisant Apache Spark pour paralléliser votre entraînement. Pour les clusters Spark, par défaut, FLAML lance un essai par exécuteur. Vous pouvez également personnaliser le nombre d’essais simultanés en utilisant l’argument n_concurrent_trials.

automl.fit(X_train, y_train, n_concurrent_trials=4, use_spark=True)

Pour en savoir plus sur la manière de paralléliser vos essais AutoML, vous pouvez consulter la documentation FLAML pour les tâches Spark parallèles.

Suivre avec MLflow

Vous pouvez également profiter de l’intégration MLflow de Fabric pour capturer les métriques, les paramètres et les métriques des pistes explorées.

import mlflow
mlflow.autolog()

with mlflow.start_run(nested=True):
    automl.fit(dataframe=pandas_df, label='Bankrupt?', mlflow_exp_name = "automl_spark_demo")

# You can also provide a run_name pre-fix for the child runs

automl_experiment = flaml.AutoML()
automl_settings = {
    "metric": "r2",
    "task": "regression",
    "use_spark": True,
    "mlflow_exp_name": "test_doc",
    "estimator_list": [
        "lgbm",
        "rf",
        "xgboost",
        "extra_tree",
        "xgb_limitdepth",
    ],  # catboost does not yet support mlflow autologging
}
with mlflow.start_run(run_name=f"automl_spark_trials"):
    automl_experiment.fit(X_train=train_x, y_train=train_y, **automl_settings)

Modèles pris en charge

AutoML dans Fabric prend en charge les modèles suivants :

Classification	Régression	Prévision de séries chronologiques
(PySpark) Classificateur d’arbres boostés en gradient (GBT)	(PySpark) Régression de survie avec temps de défaillance accéléré (AFT)	Arimax
(PySpark) SVM linéaire	(PySpark) Régression linéaire généralisée	AutoARIMA
(PySpark) Naive Bayes	(PySpark) Régression d’arbres boostés en gradient (GBT)	Average
(Synapse) LightGBM	(PySpark) Régression linéaire	CatBoost
CatBoost	(Synapse) LightGBM	Arbre de décision
Arbre de décision	CatBoost	ExponentialSmoothing
Arborescences extrêmement aléatoires	Arborescence de décision	Arborescences extrêmement aléatoires
Boosting de gradient	Elastic Net	ForecastTCN
K plus proches voisins	Arborescences extrêmement aléatoires	Gradient Boosting
Light GBM	Gradient Boosting	Lissage exponentiel Holt-Winters
Linear SVC	K plus proches voisins	K plus proches voisins
Logistic Regression	LARS Lasso	LARS Lasso
Régression logistique avec la régularisation L1/L2	Light GBM	Light GBM
Naive Bayes	Régression logistique avec la régularisation L1/L2	Naive
Forêt aléatoire	Random Forest	Orbite
Forêt aléatoire sur Spark	Forêt aléatoire sur Spark	Prophet
Stochastic Gradient Descent (SGD)	Stochastic Gradient Descent (SGD)	Forêt aléatoire
Support Vector Classification (SVC)	XGBoost	SARIMAX
XGboost	XGBoost avec profondeur limitée	SeasonalAverage
XGBoost avec profondeur limitée		SeasonalNaive
		Transformateur de fusion temporelle
		XGBoost
		XGBoost pour les séries chronologiques
		XGBoost avec profondeur limitée pour les séries chronologiques
		ElasticNet

Visualiser les résultats

Le module flaml.visualization fournit des fonctions utilitaires pour tracer le processus d’optimisation à l’aide de Plotly. Grâce à Plotly, les utilisateurs peuvent explorer de manière interactive les résultats de leurs expériences AutoML. Pour utiliser ces fonctions de traçage, fournissez votre objet flaml.AutoML ou flaml.tune.tune.ExperimentAnalysis optimisé en entrée.

Vous pouvez utiliser les fonctions suivantes dans votre notebook :

• plot_optimization_history : tracer l’historique de l’optimisation de tous les essais de l’expérience.
• plot_feature_importance : tracer l’importance de chaque caractéristique dans le jeu de données.
• plot_parallel_coordinate : tracer les relations entre les paramètres à haute dimension dans l’expérience.
• plot_contour : tracer les relations entre les paramètres sous forme de tracé de contour dans l’expérience.
• plot_edf : tracer la valeur objective EDF (fonction de distribution empirique) de l’expérience.
• plot_timeline : tracer la chronologie de l’expérience.
• plot_slice : trace la relation entre les paramètres sous la forme d’un tracé de tranches dans le cadre d’une étude.
• plot_param_importance : tracer l’importance des hyperparamètres de l’expérience.

Contenu connexe

• Visualiser les résultats AutoML