Suivre et comparer des modèles à l’aide de modèles journalisés MLflow

Les modèles journalisés MLflow vous aident à suivre la progression 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 une LoggedModel qui relie toutes ses informations critiques à l’aide d’un ID unique. Pour tirer parti de la puissance de LoggedModels, commencez à utiliser MLflow 3.

Pour les applications GenAI, LoggedModels peut être créé pour capturer des commits Git ou des ensembles de paramètres en tant qu'objets dédiés qui peuvent ensuite être liés à des traces et des métriques. Dans le deep learning et le ML classique, LoggedModels sont produits à partir d’exécutions MLflow, qui sont des concepts existants dans MLflow et peuvent être considérés comme des travaux qui exécutent du 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 comme entrée 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 liens 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 enregistrés vous permet de comparer les modèles entre eux, de trouver le modèle le plus performant et de suivre les informations pendant le débogage.

Les modèles enregistrés peuvent également être inscrits dans le registre du modèle catalogue Unity, ce qui permet d’obtenir des informations sur le modèle à partir de toutes les expériences et espaces de travail MLflow disponibles dans un emplacement unique. Pour plus d’informations, consultez Les améliorations apportées au Registre de modèles avec MLflow 3.

Flux de suivi de modèle pour l’IA générative, le ML traditionnel et l’apprentissage profond.

Suivi amélioré des modèles d'IA générative et de Deep Learning

Les flux de travail d’IA et d’apprentissage profond génératifs tirent parti du suivi granulaire fourni par les modèles journalisés.

Gen AI - Données d’évaluation et de trace unifiées :

Les modèles Gen AI génèrent des métriques supplémentaires pendant l’évaluation et le déploiement, telles que les données et les traces de commentaires des réviseurs.
L’entité LoggedModel vous permet d’interroger 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’apprentissage profond crée plusieurs points de contrôle, qui sont des captures instantanées de l’état du modèle à un point particulier pendant l’entraînement.
MLflow crée un point de contrôle distinct LoggedModel pour chaque point de contrôle, contenant les métriques et les données de performances du modèle. Cela vous permet de comparer et d’évaluer les points de contrôle pour identifier efficacement les modèles les plus performants.

Créer un modèle enregistré

Pour créer un modèle journalisé, utilisez la même log_model() API que les charges de travail MLflow existantes. Les extraits de code suivants montrent comment créer un modèle journalisé pour l’IA gen, l’apprentissage profond et les flux de travail ML traditionnels.

Pour obtenir des exemples complets de notebooks exécutables, consultez Exemples de notebooks.

Génération d’IA

L’extrait de code suivant montre comment journaliser un agent LangChain. Utilisez la méthode log_model() pour votre version d'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)

Démarrez un travail d’évaluation et liez les métriques à un modèle journalisé en fournissant l’identifiant unique model_id pour le 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
  )

Apprentissage approfondi

L’extrait de code suivant montre comment créer des modèles journalisés pendant l’apprentissage profond. Utilisez la méthode log_model() pour votre version de modèle 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 traditionnel

L’extrait de code suivant montre comment consigner un modèle sklearn et lier des métriques à l’objet Logged Model. Utilisez la méthode log_model() pour votre version de modèle 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
)

Exemples de notebooks

Pour obtenir des exemples de notebooks qui illustrent l’utilisation de LoggedModels, consultez les pages suivantes :

Afficher les modèles et suivre la progression

Vous pouvez afficher vos modèles enregistrés dans l’interface utilisateur de l’espace de travail :

Accédez à l’onglet Expériences de votre espace de travail.
Sélectionnez une expérience. Sélectionnez ensuite l’onglet Modèles .

Cette page contient tous les modèles journalisés associés à l’expérience, ainsi que leurs métriques, paramètres et artefacts.

Interface utilisateur de suivi des modèles.

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

Graphiques de métriques d’interface utilisateur de suivi des modèles.

Rechercher et filtrer des modèles journalisés

Sous l’onglet Modèles , vous pouvez rechercher et filtrer les modèles journalisés en fonction de leurs attributs, paramètres, balises et métriques.

Vous pouvez filtrer les métriques en fonction des performances spécifiques au jeu de données, et seuls les modèles avec des valeurs de métrique correspondantes sur les jeux de données donnés sont retournés. Si les filtres de jeu de données sont fournis sans filtres métriques, les modèles avec toutes les métriques sur ces jeux de données sont retourné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 des attributs, des paramètres et des balises de type chaîne :

=, , !=IN, ,NOT IN

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

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

Rechercher des modèles journalisés par programmation

Vous pouvez rechercher des modèles journalisés à l’aide de l’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>}
  ]
)

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

Exécutions de recherche par entrées et sorties de modèle

Vous pouvez rechercher des exécutions par ID de modèle pour retourner toutes les exécutions dont le modèle journalisé est une entrée ou une sortie. Pour plus d’informations sur la syntaxe de chaîne de caractères de filtrage, consultez filtrage des exécutions.

Vous pouvez rechercher des exécutions à l’aide de l’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>")

Étapes suivantes

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-08-13