AI-Anwendungen bewerten¶

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)

Szenario 2: Ablaufverfolgung einer Funktion mit einem bestimmten Spantyp¶

Ein Spantyp spezifiziert die Art der Funktion und verbessert die Lesbarkeit und das Verständnis der Ablaufverfolgungen. Beispiel: In einer RAG-Anwendung können Sie den Spantyp als RETRIEVAL für Ihren Suchservice (oder Abruf) angeben und den Spantyp als GENERATION für den LLM-Inferenzaufruf angeben. Die folgenden Spantypen werden unterstützt:

• RETRIEVAL: Spantyp für Abruf- oder Suchfunktionen

• GENERATION: Spantyp für Modellinferenz-Aufrufe von einer LLM

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

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

from trulens.otel.semconv.trace import SpanAttributes

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)

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

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)

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.

Automatische Instrumentierung von Framework-Anwendungen¶

Zusätzlich zur manuellen Instrumentierung mit dem @instrument()-Decorator bietet TruLens spezielle Wrapper, die automatisch Anwendungen instrumentieren, die mit gängigen LLM-Frameworks erstellt wurden. Diese Wrapper ermöglichen die Integration und die automatische Ablaufverfolgung, ohne dass einzelne Funktionen manuell dekoriert werden müssen.

from trulens.apps.langchain import TruChain

# Wrap your LangChain application
tru_recorder = TruChain(
    rag_chain,
    app_name="my_langchain_app",
    app_version="v1.0"
)

# Use the recorder as a context manager
with tru_recorder as recording:
    response = rag_chain.invoke(input_query)

from trulens.apps.langgraph import TruGraph

# Wrap your LangGraph application
tru_recorder = TruGraph(
    graph,
    app_name="my_langgraph_app",
    app_version="v1.0"
)

# Use the recorder as a context manager
with tru_recorder as recording:
    response = graph.invoke({"messages": [("user", input_query)]})

from trulens.apps.llamaindex import TruLlama

# Wrap your LlamaIndex query engine
tru_recorder = TruLlama(
    query_engine,
    app_name="my_llamaindex_app",
    app_version="v1.0"
)

# Use the recorder as a context manager
with tru_recorder as recording:
    response = query_engine.query(input_query)

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"
)

• 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)

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)

Anfrageparameter:

• run_name: str: Name des Laufs

Lauf-Metadaten anzeigen¶

Beschreibt die Details des Laufs.

run.describe()

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"

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",
])

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()

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()

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()

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()

Antwort:

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