Premiers pas : créer votre premier modèle de machine learning sur Databricks
Ce Notebook d’exemple illustre comment entraîner un modèle de classification de Machine Learning sur Databricks. Databricks Runtime for Machine Learning est livré avec de nombreuses bibliothèques préinstallées, notamment scikit-learn pour les algorithmes d'entraînement et de prétraitement, MLflow pour suivre le processus de développement du modèle et Hyperopt avec SparkTrials pour monter en charge l'ajustement des hyperparamètres.
Dans ce notebook, vous créez un modèle de classification pour prédire si un vin est considéré comme de « haute qualité ». Le dataset se compose de 11 caractéristiques de différents vins (par exemple, la teneur en alcool, l'acidité et le sucre résiduel) et d'un classement de qualité de 1 à 10.
Ce didacticiel couvre :
- Partie 1 : Entraîner un modèle de classification avec le suivi MLflow
- Partie 2 : Réglage des hyperparamètres pour améliorer les performances du modèle
- Partie 3 : Enregistrer les résultats et les modèles dans Unity Catalog
- Partie 4 : Déployer le modèle
Pour plus de détails sur la mise en production du Machine Learning sur Databricks, y compris la gestion du cycle de vie des modèles et l'inférence des modèles, consultez l'exemple ML de bout en bout.
Le dataset est disponible sur le UCI Machine Learning Repository et est présenté dans Modeling wine preferences by data mining from physicochemical properties [Cortez et al., 2009].
Exigences
- Cluster exécutant l'une des versions suivantes de Databricks Runtime : 13.3 LTS ML, 14.3 LTS ML, 15.4 LTS ML ou 16.4 LTS ML. Pour Databricks Runtime 17.3 LTS ML ou version ultérieure, consultez Tutoriel : Créer votre premier modèle de machine learning sur Databricks.
Configuration
Dans cette section, vous faites ce qui suit :
- Configurez le client MLflow pour utiliser Unity Catalog comme registre de modèles.
- Définir le catalogue et le schéma où le modèle sera enregistré.
- Lisez les données et enregistrez-les dans des tables dans Unity Catalog.
- Prétraitez les données.
Configurer le client MLflow
Par default, le client Python MLflow crée des modèles dans le registre de modèles du Workspace Databricks. Pour enregistrer des modèles dans Unity Catalog, configurez le client MLflow comme indiqué dans la cellule suivante.
import mlflow
mlflow.set_registry_uri("databricks-uc")
La cellule suivante définit le catalogue et le schéma où le modèle sera enregistré. Vous devez disposer du privilège USE CATALOG sur le catalogue, et des privilèges USE_SCHEMA, CREATE_TABLE et CREATE_MODEL sur le schéma. Changez les noms du catalogue et du schéma dans la cellule suivante si nécessaire.
Pour plus d'information, consultez la documentation Unity Catalog.
# Specify the catalog and schema to use. You must have USE_CATALOG privilege on the catalog and USE_SCHEMA, CREATE_TABLE, and CREATE_MODEL privileges on the schema.
# Change the catalog and schema here if necessary.
CATALOG_NAME = "main"
SCHEMA_NAME = "default"
Lire les données et les enregistrer dans des tables Unity Catalog
Le dataset est disponible dans databricks-datasets. Dans la cellule suivante, vous lisez les données à partir de .csv fichiers dans des DataFrames Spark. Vous écrivez ensuite les DataFrames dans des tables dans Unity Catalog. Ceci assure la persistance des données et vous permet de contrôler comment les partager avec d'autres.
white_wine = spark.read.csv("/databricks-datasets/wine-quality/winequality-white.csv", sep=';', header=True)
red_wine = spark.read.csv("/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")
Prétraiter les données
# Import required libraries
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
# 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
)
Partie 1. Entraîner un modèle de classification
# Enable MLflow autologging for this notebook
mlflow.autolog()
Ensuite, entraînez un classifieur dans le contexte d'une exécution MLflow, qui journalise automatiquement le modèle entraîné ainsi que de nombreuses métriques et paramètres associés.
Vous pouvez compléter la journalisation avec des métriques supplémentaires telles que le score AUC du modèle sur le dataset de test.
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))
Afficher les exécutions MLflow
Pour afficher l'exécution d'entraînement journalisée, cliquez sur l'icône **Experimentation** 
en haut à droite du notebook pour afficher la barre latérale d'experimentation. Si nécessaire, cliquez sur l'icône refresh pour récupérer et surveiller les dernières exécutions.
Pour afficher la page d'Experimentation MLflow plus détaillée, cliquez sur l'icône de la page d'Experimentation. Cette page vous permet de comparer les exécutions et d'afficher les détails pour des exécutions spécifiques. Consultez le suivi du développement de modèles à l'aide d'MLflow.
Charger les modèles
Vous pouvez également accéder aux résultats d'une exécution spécifique à l'aide de l'API MLflow. Le code de la cellule suivante illustre comment charger le modèle entraîné dans une exécution MLflow donnée et l'utiliser pour faire des prédictions. Vous trouverez également des extraits de code pour le chargement de modèles spécifiques sur la page d'exécution MLflow.
# After a model has been logged, you can load it in different notebooks or jobs
# mlflow.pyfunc.load_model makes model prediction available under a common API
model_loaded = mlflow.pyfunc.load_model(
'runs:/{run_id}/model'.format(
run_id=run.info.run_id
)
)
predictions_loaded = model_loaded.predict(X_test)
predictions_original = model.predict(X_test)
# The loaded model should match the original
assert(np.array_equal(predictions_loaded, predictions_original))
Partie 2. Ajustement des hyperparamètres
À ce stade, vous avez entraîné un modèle simple et utilisé le service de suivi MLflow pour organiser votre travail. Ensuite, vous pouvez effectuer un réglage plus sophistiqué à l'aide d'Hyperopt.
Entraînement parallèle avec Hyperopt et SparkTrials
Hyperopt est une bibliothèque Python pour l'optimisation des hyperparamètres. Pour plus d'informations sur l'utilisation d'Hyperopt dans Databricks, consultez Utiliser des algorithmes d'entraînement distribués avec Hyperopt.
Vous pouvez utiliser Hyperopt avec SparkTrials pour effectuer des balayages d'hyperparamètres et entraîner plusieurs modèles en parallèle. Cela réduit le temps nécessaire pour optimiser les performances du modèle. Le suivi MLflow est intégré à Hyperopt pour enregistrer automatiquement les modèles et les paramètres.
# 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)
Recherchez les exécutions pour récupérer le meilleur modèle
Puisque toutes les exécutions sont suivies par MLflow, vous pouvez récupérer les métriques et les parameters pour la meilleure exécution en utilisant l'API de recherche d'exécutions MLflow afin de trouver l'exécution de réglage avec l'auc de test le plus élevé.
Ce modèle ajusté devrait être plus performant que les modèles plus simples entraînés dans la Partie 1.
# 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"]))
best_model_pyfunc = mlflow.pyfunc.load_model(
'runs:/{run_id}/model'.format(
run_id=best_run.run_id
)
)
# Make a dataset with all predictions
best_model_predictions = X_test
best_model_predictions["prediction"] = best_model_pyfunc.predict(X_test)
Partie 3. Enregistrer les résultats et les modèles dans Unity Catalog
predictions_table = f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions"
spark.sql(f"DROP TABLE IF EXISTS {predictions_table}")
results = spark.createDataFrame(best_model_predictions)
# Write results back to Unity Catalog from Python
results.write.saveAsTable(f"{CATALOG_NAME}.{SCHEMA_NAME}.predictions")
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")
Partie 4. Déployer le modèle
Après avoir enregistré votre modèle dans Unity Catalog, vous pouvez le déployer en utilisant l'interface utilisateur de service. Les instructions suivantes donnent une brève description. Pour plus d'information, consultez Créer des Endpoint de service de modèle personnalisés.
- Cliquez sur Service dans la barre latérale pour afficher l’interface utilisateur de Service.
-
Cliquez sur Créer un Endpoint de service .
-
Dans le champ Nom , fournissez un nom pour votre Endpoint.
-
Dans la section Entités servies
- Cliquez dans le champ Entité pour ouvrir le formulaire Sélectionner l'entité servie .
- Sélectionnez Mes modèles- Unity Catalog . Le formulaire se met à jour dynamiquement en fonction de votre sélection.
- Sélectionnez le
wine_quality_modelet la version du modèle que vous souhaitez déployer. - Sélectionnez 100 comme pourcentage du trafic que vous souhaitez acheminer vers votre modèle déployé.
- Sélectionnez **CPU** comme type de calcul pour cet exemple.
- Sous **compute Monter en charge-out**, sélectionnez **Small** comme taille de Monter en charge du compute.
-
Cliquez sur Créer. La page **Endpoint de service** s'affiche, avec l'**état de l'Endpoint de service** indiqué comme **Non prêt**.
-
Lorsque votre endpoint est **Prêt**, sélectionnez **Utiliser** pour soumettre une requête d'inférence à l'endpoint.