Affichez les résultats de l'entraînement avec les exécutions MLflow

Cet article décrit comment utiliser les exécutions MLflow pour afficher et analyser les résultats d'une expérimentation d'entraînement de modèle, et comment gérer et organiser les exécutions. Pour plus d'informations sur les expérimentations MLflow, consultez Organiser les exécutions d'entraînement avec les expérimentations MLflow.

Une exécution MLflow correspond à une seule exécution de code de modèle. Chaque exécution enregistre des informations telles que le notebook qui a lancé l'exécution, les modèles créés par l'exécution, les paramètres de modèle et les métriques enregistrés comme paires clé-valeur, les balises pour les métadonnées d'exécution et les artefacts ou fichiers de sortie créés par l'exécution.

Toutes les exécutions MLflow sont enregistrées dans l'expérimentation active. Si vous n'avez pas explicitement défini une expérimentation comme étant l'expérimentation active, les exécutions sont enregistrées dans l'expérimentation du Notebook.

Afficher les détails de l'exécution

Vous pouvez accéder à une exécution soit depuis sa page de détails d'expérimentation, soit directement depuis le Notebook qui a créé l'exécution.

À partir de la page des détails de l'Experimentation, cliquez sur le nom de l'exécution dans le tableau des exécutions.

Depuis le notebook, cliquez sur le nom de l'exécution dans la barre latérale des exécutions d'Experimentation.

L'écran d'exécution affiche l'ID de l'exécution, les paramètres utilisés pour l'exécution, les métriques résultant de l'exécution, et les détails de l'exécution, y compris un link vers le Notebook source. Les artefacts enregistrés à partir de l’exécution sont disponibles dans l’onglet tab .

Extraits de code pour la prédiction

Si vous loggez un modèle à partir d'une exécution, le modèle apparaît dans la tab , avec des extraits de code illustrant comment charger et utiliser le modèle pour faire des prédictions sur les DataFrames Spark et Pandas. Dans MLflow 3, les modèles sont désormais des objets de première classe distincts plutôt que d'être enregistrés comme artefacts d'exécution. Pour plus d’informations, consultez Get start with MLflow 3 pour les modèles.

Afficher le notebook utilisé pour une exécution

Pour afficher la version du Notebook qui a créé une exécution :

• Sur la page des détails de l'Expérimentation, cliquez sur le Link dans la colonne **Source**.
• Sur la page d'exécution, cliquez sur le Link à côté de Source .
• Depuis le Notebook, dans la barre latérale Exécutions d'Experimentation, cliquez sur l'icône Notebook dans la boîte correspondant à cette exécution d'Experimentation.

La version du notebook associée à l'exécution apparaît dans la fenêtre principale avec une barre de surbrillance indiquant la date et l'heure de l'exécution.

Ajouter une balise à une exécution

Les tags sont des paires clé-valeur que vous pouvez créer et utiliser plus tard pour rechercher des exécutions.

1. Dans le tableau Détails de la page d'exécution, cliquez sur Ajouter des balises à côté de Balises .

   

2. La boîte de dialogue Ajouter/Modifier des tags s'ouvre. Dans le champ **Clé**, saisissez un nom pour la clé, et cliquez sur **Ajouter un tag**.

   

3. Dans le champ Valeur , saisissez la valeur du tag.

4. Cliquez sur le signe plus pour enregistrer la paire clé-valeur que vous venez de saisir.

   

5. Pour ajouter des tags supplémentaires, répétez les étapes 2 à 4.

6. Lorsque vous avez terminé, cliquez sur **Enregistrer les tags**.

Modifier ou supprimer un tag pour une exécution

1. Dans le tableau Détails de la page d'exécution, cliquez sur à côté des balises existantes.

   

2. La boîte de dialogue Ajouter/Modifier des tags s'ouvre.

   1. Pour supprimer un tag, cliquez sur le X de ce tag.

      

   2. Pour modifier une balise, sélectionnez la clé dans le menu déroulant et modifiez la valeur dans le champ Valeur . Cliquez sur le signe plus pour enregistrer votre modification.

      

3. Lorsque vous avez terminé, cliquez sur **Enregistrer les tags**.

Renommer l'exécution

Pour renommer une exécution, cliquez sur le menu kebab dans le coin supérieur droit de la page d’exécution (à côté du bouton **Autorisations**) et sélectionnez **Renommer**.

Sélectionner les colonnes à afficher

Pour contrôler les colonnes affichées dans le tableau des exécutions de la page des détails de l'expérimentation, cliquez sur Colonnes et sélectionnez dans le menu déroulant.

Filtrer les exécutions

Vous pouvez rechercher des exécutions dans le tableau de la page des détails d’Experimentation en fonction des valeurs des paramètres ou des métriques. Vous pouvez également rechercher des exécutions par tag.

• Pour rechercher des exécutions qui correspondent à une expression contenant des valeurs de parameter et de métrique, saisissez une query dans le champ de recherche et appuyez sur Entrée. Voici quelques exemples de syntaxe de query :

  metrics.r2 > 0.3

  params.elasticNetParam = 0.5

  params.elasticNetParam = 0.5 AND metrics.avg_areaUnderROC > 0.3

  MIN(metrics.rmse) <= 1

  MAX(metrics.memUsage) > 0.9

  LATEST(metrics.memUsage) = 0 AND MIN(metrics.rmse) <= 1

  Par default, les valeurs de métrique sont filtrées en fonction de la dernière valeur enregistrée. L'utilisation de MIN ou MAX vous permet de rechercher des exécutions en fonction, respectivement, des valeurs métriques minimales ou maximales. Seules les exécutions enregistrées après août 2024 ont des valeurs de métrique minimales et maximales.

• Pour rechercher des exécutions par tag, saisissez les tags au format : tags.<key>="<value>". Les valeurs de chaîne doivent être entre guillemets comme indiqué.

  tags.estimator_name="RandomForestRegressor"

  tags.color="blue" AND tags.size=5

  Les clés et les valeurs peuvent contenir des espaces. Si la clé contient des espaces, vous devez l'encadrer de guillemets inversés comme indiqué.

  tags.`my custom tag` = "my value"

Vous pouvez également filtrer les exécutions en fonction de leur état (Actif ou Supprimé), de la date de création de l'exécution et des datasets utilisés. Pour ce faire, effectuez vos sélections dans les menus déroulants **Heure de création**, **État** ou **Datasets** respectivement.

download runs

Vous pouvez download les exécutions depuis la page de détails de l'expérience comme suit :

1. Cliquez sur pour ouvrir le menu kebab.

   

2. Pour télécharger un fichier au format CSV contenant toutes les exécutions affichées (jusqu'à un maximum de 100), sélectionnez download <n> exécutions . MLflow crée et download un fichier avec une exécution par ligne, contenant les champs suivants pour chaque exécution :

   Start Time, Duration, Run ID, Name, Source Type, Source Name, User, Status, <parameter1>, <parameter2>, ..., <metric1>, <metric2>, ...

3. Si vous souhaitez download plus de 100 exécutions ou si vous souhaitez download des exécutions par programmation, sélectionnez **Download toutes les exécutions**. Une boîte de dialogue s'ouvre et affiche un extrait de code que vous pouvez copier ou ouvrir dans un notebook. Après avoir exécuté ce code dans une cellule de notebook, sélectionnez **download toutes les lignes** dans le résultat de la cellule.

Supprimer les exécutions

Vous pouvez supprimer des exécutions depuis la page des détails de l'expérimentation en suivant les étapes suivantes :

1. Dans l'expérimentation, sélectionnez une ou plusieurs exécutions en cliquant sur la case à cocher à gauche de l'exécution.
2. Cliquez sur **Supprimer**.
3. Si l'exécution est une exécution parente, décidez si vous souhaitez également supprimer les exécutions descendantes. Cette option est sélectionnée par default.
4. Cliquez sur Supprimer pour confirmer. Les exécutions supprimées sont conservées pendant 30 jours. Pour afficher les exécutions supprimées, sélectionnez **Supprimé** dans le champ État.

Suppression en bloc des exécutions basée sur l'heure de création

Vous pouvez utiliser Python pour supprimer en bloc les exécutions d'une Experimentation qui ont été créées avant ou à partir d'un Timestamp UNIX. Avec Databricks Runtime 14.1 ou version ultérieure, vous pouvez appeler l'API mlflow.delete_runs pour supprimer les exécutions et renvoyer le nombre d'exécutions supprimées.

Voici les mlflow.delete_runs paramètres :

• experiment_id: L'ID de l'experimentation contenant les exécutions à supprimer.
• max_timestamp_millis: Le Timestamp de création maximal en millisecondes depuis l'époque UNIX pour la suppression des exécutions. Seules les exécutions créées avant ou à cet Timestamp sont supprimées.
• max_runsFacultatif. Un entier positif qui indique le nombre maximal d'exécutions à supprimer. La valeur maximale autorisée pour max_runs est de 10 000. Si non spécifié, max_runs est par default à 10000.

Python

import mlflow

# Replace <experiment_id>, <max_timestamp_ms>, and <max_runs> with your values.
runs_deleted = mlflow.delete_runs(
  experiment_id=<experiment_id>,
  max_timestamp_millis=<max_timestamp_ms>,
  max_runs=<max_runs>
)
# Example:
runs_deleted = mlflow.delete_runs(
  experiment_id="4183847697906956",
  max_timestamp_millis=1711990504000,
  max_runs=10
)

À l’aide de Databricks Runtime 13.3 LTS ou d’une version antérieure, vous pouvez exécuter le code client suivant dans un Notebook Databricks.

Python

from typing import Optional

def delete_runs(experiment_id: str,
                max_timestamp_millis: int,
                max_runs: Optional[int] = None) -> int:
    """
    Bulk delete runs in an experiment that were created prior to or at the specified timestamp.
    Deletes at most max_runs per request.

    :param experiment_id: The ID of the experiment containing the runs to delete.
    :param max_timestamp_millis: The maximum creation timestamp in milliseconds
                                 since the UNIX epoch for deleting runs. Only runs
                                 created prior to or at this timestamp are deleted.
    :param max_runs: Optional. A positive integer indicating the maximum number
                     of runs to delete. The maximum allowed value for max_runs
                     is 10000. If not specified, max_runs defaults to 10000.
    :return: The number of runs deleted.
    """
    from mlflow.utils.databricks_utils import get_databricks_host_creds
    from mlflow.utils.request_utils import augmented_raise_for_status
    from mlflow.utils.rest_utils import http_request

    json_body = {"experiment_id": experiment_id, "max_timestamp_millis": max_timestamp_millis}
    if max_runs is not None:
        json_body["max_runs"] = max_runs
    response = http_request(
        host_creds=get_databricks_host_creds(),
        endpoint="/api/2.0/mlflow/databricks/runs/delete-runs",
        method="POST",
        json=json_body,
    )
    augmented_raise_for_status(response)
    return response.json()["runs_deleted"]

Consultez la documentation de l'API Databricks Experiments pour les spécifications des paramètres et des valeurs de retour concernant la suppression des exécutions basées sur l'heure de création.

Restaurer les exécutions

Vous pouvez restaurer les exécutions précédemment supprimées de l'interface utilisateur comme suit :

1. Sur la page Expérimentation , dans le champ État , sélectionnez Supprimé pour afficher les exécutions supprimées.
2. Sélectionnez une ou plusieurs exécutions en cliquant sur la case à cocher à gauche de l'exécution.
3. Cliquez sur Restaurer .
4. Cliquez sur Restaurer pour confirmer. Les exécutions restaurées apparaissent désormais lorsque vous sélectionnez **Active** dans le champ État.

Exécutions de restauration en bloc basées sur l'heure de suppression

Vous pouvez également utiliser Python pour restaurer en masse les exécutions d'une Expérimentation qui ont été supprimées à ou après un Timestamp UNIX. Avec Databricks Runtime 14.1 ou une version ultérieure, vous pouvez appeler l'API mlflow.restore_runs pour restaurer les exécutions et renvoyer le nombre d'exécutions restaurées.

Voici les mlflow.restore_runs paramètres :

• experiment_id: l'ID de l'expérimentation contenant les exécutions à restaurer.
• min_timestamp_millis: Le Timestamp de suppression minimum en millisecondes depuis l'époque UNIX pour la restauration des exécutions. Seules les exécutions supprimées à partir ou après ce Timestamp sont restaurées.
• max_runsFacultatif. Un entier positif qui indique le nombre maximal d'exécutions à restaurer. La valeur maximale autorisée pour max_runs est de 10 000. Si non spécifié, max_runs est défini sur default sur 10 000.

Python

import mlflow

# Replace <experiment_id>, <min_timestamp_ms>, and <max_runs> with your values.
runs_restored = mlflow.restore_runs(
  experiment_id=<experiment_id>,
  min_timestamp_millis=<min_timestamp_ms>,
  max_runs=<max_runs>
)
# Example:
runs_restored = mlflow.restore_runs(
  experiment_id="4183847697906956",
  min_timestamp_millis=1711990504000,
  max_runs=10
)

À l’aide de Databricks Runtime 13.3 LTS ou d’une version antérieure, vous pouvez exécuter le code client suivant dans un Notebook Databricks.

Python

from typing import Optional

def restore_runs(experiment_id: str,
                 min_timestamp_millis: int,
                 max_runs: Optional[int] = None) -> int:
    """
    Bulk restore runs in an experiment that were deleted at or after the specified timestamp.
    Restores at most max_runs per request.

    :param experiment_id: The ID of the experiment containing the runs to restore.
    :param min_timestamp_millis: The minimum deletion timestamp in milliseconds
                                 since the UNIX epoch for restoring runs. Only runs
                                 deleted at or after this timestamp are restored.
    :param max_runs: Optional. A positive integer indicating the maximum number
                     of runs to restore. The maximum allowed value for max_runs
                     is 10000. If not specified, max_runs defaults to 10000.
    :return: The number of runs restored.
    """
    from mlflow.utils.databricks_utils import get_databricks_host_creds
    from mlflow.utils.request_utils import augmented_raise_for_status
    from mlflow.utils.rest_utils import http_request
    json_body = {"experiment_id": experiment_id, "min_timestamp_millis": min_timestamp_millis}
    if max_runs is not None:
        json_body["max_runs"] = max_runs
    response = http_request(
        host_creds=get_databricks_host_creds(),
        endpoint="/api/2.0/mlflow/databricks/runs/restore-runs",
        method="POST",
        json=json_body,
    )
    augmented_raise_for_status(response)
    return response.json()["runs_restored"]

Consultez la documentation de l'API Databricks Experiments pour les paramètres et les spécifications des valeurs de retour pour restaurer les exécutions en fonction de l'heure de suppression.

Comparer les exécutions

Vous pouvez comparer les exécutions d'une seule Experimentation ou de plusieurs Experimentations. La page Comparaison des exécutions présente des informations sur les exécutions sélectionnées sous forme de tableau. Vous pouvez également créer des visualisations des résultats d'exécution et des tables d'informations d'exécution, de paramètres d'exécution et de métriques. Consultez Comparer les exécutions et les modèles MLflow à l'aide de graphes et de graphiques.

Les tables Parameters et Metrics affichent les paramètres et les métriques d'exécution de toutes les exécutions sélectionnées. Les colonnes de ces tables sont identifiées par la table Run details immédiatement au-dessus. Pour simplifier, vous pouvez masquer les paramètres et les métriques identiques dans toutes les exécutions sélectionnées en activant/désactivant .

Comparer les exécutions d'une seule expérience

1. Sur la page des détails de l'expérimentation, sélectionnez deux runs ou plus en cliquant sur la case à cocher à gauche du run, ou sélectionnez tous les runs en cochant la case en haut de la colonne.
2. Cliquez sur Comparer . L'écran « Comparaison de <N> exécutions » s'affiche.

Comparez les exécutions de plusieurs expérimentations.

1. Sur la page des expériences, sélectionnez les expériences que vous souhaitez comparer en cliquant dans la case à gauche du nom de l'expérience.
2. Cliquez sur Compare (n) ( n correspond au nombre d’expérimentations que vous avez sélectionnées). Un écran apparaît, affichant toutes les exécutions des expérimentations que vous avez sélectionnées.
3. Sélectionnez deux exécutions ou plus en cliquant dans la case à cocher à gauche de l'exécution, ou sélectionnez toutes les exécutions en cochant la case en haut de la colonne.
4. Cliquez sur Comparer . L'écran « Comparaison de <N> exécutions » s'affiche.

Comparer les exécutions à l'aide des tables système

Les métadonnées MLflow pour les expérimentations et les exécutions sont également disponibles dans les tables système, où vous pouvez tirer parti de Databricks SQL et de tous les outils lakehouse que Databricks offre pour analyser vos données d'expérimentation. Pour plus de détails, consultez la référence des tables système MLflow.

Copier les exécutions entre les Workspace

Pour importer ou exporter des exécutions MLflow vers ou depuis votre Workspace Databricks, vous pouvez utiliser le projet open source piloté par la communauté MLflow Export-Import.