Exemplo de Registro de Modelo de Espaço de Trabalho

Este exemplo ilustra como usar o Registro de Modelo de Espaço de Trabalho para criar um aplicativo de aprendizado de máquina que prevê a saída diária de energia de um parque eólico. O exemplo mostra como:

• Rastreie e registre modelos com MLflow
• Registar modelos com o Registo Modelo
• Descrever modelos e fazer transições de estágio da versão do modelo
• Integre modelos registrados com aplicativos de produção
• Pesquisar e descobrir modelos no Registro de Modelo
• Arquivar e excluir modelos

O artigo descreve como executar essas etapas usando as UIs e APIs do Registro MLflow Tracking e MLflow Model.

Para um bloco de anotações que executa todas essas etapas usando as APIs MLflow Tracking e Registry, consulte o bloco de anotações de exemplo Model Registry.

Carregue o conjunto de dados, o modelo de trem e a trilha com o MLflow Tracking

Antes de registrar um modelo no Registro Modelo, você deve primeiro treinar e registrar o modelo durante uma execução de experimento. Esta seção mostra como carregar o conjunto de dados do parque eólico, treinar um modelo e registrar a execução do treinamento no MLflow.

Carregar conjunto de dados

O código a seguir carrega um conjunto de dados contendo dados meteorológicos e informações de saída de energia para um parque eólico nos Estados Unidos. O conjunto de dados contém wind direction, , e air temperature apresenta amostras a cada seis horas (uma vez a 00:00, uma vez a 08:00, e uma vez a 16:00), bem como a potência agregada diária (power), ao longo wind speedde 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"]

Preparar o modelo

O código a seguir treina uma rede neural usando o TensorFlow Keras para prever a saída de energia com base nas características meteorológicas no conjunto de dados. O MLflow é usado para rastrear 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 interface do usuário MLflow

Nesta secção:

• Criar um novo modelo registado
• Explore a interface do usuário do Registro Modelo
• Adicionar descrições de modelo
• Fazer a transição de uma versão do modelo

Criar um novo modelo registado

1. Navegue até a barra lateral MLflow Experiment Runs clicando no ícone Experimento na barra lateral direita do bloco de anotações do Azure Databricks.

   

2. Localize a MLflow Run correspondente à sessão de treinamento do modelo Keras do TensorFlow e abra-a na interface do usuário MLflow Run clicando no ícone Exibir Detalhes da Execução .

3. Na interface do usuário do MLflow, role para baixo até a seção Artefatos e clique no diretório chamado 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 Registar. Isso registra um novo modelo chamado power-forecasting-model e cria uma nova versão do modelo: Version 1.

   

   Após alguns momentos, a interface do usuário do MLflow exibe um link para o novo modelo registrado. Siga este link para abrir a nova versão do modelo na interface do usuário do Registro do Modelo MLflow.

Explore a interface do usuário do Registro Modelo

A página de versão do modelo na interface do usuário do Registro do Modelo MLflow fornece informações sobre Version 1 o modelo de previsão registrado, incluindo seu autor, tempo de criação e seu estágio atual.

A página de versão do modelo também fornece um link Source Run , que abre o MLflow Run que foi usado para criar o modelo na interface do usuário MLflow Run. Na interface do usuário MLflow Run, você pode acessar o link Bloco de anotações de origem para exibir um instantâneo do bloco de anotações do Azure Databricks que foi usado para treinar o modelo.

Para navegar de volta para o Registro do Modelo MLflow, clique em Modelos na barra lateral.

A home page resultante do Registro de Modelo MLflow exibe uma lista de todos os modelos registrados em seu espaço de trabalho do Azure 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. As descrições de modelos registrados são úteis para registrar informações que se aplicam a várias versões do modelo (por exemplo, uma visão geral do problema de modelagem e do conjunto de dados). As descrições da versão do modelo são úteis para detalhar os atributos exclusivos de uma determinada versão 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 Guardar.

3. Clique no link Versão 1 na página do modelo registrado para navegar de volta para a 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 Guardar.

Fazer a transição de uma versão do modelo

O Registro do Modelo MLflow define vários estágios do modelo: Nenhum, Preparo, Produção e Archived. Cada etapa tem um significado único. Por exemplo, o preparo destina-se ao teste de modelo, enquanto a produção é para modelos que concluíram os processos de teste ou revisão e foram implantados em aplicativos.

1. Clique no botão Palco 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 de transição de estágio para fazer a transição do modelo para Produção.

   

   Depois que a versão do modelo é transferida para Produção, o estágio atual é exibido na interface do usuário e uma entrada é adicionada ao log de atividades 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 Registro do modelo usa a versão mais recente do modelo (a versão do modelo com o ID da versão maior). A página do modelo registrado exibe todas as versões de um modelo específico.

Registrar e gerenciar o modelo usando a API MLflow

Nesta secção:

• Definir o nome do modelo programaticamente
• Registar o modelo
• Adicionar descrições de modelo e versão do modelo usando a API
• Fazer a transição de uma versão do modelo e recuperar detalhes usando a API

Definir o nome do modelo programaticamente

Agora que o modelo foi registrado e transferido para Produção, você pode fazer referência a ele usando APIs programáticas MLflow. Defina o nome do modelo registado da seguinte forma:

model_name = "power-forecasting-model"

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

Adicionar descrições de modelo e versão do modelo 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."
)

Fazer a transição de uma versão do modelo e recuperar 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 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 Registro de Modelo 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)

Previsão de potência de saída 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 forecast_power() aplicativo 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.

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

As técnicas clássicas de aprendizagem automática também são eficazes para a previsão de energia. O código a seguir treina um modelo de floresta aleatório usando scikit-learn e o registra com o MLflow Model Registry por meio da mlflow.sklearn.log_model() função.

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

Buscar o ID da nova versão do modelo usando a pesquisa do Registro do Modelo MLflow

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)

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

Transfira a nova versão do modelo para Preparo 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 Preparo e avalia seu desempenho.

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 tem um bom desempenho no preparo, 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 potência de previsão com a seção de 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")

Existem agora duas versões do modelo de previsão na etapa de Produção : a versão do modelo treinada no modelo Keras e a versão treinada no scikit-learn.

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

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

Arquivar Version 1 na interface do usuário do MLflow

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

1. Abra a página de versão do modelo correspondente na interface do usuário do Registro do Modelo MLflow:

   

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

   

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

   

Arquivar Version 1 usando a API MLflow

O código a seguir usa a MlflowClient.update_model_version() função para arquivar Version 1 o 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",
)

Exclusão Version 1 do modelo de previsão de energia

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

Excluir Version 1 na interface do usuário do MLflow

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

1. Abra a página de versão do modelo correspondente na interface do usuário do Registro do Modelo MLflow.

   

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

Excluir o modelo usando a API MLflow

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

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)

Bloco de Notas

Bloco de anotações de exemplo do Registro do Modelo MLflow

Obter o bloco de notas