Pular para o conteúdo principal

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​

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

    barra lateral de execução

  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.

    Modelo de registro

  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.

    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.

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.

Página de versão do modelo

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.

Fonte execução

Notebook de origem

Para navegar de volta ao MLflow Model Registry, clique em Ícone de modelos 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 de edição í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.

    Adicionar descrição do modelo

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

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

    Transição para a 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.

    Etapa 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 do modelo registrado

registrar e gerenciar o modelo usando o site MLflow API​

Nesta secção:

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.

Versões do modelo do produto

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:

    Transição para arquivado

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

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

    Excluir versão do modelo

  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
Última atualização em