Delen via

Modellen bijhouden en vergelijken met MLflow Logged Models

Met MLflow Logged Models kunt u de voortgang van een model gedurende de gehele levenscyclus bijhouden. Wanneer u een model traint, gebruik mlflow.<model-flavor>.log_model() om een LoggedModel te creëren dat alle essentiële informatie samenbrengt met behulp van een unieke ID. Ga aan de slag met MLflow 3 om de kracht van LoggedModelsMLflow te benutten.

Voor GenAI-toepassingen kan LoggedModels worden gecreëerd om git commits of parametergroepen vast te leggen als toegewezen objecten, die vervolgens kunnen worden gekoppeld aan traceringen en metriek. In deep learning en klassieke ML LoggedModels worden geproduceerd uit MLflow-uitvoeringen. Dit zijn bestaande concepten in MLflow en kunnen worden beschouwd als taken die modelcode uitvoeren. Trainingsuitvoeringen produceren modellen als uitvoer en evaluatieuitvoeringen gebruiken bestaande modellen als invoer om metrische gegevens en andere informatie te produceren die u kunt gebruiken om de prestaties van een model te beoordelen.

Het LoggedModel object blijft behouden gedurende de levenscyclus van het model, in verschillende omgevingen en bevat koppelingen naar artefacten, zoals metagegevens, metrische gegevens, parameters en de code die wordt gebruikt om het model te genereren. Met logboekmodeltracering kunt u modellen vergelijken met elkaar, het meest presterende model vinden en informatie opsporen tijdens foutopsporing.

Geregistreerde modellen kunnen ook worden geregistreerd bij het Unity Catalog-modelregister, waardoor informatie wordt gemaakt over het model van alle MLflow-experimenten en werkruimten die beschikbaar zijn op één locatie. Zie Verbeteringen in modelregisters met MLflow 3 voor meer informatie.

Modeltrackingstroom voor gen AI, deep learning en traditionele ML.

Verbeterde tracering voor GenAI- en Deep Learning-modellen

Generatieve AI- en deep learning-werkstromen profiteren vooral van de gedetailleerde tracering die Logged Models biedt.

Gen AI - geïntegreerde evaluatie- en traceringsgegevens:

  • Gen AI-modellen genereren extra metrische gegevens tijdens de evaluatie en implementatie, zoals feedbackgegevens en traceringen van revisoren.
  • Met LoggedModel de entiteit kunt u een query uitvoeren op alle informatie die door een model wordt gegenereerd met behulp van één interface.

Deep Learning: efficiënt controlepuntbeheer:

  • Deep Learning-training maakt meerdere controlepunten. Dit zijn momentopnamen van de status van het model op een bepaald punt tijdens de training.
  • MLflow maakt een afzonderlijk LoggedModel voor elk controlepunt, dat de metrische gegevens en prestatiegegevens van het model bevat. Hiermee kunt u controlepunten vergelijken en evalueren om de best presterende modellen efficiënt te identificeren.

Een geregistreerd model maken

Als u een geregistreerd model wilt maken, gebruikt u dezelfde log_model() API als bestaande MLflow-workloads. De volgende codefragmenten laten zien hoe u een vastgelegd model voor gen AI, deep learning en traditionele ML-werkstromen maakt.

Zie voor volledige, uitvoerbare voorbeeldnotebooks Voorbeeldnotebooks.

Gen AI

In het volgende codefragment ziet u hoe u een LangChain-agent kunt registreren. Gebruik de log_model() methode voor de gewenste variant van agent.

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

Start een evaluatietaak en koppel de metrieken aan een geregistreerd model door de unieke model_id en LoggedModel op te geven.

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

Diep leren

In het volgende codefragment ziet u hoe u vastgelegde modellen maakt tijdens deep learning-training. Gebruik de log_model() methode voor uw MLflow-model.

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

Traditionele ML

In het volgende codefragment ziet u hoe u een sklearn-model kunt registreren en metrische gegevens kunt koppelen aan het Logged Model. Gebruik de log_model() methode voor uw MLflow-model.

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

Voorbeeldnotitieblokken

Zie de volgende pagina's voor bijvoorbeeld notitieblokken die het gebruik van LoggedModelsillustreren:

Modellen weergeven en voortgang bijhouden

U kunt de aangemelde modellen bekijken in de gebruikersinterface van de werkruimte:

  1. Ga naar het tabblad Experimenten in uw werkruimte.
  2. Selecteer een experiment. Selecteer vervolgens het tabblad Modellen .

Deze pagina bevat alle geregistreerde modellen die aan het experiment zijn gekoppeld, samen met hun metrische gegevens, parameters en artefacten.

Gebruikersinterface voor modelopvolging.

U kunt grafieken genereren om metrische gegevens bij te houden tijdens runs.

Metrische grafieken van de gebruikersinterface voor het bijhouden van modellen.

Vastgelegde modellen zoeken en filteren

Op het tabblad Modellen kunt u vastgelegde modellen zoeken en filteren op basis van hun kenmerken, parameters, tags en metrische gegevens.

In de UI voor het volgen van modellen worden gelogde modellen gezocht.

U kunt metrische gegevens filteren op basis van gegevenssetspecifieke prestaties en alleen modellen met overeenkomende metrische waarden voor de opgegeven gegevenssets worden geretourneerd. Als er gegevenssetfilters worden geleverd zonder metrische filters, worden modellen met welke metrische gegevenssets dan ook geretourneerd.

U kunt filteren op basis van de volgende kenmerken:

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

Gebruik de volgende operators om tekenreeksachtige kenmerken, parameters en tags te zoeken en te filteren:

  • =,!=,IN,NOT IN

Gebruik de volgende vergelijkingsoperatoren om numerieke kenmerken en metrische gegevens te zoeken en te filteren:

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

Programmatisch zoeken in vastgelegde modellen

U kunt zoeken naar vastgelegde modellen met behulp van de MLflow-API:

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

Zie de MLflow 3 API-documentatie voor meer informatie en aanvullende zoekparameters.

Zoekopdrachten worden uitgevoerd op modelinvoer en -uitvoer

U kunt uitgevoerde uitvoeringen zoeken op model-id om alle uitvoeringen te retourneren die het vastgelegde model hebben als invoer of uitvoer. Voor meer informatie over de syntaxis van de filtertekenreeks, zie filteren voor runs.

Modeltracking UI search logged models by model ID.

U kunt zoeken naar uitvoeringen met behulp van de MLflow-API:

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

Volgende stappen

Zie de volgende artikelen voor meer informatie over andere nieuwe functies van MLflow 3:

  • Last updated on