Bien démarrer : construisez votre premier modèle Machine Learning dans Azure Databricks

Cet article explique comment créer un modèle de classification d’apprentissage automatique à l’aide de la bibliothèque scikit-learn sur Azure Databricks.

L’objectif est de créer un modèle de classification pour prédire si un vin est considéré comme « de haute qualité ». Le jeu de données comprend 11 caractéristiques de différents vins (par exemple, la teneur en alcool, l’acide et le sucre résiduel) et un classement de qualité compris entre 1 et 10.

Cet exemple illustre également l’utilisation de MLflow pour suivre le processus de développement de modèles et Hyperopt pour automatiser le réglage des hyperparamètres.

Le jeu de données provient du référentiel apprentissage automatique UCI, présenté dans Modélisation des préférences de vin par l’exploration de données à partir des propriétés physicochimiques [ Cortez et al., 2009].

Avant de commencer

• Vous devez activer votre espace de travail pour Unity Catalog.
• Vous devez avoir l’autorisation de créer un cluster ou avoir accès à un cluster.
• Vous devez disposer du privilège USE_CATALOG sur le catalogue.
• Dans ce catalogue, vous devez disposer des privilèges suivants sur un schéma : USE_SCHEMA, CREATE_TABLE et CREATE_MODEL.

Conseil

Tout le code de cet article est disponible dans un notebook que l’on peut importer directement dans votre espace de travail. Consultez Exemple de notebook : Créer un modèle de classification.

Étape 1 : Créer un notebook Databricks

Pour créer un notebook dans votre espace de travail, cliquez sur Nouveau dans la barre latérale, puis sur Notebook. Un notebook vide s’ouvre dans l’espace de travail.

Pour en savoir plus sur la création et la gestion des notebooks, consultez Gérer les notebooks.

Étape 2 : Connecter les ressources de calcul

Pour effectuer une analyse de données exploratoire et l’ingénierie des données, vous devez avoir accès au calcul.

Pour obtenir des instructions sur la connexion à des ressources de calcul existantes, veuillez consultez Calcul. Pour obtenir des instructions sur la configuration d’une nouvelle ressource de calcul, consultez la référence de configuration de calcul.

Les étapes décrites dans cet article nécessitent Databricks Runtime pour l’apprentissage automatique. Pour plus d’informations et d’instructions sur la sélection d’une version ML de Databricks Runtime, consultez Databricks Runtime pour l’apprentissage automatique.

Étape 3 : Configurer le registre de modèles, le catalogue et le schéma

Deux étapes importantes sont nécessaires avant de commencer. Premièrement, vous devez configurer le client MLflow pour utiliser le catalogue Unity comme registre de modèles. Saisir le code suivant dans une nouvelle cellule de votre notebook.

Python

import mlflow
mlflow.set_registry_uri("databricks-uc")

Vous devez également définir le catalogue et le schéma dans lequel le modèle sera inscrit. Vous devez disposer de privilèges USE CATALOG sur le catalogue et des privilèges USE_SCHEMA, CREATE_TABLE et CREATE_MODEL sur le schéma.

Pour plus d’informations sur comment utiliser Unity Catalog, consultez Qu’est-ce que Unity Catalog ?.

Saisir le code suivant dans une nouvelle cellule de votre notebook.

Python

# If necessary, replace "main" and "default" with a catalog and schema for which you have the required permissions.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"

Étape 4 : Charger des données et créer des tables de catalogue Unity

Cet exemple utilise deux fichiers CSV intégrés à Azure Databricks. Pour découvrir comment ingérer vos propres données, consultez Ingérer des données dans un lakehouse Databricks.

Saisir le code suivant dans une nouvelle cellule de votre notebook.

Python

white_wine = spark.read.csv("dbfs:/databricks-datasets/wine-quality/winequality-white.csv", sep=';', header=True)
red_wine = spark.read.csv("dbfs:/databricks-datasets/wine-quality/winequality-red.csv", sep=';', header=True)

# Remove the spaces from the column names
for c in white_wine.columns:
    white_wine = white_wine.withColumnRenamed(c, c.replace(" ", "_"))
for c in red_wine.columns:
    red_wine = red_wine.withColumnRenamed(c, c.replace(" ", "_"))

# Define table names
red_wine_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine"
white_wine_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine"

# Write to tables in Unity Catalog
spark.sql(f"DROP TABLE IF EXISTS {red_wine_table}")
spark.sql(f"DROP TABLE IF EXISTS {white_wine_table}")
white_wine.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine")
red_wine.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine")

Étape 5. Prétraiter et fractionner les données

Dans cette étape, vous chargez les données des tables de catalogue Unity que vous avez créées à l’étape 4 dans des DataFrames Pandas et prétraitez les données. Le code de cette section permet d’effectuer les opérations suivantes :

1. Chargement des données en tant que Pandas DataFrame.
2. Ajoute une colonne booléenne à chaque DataFrame pour distinguer les vins rouges et blancs, puis combine les DataFrames dans un nouveau DataFrame, data_df.
3. Le jeu de données comprend une colonne quality qui évalue les vins de 1 à 10, avec 10 indiquant la plus haute qualité. Le code transforme cette colonne en deux valeurs de classification : « Vrai » pour indiquer un vin de haute qualité (quality>= 7) et « Faux » pour indiquer un vin qui n’est pas de haute qualité (quality< 7).
4. Fractionne le DataFrame en deux ensembles de données distincts, l’un pour la formation et l’autre pour le test.

Tout d’abord, importez les bibliothèques exigées :

Python

import numpy as np
import pandas as pd
import sklearn.datasets
import sklearn.metrics
import sklearn.model_selection
import sklearn.ensemble

import matplotlib.pyplot as plt

from hyperopt import fmin, tpe, hp, SparkTrials, Trials, STATUS_OK
from hyperopt.pyll import scope

À présent, chargez et prétraiter les données :

Python

# Load data from Unity Catalog as Pandas dataframes
white_wine = spark.read.table(f"{CATALOG_NAME}.{SCHEMA_NAME}.white_wine").toPandas()
red_wine = spark.read.table(f"{CATALOG_NAME}.{SCHEMA_NAME}.red_wine").toPandas()

# Add Boolean fields for red and white wine
white_wine['is_red'] = 0.0
red_wine['is_red'] = 1.0
data_df = pd.concat([white_wine, red_wine], axis=0)

# Define classification labels based on the wine quality
data_labels = data_df['quality'].astype('int') >= 7
data_df = data_df.drop(['quality'], axis=1)

# Split 80/20 train-test
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(
  data_df,
  data_labels,
  test_size=0.2,
  random_state=1
)

Étape 6. Entraîner le modèle de classification

Cette étape entraîne un classifieur de boosting de gradient à l’aide des paramètres d’algorithme par défaut. Il applique ensuite le modèle résultant au jeu de données de test et calcule, journalise et affiche la zone sous la courbe d’exploitation du récepteur pour évaluer les analyses des performances du modèle.

Commencez par activer l’autologging MLflow :

Python

mlflow.autolog()

Démarrez à présent l’exécution de l’entraînement du modèle :

Python

with mlflow.start_run(run_name='gradient_boost') as run:
    model = sklearn.ensemble.GradientBoostingClassifier(random_state=0)

    # Models, parameters, and training metrics are tracked automatically
    model.fit(X_train, y_train)

    predicted_probs = model.predict_proba(X_test)
    roc_auc = sklearn.metrics.roc_auc_score(y_test, predicted_probs[:,1])
    roc_curve = sklearn.metrics.RocCurveDisplay.from_estimator(model, X_test, y_test)

    # Save the ROC curve plot to a file
    roc_curve.figure_.savefig("roc_curve.png")

    # The AUC score on test data is not automatically logged, so log it manually
    mlflow.log_metric("test_auc", roc_auc)

    # Log the ROC curve image file as an artifact
    mlflow.log_artifact("roc_curve.png")

    print("Test AUC of: {}".format(roc_auc))

Les résultats de la cellule présentent la zone calculée sous la courbe et un tracé de la courbe ROC :

Étape 7. Afficher les exécutions d’expériences dans MLflow

Le suivi des expériences MLflow vous permet de suivre le développement de modèles en produisant un journal d’activités du code et des résultats au fur et à mesure que vous développez des modèles de manière itérative.

Pour afficher les résultats du journal d’activités de l’exécution d’entraînement que vous venez d’exécuter, cliquez sur le lien dans la sortie de la cellule, comme illustré dans l’image suivante.

La page d’expérience permet de comparer les exécutions et d’afficher les détails des exécutions spécifiques. Consultez le Suivi des expériences MLflow.

Étape 8 : Optimisation des hyperparamètres

Une étape importante dans le développement d’un modèle ML optimise l’exactitude du modèle en paramétrant les paramètres qui contrôlent l’algorithme, appelés hyperparamètres.

Databricks Runtime ML comprend Hyperopt, bibliothèque Python pour le réglage des hyperparamètres. Vous pouvez utiliser Hyperopt pour exécuter des balayages hyperparamètres et entraîner plusieurs modèles en parallèle, ce qui réduit le temps nécessaire pour optimiser les analyses de performance du modèle. Le suivi MLflow est intégré à Hyperopt afin de journaliser automatiquement les modèles et les paramètres. Pour plus d’informations sur l’utilisation de Hyperopt dans Databricks, consultez Réglage des hyperparamètres.

Le code ci-après indique un exemple d’utilisation de Hyperopt.

Python

# Define the search space to explore
search_space = {
  'n_estimators': scope.int(hp.quniform('n_estimators', 20, 1000, 1)),
  'learning_rate': hp.loguniform('learning_rate', -3, 0),
  'max_depth': scope.int(hp.quniform('max_depth', 2, 5, 1)),
}

def train_model(params):
  # Enable autologging on each worker
  mlflow.autolog()
  with mlflow.start_run(nested=True):
    model_hp = sklearn.ensemble.GradientBoostingClassifier(
      random_state=0,
      **params
    )
    model_hp.fit(X_train, y_train)
    predicted_probs = model_hp.predict_proba(X_test)
    # Tune based on the test AUC
    # In production, you could use a separate validation set instead
    roc_auc = sklearn.metrics.roc_auc_score(y_test, predicted_probs[:,1])
    mlflow.log_metric('test_auc', roc_auc)

    # Set the loss to -1*auc_score so fmin maximizes the auc_score
    return {'status': STATUS_OK, 'loss': -1*roc_auc}

# SparkTrials distributes the tuning using Spark workers
# Greater parallelism speeds processing, but each hyperparameter trial has less information from other trials
# On smaller clusters try setting parallelism=2
spark_trials = SparkTrials(
  parallelism=1
)

with mlflow.start_run(run_name='gb_hyperopt') as run:
  # Use hyperopt to find the parameters yielding the highest AUC
  best_params = fmin(
    fn=train_model,
    space=search_space,
    algo=tpe.suggest,
    max_evals=32,
    trials=spark_trials)

Étape 9. Trouvez le meilleur modèle et l’inscrire auprès d’Unity Catalog

Le code suivant identifie l’exécution qui a produit les meilleurs résultats, comme mesuré par la zone sous la courbe ROC :

Python

# Sort runs by their test auc. In case of ties, use the most recent run.
best_run = mlflow.search_runs(
  order_by=['metrics.test_auc DESC', 'start_time DESC'],
  max_results=10,
).iloc[0]
print('Best Run')
print('AUC: {}'.format(best_run["metrics.test_auc"]))
print('Num Estimators: {}'.format(best_run["params.n_estimators"]))
print('Max Depth: {}'.format(best_run["params.max_depth"]))
print('Learning Rate: {}'.format(best_run["params.learning_rate"]))

À l’aide du modèle run_id que vous avez identifié pour le meilleur modèle, le code suivant inscrit ce modèle dans le catalogue Unity.

Python

model_uri = 'runs:/{run_id}/model'.format(
    run_id=best_run.run_id
  )

mlflow.register_model(model_uri, f"{CATALOG_NAME}.{SCHEMA_NAME}.wine_quality_model")

Exemple de notebook : Créer un modèle de classification

Utilisez le notebook suivant pour effectuer les étapes contenues dans cet article. Pour obtenir des instructions sur l’importation d’un notebook dans un espace de travail Databricks Azure, consultez Importer un notebook.

Créez votre premier modèle Machine Learning avec Databricks

Obtenir le notebook

En savoir plus

Databricks fournit une plateforme unique qui sert chaque étape du développement et de déploiement du ML, des données brutes aux tables d’inférence qui enregistrent chaque demande et réponse pour un modèle servi. Les scientifiques des données, les ingénieurs des données, les ingénieurs ML et DevOps peuvent effectuer leurs tâches à l’aide du même ensemble d’outils et d’une source unique de vérité pour les données.

Pour en savoir plus, consultez les articles suivants :

• Didacticiels sur l’apprentissage automatique et l’IA
• Vue d’ensemble de l’apprentissage automatique et de l’IA et sur Databricks
• Vue d’ensemble de la formation de l’apprentissage automatique et des modèles d’IA sur Databricks
• MLflow pour l’agent IA générative et le cycle de vie du modèle d'apprentissage automatique

Ressources associées

• scikit-learn