Śledzenie i porównywanie modeli przy użyciu modeli zarejestrowanych przez platformę MLflow

Modele zarejestrowane przez platformę MLflow ułatwiają śledzenie postępu modelu w całym cyklu życia. Podczas trenowania modelu użyj mlflow.<model-flavor>.log_model(), aby utworzyć LoggedModel, które powiąże wszystkie jego krytyczne informacje, wykorzystując unikatowy identyfikator. Aby wykorzystać możliwości LoggedModelsprogramu , rozpocznij pracę z platformą MLflow 3.

W przypadku aplikacji GenAI można utworzyć obiekty dedykowane do przechwytywania zatwierdzeń w Git lub zestawów parametrów, które mogą być następnie połączone ze śladami i metrykami. W przypadku głębokiego uczenia się i klasycznego uczenia maszynowego LoggedModels są generowane z przebiegów MLflow, które są już istniejącymi pojęciami w środowisku MLflow i można je uznać za zadania wykonujące kod modelu. Przebiegi trenowania generują modele jako dane wyjściowe, a przebiegi oceny używają istniejących modeli jako danych wejściowych do tworzenia metryk i innych informacji, których można użyć do oceny wydajności modelu.

Obiekt LoggedModel utrzymuje się w całym cyklu życia modelu, w różnych środowiskach i zawiera linki do artefaktów, takich jak metadane, metryki, parametry i kod używany do generowania modelu. Śledzenie zarejestrowanego modelu umożliwia porównywanie modeli ze sobą, znajdowanie najbardziej wydajnych modeli i śledzenie informacji podczas debugowania.

Zarejestrowane modele mogą być również wpisane do katalogu Unity, co umożliwia dostęp do informacji o modelu ze wszystkich eksperymentów i przestrzeni roboczych MLflow w jednej lokalizacji. Aby uzyskać więcej informacji, zobacz Ulepszenia rejestru modeli za pomocą platformy MLflow 3.

Ulepszone śledzenie modeli sztucznej inteligencji generatywnej i uczenia głębokiego

Przepływy pracy związane z generatywną sztuczną inteligencją i uczeniem głębokim szczególnie korzystają z granularnego śledzenia zapewnianego przez zarejestrowane modele.

Generatywna sztuczna inteligencja — ujednolicone dane oceny i śledzenia:

• Modele generatywnej sztucznej inteligencji generują dodatkowe metryki podczas oceny i wdrażania, takie jak opinie recenzentów i ślady.
• Jednostka LoggedModel umożliwia wykonywanie zapytań dotyczących wszystkich informacji generowanych przez model przy użyciu jednego interfejsu.

Uczenie głębokie — wydajne zarządzanie punktami kontrolnymi:

• Trenowanie uczenia głębokiego tworzy wiele punktów kontrolnych, które są migawkami stanu modelu w określonym punkcie podczas trenowania.
• Platforma MLflow tworzy oddzielny LoggedModel dla każdego punktu kontrolnego, zawierając metryki i dane wydajności modelu. Dzięki temu można porównywać i oceniać punkty kontrolne w celu efektywnego identyfikowania najlepiej działających modeli.

Tworzenie zarejestrowanego modelu

Aby utworzyć model rejestrowany, użyj tego samego log_model() interfejsu API co istniejące obciążenia MLflow. Poniższe fragmenty kodu pokazują, jak utworzyć rejestrowany model dla gen AI, uczenia głębokiego oraz tradycyjnych procesów uczenia maszynowego.

Aby uzyskać kompletne przykłady notesów z możliwością uruchamiania, zobacz Przykładowe notesy.

Sztuczna inteligencja generatywna

Poniższy fragment kodu przedstawia sposób rejestrowania agenta LangChain. Użyj metody log_model() dla twojego typu agenta.

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

Uruchom zadanie oceny i połącz metryki z zalogowanym modelem, podając unikatowy element model_id dla elementu 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
  )

Uczenie głębokie

Poniższy fragment kodu pokazuje, jak utworzyć zarejestrowane modele podczas trenowania uczenia głębokiego. Użyj metody log_model() dla swojego typu modelu 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
          )

Tradycyjne uczenie maszynowe

Poniższy fragment kodu pokazuje, jak zarejestrować model sklearn i połączyć metryki z elementem Logged Model. Użyj metody log_model() dla swojego typu modelu 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
)

Przykładowe notatniki

Na przykład notesy ilustrujące użycie programu LoggedModels, zobacz następujące strony:

• Workflow uczenia głębokiego MLflow 3
• Tradycyjny przepływ pracy ML w MLflow 3

Wyświetlanie modeli i śledzenie postępu

Zarejestrowane modele można wyświetlić w interfejsie użytkownika obszaru roboczego:

1. Przejdź do karty Eksperymenty w obszarze roboczym.
2. Wybierz eksperyment. Następnie wybierz kartę Modele .

Ta strona zawiera wszystkie zarejestrowane modele skojarzone z eksperymentem wraz z ich metrykami, parametrami i artefaktami.

Aby śledzić metryki w przebiegach, można wygenerować wykresy.

Wyszukiwanie i filtrowanie zarejestrowanych modeli

Na karcie Modele można wyszukiwać i filtrować zarejestrowane modele na podstawie ich atrybutów, parametrów, tagów i metryk.

Metryki można filtrować na podstawie wydajności specyficznej dla zestawu danych, a zwracane są tylko modele z pasującymi wartościami metryk dla danych zestawów danych. Jeśli filtry zestawów danych są udostępniane bez żadnych filtrów metryk, zwracane są modele z dowolnymi metrykami dotyczącymi tych zestawów danych.

Można filtrować na podstawie następujących atrybutów:

• model_id
• model_name
• status
• artifact_uri
• creation_time (numeryczne)
• last_updated_time (numeryczne)

Użyj następujących operatorów, aby wyszukiwać i filtrować atrybuty, parametry i tagi podobne do ciągu:

• =, , !=, , INNOT IN

Użyj następujących operatorów porównania, aby wyszukiwać i filtrować atrybuty liczbowe i metryki:

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

Programowe wyszukiwanie zarejestrowanych modeli

Możesz wyszukać zarejestrowane modele przy użyciu interfejsu API platformy 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>}
  ]
)

Aby uzyskać więcej informacji i dodatkowych parametrów wyszukiwania, zobacz dokumentację interfejsu API platformy MLflow 3.

Wyszukiwanie jest uruchamiane według danych wejściowych i wyjściowych modelu

Możesz wyszukiwać przebiegi według identyfikatora modelu, aby zwrócić wszystkie uruchomienia, które mają zarejestrowany model jako dane wejściowe lub wyjściowe. Aby uzyskać więcej informacji na temat składni ciągu filtru, zobacz filtrowanie przebiegów.

Możesz wyszukać przebiegi za pomocą 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>")

Dalsze kroki

Aby dowiedzieć się więcej o innych nowych funkcjach platformy MLflow 3, zobacz następujące artykuły:

• Ulepszenia rejestru modeli za pomocą platformy MLflow 3.
• Zadania wdrażania platformy MLflow 3.