Udostępnij za pośrednictwem

Tworzenie monitora przy użyciu interfejsu API

  • Artykuł

Na tej stronie opisano sposób tworzenia monitora w usłudze Databricks przy użyciu zestawu SDK usługi Databricks i opisano wszystkie parametry używane w wywołaniach interfejsu API. Możesz również tworzyć monitory i zarządzać nimi przy użyciu interfejsu API REST. Aby uzyskać informacje referencyjne, zobacz dokumentację zestawu SDK monitorowania usługi Lakehouse i dokumentację interfejsu API REST.

Możesz utworzyć monitor na dowolnej zarządzanej lub zewnętrznej tabeli Delta zarejestrowanej w Unity Catalog. W metasklepie katalogu Unity można utworzyć tylko jeden monitor dla każdej tabeli.

Wymagania

Interfejs API monitorowania usługi Lakehouse jest wbudowany w databricks-sdk 0.28.0 i nowsze. Aby użyć najnowszej wersji interfejsu API, użyj następującego polecenia na początku notesu, aby zainstalować klienta języka Python:

%pip install "databricks-sdk>=0.28.0"

Aby uwierzytelnić się w celu korzystania z zestawu SDK usługi Databricks w danym środowisku, zobacz Uwierzytelnianie.

Typy profilów

Podczas tworzenia monitora wybierasz jeden z następujących typów profilów: TimeSeries, InferenceLog lub Snapshot. W tej sekcji krótko opisano każdą opcję. Aby uzyskać szczegółowe informacje, zobacz dokumentację interfejsu API lub dokumentację interfejsu API REST.

Uwaga

  • Podczas pierwszego tworzenia szeregu czasowego lub profilu wnioskowania monitor analizuje tylko dane z 30 dni przed jego utworzeniem. Po utworzeniu monitora wszystkie nowe dane są przetwarzane.
  • Monitory zdefiniowane na widokach zmaterializowanych i tabelach przesyłania strumieniowego nie obsługują przetwarzania przyrostowego.

Napiwek

W przypadku profilów TimeSeries i Inference najlepszym rozwiązaniem jest włączenie strumienia danych zmiany (CDF) w tabeli. Po włączeniu usługi CDF przetwarzane są tylko nowo dołączone dane, a nie ponowne przetwarzanie całej tabeli przy każdym odświeżeniu. Dzięki temu wykonywanie operacji jest bardziej wydajne i redukuje koszty w miarę jak skalujesz monitorowanie w wielu tabelach.

TimeSeries profil

Profil TimeSeries porównuje dystrybucje danych w oknach czasowych. TimeSeries W przypadku profilu należy podać następujące informacje:

  • Kolumna znacznika czasu (timestamp_col). Typ danych kolumny sygnatury czasowej musi być TIMESTAMP lub typ, który można przekonwertować na znaczniki czasu przy użyciu funkcji to_timestampPySpark.
  • Zestaw granularities, na którym mają być obliczane metryki. Dostępne szczegółowości to "5 minut", "30 minut", "1 godzina", "1 dzień", "1 tydzień", "2 tygodnie", "3 tygodnie", "4 tygodnie", "1 miesiąc", "1 rok".
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import MonitorTimeSeries

w = WorkspaceClient()
w.quality_monitors.create(
  table_name=f"{catalog}.{schema}.{table_name}",
  assets_dir=f"/Workspace/Users/{user_email}/databricks_lakehouse_monitoring/{catalog}.{schema}.{table_name}",
  output_schema_name=f"{catalog}.{schema}",
  time_series=MonitorTimeSeries(timestamp_col=ts, granularities=["30 minutes"])
)

InferenceLog profil

Profil InferenceLog jest podobny do TimeSeries profilu, ale zawiera również metryki jakości modelu. W przypadku profilu InferenceLog wymagane są następujące parametry:

Parametr Opis
problem_type MonitorInferenceLogProblemType.PROBLEM_TYPE_CLASSIFICATION lub MonitorInferenceLogProblemType.PROBLEM_TYPE_REGRESSION
prediction_col Kolumna zawierająca przewidywane wartości modelu.
timestamp_col Kolumna zawierająca znacznik czasu zapytania w zakresie wnioskowania.
model_id_col Kolumna zawierająca identyfikator modelu używanego do przewidywania.
granularities Określa sposób partycjonowania danych w ramach okien czasowych. Możliwe wartości: "5 minut", "30 minut", "1 godzina", "1 dzień", "1 tydzień", "2 tygodnie", "3 tygodnie", "4 tygodnie", "1 miesiąc", "1 rok".

Istnieje również opcjonalny parametr:

Parametr opcjonalny Opis
label_col Kolumna zawierająca podstawowe informacje dotyczące prognoz modelu. 
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import MonitorInferenceLog, MonitorInferenceLogProblemType

w = WorkspaceClient()
w.quality_monitors.create(
  table_name=f"{catalog}.{schema}.{table_name}",
  assets_dir=f"/Workspace/Users/{user_email}/databricks_lakehouse_monitoring/{catalog}.{schema}.{table_name}",
  output_schema_name=f"{catalog}.{schema}",
  inference_log=MonitorInferenceLog(
        problem_type=MonitorInferenceLogProblemType.PROBLEM_TYPE_CLASSIFICATION,
        prediction_col="preds",
        timestamp_col="ts",
        granularities=["30 minutes", "1 day"],
        model_id_col="model_ver",
        label_col="label", # optional
  )
)

W przypadku profilów InferenceLog wycinki są tworzone automatycznie na podstawie odrębnych wartości model_id_col.

Snapshot profil

W przeciwieństwie do TimeSeriesprofil Snapshot monitoruje zmianę pełnej zawartości tabeli w czasie. Metryki są obliczane na wszystkich danych w tabeli i monitorują stan tabeli przy każdym odświeżeniu monitora.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import MonitorSnapshot

w = WorkspaceClient()
w.quality_monitors.create(
  table_name=f"{catalog}.{schema}.{table_name}",
  assets_dir=f"/Workspace/Users/{user_email}/databricks_lakehouse_monitoring/{catalog}.{schema}.{table_name}",
  output_schema_name=f"{catalog}.{schema}",
  snapshot=MonitorSnapshot()
)

Odśwież i wyświetl wyniki monitorowania

Aby odświeżyć tabele metryk, użyj run_refresh. Na przykład:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
w.quality_monitors.run_refresh(
    table_name=f"{catalog}.{schema}.{table_name}"
)

Podczas wywoływania run_refresh z notesu tabele metryk monitora są tworzone lub aktualizowane. To obliczenie jest uruchamiane na bezserwerowych obliczeniach, a nie w klastrze, do którego jest dołączony notes. Możesz nadal uruchamiać polecenia w notesie, gdy statystyki monitora są aktualizowane.

Aby uzyskać informacje o statystykach przechowywanych w tabelach metryk, zobacz Monitor Tabele Metryk Tabele Metryk to tabele katalogu Unity. Zapytania można wykonywać w notesach lub w Eksploratorze zapytań SQL i wyświetlać je w Eksploratorze wykazu.

Aby wyświetlić historię wszystkich odświeżeń skojarzonych z monitorem, użyj polecenia list_refreshes.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
w.quality_monitors.list_refreshes(
    table_name=f"{catalog}.{schema}.{table_name}"
)

Aby uzyskać stan określonego przebiegu, który został umieszczony w kolejce, uruchomiony lub zakończony, użyj get_refresh.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
run_info = w.quality_monitors.run_refresh(table_name=f"{catalog}.{schema}.{table_name}")

w.quality_monitors.get_refresh(
    table_name=f"{catalog}.{schema}.{table_name}",
    refresh_id = run_info.refresh_id
)

Aby anulować odświeżanie, które jest w kolejce lub uruchomione, użyj cancel_refresh.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
run_info = w.quality_monitors.run_refresh(table_name=f"{catalog}.{schema}.{table_name}")

w.quality_monitors.cancel_refresh(
    table_name=f"{catalog}.{schema}.{table_name}",
    refresh_id=run_info.refresh_id
)

Wyświetlanie ustawień monitora

Możesz przejrzeć ustawienia monitorowania przy użyciu interfejsu API get_monitor.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
w.quality_monitors.get(f"{catalog}.{schema}.{table_name}")

Zaplanuj

Aby skonfigurować monitor do uruchomienia zgodnie z harmonogramem, użyj parametru schedulecreate_monitor:

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import MonitorTimeSeries, MonitorCronSchedule

w = WorkspaceClient()
w.quality_monitors.create(
  table_name=f"{catalog}.{schema}.{table_name}",
  assets_dir=f"/Workspace/Users/{user_email}/databricks_lakehouse_monitoring/{catalog}.{schema}.{table_name}",
  output_schema_name=f"{catalog}.{schema}",
  time_series=MonitorTimeSeries(timestamp_col=ts, granularities=["30 minutes"]),
  schedule=MonitorCronSchedule(
        quartz_cron_expression="0 0 12 * * ?", # schedules a refresh every day at 12 noon
        timezone_id="PST",
    )
)

Aby uzyskać więcej informacji, zobacz wyrażenia cron.

Notifications

Aby skonfigurować powiadomienia dla monitora, użyj parametru notificationscreate_monitor:

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.catalog import MonitorTimeSeries, MonitorNotifications, MonitorDestination

w = WorkspaceClient()
w.quality_monitors.create(
  table_name=f"{catalog}.{schema}.{table_name}",
  assets_dir=f"/Workspace/Users/{user_email}/databricks_lakehouse_monitoring/{catalog}.{schema}.{table_name}",
  output_schema_name=f"{catalog}.{schema}",
  time_series=MonitorTimeSeries(timestamp_col=ts, granularities=["30 minutes"]),
  notifications=MonitorNotifications(
        # Notify the given email when a monitoring refresh fails or times out.
        on_failure=MonitorDestination(
            email_addresses=["your_email@domain.com"]
        )
    )
)

Na typ zdarzenia jest obsługiwanych maksymalnie 5 adresów e-mail (na przykład "on_failure").

Kontrolowanie dostępu do tabel metryk

Tabele metryk i pulpit nawigacyjny utworzony przez monitor są własnością użytkownika, który utworzył monitor. Uprawnienia Unity Catalog umożliwiają kontrolowanie dostępu do tabel metryk. Aby udostępnić pulpity nawigacyjne w obszarze roboczym, użyj przycisku Udostępnij w prawym górnym rogu pulpitu nawigacyjnego.

Usuwanie monitora

Aby usunąć monitor:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
w.quality_monitors.delete(table_name=f"{catalog}.{schema}.{table_name}")

To polecenie nie powoduje usunięcia tabel profilów i pulpitu nawigacyjnego utworzonego przez monitor. Musisz usunąć te zasoby w osobnym kroku lub zapisać je w innej lokalizacji.

Przykładowe notesy

W poniższych przykładowych notesach pokazano, jak utworzyć monitor, odświeżyć monitor i zbadać utworzone tabele metryk.

Przykład notesu: profil szeregów czasowych

W tym notesie pokazano, jak utworzyć TimeSeries monitor typów.

Przykładowy notes timeSeries Lakehouse Monitor

Weź notes

Przykład notesu: profil wnioskowania (regresja)

W tym notesie pokazano, jak utworzyć InferenceLog monitor typów dla problemu regresji.

Przykład regresji wnioskowania usługi Lakehouse Monitor

Pobieranie notesu

Przykład notesu: profil wnioskowania (klasyfikacja)

W tym notesie pokazano, jak utworzyć InferenceLog monitor typów pod kątem problemu klasyfikacji.

Przykładowy notes klasyfikacji usługi Inference Lakehouse Monitor

Zdobądź notesnik

Przykład notesu: profil migawki

W tym notesie pokazano, jak utworzyć Snapshot monitor typów.

Przykładowy notes usługi Snapshot Lakehouse Monitor

Weź notes