Monitorowanie aplikacji GenAI w środowisku produkcyjnym

Ważne

Ta funkcja jest dostępna w wersji beta. Administratorzy obszaru roboczego mogą kontrolować dostęp do tej funkcji ze strony Podglądy . Zobacz Zarządzanie podglądami Azure Databricks.

Monitorowanie produkcji umożliwia automatyczne uruchamianie wskaźników MLflow 3 na śladach z aplikacji GenAI w celu ciągłej oceny jakości. Harmonogramujesz ewaluatorów względem eksperymentu MLflow, a usługa monitorowania ocenia konfigurowalną próbkę nadchodzących śladów. Wyniki są dołączane jako informacja zwrotna do każdego ocenianego śladu.

Monitorowanie produkcji obejmuje następujące elementy:

• Automatyczna ocena jakości przy użyciu wbudowanych lub niestandardowych punktów oceny, w tym sędziów wieloeściowych do oceniania całych konwersacji.
• Konfigurowalne stawki próbkowania, dzięki czemu można kontrolować kompromis między pokryciem a kosztem obliczeniowym.
• Użyj tych samych punktów oceny w środowisku deweloperskim i produkcyjnym, aby zapewnić spójną ocenę.
• Ciągła ocena jakości z monitorowaniem uruchomionym w tle.

Uwaga / Notatka

Monitorowanie stanu produkcji w MLflow 3 jest kompatybilne ze śladami rejestrowanymi w MLflow 2.

Wymagania wstępne

Przed skonfigurowaniem monitorowania produkcyjnego upewnij się, że masz:

• Eksperyment MLflow: eksperyment MLflow, w którym są rejestrowane ślady. Jeśli nie określono eksperymentu, używany jest aktywny eksperyment.
• Instrumentowana aplikacja produkcyjna: Aplikacja GenAI musi rejestrować ślady za pomocą MLflow Tracing. Zobacz przewodnik Śledzenie produkcji.
• Zdefiniowane scorery: przetestowane scorery, które współpracują z formatem śledzenia aplikacji. Jeśli użyłeś swojej aplikacji produkcyjnej jako predict_fn w mlflow.genai.evaluate() podczas rozwoju, twoje narzędzia oceniające są prawdopodobnie już zgodne.

• Identyfikator magazynu SQL (dla logów Unity Catalog): Jeśli logi są przechowywane w Unity Catalog, należy skonfigurować identyfikator magazynu SQL, aby monitoring działał poprawnie. Zobacz Włączanie monitorowania produkcyjnego.

Wprowadzenie

Aby skonfigurować monitorowanie produkcyjne, należy zarejestrować wskaźnik w eksperymencie MLflow, a następnie uruchomić go przy użyciu konfiguracji próbkowania. Ten wzorzec dwuetapowy (.register() następnie .start()) ma zastosowanie do wszystkich typów modułów oceny.

Uwaga / Notatka

W dowolnym momencie co najwyżej 20 punktatorów może być skojarzonych z eksperymentem na potrzeby ciągłego monitorowania jakości.

Aby uzyskać więcej informacji na temat punktatorów, zobacz następujące tematy:

• Osoby oceniające i sędziowie LLM
• Sędziowie niestandardowi
• Tworzenie niestandardowych wyników opartych na kodzie

W poniższych sekcjach opisano sposób używania różnych typów sędziów i sposobu ich łączenia. Rozwiń sekcję, aby dowiedzieć się więcej.

Tworzenie i planowanie sędziów LLM przy użyciu interfejsu użytkownika

Tworzenie i planowanie sędziów LLM przy użyciu interfejsu użytkownika

Interfejs użytkownika eksperymentu MLflow umożliwia tworzenie i testowanie oceniaczy bazujących na modelach LLM.

Aby utworzyć nowego sędziego LLM:

1. Przejdź do karty Sędziowie w interfejsie użytkownika eksperymentu MLflow.

   

2. Kliknij pozycję Nowy sędzia LLM.

   

3. Określ, co będzie oceniane przez oceniającego, wybierając opcję Ślady lub Sesje.

4. Wprowadź nazwę sędziego.

5. Kliknij strzałkę, jak pokazano, aby wyświetlić sekcję Kryteria oceny .

   

6. Z menu rozwijanego wybierz typ sędziego. Niektóre typy sędziów umożliwiają wprowadzanie niestandardowych instrukcji, w tym zmiennych.

7. Kliknij strzałkę, jak pokazano, aby wyświetlić sekcję Automatyczna ocena .

   

8. Ustaw przełącznik Uruchom dla wszystkich przyszłych śladów zgodnie z potrzebami.

9. (Opcjonalnie) W obszarze Ustawienia zaawansowane dostosuj częstotliwość próbkowania i ciąg filtru , aby kontrolować, które ślady są oceniane.

10. (Opcjonalnie) Aby przetestować nowego sędziego na zestawie istniejących śladów:

    1. Kliknij pozycję Wybierz ślady w okienku po lewej stronie. Zostanie wyświetlone wyskakujące okienko.
    2. Wybierz ślady do uruchomienia, a następnie kliknij pozycję Wybierz (n).
    3. Kliknij pozycję Uruchom sędziego. Ślady są oceniane, a wyniki są wyświetlane.
    4. Przejrzyj wyniki. Użyj przycisków Dalej i Poprzedni , aby przejść przez wyniki dla każdego wybranego śladu.
    5. W razie potrzeby zmodyfikuj sędziego i iteruj, dopóki nie będziesz zadowolony z wyników sędziego.

11. Aby utworzyć sędziego, kliknij pozycję Utwórz sędziego.

Nie można utworzyć niestandardowego sędziego kodu przy użyciu interfejsu użytkownika. Aby wyświetlić kod szablonu, który można skopiować do notesu i edytować w razie potrzeby, wykonaj następujące czynności:

1. Kliknij strzałkę listy rozwijanej obok przycisku Nowy sędzia LLM , a następnie wybierz pozycję Niestandardowy sędzia kodu.

   

2. Zostanie wyświetlone okienko zawierające instrukcje oraz kod szablonu pokazujące, jak definiować i uruchamiać mechanizm oceny kodu.

Korzystanie z wbudowanych mechanizmów oceniania LLM

Użyj wbudowanych sędziów LLM

MLflow udostępnia kilka wbudowanych mechanizmów oceny LLM, które można używać od razu.

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Register the scorer with a name and start monitoring
safety_judge = Safety().register(name="my_safety_judge")  # name must be unique to experiment
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

Domyślnie każdy sędzia używa hostowanej w usłudze Databricks funkcji LLM przeznaczonej do przeprowadzania ocen jakości genAI. Możesz zmienić model sędziego, aby zamiast tego użyć modelu usługi Databricks obsługującego punkt końcowy przy użyciu argumentu model w definicji wskaźnika. Model musi być określony w formacie databricks:/<databricks-serving-endpoint-name>.

safety_judge = Safety(model="databricks:/databricks-gpt-oss-20b").register(name="my_custom_safety_judge")

Wskazówki dotyczące używania sędziów LLM

Wskazówki dotyczące używania sędziów LLM

Sędziowie LLM oceniają dane wejściowe i wyjściowe przy użyciu kryteriów zaliczenia/niezaliczenia wyrażonych w języku naturalnym.

from mlflow.genai.scorers import Guidelines

# Create and register the guidelines scorer
english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"]
).register(name="is_english")  # name must be unique to experiment

# Start monitoring with the specified sample rate
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

Podobnie jak w przypadku wbudowanych sędziów, można zmienić model sędziowski na używanie punktu końcowego usługi modelu Databricks.

english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"],
  model="databricks:/databricks-gpt-oss-20b",
).register(name="custom_is_english")

Używanie sędziów LLM z niestandardowymi monitami

Korzystanie z sędziów LLM z niestandardowymi podpowiedziami

Aby uzyskać większą elastyczność niż sędziowie wytycznych, użyj sędziów LLM z niestandardowymi monitami, które umożliwiają ocenę jakości na różnych poziomach z dostosowywalnymi kategoriami wyboru.

from typing import Literal
from mlflow.genai import make_judge
from mlflow.genai.scorers import ScorerSamplingConfig

# Create a custom judge using make_judge
formality_judge = make_judge(
    name="formality",
    instructions="""You will look at the response and determine the formality of the response.

Request: {{ inputs }}
Response: {{ outputs }}

Evaluate whether the response is formal, somewhat formal, or not formal.
A response is somewhat formal if it mentions friendship, etc.""",
    feedback_value_type=Literal["formal", "semi_formal", "not_formal"],
    model="databricks:/databricks-gpt-oss-20b",  # optional
)

# Register the custom judge and start monitoring
registered_judge = formality_judge.register(name="my_formality_judge")  # name must be unique to experiment
registered_judge = registered_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.1))

Używanie niestandardowych funkcji oceniających

Używanie niestandardowych funkcji oceniających

Aby uzyskać maksymalną elastyczność, zdefiniuj i użyj niestandardowej funkcji scorer.

:::ważne niestandardowe wymagania dotyczące wskaźnika na potrzeby monitorowania w środowisku produkcyjnym

• Obsługiwane są tylko oceniacze oparte na dekoratorach @scorer. Nie można zarejestrować podklas opartych na Scorer klasach na potrzeby monitorowania produkcyjnego. Jeśli potrzebujesz wskaźnika opartego na klasie, refaktoryzuj go, aby zamiast tego użyć dekoratora @scorer .
• Moduły wyników muszą być zdefiniowane i zarejestrowane w notesie usługi Databricks. Usługa monitorowania serializuje kod funkcji oceniającej do zdalnego wykonywania, a ta serializacja wymaga środowiska notatnika. Program Scorers zdefiniowany w autonomicznych plikach Python lub lokalnych środowiskach IDE nie może być serializowany na potrzeby monitorowania produkcyjnego.
• Eksperci oceniający muszą być niezależni. Ponieważ funkcje oceniające są przetwarzane jako kod do zdalnego wykonywania, wszystkie importy muszą być umieszczone bezpośrednio w treści funkcji. Funkcja nie może odwoływać się do zmiennych, obiektów ani modułów zdefiniowanych poza nią.

:::

Podczas definiowania niestandardowych modułów oceny nie należy używać wskazówek dotyczących typów, które muszą być importowane w podpisie funkcji. Jeśli treść funkcji scorer używa pakietów, które należy zaimportować, zaimportuj te pakiety wewnątrz funkcji, aby zapewnić właściwą serializację.

Niektóre pakiety są domyślnie dostępne bez konieczności importu inline. Obejmują one databricks-agents, mlflow-skinny, openaii wszystkie pakiety uwzględnione w środowisku bezserwerowym w wersji 2.

from mlflow.genai.scorers import scorer, ScorerSamplingConfig


# Custom metric: Check if response mentions Databricks
@scorer
def mentions_databricks(outputs):
    """Check if the response mentions Databricks"""
    return "databricks" in str(outputs.get("response", "")).lower()

# Register and start monitoring
databricks_scorer = mentions_databricks.register(name="databricks_mentions")
databricks_scorer = databricks_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

Aby uzyskać więcej przykładów niestandardowych scorerów, zobacz Tworzenie niestandardowych scorerów opartych na kodzie.

Użyj sędziów wieloetapowych

Korzystanie z sędziów wieloetapowych

Monitorowanie produkcji obsługuje sędziów wielozadaniowych, którzy oceniają całe rozmowy, a nie poszczególne ślady. Sędziowie oceniają wzorce jakości w ramach wielu interakcji, takich jak frustracja użytkownika i kompletność konwersacji. Sędziowie wieloobrotowi są rejestrowani i uruchomieni tak samo jak sędziowie jednoobrotowi.

Zadanie monitorowania automatycznie grupuje ślady konwersacji na podstawie tagu mlflow.trace.session . Sędziowie wieloetapowi działają po zakończeniu konwersacji — domyślnie konwersacja kończy się, gdy przez 5 minut nie są pozyskiwane żadne nowe ślady z tym identyfikatorem sesji. Aby skonfigurować ten bufor, ustaw zmienną MLFLOW_ONLINE_SCORING_DEFAULT_SESSION_COMPLETION_BUFFER_SECONDS środowiskową w zadaniu monitorowania.

Aby uzyskać pełną listę dostępnych sędziów wieloetapowych, zobacz sędziów wieloetapowych. Aby uzyskać szczegółowe informacje na temat oceny konwersacji, zobacz Ocena konwersacji.

Uwaga / Notatka

Aby korzystać z sędziów rozmów wieloetapowych, agent musi ustawić identyfikatory sesji na śledzenia. Aby uzyskać szczegółowe informacje, zobacz Śledzenie użytkowników i sesji .

from mlflow.genai.scorers import (
    ConversationCompleteness,
    UserFrustration,
    ScorerSamplingConfig,
)

# Register and start multi-turn judges just like single-turn judges
completeness_scorer = ConversationCompleteness().register(name="conversation_completeness")
completeness_scorer = completeness_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

frustration_scorer = UserFrustration().register(name="user_frustration")
frustration_scorer = frustration_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

Łączenie sędziów

Łączenie sędziów

W jednym eksperymencie można połączyć sędziów dla pojedynczej tury i sędziów dla wielu tur. Zarejestruj i uruchom każdy scorer osobno.

from mlflow.genai.scorers import Safety, Guidelines, UserFrustration, ScorerSamplingConfig

# Single-turn judges
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))

english_judge = Guidelines(
    name="english",
    guidelines=["The response must be in English"]
).register(name="is_english")
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

# Multi-turn judge
frustration_judge = UserFrustration().register(name="frustration")
frustration_judge = frustration_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.3))

Wyświetlanie wyników

Po zaplanowaniu modułów oceny poczekaj 15–20 minut na wstępne przetwarzanie. Następnie:

1. Przejdź do eksperymentu MLflow.
2. Otwórz kartę Ślady , aby wyświetlić oceny dołączone do śladów.
3. Użyj pulpitów nawigacyjnych do śledzenia trendów jakości.

W przypadku sędziów oceniających w wielu etapach oceny są dołączane do pierwszego śladu wykonania w każdej sesji. Aby uzyskać szczegółowe informacje, zobacz Jak są przechowywane oceny .

Najlepsze rozwiązania

Strategia próbkowania

• W przypadku kluczowych punktów oceny, takich jak kontrole bezpieczeństwa i zabezpieczeń, użyj polecenia sample_rate=1.0.

• W przypadku kosztownych oceniających, takich jak złożone algorytmy LLM, użyj niższej częstotliwości próbkowania (0,05-0,2).

• W przypadku poprawy iteracyjnej podczas opracowywania należy używać umiarkowanych wskaźników (0,3-0,5).

• Zrównoważenie pokrycia i kosztów, jak pokazano w następujących przykładach:

  # High-priority scorers: higher sampling
  safety_judge = Safety().register(name="safety")
  safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))  # 100% coverage for critical safety
  
  # Expensive scorers: lower sampling
  complex_scorer = ComplexCustomScorer().register(name="complex_analysis")
  complex_scorer = complex_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.05))  # 5% for expensive operations
  

Filtruj ślady

Użyj parametru filter_string w ScorerSamplingConfig, aby kontrolować, które ślady ocenia scorer. Używa to tej samej składni filtru co mlflow.search_traces().

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Only evaluate traces that completed successfully
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=1.0,
        filter_string="attributes.status = 'OK'"
    ),
)

Można połączyć wiele warunków:

import time

# Evaluate successful traces from the last 24 hours
one_day_ago = int((time.time() - 86400) * 1000)
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=0.5,
        filter_string=f"attributes.status = 'OK' AND attributes.timestamp_ms > {one_day_ago}"
    ),
)

Niestandardowy projekt skorera

Zachowaj samodzielność niestandardowych mechanizmów oceniania, jak pokazano w poniższym przykładzie:

@scorer
def well_designed_scorer(inputs, outputs):
    # All imports inside the function
    import re
    import json

    # Handle missing data gracefully
    response = outputs.get("response", "")
    if not response:
        return 0.0

    # Return consistent types
    return float(len(response) > 100)

Rozwiązywanie problemów

Wyniki nie są uruchomione

Jeśli moduły oceny nie są wykonywane, sprawdź następujące kwestie:

1. Sprawdź eksperyment: upewnij się, że ślady są rejestrowane w eksperymencie, a nie do poszczególnych przebiegów.
2. Częstotliwość próbkowania: przy niskich współczynnikach próbkowania może upłynąć trochę czasu, aby zobaczyć wyniki.
3. Sprawdź ciąg filtru: Upewnij się, że twoje filter_string odpowiadają rzeczywistym śladom.

Problemy z serializacji

Niestandardowe moduły oceniające do monitorowania produkcyjnego są serializowane, aby można je było wykonywać zdalnie przez usługę monitorowania. Nakłada to kilka ograniczeń:

• Wymagania notatnika: Funkcje niestandardowe @scorer muszą być zdefiniowane i zarejestrowane w notatniku Databricks. Mechanizm serializacji opiera się na środowisku notebooka.
• Funkcje samodzielne: wszystkie importy muszą być wbudowane w treści funkcji. Odwołania do zmiennych zewnętrznych, modułów lub obiektów zdefiniowanych poza funkcją nie są przechwytywane podczas serializacji.
• Brak oceniaczy opartych na klasach: można zarejestrować tylko mechanizmy oceny na podstawie dekoratora. Podklasy oparte na Scorer klasach nie mogą być serializowane na potrzeby zdalnego wykonywania.
• Brak wskazówek dotyczących typów wymagających importu: wskazówki dotyczące typów w podpisie funkcji, które wymagają instrukcji importu (na przykład List z typing) powodują błędy serializacji.

Podczas tworzenia niestandardowego modułu oceniania uwzględnij importy w definicji funkcji.

# Avoid external dependencies
import external_library  # Outside function

@scorer
def bad_scorer(outputs):
    return external_library.process(outputs)

# Include imports in the function definition
@scorer
def good_scorer(outputs):
    import json  # Inside function
    return len(json.dumps(outputs))

# Avoid using type hints in scorer function signature that requires imports
from typing import List

@scorer
def scorer_with_bad_types(outputs: List[str]):
    return False

# Class-based scorers are not supported for production monitoring
class MyScorer(Scorer):
    name: str = "my_scorer"
    def __call__(self, outputs):
        return len(outputs) > 10

Dalsze kroki

• Zarządzanie punktatorami produkcyjnymi — zarządzanie cyklem życia punktatorów produkcyjnych.
• Wypełnianie historycznych śladów za pomocą punktatorów — retroaktywne zastosowanie punktatorów do historycznych śladów.
• Archiwizowanie śladów w Tabeli Delta — zapisywanie śladów i ocen w Tabeli Delta.
• Tworzenie niestandardowych modułów oceny opartych na kodzie — twórz oceny dostosowane do Twoich potrzeb.
• Ewaluuj konwersacje — dowiedz się więcej o ocenie konwersacji wielozwrotowej i sędziach wielozwrotowych.
• Tworzenie zestawów danych oceny MLflow — użyj wyników monitorowania, aby poprawić jakość.

Przewodniki referencyjne

• Dokumentacja interfejsu API zarządzania cyklem życia scorera — dokumentacja interfejsu API zarządzania cyklem życia scorera.
• Osoby oceniające i sędziowie LLM — Zrozumienie metryk, które napędzają monitorowanie.
• Ocena GenAI podczas rozwoju — jak ocena offline odnosi się do środowiska produkcyjnego.