Partilhar via

Rastreie e compare modelos usando modelos registrados MLflow

Os modelos registrados MLflow ajudam a acompanhar o progresso de um modelo ao longo de seu ciclo de vida. Ao treinar um modelo, use mlflow.<model-flavor>.log_model() para criar um LoggedModel que una todas as suas informações críticas usando um ID exclusivo. Para aproveitar o poder do LoggedModels, comece a usar o MLflow 3.

Para aplicativos GenAI, LoggedModels pode ser criado para capturar commits git ou conjuntos de parâmetros como objetos dedicados que podem ser vinculados a rastreamentos e métricas. No deep learning e no ML clássico, LoggedModels são produzidos a partir de execuções do MLflow, que são conceitos existentes no MLflow e podem ser pensados como tarefas que executam código de 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 durante todo o ciclo de vida do modelo, em diferentes ambientes, e contém links para artefatos como metadados, métricas, parâmetros e o código usado para gerar o modelo. O acompanhamento de modelos registrados permite comparar modelos entre si, encontrar o modelo com melhor desempenho e rastrear informações durante a depuração.

Os modelos registrados também podem ser registrados no registro do modelo do Unity Catalog, disponibilizando informações sobre o modelo de todos os experimentos e espaços de trabalho do MLflow em um único local. Para obter mais detalhes, consulte Aprimoramentos do Registro de modelo com MLflow 3.

Fluxo de rastreamento de modelo para IA generativa, aprendizado profundo e ML tradicional.

Rastreamento aprimorado para modelos de Inteligência Artificial generativa e aprendizado profundo

A IA generativa e os fluxos de trabalho de aprendizagem profunda se beneficiam especialmente do acompanhamento granular que os modelos registrados fornecem.

Gen AI - avaliação unificada e dados de rastreio:

  • Os modelos de IA da geração geram métricas adicionais durante a avaliação e a implantação, como dados e rastreamentos de feedback do revisor.
  • A LoggedModel entidade permite consultar todas as informações geradas por um modelo usando uma única interface.

Deep learning - gestão eficiente de pontos 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 ponto específico durante o treinamento.
  • O MLflow cria um LoggedModel separado para cada checkpoint, contendo as métricas e os dados de desempenho do modelo. Isso permite comparar e avaliar pontos de verificação para identificar os modelos com melhor desempenho de forma eficiente.

Criar um modelo registrado

Para criar um modelo registrado, use a mesma log_model() API que as cargas de trabalho MLflow existentes. Os trechos de código a seguir mostram como criar um modelo registrado para IA de geração, aprendizado profundo e fluxos de trabalho de ML tradicionais.

Para obter exemplos completos e executáveis de blocos de anotações, consulte Exemplos de blocos de anotações.

Geração AI

O trecho de código a seguir mostra como registrar um agente LangChain. Use o método log_model() para o seu sabor 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 Logado, fornecendo o exclusivo model_id 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
  )

Aprendizagem profunda

O trecho de código a seguir mostra como criar modelos registrados durante o treinamento de aprendizado profundo. Use o método log_model() para a sua variante do 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 trecho 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 a sua variante do 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 cadernos

Por exemplo, para ver blocos de notas que ilustram a utilização do LoggedModels, consulte as páginas seguintes:

Veja modelos e acompanhe o progresso

Pode ver os seus modelos registados na interface do espaço de trabalho.

  1. Vá para a guia Experimentos em seu espaço de trabalho.
  2. 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 métricas em todas as execuções.

Gráficos de métricas de acompanhamento de modelos na interface.

Pesquisar e filtrar modelos registrados

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

Interface de pesquisa de rastreamento de modelos procura modelos registados.

Você pode filtrar métricas com base no desempenho específico do conjunto de dados, e somente modelos com valores de métricas 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 tags semelhantes a cadeias de caracteres:

  • =, !=, IN, NOT IN

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

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

Pesquisar modelos registrados programaticamente

Você pode pesquisar modelos registrados usando a API 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 MLflow 3.

A pesquisa é executada por entradas e saídas do modelo

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

Modelos de pesquisa de interface do usuário de rastreamento de modelos registrados por ID de modelo.

Você pode pesquisar processos usando a API 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óximos passos

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

  • Last updated on