Workspace Model Registry exemple

remarque

Cette documentation traite du Workspace Model Registry. Databricks recommande d'utiliser les modèles dans Unity Catalog. Les modèles d'Unity Catalog offrent une gouvernance centralisée des modèles, un accès entre les Workspace, une traçabilité et un déploiement. Le Workspace Model Registry sera déprécié à l'avenir.

Cet exemple illustre comment utiliser le Workspace Model Registry pour créer une application de Machine Learning qui prévoit la production d'énergie quotidienne d'un parc éolien. L'exemple montre comment :

• Suivre et enregistrer les modèles avec MLflow
• Enregistrer des modèles avec le Model Registry
• Décrire les modèles et effectuer des transitions d'étape de version de modèle
• Intégrer les modèles ajoutés au registre aux applications de production
• Recherchez et découvrez des modèles dans le Model Registry
• Archiver et supprimer les modèles

L'article décrit comment effectuer ces étapes à l'aide des interfaces utilisateur (UI) et des APIs de MLflow Tracking et de MLflow Model Registry.

Pour un Notebook qui effectue toutes ces étapes à l'aide des APIs MLflow Tracking et Registry, consultez le Notebook d'exemple Model Registry.

Chargez le dataset, entraînez le modèle et suivez-le avec MLflow Tracking

Avant de pouvoir enregistrer un modèle dans le Model Registry, vous devez d'abord entraîner et Log le modèle lors d'une exécution d'Experimentation. Cette section montre comment charger le dataset du parc éolien, entraîner un modèle et enregistrer l'exécution d'entraînement dans MLflow.

Charger le dataset

Le code suivant charge un dataset contenant des données météorologiques et des informations de production d'énergie pour un parc éolien aux États-Unis. Le dataset contient des fonctionnalités wind direction, wind speed et air temperature échantillonnées toutes les six heures (une fois à 00:00, une fois à 08:00 et une fois à 16:00), ainsi que la production d'énergie agrégée quotidienne (power), sur plusieurs années.

Python

import pandas as pd
wind_farm_data = pd.read_csv("https://github.com/dbczumar/model-registry-demo-notebook/raw/master/dataset/windfarm_data.csv", index_col=0)

def get_training_data():
  training_data = pd.DataFrame(wind_farm_data["2014-01-01":"2018-01-01"])
  X = training_data.drop(columns="power")
  y = training_data["power"]
  return X, y

def get_validation_data():
  validation_data = pd.DataFrame(wind_farm_data["2018-01-01":"2019-01-01"])
  X = validation_data.drop(columns="power")
  y = validation_data["power"]
  return X, y

def get_weather_and_forecast():
  format_date = lambda pd_date : pd_date.date().strftime("%Y-%m-%d")
  today = pd.Timestamp('today').normalize()
  week_ago = today - pd.Timedelta(days=5)
  week_later = today + pd.Timedelta(days=5)

  past_power_output = pd.DataFrame(wind_farm_data)[format_date(week_ago):format_date(today)]
  weather_and_forecast = pd.DataFrame(wind_farm_data)[format_date(week_ago):format_date(week_later)]
  if len(weather_and_forecast) < 10:
    past_power_output = pd.DataFrame(wind_farm_data).iloc[-10:-5]
    weather_and_forecast = pd.DataFrame(wind_farm_data).iloc[-10:]

  return weather_and_forecast.drop(columns="power"), past_power_output["power"]

Entraîner le modèle

Le code suivant entraîne un réseau de neurones utilisant TensorFlow Keras pour prédire la puissance de sortie basée sur les caractéristiques météorologiques dans le dataset. MLflow est utilisé pour suivre les hyperparamètres du modèle, les métriques de performance, le code source et les artefacts.

Python

def train_keras_model(X, y):
  import tensorflow.keras
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Dense

  model = Sequential()
  model.add(Dense(100, input_shape=(X_train.shape[-1],), activation="relu", name="hidden_layer"))
  model.add(Dense(1))
  model.compile(loss="mse", optimizer="adam")

  model.fit(X_train, y_train, epochs=100, batch_size=64, validation_split=.2)
  return model

import mlflow

X_train, y_train = get_training_data()

with mlflow.start_run():
  # Automatically capture the model's parameters, metrics, artifacts,
  # and source code with the `autolog()` function
  mlflow.tensorflow.autolog()

  train_keras_model(X_train, y_train)
  run_id = mlflow.active_run().info.run_id

Inscrivez et gérez le modèle à l'aide de l'interface utilisateur de MLflow.

Dans cette section :

• Créer un nouveau modèle enregistré
• Explorer l’interface utilisateur de Model Registry
• Ajouter des descriptions de modèle
• Faire passer une version de modèle

Créer un nouveau modèle enregistré

1. Accédez à la barre latérale des exécutions d'expérience MLflow en cliquant sur l'icône Experimentation dans la barre latérale droite du Notebook Databricks.

   

2. Localisez l'exécution MLflow correspondant à la session de formation du Modèle Keras TensorFlow et ouvrez-la dans l'interface utilisateur d'exécution MLflow en cliquant sur l'icône **Afficher les détails de l'exécution**.

3. Dans l'interface utilisateur de MLflow, faites défiler jusqu'à la section Artifacts et cliquez sur le répertoire nommé model . Cliquez sur le bouton Ajouter le modèle au registre qui apparaît.

   

4. Sélectionnez Créer un nouveau modèle dans le menu déroulant, et saisissez le nom de modèle suivant : power-forecasting-model.

5. Cliquez sur **S'inscrire**. Cela enregistre un nouveau modèle appelé power-forecasting-model et crée une nouvelle version de modèle : Version 1.

   

   Après quelques instants, l'interface utilisateur MLflow affiche un Link vers le nouveau modèle enregistré. Suivez ce Link pour ouvrir la nouvelle version du modèle dans l'interface utilisateur du MLflow Model Registry.

Explorez l'interface utilisateur du Model Registry

La page des versions de modèle dans l’interface utilisateur de MLflow Model Registry fournit des informations sur Version 1 du modèle de prévision enregistré, y compris son auteur, son heure de création et son étape actuelle.

La page de version du modèle fournit également un Link d'exécution Source, qui ouvre l'exécution MLflow qui a été utilisée pour créer le modèle dans l'interface utilisateur d'exécution MLflow. À partir de l'interface utilisateur d'exécution MLflow, vous pouvez accéder au Link du Notebook Source pour afficher un instantané du Notebook Databricks qui a été utilisé pour entraîner le modèle.

Pour revenir au MLflow Model Registry, cliquez sur **Modèles** dans la barre latérale.

La page d'accueil du MLflow Model Registry résultante affiche une liste de tous les modèles enregistrés dans votre Databricks Workspace, y compris leurs versions et leurs stades.

Cliquez sur le power-forecasting-model link pour ouvrir la page du modèle enregistré, qui affiche toutes les versions du modèle de prévision.

Ajouter des descriptions de modèle

Vous pouvez ajouter des descriptions aux modèles enregistrés et aux versions de modèle. Les descriptions de modèles enregistrés sont utiles pour enregistrer les informations qui s'appliquent à plusieurs versions de modèle (par exemple, un aperçu général du problème de modélisation et du dataset). Les descriptions des versions de modèle sont utiles pour détailler les attributs uniques d'une version de modèle particulière (par exemple, la méthodologie et l'algorithme utilisés pour développer le modèle).

1. Ajoutez une description de haut niveau au modèle de prévision de la consommation électrique enregistré. Cliquez sur l'icône et saisissez la description suivante :

   This model forecasts the power output of a wind farm based on weather data. The weather data consists of three features: wind speed, wind direction, and air temperature.

   

2. Cliquez sur Enregistrer .

3. Cliquez sur le Link Version 1 depuis la page du modèle enregistré pour revenir à la page de version du modèle.

4. Cliquez sur l'icône et entrez la description suivante :

   This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer.

   

5. Cliquez sur Enregistrer .

Transitionner une version de modèle

Le MLflow Model Registry définit plusieurs étapes de modèle : Aucun , Préparation , Production et Archived. Chaque étape a une signification unique. Par exemple, Staging est destiné aux tests de modèles, tandis que Production est pour les modèles qui ont terminé les processus de test ou de révision et ont été déployés dans les applications.

1. Cliquez sur le bouton Stage pour afficher la liste des étapes de modèle disponibles et vos options de transition d'étape disponibles.

2. Sélectionnez Transition vers -> Production et appuyez sur OK dans la fenêtre de confirmation de la transition d'étape pour faire passer le modèle en Production .

   

   Une fois la version du modèle passée en production , l’étape actuelle s’affiche dans l’interface utilisateur et une entrée est ajoutée au journal d’activités pour refléter la transition.

   

   

Le MLflow Model Registry permet à plusieurs versions de modèles de partager la même étape. Lorsqu'un modèle est référencé par étape, le Model Registry utilise la dernière version du modèle (la version du modèle avec l'ID de version le plus élevé). La page du modèle enregistré affiche toutes les versions d'un modèle particulier.

Enregistrez et gérez le modèle à l'aide de l'API MLflow

Dans cette section :

• Définissez le nom du modèle par programme
• Enregistrer le modèle
• Ajoutez les descriptions du modèle et de la version du modèle à l'aide de l'API.
• Faire passer une version de modèle et récupérer les détails à l'aide de l'API

Définir le nom du modèle par programme

Maintenant que le modèle a été enregistré et est passé à l'état de Production , vous pouvez y faire référence à l'aide des APIs programmatiques MLflow. Définissez le nom du modèle enregistré comme suit :

Python

model_name = "power-forecasting-model"

Enregistrer le modèle

Python

model_name = get_model_name()

import mlflow

# The default path where the MLflow autologging function stores the TensorFlow Keras model
artifact_path = "model"
model_uri = "runs:/{run_id}/{artifact_path}".format(run_id=run_id, artifact_path=artifact_path)

model_details = mlflow.register_model(model_uri=model_uri, name=model_name)

import time
from mlflow.tracking.client import MlflowClient
from mlflow.entities.model_registry.model_version_status import ModelVersionStatus

# Wait until the model is ready
def wait_until_ready(model_name, model_version):
  client = MlflowClient()
  for _ in range(10):
    model_version_details = client.get_model_version(
      name=model_name,
      version=model_version,
    )
    status = ModelVersionStatus.from_string(model_version_details.status)
    print("Model status: %s" % ModelVersionStatus.to_string(status))
    if status == ModelVersionStatus.READY:
      break
    time.sleep(1)

wait_until_ready(model_details.name, model_details.version)

Ajoutez les descriptions des modèles et des versions de modèle à l’aide de l’API

Python

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.update_registered_model(
  name=model_details.name,
  description="This model forecasts the power output of a wind farm based on weather data. The weather data consists of three features: wind speed, wind direction, and air temperature."
)

client.update_model_version(
  name=model_details.name,
  version=model_details.version,
  description="This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer."
)

Faire passer une version de modèle et récupérer les détails à l'aide de l'API

Python

client.transition_model_version_stage(
  name=model_details.name,
  version=model_details.version,
  stage='production',
)
model_version_details = client.get_model_version(
  name=model_details.name,
  version=model_details.version,
)
print("The current model stage is: '{stage}'".format(stage=model_version_details.current_stage))

latest_version_info = client.get_latest_versions(model_name, stages=["production"])
latest_production_version = latest_version_info[0].version
print("The latest production version of the model '%s' is '%s'." % (model_name, latest_production_version))

Chargez les versions du modèle enregistré à l'aide de l'API

Le composant Modèles MLflow définit des fonctions pour le chargement de modèles à partir de plusieurs frameworks de machine learning. Par exemple, mlflow.tensorflow.load_model() est utilisé pour charger les modèles TensorFlow qui ont été enregistrés au format MLflow, et mlflow.sklearn.load_model() est utilisé pour charger les modèles scikit-learn qui ont été enregistrés au format MLflow.

Ces fonctions peuvent charger des modèles à partir du MLflow Model Registry.

Python

import mlflow.pyfunc

model_version_uri = "models:/{model_name}/1".format(model_name=model_name)

print("Loading registered model version from URI: '{model_uri}'".format(model_uri=model_version_uri))
model_version_1 = mlflow.pyfunc.load_model(model_version_uri)

model_production_uri = "models:/{model_name}/production".format(model_name=model_name)

print("Loading registered model version from URI: '{model_uri}'".format(model_uri=model_production_uri))
model_production = mlflow.pyfunc.load_model(model_production_uri)

Prévision de la production d'énergie avec le modèle de production

Dans cette section, le modèle de production est utilisé pour évaluer les données de prévision météorologique pour le parc éolien. L'application forecast_power() charge la dernière version du modèle de prévision depuis l'étape spécifiée et l'utilise pour prévoir la production d'énergie au cours des cinq prochains jours.

Python

def plot(model_name, model_stage, model_version, power_predictions, past_power_output):
  import pandas as pd
  import matplotlib.dates as mdates
  from matplotlib import pyplot as plt
  index = power_predictions.index
  fig = plt.figure(figsize=(11, 7))
  ax = fig.add_subplot(111)
  ax.set_xlabel("Date", size=20, labelpad=20)
  ax.set_ylabel("Power\noutput\n(MW)", size=20, labelpad=60, rotation=0)
  ax.tick_params(axis='both', which='major', labelsize=17)
  ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d'))
  ax.plot(index[:len(past_power_output)], past_power_output, label="True", color="red", alpha=0.5, linewidth=4)
  ax.plot(index, power_predictions.squeeze(), "--", label="Predicted by '%s'\nin stage '%s' (Version %d)" % (model_name, model_stage, model_version), color="blue", linewidth=3)
  ax.set_ylim(ymin=0, ymax=max(3500, int(max(power_predictions.values) * 1.3)))
  ax.legend(fontsize=14)
  plt.title("Wind farm power output and projections", size=24, pad=20)
  plt.tight_layout()
  display(plt.show())

def forecast_power(model_name, model_stage):
  from mlflow.tracking.client import MlflowClient
  client = MlflowClient()
  model_version = client.get_latest_versions(model_name, stages=[model_stage])[0].version
  model_uri = "models:/{model_name}/{model_stage}".format(model_name=model_name, model_stage=model_stage)
  model = mlflow.pyfunc.load_model(model_uri)
  weather_data, past_power_output = get_weather_and_forecast()
  power_predictions = pd.DataFrame(model.predict(weather_data))
  power_predictions.index = pd.to_datetime(weather_data.index)
  print(power_predictions)
  plot(model_name, model_stage, int(model_version), power_predictions, past_power_output)

Créer une nouvelle version de modèle

Les techniques classiques de Machine Learning sont également efficaces pour la prévision de puissance. Le code suivant entraîne un modèle de forêt aléatoire à l'aide de scikit-learn et l'enregistre dans le MLflow Model Registry via la fonction mlflow.sklearn.log_model().

Python

import mlflow.sklearn
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

with mlflow.start_run():
  n_estimators = 300
  mlflow.log_param("n_estimators", n_estimators)

  rand_forest = RandomForestRegressor(n_estimators=n_estimators)
  rand_forest.fit(X_train, y_train)

  val_x, val_y = get_validation_data()
  mse = mean_squared_error(rand_forest.predict(val_x), val_y)
  print("Validation MSE: %d" % mse)
  mlflow.log_metric("mse", mse)

  # Specify the `registered_model_name` parameter of the `mlflow.sklearn.log_model()`
  # function to register the model with the MLflow Model Registry. This automatically
  # creates a new model version
  mlflow.sklearn.log_model(
    sk_model=rand_forest,
    artifact_path="sklearn-model",
    registered_model_name=model_name,
  )

Récupérez l'ID de la nouvelle version du modèle à l'aide de la recherche du MLflow Model Registry

Python

from mlflow.tracking.client import MlflowClient
client = MlflowClient()

model_version_infos = client.search_model_versions("name = '%s'" % model_name)
new_model_version = max([model_version_info.version for model_version_info in model_version_infos])

wait_until_ready(model_name, new_model_version)

Ajouter une description à la nouvelle version du modèle

Python

client.update_model_version(
  name=model_name,
  version=new_model_version,
  description="This model version is a random forest containing 100 decision trees that was trained in scikit-learn."
)

Faites passer la nouvelle version du modèle en pré-production et testez le modèle

Avant de déployer un modèle vers une application de production, il est souvent de bonne pratique de le tester dans un environnement de préproduction. Le code suivant fait passer la nouvelle version du modèle à la pré-production et évalue ses performances.

Python

client.transition_model_version_stage(
  name=model_name,
  version=new_model_version,
  stage="Staging",
)

forecast_power(model_name, "Staging")

Déployer la nouvelle version du modèle en production

Après avoir vérifié que la nouvelle version du modèle fonctionne bien en pré-production, le code suivant fait passer le modèle en Production et utilise exactement le même code d'application de la section Prévoir la puissance de sortie avec le modèle de production pour produire une prévision de puissance.

Python

client.transition_model_version_stage(
  name=model_name,
  version=new_model_version,
  stage="production",
)

forecast_power(model_name, "production")

Il existe désormais deux versions de modèle du modèle de prévision en phase de production : la version de modèle entraînée dans Modèle Keras et la version entraînée dans scikit-learn.

remarque

Lorsque vous faites référence à un modèle par étape, le MLflow Model Registry utilise automatiquement la dernière version de production. Ceci vous permet de mettre à jour vos modèles de production sans modifier le code de l'application.

Archiver et supprimer des modèles

Lorsqu'une version de modèle n'est plus utilisée, vous pouvez l'archiver ou la supprimer. Vous pouvez également supprimer un modèle enregistré entier ; cela supprime toutes les versions de modèle associées.

Archives Version 1 du modèle de prévisions de puissance

Archivez Version 1 du modèle de prévision de puissance, car il n'est plus utilisé. Vous pouvez archiver les modèles dans l'interface utilisateur du MLflow Model Registry ou via l'API MLflow.

Archive Version 1 dans l'interface utilisateur de MLflow

Pour archiver Version 1 du modèle de prévision de puissance :

1. Ouvrez sa page de version de modèle correspondante dans l'interface utilisateur du MLflow Model Registry :

   

2. Cliquez sur le bouton **Stage**, sélectionnez **Transitionner vers -> Archivé** :

   

3. Appuyez sur OK dans la fenêtre de confirmation de la transition d'étape.

   

Archiver Version 1 à l'aide de l'API MLflow

Le code suivant utilise la fonction MlflowClient.update_model_version() pour archiver Version 1 du modèle de prévision de puissance.

Python

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.transition_model_version_stage(
  name=model_name,
  version=1,
  stage="Archived",
)

Supprimer Version 1 du modèle de prévision de la puissance

Vous pouvez également utiliser l'UI MLflow ou l'API MLflow pour supprimer les versions du modèle.

attention

La suppression de la version du modèle est permanente et ne peut pas être annulée.

Supprimer Version 1 dans l’interface utilisateur de MLflow

Pour supprimer Version 1 du modèle de prévision de puissance :

1. Ouvrez sa page de version de modèle correspondante dans l'interface utilisateur du MLflow Model Registry.

   

2. Sélectionnez la flèche déroulante en regard de l'identifiant de version et cliquez sur **Supprimer**.

Supprimez Version 1 à l'aide de l'API MLflow

Python

client.delete_model_version(
   name=model_name,
   version=1,
)

Supprimer le modèle à l'aide de l'API MLflow

Vous devez d'abord faire passer toutes les étapes de version de modèle restantes à None ou Archivé .

Python

from mlflow.tracking.client import MlflowClient

client = MlflowClient()
client.transition_model_version_stage(
  name=model_name,
  version=2,
  stage="Archived",
)

Python

client.delete_registered_model(name=model_name)

Notebook

Notebook d'exemple MLflow Model Registry

Ouvrir le notebook dans un nouvel ongletOuvrir dans Databricks