AI-Anwendungen bewerten

Um eine generative AI-Anwendung zu bewerten, gehen Sie folgendermaßen vor:

  1. Erstellen Sie die App und instrumentieren Sie sie mit Trulens SDK (mit Python erstellte Anwendungen werden unterstützt).

  2. Registrieren Sie die App in Snowflake.

  3. Erstellen Sie einen Lauf, indem Sie den Eingabedatensatz angeben.

  4. Führen Sie den Lauf aus, um Ablaufverfolgungen zu generieren und Bewertungskennzahlen zu berechnen.

  5. Sehen Sie sich die Bewertungsergebnisse in Snowsight an.

Die App instrumentieren

Nachdem Sie Ihre generative AI-Anwendung in Python erstellt haben, importieren Sie die TruLens SDK, um sie zu instrumentieren. TruLens SDK bietet einen @instrument() Decorator, mit dem Sie die Funktionen in Ihrer Anwendung instrumentieren können, um die Ablaufverfolgung zu erzeugen und die Metrik zu berechnen.

  • Um den Decorator zu verwenden, fügen Sie den folgenden Import in Ihre Python-Anwendung ein:

    from trulens.core.otel.instrument import instrument
    
    Copy

Sie können die Granularität des @instrument()-Decorators je nach Ihren Anforderungen ändern.

Szenario 1: Ablaufverfolgung einer Funktion

Sie können @instrument() vor der Funktion hinzufügen, die Sie ablaufen lassen möchten. Damit werden automatisch die Eingaben in die Funktion, die Ausgaben (Rückgabewerte) und die Latenzzeit der Ausführung erfasst. Der folgende Code veranschaulicht beispielsweise die Ablaufverfolgung einer answer_query-Funktion, die automatisch die Eingabeabfrage und die endgültige Antwort erfasst:

@instrument()
def answer_query(self, query: str) -> str:
    context_str = self.retrieve_context(query)
    return self.generate_completion(query, context_str)
Copy

Szenario 2: Ablaufverfolgung einer Funktion mit einem bestimmten Spantyp

Ein Spantyp gibt die Art der Funktion an und verbessert die Lesbarkeit und das Verständnis der Ablaufverfolgung. In einer RAG-Anwendung können Sie beispielsweise für Ihren Suchdienst (oder Retriever) den Spantyp „RETRIEVAL“ und für den LLM-Inferenzaufruf den Spantyp „GENERATION“ angeben. Die folgenden Spantypen werden unterstützt:

  • RETRIEVAL: Spantyp für Abruf- oder Suchfunktionen

  • GENERATION: Spantyp für Modellinferenzaufrufe aus einer LLM

  • RECORD_ROOT: Spantyp für die Hauptfunktion in Ihrer Anwendung

Wenn Sie mit @instrument() keinen Spantyp angeben, wird standardmäßig ein Spantyp UNKNOWN zugewiesen. Um span-Attribute zu verwenden, fügen Sie den folgenden Import in Ihre Python-Anwendung ein.

from trulens.otel.semconv.trace import SpanAttributes
Copy

Der folgende Codeschnipsel demonstriert die Ablaufverfolgung einer RAG-Anwendung. Dem Spantyp muss immer SpanAttributes.SpanType vorangestellt werden.

@instrument(span_type=SpanAttributes.SpanType.RETRIEVAL)
def retrieve_context(self, query: str) -> list:
    """
    Retrieve relevant text from vector store.
    """
    return self.retrieve(query)

@instrument(span_type=SpanAttributes.SpanType.GENERATION)
def generate_completion(self, query: str, context_str: list) -> str:
    """
    Generate answer from context by calling an LLM.
    """
    return response

@instrument(span_type=SpanAttributes.SpanType.RECORD_ROOT)
def answer_query(self, query: str) -> str:
    context_str = self.retrieve_context(query)
    return self.generate_completion(query, context_str)
Copy

Szenario 3: Ablaufverfolgung einer Funktion und Berechnung von Auswertungen

Zusätzlich zur Bereitstellung von Spantypen müssen Sie die relevanten Parameter in Ihrer Anwendung den span-Attributen zuordnen, um die Metriken zu berechnen. Um zum Beispiel die Kontextrelevanz in einer RAG-Anwendung zu berechnen, müssen Sie die relevanten Abfrage- und Abrufergebnisparameter den entsprechenden Attributen RETRIEVAL.QUERY_TEXT bzw. RETRIEVAL.RETRIEVED_CONTEXTS zuweisen. Die Attribute, die zur Berechnung der einzelnen Metriken erforderlich sind, finden Sie auf der Seite Metriken.

Die folgenden span-Attribute werden für jeden Spantyp unterstützt:

  • RECORD_ROOT: INPUT, OUTPUT, GROUND_TRUTH_OUTPUT

  • RETRIEVAL: QUERY_TEXT, RETRIEVED_CONTEXTS

  • GENERATION: Keine

Um span-Attribute zu verwenden, müssen Sie den folgenden Import in Ihre Python-Anwendung einfügen.

from trulens.otel.semconv.trace import SpanAttributes
Copy

Der folgende Codeschnipsel ist ein Beispiel für die Berechnung der Kontextrelevanz für einen Abrufdienst. Die Attribute müssen immer dem Format SpanAttributes.<Spantyp>.<Attributname> (z. B. SpanAttributes.RETRIEVAL.QUERY_TEXT) entsprechen.

@instrument(
    span_type=SpanAttributes.SpanType.RETRIEVAL,
    attributes={
        SpanAttributes.RETRIEVAL.QUERY_TEXT: "query",
        SpanAttributes.RETRIEVAL.RETRIEVED_CONTEXTS: "return",
    }
)
def retrieve_context(self, query: str) -> list:
    """
    Retrieve relevant text from vector store.
    """
    return self.retrieve(query)
Copy

Im vorangegangenen Beispiel steht query für den Eingabeparameter für retrieve_context() und return für den zurückgegebenen Wert. Diese werden den Attributen RETRIEVAL.QUERY_TEXT und RETRIEVAL.RETRIEVED_CONTEXTS zugewiesen, um die Kontextrelevanz zu berechnen.

App in Snowflake registrieren

Um Ihre generative AI-Anwendung in Snowflake für die Erfassung von Ablaufverfolgungen und die Durchführung von Auswertungen zu registrieren, müssen Sie mit Hilfe von TruLens SDK ein TruApp-Objekt erstellen, das den Aufruf (die Ausführung) der Anwendung des Benutzers aufzeichnet und Ablaufverfolgungen nach Snowflake exportiert.

tru_app = TruApp(
    test_app: Any,
    app_name: str,
    app_version: str,
    connector: SnowflakeConnector,
    main_method: callable  # i.e. test_app.answer_query
)
Copy

Parameter:

  • test_app: Any: eine Instanz der benutzerdefinierten Anwendung, die später während eines Laufs zur Auswertung aufgerufen wird. d. h. test_app = RAG()

  • app_name: str: ist der Name der Anwendung, die der Benutzer angeben kann und die im Snowflake-Konto des Benutzers verwaltet wird.

  • app_version: str: ist die Version, die der Benutzer für die test_app angeben kann, um Experimente verfolgen und vergleichen zu können.

  • connector: SnowflakeConnector: eine Wrapper-Klasse, die Snowpark-Sitzungen und Snowflake DB-Verbindungen verwaltet.

  • main_method: callable (Optional): ist die Einstiegspunkt-Methode für die Anwendung des Benutzers, die SDK mitteilt, wie test_app von Benutzern aufgerufen werden soll und wo die Ablaufverfolgung des Aufrufs der Benutzeranwendung (angegeben durch test_app) beginnen soll. Für das Beispiel der Klasse RAG kann die main_method als test_app.answer_query angegeben werden, vorausgesetzt, die Antwortmethode ist der Einstiegspunkt der App. Alternativ können Sie die Einstiegspunkt-Methode mit dem span-Attribut RECORD_ROOT instrumentieren. In diesem Fall ist dieser Parameter nicht erforderlich.

Lauf erstellen

Um einen Bewertungsjob zu beginnen, müssen Sie einen Lauf erstellen. Um einen Lauf zu erstellen, muss eine Laufkonfiguration angegeben werden. Die Funktion add_run() verwendet die Laufkonfiguration, um einen neuen Lauf zu erstellen.

Konfiguration ausführen

Ein Lauf wird aus einer RunConfig erstellt

run_config = RunConfig(
    run_name=run_name,
    description="desc",
    label="custom tag useful for grouping comparable runs",
    source_type="DATAFRAME",
    dataset_name="My test dataframe name",
    dataset_spec={
        "RETRIEVAL.QUERY_TEXT": "user_query_field",
        "RECORD_ROOT.INPUT": "user_query_field",
        "RECORD_ROOT.GROUND_TRUTH_OUTPUT": "golden_answer_field",
    },
    llm_judge_name: "mistral-large2"
)
Copy
  • run_name: str: Der Name des Laufs sollte unter derselben TruApp eindeutig sein

  • description: str (optional): Zeichenfolge zur Beschreibung des Laufs

  • label: str (optional): Etikett zur Gruppierung von Läufen

  • source_type: str: gibt die Quelle des Datensatzes an. Es kann entweder DATAFRAME für einen Python-Datenrahmen oder TABLE für eine Benutzertabelle im Snowflake-Konto sein.

  • dataset_name: str: ein beliebiger, vom Benutzer angegebener Name, wenn source_type DATAFRAME ist. Oder ein gültiger Snowflake-Tabellenname unter dem Konto des Benutzers im aktuellen Kontext (Datenbank und Schema) oder ein vollqualifizierter Snowflake-Namen in der Form „database.schema.table_name“.

  • dataset_spec: Dict[str, str]: ein Wörterbuch, das die Zuordnung von unterstützten span-Attributen zu den Spaltennamen des Benutzers im Datenrahmen oder in der Tabelle unterstützt. Die zulässigen Schlüssel sind span-Attribute, wie auf der Seite Datensatz angegeben, und die zulässigen Werte sind Spaltennamen in dem vom Benutzer angegebenen Datenrahmen oder der Tabelle. Zum Beispiel muss „golden_answer_field“ im obigen Beispiel für die Laufkonfiguration ein gültiger Spaltenname sein

  • llm_judge_name: str (Optional): Name, der bei der LLM -basierten Metrikberechnung als LLM-Richter verwendet wird. Die unterstützten Richter finden Sie auf der Seite mit den Modellen. Wenn nicht angegeben, ist der Standardwert llama3.1-70b

run = tru_app.add_run(run_config=run_config)
Copy

Anfrageparameter:

  • run_config: RunConfig: enthält die Konfiguration für den Lauf.

Lauf abrufen

Ruft den Lauf ab.

run = tru_app.get_run(run_name=run_name)
Copy

Anfrageparameter:

  • run_name: str: Name des Laufs

Lauf-Metadaten anzeigen

Beschreibt die Details des Laufs.

run.describe()
Copy

Lauf aufrufen

Sie können den Lauf mit der Funktion run.start() aufrufen. Sie liest die Eingaben aus dem in der Laufkonfiguration angegebenen Datensatz, ruft die Anwendung für jede Eingabe auf, erzeugt die Ablaufverfolgung und nimmt die Informationen zur Speicherung in Ihrem Snowflake-Konto auf. run.start() ist ein blockierender Aufruf, bis die Anwendung für alle Eingaben in Ihrem Datensatz aufgerufen und die Aufnahme abgeschlossen oder zeitlich begrenzt wurde.

run.start()  # if source_type is "TABLE"

run.start(input_df=user_input_df)  # if source_type is "DATAFRAME"
Copy

Anfrageparameter:

  • input_df: DataFrame (Optional): ist ein Pandas-Datenrahmen aus dem SDK. Wenn in der Laufkonfiguration als source_type DATAFRAME angegeben ist, ist dieses Feld obligatorisch. Wenn der source_type TABLE ist, ist dieses Feld nicht erforderlich.

Metriken berechnen

Sie können die Metrikberechnungen mit run.compute_metrics() starten, nachdem die Anwendung aufgerufen wurde und alle Ablaufverfolgungen aufgenommen wurden. Solange der Status des Laufs INVOCATION_IN_PROGRESS ist, kann die Berechnung nicht gestartet werden. Sobald der Status INVOCATION_COMPLETED oder INVOCATION_PARTIALLY_COMPLETED ist, kann run.compute_metrics() gestartet werden. run.compute_metrics() ist eine asynchrone, nicht blockierende Funktion. Sie können compute_metrics während desselben Laufs mehrmals mit unterschiedlichen Metriken aufrufen, und jeder Aufruf löst einen neuen Berechnungsauftrag aus. Beachten Sie, dass einmal berechnete Metriken nicht noch einmal für denselben Lauf berechnet werden können.

run.compute_metrics(metrics=[
    "coherence",
    "answer_relevance",
    "groundedness",
    "context_relevance",
    "correctness",
])
Copy

Anfrageparameter:

  • metrics: List[str]: Liste der Zeichenfolgenamen der in Metrics aufgeführten Metriken. Der Name der Metrik sollte in Snake-Cases angegeben werden, d. h. Kontextrelevanz sollte als context_relevance angegeben werden.

Laufstatus prüfen

Sie können den Status des Laufs überprüfen, nachdem er bereits begonnen hat. Die Liste der Status finden Sie im Abschnitt Ausführungsstatus.

run.get_status()
Copy

Lauf abbrechen

Sie können einen bestehenden Lauf mit run.cancel() abbrechen. Diese Operation verhindert alle zukünftigen Aktualisierungen des Laufs, einschließlich des Laufstatus und der Metadatenfelder.

run.cancel()
Copy

Lauf löschen

Sie können einen bestehenden Lauf mit run.delete() löschen. Bei dieser Operation werden die mit dem Lauf verknüpften Metadaten gelöscht und auf die Bewertungsergebnis kann nicht zugegriffen werden. Die im Rahmen der Läufe erzeugten Ablaufverfolgungen und Auswertungen werden jedoch nicht gelöscht und bleiben gespeichert. Weitere Informationen zur Speicherung und Löschung von Auswertungen und Ablaufverfolgung finden Sie im Abschnitt Observability-Daten.

run.delete()
Copy

Läufe für eine Anwendung auflisten

Sie können die Liste aller verfügbaren Läufe, die einem bestimmten TruApp-Anwendungsobjekt entsprechen, mit der Funktion list_runs() einsehen.

tru_app.list_runs()
Copy

Antwort:

Gibt eine Liste aller unter tru_app erstellten Läufe zurück.

Auswertungen und Ablaufverfolgungen anzeigen

Gehen Sie wie folgt vor, um die Bewertungsergebnisse anzuzeigen:

  1. Navigieren Sie zu Snowsight.

  2. Wählen Sie AI & ML aus.

  3. Wählen Sie Evaluations aus.

Gehen Sie wie folgt vor, um die Bewertungsergebnisse für Ihre Anwendungsläufe anzuzeigen:

  • Um die Läufe zu einer bestimmten Anwendung anzuzeigen, wählen Sie die Anwendung aus.

  • Um die Bewertungsergebnisse für einen Lauf anzuzeigen, wählen Sie den Lauf aus. Sie sehen die aggregierten Ergebnisse und die Ergebnisse für die einzelnen Datensätze.

  • Um Ablaufverfolgungen für einen Datensatz anzuzeigen, wählen Sie ihn aus. Sie können detaillierte Ablaufverfolgungen, Latenzzeiten, Eingaben und Ausgaben in jedem Stagingbereich der Anwendung, Bewertungsergebnisse und Erklärungen des LLM-Richters für die generierte Genauigkeitspunktzahl einsehen.

Um Läufe zu vergleichen, die denselben Datensatz verwenden, wählen Sie mehrere Läufe aus und wählen Sie Compare, um die Ausgaben und die Bewertungspunktzahlen zu vergleichen.