Suivez et comparez les modèles à l'aide des modèles journalisés MLflow.

Les modèles enregistrés MLflow vous aident à suivre l'avancement d'un modèle tout au long de son cycle de vie. Lorsque vous entraînez un modèle, utilisez mlflow.<model-flavor>.log_model() pour créer un LoggedModel qui regroupe toutes ses informations critiques à l'aide d'un identifiant unique. Pour tirer parti de la puissance de LoggedModels, démarrez avec MLflow 3.

Pour les applications GenAI, LoggedModels peuvent être créés pour capturer les commits Git ou les ensembles de paramètres comme des objets dédiés qui peuvent ensuite être liés aux traces et aux métriques. En apprentissage profond et en ML classique, LoggedModels sont produits à partir des exécutions MLflow, qui sont des concepts existants dans MLflow et peuvent être considérés comme des Jobs qui exécutent le code de modèle. Les exécutions d'entraînement produisent des modèles en tant que sorties, et les exécutions d'évaluation utilisent des modèles existants en tant qu'entrées pour produire des métriques et d'autres informations que vous pouvez utiliser pour évaluer les performances d'un modèle.

L’objet LoggedModel persiste tout au long du cycle de vie du modèle, dans différents environnements, et contient des Link vers des artefacts tels que les métadonnées, les métriques, les paramètres et le code utilisé pour générer le modèle. Le suivi des modèles journalisés vous permet de comparer les modèles entre eux, de trouver le modèle le plus performant et de suivre les informations lors du debugging.

Les modèles journalisés peuvent également être enregistrés dans le registre de modèles Unity Catalog, rendant les informations sur le modèle de toutes les expérimentations et de tous les workspaces MLflow disponibles en un seul endroit. Pour plus de détails, consultez les améliorations du Model Registry avec MLflow 3.

Suivi amélioré pour l'IA générative et les modèles de deep learning

Les workflows d'IA générative et de deep learning bénéficient particulièrement du suivi granulaire fourni par Logged Models.

Gen AI – évaluation unifiée et données de trace :

• Les modèles Gen AI génèrent des métriques supplémentaires lors de l'évaluation et du déploiement, telles que les données de feedback des réviseurs et les traces.
• L'entité LoggedModel vous permet de query toutes les informations générées par un modèle à l'aide d'une seule interface.

Deep learning : gestion efficace des points de contrôle

• L'entraînement en deep learning crée plusieurs points de contrôle, qui sont des instantanés de l'état du modèle à un moment précis de l'entraînement.
• MLflow crée un LoggedModel distinct pour chaque point de contrôle, contenant les métriques et les données de performance du modèle. Cela vous permet de comparer et d'évaluer les points de contrôle pour identifier les modèles les plus performants efficacement.

Créer un modèle enregistré

Pour créer un modèle enregistré, utilisez la même API log_model() que les workloads MLflow existants. Les extraits de code suivants montrent comment créer un modèle enregistré pour les workflows d'IA générative, d'apprentissage profond et de ML traditionnel.

Pour des exemples de Notebook complets et exécutables, consultez Exemples de Notebooks.

Gen AI

L'extrait de code suivant montre comment consigner un agent LangChain. Utilisez la méthode log_model() pour votre type d'agent.

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,
  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 an evaluation Job and Link the metrics to a Log Model by providing the unique model_id for the 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

L'extrait de code suivant montre comment créer des modèles enregistrés pendant l'entraînement de deep learning. Utilisez la méthode log_model() pour votre variante de modèle 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()

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

Traditional ML

L'extrait de code suivant montre comment enregistrer un modèle sklearn et lier les métriques au Logged Model. Utilisez la méthode log_model() pour votre variante de modèle 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
)

Exemples de Notebooks

Pour les exemples de Notebooks qui illustrent l'utilisation de LoggedModels, consultez les pages suivantes :

• MLflow 3 : Flux de travail de deep learning
• MLflow 3 : workflow ML traditionnel

Afficher les modèles et suivre les progrès

Vous pouvez afficher vos Modèles enregistrés dans l'interface utilisateur du Workspace :

1. Accédez à l'onglet **Expérimentations** dans votre Workspace.
2. Sélectionnez une expérimentation. Sélectionnez ensuite l'onglet **tab**.

Cette page contient tous les Modèles enregistrés associés à l'expérimentation, ainsi que leurs métriques, paramètres et artefacts.

Vous pouvez générer des graphiques pour suivre les métriques sur les différentes exécutions.

Rechercher et filtrer les modèles Logs

Depuis l'onglet Models , vous pouvez rechercher et filtrer les Modèles Log en fonction de leurs attributs, parameters, tags et métriques.

Vous pouvez filtrer les métriques en fonction des performances spécifiques au dataset, et seuls les modèles avec des valeurs métriques correspondantes sur les datasets donnés sont renvoyés. Si des filtres de dataset sont fournis sans aucun filtre de métrique, les modèles avec n'importe quelle métrique sur ces datasets sont renvoyés.

Vous pouvez filtrer en fonction des attributs suivants :

• model_id
• model_name
• status
• artifact_uri
• creation_time (numérique)
• last_updated_time (numérique)

Utilisez les opérateurs suivants pour rechercher et filtrer les attributs, les paramètres et les balises de type chaîne :

• =, !=, IN, NOT IN

Utilisez les opérateurs de comparaison suivants pour rechercher et filtrer les attributs et métriques numériques :

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

Rechercher les modèles enregistrés par programmation

Vous pouvez rechercher des modèles enregistrés à l'aide de l'API MLflow :

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

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

Pour plus d'informations et des paramètres de recherche supplémentaires, consultez la documentation de l'API MLflow 3.

Rechercher les exécutions par entrées et sorties de modèle

Vous pouvez rechercher les exécutions par ID de modèle pour renvoyer toutes les exécutions qui ont le modèle enregistré comme entrée ou sortie. Pour plus d'informations sur la syntaxe des chaînes de filtre, consultez le filtrage des exécutions.

Vous pouvez rechercher des exécutions à l'aide de l'API MLflow :

Python

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

Ressources supplémentaires

Pour en savoir plus sur les autres nouvelles fonctionnalités de MLflow 3, consultez les articles suivants :

• Améliorations de Model Registry avec MLflow 3.
• Jobs de déploiement MLflow 3.