Partager via

Utiliser des métriques personnalisées avec Databricks Lakehouse Monitoring

  • Article

Cette page explique comment créer une métrique personnalisée dans Databricks Lakehouse Monitoring. En plus des statistiques d’analyse et de dérive qui sont calculées automatiquement, vous pouvez créer des métriques personnalisées. Par exemple, vous pouvez effectuer le suivi d’une moyenne pondérée qui capture certains aspects de la logique métier ou utiliser un score de qualité de modèle personnalisé. Vous pouvez également créer des métriques de dérive personnalisées qui suivent les modifications des valeurs de la table primaire (par rapport à la ligne de référence ou à la fenêtre de temps précédente).

Pour plus d’informations sur l’utilisation de l’API MonitorMetric, consultez les Informations de référence sur l’API.

Types de métriques personnalisées

Databricks Lakehouse Monitoring inclut les types de métriques personnalisées suivants :

  • Les métriques d’agrégation, qui sont calculées en fonction des colonnes de la table primaire. Les métriques agrégées sont stockées dans la table des métriques de profil.
  • Les métriques dérivées, qui sont calculées à partir de métriques agrégées précédemment calculées et qui n’utilisent pas directement les données de la table primaire. Les métriques dérivées sont stockées dans la table des métriques de profil.
  • Les métriques de dérive, qui comparent les métriques d’agrégation ou dérivées précédemment calculées à partir de deux fenêtres de temps différentes, ou entre la table primaire et la table de référence. Les métriques de dérive sont stockées dans la table des métriques de dérive.

L’utilisation de métriques dérivées et de dérive dans la mesure du possible réduit les nouveaux calculs sur la table primaire complète. Seules les métriques agrégées accèdent aux données de la table primaire. Les métriques dérivées et de dérive peuvent ensuite être calculées directement à partir des valeurs des métriques agrégées.

Paramètres des métriques personnalisés

Pour définir une métrique personnalisée, vous créez un modèle Jinja pour une expression de colonne SQL. Les tables de cette section décrivent les paramètres qui définissent la métrique et les paramètres utilisés dans le modèle Jinja.

Paramètre Description
type Valeurs possibles : MonitorMetricType.CUSTOM_METRIC_TYPE_AGGREGATE, MonitorMetricType.CUSTOM_METRIC_TYPE_DERIVED ou MonitorMetricType.CUSTOM_METRIC_TYPE_DRIFT.
name Nom de colonne de la métrique personnalisée dans les tables de métriques.
input_columns Liste des noms de colonnes dans la table d’entrée pour lesquels la métrique doit être calculée. Pour indiquer que plusieurs colonnes sont utilisées dans le calcul, utilisez :table. Consultez les exemples de cet article.
definition Modèle Jinja pour une expression SQL qui spécifie comment calculer la métrique. Consultez Créer une définition.
output_data_type Type de données Spark de la sortie de métrique dans un format de chaîne JSON.

Créer definition

Le paramètre definition doit être une expression de chaîne unique sous la forme d’un modèle Jinja. Il ne peut pas contenir de jointures ou de sous-requêtes.

Le tableau suivant énumère les paramètres que vous pouvez utiliser pour créer un modèle Jinja SQL afin de spécifier comment calculer la métrique.

Paramètre Description
{{input_column}} Colonne utilisée pour calculer la métrique personnalisée.
{{prediction_col}} Colonne contenant les prédictions du modèle ML. Utilisé avec l’analyse InferenceLog.
{{label_col}} Colonne contenant les étiquettes de vérité au sol du modèle ML. Utilisé avec l’analyse InferenceLog.
{{current_df}} Pour la dérive par rapport à la fenêtre de temps précédente. Données de la fenêtre de temps précédente.
{{base_df}} Pour la dérive par rapport à la table de référence. Données de référence.

Exemple de métrique d’agrégation

L’exemple suivant calcule la moyenne du carré des valeurs d’une colonne et est appliqué aux colonnes f1 et f2. La sortie est enregistrée en tant que nouvelle colonne dans la table des métriques de profil et s’affiche dans les lignes d’analyse correspondant aux colonnes f1 et f2. Les noms de colonnes applicables sont remplacés par le paramètre Jinja {{input_column}}.

from databricks.sdk.service.catalog import MonitorMetric, MonitorMetricType
from pyspark.sql import types as T

MonitorMetric(
    type=MonitorMetricType.CUSTOM_METRIC_TYPE_AGGREGATE,
    name="squared_avg",
    input_columns=["f1", "f2"],
    definition="avg(`{{input_column}}`*`{{input_column}}`)",
    output_data_type=T.StructField("output", T.DoubleType()).json(),
)

Le code suivant définit une métrique personnalisée qui calcule la moyenne de la différence entre les colonnes f1 et f2. Cet exemple montre l’utilisation de [":table"] dans le paramètre input_columns pour indiquer que plusieurs colonnes de la table sont utilisées dans le calcul.

from databricks.sdk.service.catalog import MonitorMetric, MonitorMetricType
from pyspark.sql import types as T

MonitorMetric(
    type=MonitorMetricType.CUSTOM_METRIC_TYPE_AGGREGATE,
    name="avg_diff_f1_f2",
    input_columns=[":table"],
    definition="avg(f1 - f2)",
    output_data_type=T.StructField("output", T.DoubleType()).json(),
)

Cet exemple calcule un score de qualité de modèle pondéré. Pour les observations où la colonne critical est True, une pénalité plus lourde est affectée lorsque la valeur prédite pour cette ligne ne correspond pas à la vérité de base. Étant donné qu’elle est définie sur les colonnes brutes (prediction et label), elle est définie en tant que métrique d’agrégation. La colonne :table indique que cette métrique est calculée à partir de plusieurs colonnes. Les paramètres Jinja {{prediction_col}} et {{label_col}} sont remplacés par le nom des colonnes de prédiction et d’étiquette de vérité au sol pour le moniteur.

from databricks.sdk.service.catalog import MonitorMetric, MonitorMetricType
from pyspark.sql import types as T

MonitorMetric(
    type=MonitorMetricType.CUSTOM_METRIC_TYPE_AGGREGATE,
    name="weighted_error",
    input_columns=[":table"],
    definition="""avg(CASE
      WHEN {{prediction_col}} = {{label_col}} THEN 0
      WHEN {{prediction_col}} != {{label_col}} AND critical=TRUE THEN 2
      ELSE 1 END)""",
    output_data_type=T.StructField("output", T.DoubleType()).json(),
)

Exemple de métrique dérivée

Le code suivant définit une métrique personnalisée qui calcule la racine carrée de la métrique squared_avg définie plus haut dans cette section. Étant donné qu’il s’agit d’une métrique dérivée, elle ne fait pas référence aux données de la table primaire et est définie en termes de métrique d’agrégation squared_avg. La sortie est enregistrée en tant que nouvelle colonne dans la table des métriques de profil.

from databricks.sdk.service.catalog import MonitorMetric, MonitorMetricType
from pyspark.sql import types as T

MonitorMetric(
    type=MonitorMetricType.CUSTOM_METRIC_TYPE_DERIVED,
    name="root_mean_square",
    input_columns=["f1", "f2"],
    definition="sqrt(squared_avg)",
    output_data_type=T.StructField("output", T.DoubleType()).json(),
)

Exemple de métriques de dérive

Le code suivant définit une métrique de dérive qui suit la modification de la métrique weighted_error définie plus haut dans cette section. Les paramètres {{current_df}} et {{base_df}} permettent à la métrique de référencer les valeurs weighted_error de la fenêtre active et de la fenêtre de comparaison. La fenêtre de comparaison peut être les données de base ou les données de la fenêtre de temps précédente. Les métriques de dérive sont enregistrées dans la table des métriques de dérive.

from databricks.sdk.service.catalog import MonitorMetric, MonitorMetricType
from pyspark.sql import types as T

MonitorMetric(
    type=MonitorMetricType.CUSTOM_METRIC_TYPE_DRIFT,
    name="error_rate_delta",
    input_columns=[":table"],
    definition="{{current_df}}.weighted_error - {{base_df}}.weighted_error",
    output_data_type=T.StructField("output", T.DoubleType()).json(),
)