Condividi tramite

Esempio del Registro di sistema del modello dell'area di lavoro

  • Articolo

Nota

Questa documentazione illustra il Registro modelli di area di lavoro. Azure Databricks consiglia di usare modelli in Unity Catalog. I modelli in Unity Catalog offrono la governance centralizzata dei modelli, l'accesso tra aree di lavoro, la lineazione e la distribuzione. Il Registro modelli dell'area di lavoro verrà deprecato in futuro.

In questo esempio viene illustrato come usare il Registro modelli di area di lavoro per creare un'applicazione di Machine Learning che prevede l'output giornaliero dell'alimentazione di una farm eolica. Nell'esempio viene illustrato come:

  • Tenere traccia e registrare i modelli con MLflow
  • Registrare i modelli con il Registro modelli
  • Descrivere i modelli e creare transizioni di fase della versione del modello
  • Integrare modelli registrati con applicazioni di produzione
  • Cercare e individuare modelli nel Registro modelli
  • Archiviare ed eliminare modelli

L'articolo descrive come eseguire questi passaggi usando le API e le API del Registro di sistema MLflow Tracking e MLflow Model.

Per un notebook che esegue tutti questi passaggi usando le API di rilevamento e Registro di sistema MLflow, vedere il notebook di esempio del Registro di sistema del modello.

Caricare set di dati, eseguire il training del modello e tenere traccia con rilevamento MLflow

Prima di poter registrare un modello nel Registro modelli, è necessario prima eseguire il training e registrare il modello durante l'esecuzione di un esperimento. Questa sezione illustra come caricare il set di dati della farm eolica, eseguire il training di un modello e registrare l'esecuzione del training in MLflow.

Caricare il set di dati

Il codice seguente carica un set di dati contenente i dati meteo e le informazioni sull'output dell'alimentazione per una farm eolica nella Stati Uniti. Il set di dati contiene , e air temperature funzionalità campionate ogni sei ore (una volta a , e una 16:00sola volta a 00:0008:00), nonché l'output di alimentazione aggregato giornaliero (power), in diversi wind speedanni.wind direction

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"]

Eseguire il training del modello

Il codice seguente esegue il training di una rete neurale usando TensorFlow Keras per stimare l'output della potenza in base alle funzionalità meteo nel set di dati. MLflow viene usato per tenere traccia degli iperparametri del modello, delle metriche delle prestazioni, del codice sorgente e degli artefatti del modello.

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

Registrare e gestire il modello usando l'interfaccia utente MLflow

In questa sezione:

Creare un nuovo modello registrato

  1. Passare alla barra laterale Dell'esperimento MLflow facendo clic sull'icona Esperimento Esperimento nella barra laterale destra del notebook di Azure Databricks.

    Esegue la barra laterale

  2. Individuare la sessione di training del modello MLflow run corrispondente alla sessione di training del modello TensorFlow Keras e aprirla nell'interfaccia utente di esecuzione MLflow facendo clic sull'icona Visualizza dettagli esecuzione.

  3. Nell'interfaccia utente MLflow scorrere verso il basso fino alla sezione Artefatti e fare clic sulla directory denominata modello. Fare clic sul pulsante Registra modello visualizzato.

    Registrare il modello

  4. Selezionare Crea nuovo modello dal menu a discesa e immettere il nome del modello seguente: power-forecasting-model.

  5. Fare clic su Registra. In questo modo viene registrato un nuovo modello denominato power-forecasting-model e viene creata una nuova versione del modello: Version 1.

    Nuova versione del modello

    Dopo alcuni momenti, l'interfaccia utente MLflow visualizza un collegamento al nuovo modello registrato. Seguire questo collegamento per aprire la nuova versione del modello nell'interfaccia utente del Registro di sistema del modello MLflow.

Esplorare l'interfaccia utente del Registro di sistema del modello

La pagina della versione del modello nell'interfaccia utente del Registro di sistema del modello MLflow fornisce informazioni sul Version 1 modello di previsione registrato, tra cui l'autore, l'ora di creazione e la relativa fase corrente.

Pagina della versione del modello

La pagina della versione del modello fornisce anche un collegamento Run di origine , che apre l'esecuzione MLflow usata per creare il modello nell'interfaccia utente di esecuzione di MLflow. Dall'interfaccia utente di esecuzione MLflow è possibile accedere al collegamento Del notebook di origine per visualizzare uno snapshot del notebook di Azure Databricks usato per eseguire il training del modello.

Esecuzione di origine

Notebook di origine

Per tornare al Registro modelli MLflow, fare clic su Modelli icona modelli nella barra laterale.

La home page del Registro modelli MLflow risultante visualizza un elenco di tutti i modelli registrati nell'area di lavoro azure Databricks, incluse le versioni e le fasi.

Fare clic sul collegamento power-forecasting-model per aprire la pagina del modello registrato, che visualizza tutte le versioni del modello di previsione.

Aggiungere descrizioni dei modelli

È possibile aggiungere descrizioni ai modelli registrati e alle versioni del modello. Le descrizioni dei modelli registrati sono utili per la registrazione delle informazioni che si applicano a più versioni del modello, ad esempio una panoramica generale del problema di modellazione e del set di dati. Le descrizioni delle versioni del modello sono utili per dettagliare gli attributi univoci di una determinata versione del modello, ad esempio la metodologia e l'algoritmo usati per sviluppare il modello.

  1. Aggiungere una descrizione generale al modello di previsione dell'alimentazione registrata. Fare clic sull'icona Modifica icona e immettere la descrizione seguente:

    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.

    Aggiungere la descrizione del modello

  2. Fare clic su Salva.

  3. Fare clic sul collegamento versione 1 dalla pagina del modello registrato per tornare alla pagina della versione del modello.

  4. Fare clic sull'icona Modifica icona e immettere la descrizione seguente:

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

    Aggiungere la descrizione della versione del modello

  5. Fare clic su Salva.

Transizione di una versione del modello

Il Registro modelli MLflow definisce diverse fasi del modello: Nessuno, Staging, Production e Archived. Ogni fase ha un significato univoco. Ad esempio, La gestione temporanea è destinata ai test dei modelli, mentre La produzione è per i modelli che hanno completato i processi di test o revisione e sono stati distribuiti nelle applicazioni.

  1. Fare clic sul pulsante Fase per visualizzare l'elenco delle fasi del modello disponibili e le opzioni di transizione della fase disponibili.

  2. Selezionare Transizione a -> Produzione e premere OK nella finestra di conferma della transizione della fase per passare il modello a Produzione.

    Transizione alla produzione

    Dopo la transizione della versione del modello a Production, la fase corrente viene visualizzata nell'interfaccia utente e viene aggiunta una voce al log attività per riflettere la transizione.

    Fase di produzione

    Attività della versione del modello

Il Registro modelli MLflow consente a più versioni del modello di condividere la stessa fase. Quando si fa riferimento a un modello in base alla fase, il Registro modelli usa la versione del modello più recente (la versione del modello con l'ID versione più grande). La pagina del modello registrato visualizza tutte le versioni di un modello specifico.

Pagina modello registrato

Registrare e gestire il modello usando l'API MLflow

In questa sezione:

Definire il nome del modello a livello di codice

Ora che il modello è stato registrato e passato a Production, è possibile farvi riferimento usando le API a livello di codice MLflow. Definire il nome del modello registrato come indicato di seguito:

model_name = "power-forecasting-model"

Registrare il modello

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)

Aggiungere descrizioni della versione del modello e del modello usando l'API

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."
)

Eseguire la transizione di una versione del modello e recuperare i dettagli usando l'API

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))

Caricare le versioni del modello registrato usando l'API

Il componente MLflow Models definisce le funzioni per il caricamento di modelli da diversi framework di Machine Learning. Ad esempio, mlflow.tensorflow.load_model() viene usato per caricare i modelli TensorFlow salvati nel formato MLflow e mlflow.sklearn.load_model() viene usato per caricare i modelli scikit-learn salvati in formato MLflow.

Queste funzioni possono caricare i modelli dal Registro modelli MLflow.

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)

Prevedere l'output dell'alimentazione con il modello di produzione

In questa sezione viene usato il modello di produzione per valutare i dati delle previsioni meteo per la farm eolica. L'applicazione forecast_power() carica la versione più recente del modello di previsione dalla fase specificata e la usa per prevedere la produzione di energia nei prossimi cinque giorni.

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)

Creare una nuova versione del modello

Le tecniche classiche di Machine Learning sono efficaci anche per la previsione dell'alimentazione. Il codice seguente esegue il training di un modello di foresta casuale usando scikit-learn e lo registra con il Registro modelli MLflow tramite la mlflow.sklearn.log_model() funzione .

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,
  )

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)

Aggiungere una descrizione alla nuova versione del modello

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."
)

Eseguire la transizione della nuova versione del modello alla gestione temporanea e testare il modello

Prima di distribuire un modello in un'applicazione di produzione, è spesso consigliabile testarlo in un ambiente di staging. Il codice seguente esegue la transizione della nuova versione del modello alla gestione temporanea e ne valuta le prestazioni.

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

forecast_power(model_name, "Staging")

Distribuire la nuova versione del modello in Produzione

Dopo aver verificato che la nuova versione del modello funzioni correttamente nella gestione temporanea, il codice seguente esegue la transizione del modello a Production e usa lo stesso codice dell'applicazione dall'output di alimentazione Forecast con la sezione del modello di produzione per produrre una previsione dell'alimentazione.

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

forecast_power(model_name, "production")

Sono ora disponibili due versioni del modello di previsione nella fase produzione : la versione del modello sottoposta a training nel modello Keras e la versione sottoposta a training in scikit-learn.

Versioni del modello di prodotto

Nota

Quando si fa riferimento a un modello per fase, il Registro modelli MLflow usa automaticamente la versione di produzione più recente. In questo modo è possibile aggiornare i modelli di produzione senza modificare il codice dell'applicazione.

Archiviare ed eliminare modelli

Quando non viene più usata una versione del modello, è possibile archiviarla o eliminarla. È anche possibile eliminare un intero modello registrato; in questo modo vengono rimosse tutte le versioni del modello associate.

Archivio Version 1 del modello di previsione alimentazione

Archivio Version 1 del modello di previsione dell'alimentazione perché non viene più usato. È possibile archiviare i modelli nell'interfaccia utente del Registro di sistema del modello MLflow o tramite l'API MLflow.

Archiviare Version 1 nell'interfaccia utente di MLflow

Per archiviare Version 1 il modello di previsione alimentazione:

  1. Aprire la pagina corrispondente della versione del modello nell'interfaccia utente del Registro di sistema del modello MLflow:

    Transizione all'archivio

  2. Fare clic sul pulsante Fase , selezionare Transizione a -> Archiviato:

    Fase archiviata

  3. Premere OK nella finestra di conferma della transizione di fase.

    Versione del modello archiviata

Archiviare Version 1 usando l'API MLflow

Il codice seguente usa la MlflowClient.update_model_version() funzione per archiviare Version 1 il modello di previsione alimentazione.

from mlflow.tracking.client import MlflowClient

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

Eliminazione Version 1 del modello di previsione alimentazione

È anche possibile usare l'interfaccia utente di MLflow o l'API MLflow per eliminare le versioni del modello.

Avviso

L'eliminazione della versione del modello è permanente e non può essere annullata.

Eliminare Version 1 nell'interfaccia utente di MLflow

Per eliminare Version 1 il modello di previsione alimentazione:

  1. Aprire la pagina corrispondente della versione del modello nell'interfaccia utente del Registro di sistema del modello MLflow.

    Eliminare la versione del modello

  2. Selezionare la freccia a discesa accanto all'identificatore della versione e fare clic su Elimina.

Eliminare Version 1 usando l'API MLflow
client.delete_model_version(
   name=model_name,
   version=1,
)
Eliminare il modello usando l'API MLflow

È prima necessario eseguire la transizione di tutte le fasi rimanenti della versione del modello a Nessuno o Archiviato.

from mlflow.tracking.client import MlflowClient

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

client.delete_registered_model(name=model_name)

Taccuino

Notebook di esempio di Registro modelli MLflow

Ottenere un notebook