Workspace Model Registry exemplo

nota

Esta documentação abrange o Workspace Model Registry. A Databricks recomenda o uso de Models no Unity Catalog. Os modelos em Unity Catalog oferecem governança centralizada de modelos, acesso entreworkspace, linhagem e implementação. O Workspace Model Registry será descontinuado 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:

• Rastreie e modelos logged with MLflow
• Modelos de registro com o Model Registry
• Descrever modelos e fazer a 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 ver um Notebook que executa todas essas etapas usando o MLflow acompanhamento e o Registry APIs, consulte o Notebook de exemploModel Registry.

Carregue dataset, modelo de trem e trilhos com MLflow acompanhamento

Antes de registrar um modelo no site, o senhor Model Registry deve primeiro treinar e log o modelo durante a execução de um experimento. Esta seção mostra como carregar o parque eólico dataset, treinar um modelo e log a execução do treinamento para MLflow.

Carga dataset

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

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

Modelo de trem

O código a seguir treina uma rede neural usando TensorFlow Keras para prever a saída de energia com base no recurso de clima em dataset. O MLflow é usado para rastrear os hiperparâmetros do modelo, as métricas de desempenho, o código-fonte e os artefatos.

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

Registrar e gerenciar o modelo usando a UI do MLflow

Nesta secção:

• Crie um novo modelo registrado
• Explorar o Model Registry UI
• Adicionar descrições de modelos
• Faça a transição de uma versão do modelo

Crie um novo modelo registrado

1. Navegue até a barra lateral de execução do experimento MLflow clicando no ícone do experimento na barra lateral direita do Notebook Databricks.

   

2. Localize a execução MLflow correspondente à sessão de treinamento TensorFlow modelo Keras e abra-a na UI de execução MLflow clicando no ícone view execution Detail .

3. Na interface do usuário do MLflow, role para baixo até a seção Artifacts (Artefatos ) e clique no diretório chamado model (modelo ). Clique no botão registrar modelo que aparece.

   

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

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

   

   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.

Explore a interface de usuário do Model Registry

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.

A página de 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 UI de execução do MLflow. Na UI de execução MLflow, o senhor pode acessar o link Source Notebook para view um instantâneo do Databricks Notebook que foi usado para treinar o modelo.

Para navegar de volta ao MLflow Model Registry, clique em Models 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 do modelo de previsão de energia para abrir a página do modelo registrado, que exibe todas as versões do modelo de previsão.

Adicionar descrições de modelos

Você pode adicionar descrições aos modelos registrados e às versões dos modelos. As 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 e insira 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.

   

2. Clique em Salvar .

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

4. Clique no í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.

   

5. Clique em Salvar .

Faça a transição de uma versão do 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 Stage (Estágio ) para exibir a lista de estágios de modelo disponíveis e as opções de transição de estágio disponíveis.

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

   

   Depois que a versão do modelo é transferida para a produção , o estágio atual é exibido na interface do usuário e uma entrada é adicionada à atividade log para refletir a transição.

   

   

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.

registrar e gerenciar o modelo usando o site MLflow API

Nesta secção:

• Defina o nome do modelo programaticamente
• registro do modelo
• Adicionar descrições de modelos e versões de modelos usando a API
• Transição de uma versão de modelo e recuperação de detalhes usando a API

Defina o nome do modelo programaticamente

Agora que o modelo foi registrado e transferido para Production , o senhor pode fazer referência a ele usando as APIs programáticas do MLflow. Defina o nome do modelo registrado da seguinte forma:

Python

model_name = "power-forecasting-model"

registro do modelo

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)

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

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

Carregar versões do modelo registrado usando a API

O componente MLflow Models define funções para carregar modelos de várias estruturas de aprendizado de máquina. 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.

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)

Preveja a produção 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 a usa para prever a produção de energia nos próximos cinco dias.

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)

Crie 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().

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

Obtenha o ID da nova versão do modelo usando a pesquisa do 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)

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

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

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

Antes de implantar um modelo em 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 o Staging e avalia seu desempenho.

Python

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

forecast_power(model_name, "Staging")

implantar a nova versão do modelo na Produção

Depois de verificar se a nova versão do modelo funciona bem 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 seção Previsão de potência de saída com o modelo de produção para produzir uma previsão de energia.

Python

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

forecast_power(model_name, "production")

Agora há 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.

nota

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 do modelo não está mais sendo usada, você pode arquivá-la ou excluí-la. Você também pode excluir um modelo registrado inteiro; isso remove todas as 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 interface do usuário 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:

   

2. Clique no botão Estágio , selecione Transição para - > Arquivado :

   

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

   

Arquivar Version 1 usando a API do 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.

Python

from mlflow.tracking.client import MlflowClient

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

Exclua Version 1 do modelo de previsão de energia

O senhor também pode usar a interface do usuário do MLflow ou a API do MLflow para excluir versões de modelos.

atenção

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

Excluir Version 1 na interface do usuário do MLflow

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

1. Abra a página da versão do modelo correspondente na interface de usuário do MLflow Model Registry.

   

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

Excluir Version 1 usando a API do MLflow

Python

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

Excluir o modelo usando a API do MLflow

Você deve primeiro fazer a transição de todos os estágios restantes da versão do modelo para Nenhum ou Arquivado .

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

MLflow Model Registry Exemplo de notebook

Open notebook in new tab