Exemplo de registro de modelo de espaço de trabalho

Observação

Esta documentação abrange o Workspace Model Registry. Databricks recomenda o uso Modelos no Unity Catalog. Os modelos no Unity Catalog fornecem governança de modelo centralizada, acesso entreworkspace, linhagem e implantação. o Workspace Model Registry será preterido no futuro.

Este exemplo ilustra como usar o Workspace Model Registry para criar um aplicativo machine learning que prevê a produção diária de energia de um parque eólico. O exemplo mostra como:

  • logsde rastreamento e modelos gerados com MLflow

  • Modelos de registro com o Model Registry

  • Descrever modelos e fazer versão do modelo transição de estágio

  • Integre modelos registrados com aplicativos de produção

  • Pesquise e descubra modelos no Model Registry

  • Arquivar e excluir modelos

Os artigos descrevem como executar essas passos usando o acompanhamento MLflow e o MLflow Model Registry UIs e APIs.

Para um Notebook que executa todas essas passos utilizando as APIs de acompanhamento e MLflow Model Registry, veja o exemplo Notebook Model Registry.

Carregar conjunto de dados, modelo de ensino e rastrear com acompanhamento do MLflow

Antes de poder registrar um modelo no Model Registry, você deve primeiro ensinar e logs o modelo durante uma execução de experimento. Esta seção mostra como carregar o dataset do parque eólico, ensinar um modelo e logs a execução do ensino no MLflow.

Carregar conjunto de dados

O código a seguir carrega um dataset contendo dados meteorológicos e informações de saída de energia para um parque eólico nos Estados Unidos. O dataset contém recursos wind direction, wind speed e air temperature amostrados a cada seis horas (uma vez em 00:00, uma vez em 08:00 e uma vez em 16:00), bem como a produção de energia agregada diária (power), ao longo de vários anos.

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

modelo de ensino

O código a seguir ensina uma rede neural usando o TensorFlow Keras para prever a saída de energia com base nos recursos climáticos do dataset. O MLflow é usado para rastrear os hiperparâmetros, métricas de desempenho, código-fonte e artefatos do modelo.

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

registrar e gerenciar o modelo usando a IU do MLflow

Criar um novo modelo registrado

  1. Navegue até a barra lateral de execução do Experimento do MLflow clicando no ícone Experimento Ícone de experiência na barra lateral direita do Databricks Notebook .

    barra lateral de execução

  2. Localize a execução do MLflow correspondente à sessão de treinamento TensorFlow modelo Keras e abra-a na IU de execução do MLflow clicando no ícone view de detalhes da execução .

  3. Na IU do MLflow, role para baixo até a seção Artefatos e clique no diretório chamado model. Clique no botão modelo de registro que aparece.

    modelo de registro

  4. Selecione Criar novo modelo no menu suspenso e insira o seguinte nome de modelo: power-forecasting-model.

  5. Clique em registro. Este registra um novo modelo chamado power-forecasting-model e cria uma nova versão do modelo: Version 1.

    Nova versão do modelo

    Após alguns instantes, a IU do MLflow exibe um link para o novo modelo registrado. Siga este link para abrir a nova versão do modelo no MLflow Model Registry UI.

Explorar o Model Registry UI

A página de versão do modelo no UI do MLflow Model Registry fornece informações sobre Version 1 do modelo de previsão registrado, incluindo seu autor, hora de criação e seu estágio atual.

Página da versão do modelo

A página da versão do modelo também fornece um link de execução de origem , que abre a execução do MLflow que foi usada para criar o modelo na IU de execução do MLflow. Na interface do usuário de execução do MLflow, você pode acessar o link Source Notebook para view um Snapshot do Databricks Notebook que foi usado para ensinar o modelo.

Execução da fonte
Notebook de origem

Para navegar de volta ao MLflow Model Registry, clique em ícone de modelos Modelos na barra lateral.

A página inicial do MLflow Model Registry resultante exibe uma lista de todos os modelos registrados em seu workspace Databricks, incluindo suas versões e estágios.

Clique no link power-forecasting-model para abrir a página do modelo registrado, que exibe todas as versões do modelo de previsão.

Adicionar descrições de modelo

Você pode adicionar descrições a modelos registrados e versões de modelos. Descrições de modelos registrados são úteis para registrar informações que se aplicam a várias versões de modelos (por exemplo, uma visão geral do problema de modelagem e dataset). As descrições da versão do modelo são úteis para detalhar os atributos exclusivos de uma versão específica do modelo (por exemplo, a metodologia e o algoritmo usados para desenvolver o modelo).

  1. Adicione uma descrição de alto nível ao modelo de previsão de energia registrado. Clique no ícone de edição ícone e digite a seguinte descrição:

    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.
    Adicionar descrição do modelo

  2. Clique em Salvar.

  3. Clique no link Versão 1 na página do modelo registrado para navegar de volta à página da versão do modelo.

  4. Clique no ícone de edição ícone e insira a seguinte descrição:

    This model version was built using TensorFlow Keras. It is a feed-forward neural network with one hidden layer.
    Adicionar descrição da versão do modelo

  5. Clique em Salvar.

Transição de uma versão de modelo

O MLflow Model Registry define vários estágios de modelo: None, Staging, Production e Archived. Cada fase tem um significado único. Por exemplo, Staging destina-se a testes de modelo, enquanto Production é para modelos que concluíram os processos de teste ou revisão e foram implantados em aplicativos.

  1. Clique no botão Estágio para exibir a lista de estágios de modelo disponíveis e suas opções de transição de estágio disponíveis.

  2. Selecione Transição para -> Produção e pressione OK na janela de confirmação da transição de estágio para fazer a transição do modelo para Produção.

    Transição para produção

    Após a transição da versão do modelo para Production, o estágio atual é exibido na interface do usuário e uma entrada é adicionada aos logs atividades para refletir a transição.

    Fase de produção
    Atividade da versão do modelo

O MLflow Model Registry permite que várias versões de modelo compartilhem o mesmo estágio. Ao fazer referência a um modelo por estágio, o Model Registry usa a versão do modelo mais recente (a versão do modelo com o maior ID de versão). A página do modelo registrado exibe todas as versões de um determinado modelo.

Página modelo registrado

registrar e gerenciar o modelo usando a API MLflow

Definir o nome do modelo programaticamente

Agora que o modelo foi registrado e transferido para Production, você pode referenciá-lo usando APIs programáticas do MLflow. Defina o nome do modelo registrado da seguinte forma:

model_name = "power-forecasting-model"

registrar o modelo 

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)

Adicione descrições de modelos e versões de modelos usando a 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."
)

Faça a transição de uma versão de modelo e recupere detalhes usando a 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))

Carregar versões do modelo registrado usando a API

O componente MLflow Models define funções para carregar modelos de várias estruturas machine learning . Por exemplo, mlflow.tensorflow.load_model() é usado para carregar modelos TensorFlow que foram salvos no formato MLflow e mlflow.sklearn.load_model() é usado para carregar modelos Scikit-Learn que foram salvos no formato MLflow.

Essas funções podem carregar modelos do MLflow Model Registry.

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)

Preveja a saída de energia com o modelo de produção

Nesta seção, o modelo de produção é usado para avaliar os dados de previsão do tempo para o parque eólico. O aplicativo forecast_power() carrega a versão mais recente do modelo de previsão do estágio especificado e o usa para prever a produção de energia nos próximos cinco dias.

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)

Criar uma nova versão do modelo

Técnicas clássicas machine learning também são eficazes para previsão de energia. O código a seguir ensina um modelo de floresta aleatória usando Scikit-Learn e registra-o com o MLflow Model Registry por meio da função mlflow.sklearn.log_model().

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

Adicione uma descrição à nova versão do modelo 

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

Faça a transição da nova versão do modelo para Staging e teste o modelo

Antes de aprimorar um modelo para um aplicativo de produção, geralmente é uma prática recomendada testá-lo em um ambiente de preparação. O código a seguir faz a transição da nova versão do modelo para Staging e avalia seu desempenho.

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

forecast_power(model_name, "Staging")

melhorou a nova versão do modelo para Produção

Depois de verificar se a nova versão do modelo tem um bom desempenho na preparação, o código a seguir faz a transição do modelo para Produção e usa exatamente o mesmo código de aplicativo da saída de energia prevista com a seção do modelo de produção para produzir uma previsão de energia.

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

forecast_power(model_name, "production")

Agora existem duas versões do modelo de previsão no estágio de Produção : a versão do modelo treinada no modelo Keras e a versão treinada no Scikit-Learn.

Versões do modelo do produto

Observação

Ao fazer referência a um modelo por estágio, o registro de MLflow Model Registry usa automaticamente a versão de produção mais recente. Isso permite que você atualize seus modelos de produção sem alterar nenhum código de aplicativo.

Arquivar e excluir modelos

Quando uma versão de modelo não estiver mais sendo usada, você pode arquivá-la ou excluí-la. Você também pode excluir um modelo registrado inteiro; isso remove todas as suas versões de modelo associadas.

Arquivo Version 1 do modelo de previsão de energia

Arquive Version 1 do modelo de previsão de energia porque não está mais sendo usado. Você pode arquivar modelos na interface do usuário do MLflow Model Registry ou por meio da API MLflow.

Arquivar Version 1 na IU do MLflow

Para arquivar Version 1 do modelo de previsão de energia:

  1. Abra sua página de versão de modelo correspondente no UI do MLflow Model Registry:

    Transição para arquivado

  2. Clique no botão Stage , selecione Transition To -> Archived:

    Estágio arquivado

  3. Pressione OK na janela de confirmação da transição de estágio.

    Versão do modelo arquivado

Arquivar Version 1 usando a API MLflow

O código a seguir usa a função MlflowClient.update_model_version() para arquivar Version 1 do modelo de previsão de energia.

from mlflow.tracking.client import MlflowClient

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

Excluir Version 1 do modelo de previsão de energia

Você também pode usar a interface do usuário do MLflow ou a API do MLflow para excluir as versões do modelo.

Aviso

A exclusão da versão do modelo é permanente e não pode ser desfeita.

Excluir Version 1 na IU do MLflow

Para excluir Version 1 do modelo de previsão de energia:

  1. Abra sua página de versão de modelo correspondente no registro de modelo UI do MLflow.

    Excluir versão do modelo

  2. Selecione a seta suspensa ao lado do identificador de versão e clique em Excluir.

Excluir Version 1 usando a API MLflow 
client.delete_model_version(
   name=model_name,
   version=1,
)
Exclua o modelo usando a API MLflow

Você deve primeiro fazer a transição de todos os estágios de versão de modelo restantes para None ou Archived.

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)

Notebook

Notebook de exemplo de registro de modelo MLflow

Abra o bloco de anotações em outra guia