Acompanhar e comparar modelos usando modelos registrados no MLflow

Os Modelos Registrados no MLflow ajudam você a acompanhar o progresso de um modelo durante todo o ciclo de vida. Ao treinar um modelo, use mlflow.<model-flavor>.log_model() para criar um LoggedModel que vincule todas as suas informações críticas usando uma ID exclusiva. Para aproveitar o poder de LoggedModels, comece a usar o MLflow 3.

Para aplicativos GenAI, LoggedModels pode ser criado para capturar confirmações do git ou conjuntos de parâmetros como objetos dedicados que podem ser vinculados a rastreamentos e métricas. No aprendizado profundo e no ML clássico, LoggedModels são produzidos a partir de execuções do MLflow, que são conceitos já existentes no MLflow e podem ser considerados como tarefas que executam o código do modelo. As execuções de treinamento produzem modelos como saídas e as execuções de avaliação usam modelos existentes como entrada para produzir métricas e outras informações que você pode usar para avaliar o desempenho de um modelo.

O LoggedModel objeto persiste em todo o ciclo de vida do modelo, em ambientes diferentes, e contém links para artefatos como metadados, métricas, parâmetros e o código usado para gerar o modelo. O monitoramento de modelos registrados permite comparar modelos entre si, encontrar o modelo com melhor desempenho e localizar informações durante a depuração.

Os Modelos Registrados também podem ser armazenados no registro de modelos do Unity Catalog, tornando as informações sobre o modelo de todos os experimentos e workspaces do MLflow disponíveis em um único local. Para obter mais detalhes, consulte aprimoramentos do Registro de Modelo com o MLflow 3.

Fluxo de acompanhamento de modelo para IA generativa, aprendizado profundo e aprendizado de máquina tradicional.

Monitoramento aprimorado para IA generativa e modelos de aprendizado profundo

Os fluxos de trabalho de IA e de aprendizado profundo se beneficiam especialmente do acompanhamento granular fornecido pelos Modelos Registrados.

Gen AI - dados unificados de avaliação e rastreamento:

Os modelos de IA generativa geram métricas adicionais durante a avaliação e implantação, como feedback de revisores e rastreamentos.
A LoggedModel entidade permite que você consulte todas as informações geradas por um modelo usando uma única interface.

Aprendizado profundo – gerenciamento eficiente de ponto de verificação:

O treinamento de aprendizado profundo cria vários pontos de verificação, que são instantâneos do estado do modelo em um determinado ponto durante o treinamento.
O MLflow cria um LoggedModel separado para cada ponto de verificação, contendo métricas e dados de desempenho do modelo. Isso permite que você compare e avalie pontos de verificação para identificar os modelos com melhor desempenho com eficiência.

Criar um modelo registrado

Para criar um modelo registrado, use a mesma log_model() API que as cargas de trabalho do MLflow. Os trechos de código a seguir mostram como criar um Modelo Registrado para IA generativa, treinamento profundo e trabalhos ML tradicionais.

Para obter exemplos de notebook completos e executáveis, consulte Notebooks de exemplo.

IA de geração

O trecho de código a seguir mostra como registrar um agente LangChain. Use o método log_model() para o seu tipo de agente.

# Log the chain with MLflow, specifying its parameters
# As a new feature, the LoggedModel entity is linked to its name and params
model_info = mlflow.langchain.log_model(
  lc_model=chain,
  name="basic_chain",
  params={
    "temperature": 0.1,
    "max_tokens": 2000,
    "prompt_template": str(prompt)
  },
  model_type="agent",
  input_example={"messages": "What is MLflow?"},
)

# Inspect the LoggedModel and its properties
logged_model = mlflow.get_logged_model(model_info.model_id)
print(logged_model.model_id, logged_model.params)

Inicie um trabalho de avaliação e vincule as métricas a um Modelo Registrado fornecendo o model_id exclusivo para o LoggedModel.

# Start a run to represent the evaluation job
with mlflow.start_run() as evaluation_run:
  eval_dataset: mlflow.entities.Dataset = mlflow.data.from_pandas(
    df=eval_df,
    name="eval_dataset",
  )
  # Run the agent evaluation
  result = mlflow.evaluate(
    model=f"models:/{logged_model.model_id}",
    data=eval_dataset,
    model_type="databricks-agent"
  )
  # Log evaluation metrics and associate with agent
  mlflow.log_metrics(
    metrics=result.metrics,
    dataset=eval_dataset,
    # Specify the ID of the agent logged above
    model_id=logged_model.model_id
  )

Aprendizado profundo

O trecho de código a seguir mostra como criar Modelos Logados durante o treinamento de Deep Learning. Use o método log_model() para o seu tipo de modelo MLflow.

# Start a run to represent the training job
with mlflow.start_run():
  # Load the training dataset with MLflow. We will link training metrics to this dataset.
  train_dataset: Dataset = mlflow.data.from_pandas(train_df, name="train")
  X_train, y_train = prepare_data(train_dataset.df)

  criterion = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(scripted_model.parameters(), lr=0.01)

  for epoch in range(101):
      X_train, y_train = X_train.to(device), y_train.to(device)
      out = scripted_model(X_train)
      loss = criterion(out, y_train)
      optimizer.zero_grad()
      loss.backward()
      optimizer.step()

      # Obtain input and output examples for MLflow Model signature creation
      with torch.no_grad():
          input_example = X_train[:1]
          output_example = scripted_model(input_example)

      # Log a checkpoint with metrics every 10 epochs
      if epoch % 10 == 0:
          # Each newly created LoggedModel checkpoint is linked with its
          # name, params, and step
          model_info = mlflow.pytorch.log_model(
              pytorch_model=scripted_model,
              name=f"torch-iris-{epoch}",
              params={
                  "n_layers": 3,
                  "activation": "ReLU",
                  "criterion": "CrossEntropyLoss",
                  "optimizer": "Adam"
              },
              step=epoch,
              signature=mlflow.models.infer_signature(
                  model_input=input_example.cpu().numpy(),
                  model_output=output_example.cpu().numpy(),
              ),
              input_example=X_train.cpu().numpy(),
          )
          # Log metric on training dataset at step and link to LoggedModel
          mlflow.log_metric(
              key="accuracy",
              value=compute_accuracy(scripted_model, X_train, y_train),
              step=epoch,
              model_id=model_info.model_id,
              dataset=train_dataset
          )

ML tradicional

O snippet de código a seguir mostra como registrar um modelo sklearn e vincular métricas ao Logged Model. Use o método log_model() para o seu tipo de modelo MLflow.

## Log the model
model_info = mlflow.sklearn.log_model(
  sk_model=lr,
  name="elasticnet",
  params={
    "alpha": 0.5,
    "l1_ratio": 0.5,
  },
  input_example = train_x
)

# Inspect the LoggedModel and its properties
logged_model = mlflow.get_logged_model(model_info.model_id)
print(logged_model.model_id, logged_model.params)

# Evaluate the model on the training dataset and log metrics
# These metrics are now linked to the LoggedModel entity
predictions = lr.predict(train_x)
(rmse, mae, r2) = compute_metrics(train_y, predictions)
mlflow.log_metrics(
  metrics={
    "rmse": rmse,
    "r2": r2,
    "mae": mae,
  },
  model_id=logged_model.model_id,
  dataset=train_dataset
)

Exemplos de notebooks

Para obter exemplos de notebooks que ilustram o uso de LoggedModels, consulte as seguintes páginas:

Exibir modelos e acompanhar o progresso

Você pode visualizar seus modelos registrados na interface do workspace.

Vá para a guia Experimentos na sua área de trabalho.
Selecione um experimento. Em seguida, selecione a guia Modelos .

Esta página contém todos os Modelos Registrados associados ao experimento, juntamente com suas métricas, parâmetros e artefatos.

Interface de rastreamento de modelo.

Você pode gerar gráficos para acompanhar as métricas ao longo de execuções.

Gráficos de métricas de monitoramento de modelo da interface do usuário.

Pesquisar e filtrar Modelos Registrados

Na guia Modelos , você pode pesquisar e filtrar Modelos Registrados com base em seus atributos, parâmetros, marcas e métricas.

Você pode filtrar métricas com base no desempenho específico do conjunto de dados e somente modelos com valores de métrica correspondentes nos conjuntos de dados fornecidos são retornados. Se os filtros de conjunto de dados forem fornecidos sem filtros de métrica, os modelos com quaisquer métricas nesses conjuntos de dados serão retornados.

Você pode filtrar com base nos seguintes atributos:

model_id
model_name
status
artifact_uri
creation_time (numérico)
last_updated_time (numérico)

Use os seguintes operadores para pesquisar e filtrar atributos, parâmetros e marcas semelhantes a cadeias de caracteres:

=, !=, , INNOT IN

Use os seguintes operadores de comparação para pesquisar e filtrar atributos e métricas numéricas:

=, !=, >, <, , >=<=

Pesquisar modelos registrados programaticamente

Você pode pesquisar modelos registrados usando a API do MLflow:

## Get a Logged Model using a model_id
mlflow.get_logged_model(model_id = <my-model-id>)

## Get all Logged Models that you have access to
mlflow.search_logged_models()

## Get all Logged Models with a specific name
mlflow.search_logged_models(
  filter_string = "model_name = <my-model-name>"
)

## Get all Logged Models created within a certain time range
mlflow.search_logged_models(
  filter_string = "creation_time >= <creation_time_start> AND creation_time <= <creation_time_end>"
)

## Get all Logged Models with a specific param value
mlflow.search_logged_models(
  filter_string = "params.<param_name> = <param_value_1>"
)

## Get all Logged Models with specific tag values
mlflow.search_logged_models(
  filter_string = "tags.<tag_name> IN (<tag_value_1>, <tag_value_2>)"
)

## Get all Logged Models greater than a specific metric value on a dataset, then order by that metric value
mlflow.search_logged_models(
  filter_string = "metrics.<metric_name> >= <metric_value>",
  datasets = [
    {"dataset_name": <dataset_name>, "dataset_digest": <dataset_digest>}
  ],
  order_by = [
    {"field_name": metrics.<metric_name>, "dataset_name": <dataset_name>,"dataset_digest": <dataset_digest>}
  ]
)

Para obter mais informações e parâmetros de pesquisa adicionais, consulte a documentação da API do MLflow 3.

Pesquisar execuções por entradas e saídas de modelo

Você pode pesquisar execuções por ID do modelo para retornar todas as execuções que têm o Modelo Registrado como entrada ou saída. Para obter mais informações sobre a sintaxe da cadeia de caracteres de filtro, consulte a filtragem para execuções.

Você pode pesquisar execuções usando a API do MLflow:

## Get all Runs with a particular model as an input or output by model id
mlflow.search_runs(filter_string = "models.model_id = <my-model-id>")

Próximas etapas

Para saber mais sobre outros novos recursos do MLflow 3, confira os seguintes artigos:

Comentários

Esta página foi útil?

Last updated on 2025-08-13