Acompanhe e compare modelos usando MLflow modelos logged (Beta)

info

Beta

Esse recurso está na versão beta.

MLflow Os modelos registrados ajudam o senhor a acompanhar o progresso de um modelo durante todo o seu ciclo de vida. Quando o senhor treinar um modelo, use o site mlflow.<model-flavor>.log_model() para criar um LoggedModel que reúna todas as suas informações críticas usando um ID exclusivo.

O objeto LoggedModel persiste durante todo o ciclo de vida do modelo, em diferentes ambientes e execuções, e contém links para artefatos como metadados, métricas, parâmetros e o código usado para gerar o modelo.

O acompanhamento registrado de modelos permite que o senhor compare modelos entre si, encontre o modelo de melhor desempenho e rastreie informações durante a depuração.

Acompanhamento aprimorado para os modelos gen AI e aprendizagem profunda

O Generative AI e a aprendizagem profunda fluxo de trabalho se beneficiam especialmente do acompanhamento granular que os modelos logados oferecem.

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

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

aprendizagem profunda - gerenciamento eficiente de pontos de controle:

• O aprendizado profundo treinamento 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 as métricas do modelo e os dados de desempenho. Isso permite que você compare e avalie pontos de verificação para identificar os modelos com melhor desempenho de forma eficiente.

Criar um modelo registrado

Para criar um modelo registrado, use o mesmo log_model() API que as cargas de trabalho existentes do MLflow. Os trechos de código a seguir mostram como criar um modelo registrado para o gen AI, aprendizagem profunda e o tradicional ML fluxo de trabalho.

Para obter exemplos completos e executáveis do Notebook, consulte Exemplo de Notebook.

Gen AI

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

Python

# 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,
  artifact_path="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)

Começar um trabalho de avaliação e vincular as métricas a um modelo registrado, fornecendo o model_id exclusivo para o LoggedModel:

Python

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

Deep learning

O trecho de código a seguir mostra como criar modelos registrados durante a aprendizagem profunda treinamento. Use o método log_model() para sua variante do modelo MLflow.

Python

# 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()

    # 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,
        input_example=X_train.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
      )

Traditional ML

O trecho de código a seguir mostra como log um modelo sklearn e vincula métricas ao Logged Model. Use o método log_model() para sua variante do modelo MLflow.

Python

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

Exemplo de notebook

Para ver exemplos de Notebook que ilustram o uso do LoggedModels, consulte as páginas a seguir:

• MLflow 3.0 generative AI fluxo de trabalho (Beta)
• MLflow 3.0 aprendizagem profunda fluxo de trabalho (Beta)
• MLflow 3.0 fluxo de trabalho tradicional de ML (Beta)

visualizar modelos e acompanhar o progresso

O senhor pode view seus modelos registrados na UI workspace:

1. Acesse o site Experiments tab em seu workspace.
2. Selecione um experimento. Em seguida, selecione Models (Modelos ) tab.

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

O senhor pode pesquisar e filtrar os modelos registrados e gerar gráficos para acompanhar as métricas em toda a execução.

Pesquisar modelos registrados programaticamente

Além da interface do usuário, pesquise os modelos registrados usando o site MLflow API:

Python

## 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()

Para obter mais informações e parâmetros de pesquisa adicionais, consulte a documentaçãoMLflow 3.0 API.