Evaluierung und Überwachung von LLM- und RAG-Anwendungen

Einführung

Die KI-Entwicklung macht erhebliche Fortschritte, insbesondere mit dem Aufkommen von Giant Language Fashions (LLMs) und Retrieval-Augmented Era (RAG) Anwendungen. Da Entwickler bestrebt sind, robustere und zuverlässigere KI-Systeme zu entwickeln, sind Instruments, die die Bewertung und Überwachung erleichtern, unverzichtbar geworden. Ein solches Device ist Opik, eine Open-Supply-Plattform zur Optimierung der Bewertung, Prüfung und Überwachung von LLM-Anwendungen. In diesem Artikel werden LLM- und RAG-Anwendungen mit Opik bewertet und überwacht.

Überblick

1. Opik ist eine von Comet entwickelte Open-Supply-Plattform zur Bewertung und Überwachung von LLM-Anwendungen.
2. Es ermöglicht die Protokollierung und Nachverfolgung von LLM-Interaktionen und hilft Entwicklern, Probleme in Echtzeit zu identifizieren und zu beheben.
3. Die Bewertung von LLMs ist von entscheidender Bedeutung, um Genauigkeit und Relevanz sicherzustellen und Halluzinationen in den Modellergebnissen zu vermeiden.
4. Opik unterstützt die Integration mit Frameworks wie Pytest und erleichtert so die Ausführung wiederverwendbarer Evaluierungspipelines.
5. Die Plattform bietet sowohl Python SDK als auch eine Benutzeroberfläche und deckt damit ein breites Spektrum an Benutzerpräferenzen ab.
6. Opik kann mit Ragas zur Überwachung und Bewertung von RAG-Systemen verwendet werden, indem Metriken wie Antwortrelevanz und Kontextgenauigkeit berechnet werden.

Was ist Opik?

Opik ist ein Open-Supply-LLM Evaluierungs- und Überwachungsplattform von Comet. Es ermöglicht Ihnen, Ihre LLM-Traces in Entwicklung und Produktion zu protokollieren, zu überprüfen und auszuwerten. Sie können die Plattform und unser LLM auch als Richterbewerter nutzen, um Probleme mit Ihrer LLM-Bewerbung zu identifizieren und zu beheben.

Warum ist eine Bewertung wichtig?

Bewerten LLMs und RAG-Systeme gehen über die Prüfung der Genauigkeit hinaus. Dazu gehören Faktoren wie Antwortrelevanz, Richtigkeit, Kontextgenauigkeit und die Vermeidung von Halluzinationen. Instruments wie Opik und Ragas Ermöglichen Sie den Groups Folgendes:

• Verfolgen Sie die LLM-Leistung in Echtzeit und identifiziert Engpässe und Bereiche, in denen das System möglicherweise falsche oder irrelevante Ausgaben generiert.
• Bewerten Sie RAG-Pipelinesum sicherzustellen, dass das Abrufsystem genaue, relevante und vollständige Informationen für die anstehenden Aufgaben bereitstellt.

Hauptmerkmale von Opik

Hier sind die wichtigsten Funktionen von Opik:

1. Finish-to-Finish-LLM-Bewertung

• Opik verfolgt automatisch die gesamte LLM-Pipeline und liefert Einblicke in jede Komponente der Anwendung. Diese Fähigkeit ist entscheidend für das Debuggen und das Verständnis, wie verschiedene Teile des Techniques interagieren1.
• Es unterstützt komplexe Auswertungen sofort und ermöglicht es Entwicklern, Metriken zu implementieren, die die Modellleistung schnell bewerten.

2. Echtzeitüberwachung

• Die Plattform ermöglicht die Echtzeitüberwachung von LLM-Anwendungen, was dabei hilft, unbeabsichtigtes Verhalten und Leistungsprobleme zu erkennen, sobald sie auftreten.
• Entwickler können Interaktionen mit ihren LLM-Anwendungen protokollieren und diese Protokolle überprüfen, um das Verständnis und die Leistung kontinuierlich zu verbessern24.

3. Integration mit Check-Frameworks

• Opik lässt sich nahtlos in gängige Check-Frameworks wie Pytest integrieren und ermöglicht so „Modell-Unit-Checks“. Diese Funktion erleichtert die Erstellung wiederverwendbarer Evaluierungspipelines, die auf verschiedene Arten angewendet werden können Anwendungen.
• Entwickler können Bewertungsdatensätze innerhalb der Plattform speichern und Bewertungen mithilfe integrierter Metriken zur Halluzinationserkennung und anderen wichtigen Maßnahmen durchführen.

4. Benutzerfreundliche Oberfläche

• Die Plattform bietet sowohl a Python SDK für Entwickler, die Codierung bevorzugen, und eine Benutzeroberfläche für diejenigen, die grafische Interaktion bevorzugen. Dieser duale Ansatz macht es einem breiteren Benutzerkreis zugänglich.

Erste Schritte mit Opik

Opik ist für die nahtlose Integration in LLM-Systeme wie die GPT-Modelle von OpenAI konzipiert. Auf diese Weise können Sie Ablaufverfolgungen protokollieren, Ergebnisse auswerten und die Leistung in jedem Pipeline-Schritt überwachen. Hier erfahren Sie, wie Sie beginnen.

Protokollspuren für OpenAI LLM-Aufrufe – Setup-Umgebung

1. Erstellen Sie ein Opik-Konto: Gehen Sie rüber zu Komet und ein Konto erstellen. Zum Protokollieren von Traces benötigen Sie einen API-Schlüssel.
2. Protokollierungsspuren für OpenAI LLM-Aufrufe: Mit Opik können Sie Spuren protokollieren OpenAI Aufrufe, indem Sie sie mit der Funktion track_openai umschließen. Dadurch wird sichergestellt, dass jede Interaktion mit dem LLM protokolliert wird, was eine detaillierte Analyse ermöglicht.

Set up

Sie können Opik mit pip installieren:

!pip set up --upgrade --quiet opik openai

import opik

opik.configure(use_local=False)

import os

import getpass

if "OPENAI_API_KEY" not in os.environ:

    os.environ("OPENAI_API_KEY") = getpass.getpass("Enter your OpenAI API key: ")

Opik lässt sich in OpenAI integrieren, um eine einfache Möglichkeit zur Protokollierung von Ablaufverfolgungen für alle OpenAI-LLM-Aufrufe zu bieten.

Comet bietet eine gehostete Model der Opik-Plattform. Sie können ein Konto erstellen und Ihren API-Schlüssel erhalten.

Protokollierungsspuren für OpenAI LLM-Aufrufe – Protokollierungsspuren

from opik.integrations.openai import track_openai

from openai import OpenAI

os.environ("OPIK_PROJECT_NAME") = "openai-integration-demo"

consumer = OpenAI()

openai_client = track_openai(consumer)

immediate = """

Write a brief two sentence story about Opik.

"""

completion = openai_client.chat.completions.create(

    mannequin="gpt-3.5-turbo",

    messages=(

        {"position": "person", "content material": immediate}

    )

)

print(completion.selections(0).message.content material)

Um Spuren zu Opik zu protokollieren, müssen wir unsere OpenAI-Aufrufe mit der Funktion track_openai umschließen.

Dieses Beispiel zeigt, wie man einen von Opik umhüllten OpenAI-Consumer für die Hint-Protokollierung einrichtet und mit einer einfachen Eingabeaufforderung eine Chat-Abschlussanforderung erstellt.

Die Eingabeaufforderungs- und Antwortnachrichten werden automatisch in OPik protokolliert und können in der Benutzeroberfläche angezeigt werden.

Protokollierungsspuren für OpenAI LLM-Aufrufe – Protokollierung mehrstufiger Spuren

from opik import monitor

from opik.integrations.openai import track_openai

from openai import OpenAI

os.environ("OPIK_PROJECT_NAME") = "openai-integration-demo"

consumer = OpenAI()

openai_client = track_openai(consumer)

@monitor

def generate_story(immediate):

    res = openai_client.chat.completions.create(

        mannequin="gpt-3.5-turbo",

        messages=(

            {"position": "person", "content material": immediate}

        )

    )

    return res.selections(0).message.content material

@monitor

def generate_topic():

    immediate = "Generate a subject for a narrative about Opik."

    res = openai_client.chat.completions.create(

        mannequin="gpt-3.5-turbo",

        messages=(

            {"position": "person", "content material": immediate}

        )

    )

    return res.selections(0).message.content material

@monitor

def generate_opik_story():

    matter = generate_topic()

    story = generate_story(matter)

    return story

generate_opik_story()

Wenn Ihre LLM-Pipeline mehrere Schritte enthält, können Sie den Monitor Decorator verwenden, um die Ablaufverfolgungen für jeden Schritt zu protokollieren.

Wenn OpenAI innerhalb eines dieser Schritte aufgerufen wird, wird der LLM-Aufruf dem entsprechenden Schritt zugeordnet.

Dieses Beispiel zeigt, wie Sie mithilfe des @track-Dekorators Ablaufverfolgungen für mehrere Schritte in einem Prozess protokollieren und dabei den Fluss von der Themengenerierung zur Story-Generierung erfassen.

Opik mit Ragas zur Überwachung und Bewertung von RAG Techniques

!pip set up --quiet --upgrade opik ragas

import opik

opik.configure(use_local=False)

• Hier sind zwei Hauptmöglichkeiten, Opik mit Ragas zu verwenden:
  • Verwendung von Ragas-Metriken zur Bewertung von Spuren.
  • Verwenden der Ragas-Bewertungsfunktion zum Bewerten eines Datensatzes.
• Komet stellt eine gehostete Model der Opik-Plattform bereit. Du kannst ein Konto erstellen und holen Sie sich dort Ihren API-Schlüssel.

Beispiel zum Festlegen eines API-Schlüssels:

import os

import getpass

if "OPENAI_API_KEY" not in os.environ:

    os.environ("OPENAI_API_KEY") = getpass.getpass("Enter your OpenAI API key: ")

Erstellen einer einfachen RAG-Pipeline mit Ragas-Metriken

Ragas bietet eine Reihe von Metriken, die zur Bewertung der Qualität einer RAG-Pipeline verwendet werden können, einschließlich, aber nicht beschränkt auf: Antwortrelevanz, Antwortähnlichkeit, Antwortkorrektheit, Kontextgenauigkeit, Kontextrückruf, Kontextentitätsrückruf, Zusammenfassungsbewertung.

Eine vollständige Liste der Metriken finden Sie im Ragas-Dokumentation.

Diese Metriken können im Handumdrehen berechnet und in Opik in Traces oder Spans protokolliert werden. In diesem Beispiel erstellen wir zunächst eine einfache RAG-Pipeline und bewerten sie dann mithilfe der Metrik „answer_relevancy“.

# Import the metric

from ragas.metrics import AnswerRelevancy

# Import some extra dependencies

from langchain_openai.chat_models import ChatOpenAI

from langchain_openai.embeddings import OpenAIEmbeddings

from ragas.llms import LangchainLLMWrapper

from ragas.embeddings import LangchainEmbeddingsWrapper

# Initialize the Ragas metric

llm = LangchainLLMWrapper(ChatOpenAI())

emb = LangchainEmbeddingsWrapper(OpenAIEmbeddings())

answer_relevancy_metric = AnswerRelevancy(llm=llm, embeddings=emb)

Um die Ragas-Metrik ohne Verwendung der Evaluierungsfunktion zu verwenden, müssen Sie sie mit einem RunConfig-Objekt und einem LLM-Anbieter initialisieren. In diesem Beispiel verwenden wir LangChain als LLM-Anbieter mit aktiviertem Opik-Tracer.

Wir beginnen zunächst mit der Initialisierung der Ragas-Metrik.

# Run this cell first in case you are operating this in a Jupyter pocket book

import nest_asyncio

nest_asyncio.apply()

import asyncio

from ragas.integrations.opik import OpikTracer

from ragas.dataset_schema import SingleTurnSample

import os

os.environ("OPIK_PROJECT_NAME") = "ragas-integration"

# Outline the scoring operate

def compute_metric(metric, row):

    row = SingleTurnSample(**row)

    opik_tracer = OpikTracer(tags=("ragas"))

    async def get_score(opik_tracer, metric, row):

        rating = await metric.single_turn_ascore(row, callbacks=(opik_tracer))

        return rating

    # Run the async operate utilizing the present occasion loop

    loop = asyncio.get_event_loop()

    outcome = loop.run_until_complete(get_score(opik_tracer, metric, row))

    return outcome

• Sobald die Metrik initialisiert ist, können Sie sie zum Bewerten einer Beispielfrage verwenden.
• Dazu müssen wir zunächst eine Bewertungsfunktion definieren, die einen Datensatz mit Eingaben, Kontext usw. aufnehmen und ihn anhand der zuvor definierten Metrik bewerten kann.
• Da die Metrikbewertung asynchron erfolgt, müssen Sie die Asyncio-Bibliothek verwenden, um die Bewertungsfunktion auszuführen.

# Rating a easy instance

row = {

   "user_input": "What's the capital of France?",

   "response": "Paris",

   "retrieved_contexts": ("Paris is the capital of France.", "Paris is in France."),

}

rating = compute_metric(answer_relevancy_metric, row)

print("Reply Relevancy rating:", rating)

Wenn Sie nun zu Opik navigieren, können Sie sehen, dass im Default Venture-Projekt ein neuer Hint erstellt wurde.

Sie können die Funktion „update_current_trace“ verwenden, um Ablaufverfolgungen zu bewerten.

Diese Methode hat den Vorteil, dass die Bewertungsspanne zur Ablaufverfolgung hinzugefügt wird, was eine tiefergehende Untersuchung des RAG-Prozesses ermöglicht. Da die Ragas-Metrik jedoch synchron berechnet wird, ist sie möglicherweise nicht für den Einsatz in Produktionsszenarien geeignet.

from opik import monitor, opik_context

@monitor

def retrieve_contexts(query):

    # Outline the retrieval operate, on this case we'll onerous code the contexts

    return ("Paris is the capital of France.", "Paris is in France.")

@monitor

def answer_question(query, contexts):

    # Outline the reply operate, on this case we'll onerous code the reply

    return "Paris"

@monitor(identify="Compute Ragas metric rating", capture_input=False)

def compute_rag_score(answer_relevancy_metric, query, reply, contexts):

    # Outline the rating operate

    row = {"user_input": query, "response": reply, "retrieved_contexts": contexts}

    rating = compute_metric(answer_relevancy_metric, row)

    return rating

@monitor

def rag_pipeline(query):

    # Outline the pipeline

    contexts = retrieve_contexts(query)

    reply = answer_question(query, contexts)

    rating = compute_rag_score(answer_relevancy_metric, query, reply, contexts)

    opik_context.update_current_trace(

        feedback_scores=({"identify": "answer_relevancy", "worth": spherical(rating, 4)})

    )

    return reply

rag_pipeline("What's the capital of France?")

Datensätze auswerten

from datasets import load_dataset

from ragas.metrics import context_precision, answer_relevancy, faithfulness

from ragas import consider

from ragas.integrations.opik import OpikTracer

fiqa_eval = load_dataset("explodinggradients/fiqa", "ragas_eval")

# Reformat the dataset to match the schema anticipated by the Ragas consider operate

dataset = fiqa_eval("baseline").choose(vary(3))

dataset = dataset.map(

    lambda x: {

        "user_input": x("query"),

        "reference": x("ground_truths")(0),

        "retrieved_contexts": x("contexts"),

    }

)

opik_tracer_eval = OpikTracer(tags=("ragas_eval"), metadata={"evaluation_run": True})

outcome = consider(

    dataset,

    metrics=(context_precision, faithfulness, answer_relevancy),

    callbacks=(opik_tracer_eval),

)

print(outcome)

Wenn Sie einen Datensatz bewerten möchten, können Sie die Auswertungsfunktion von Raga verwenden. Wenn diese Funktion aufgerufen wird, berechnet die Ragas-Bibliothek die Metriken für jede Zeile im Datensatz und gibt eine Zusammenfassung der Ergebnisse zurück.

Verwenden Sie den OpikTracer-Callback, um die Bewertungsergebnisse auf der Opik-Plattform zu protokollieren:

Evaluierung von LLM-Anwendungen mit Opik

Durch die Bewertung Ihrer LLM-Anwendung können Sie Vertrauen in deren Leistung gewinnen. Dieser Evaluierungssatz wird häufig sowohl während der Entwicklung als auch im Rahmen des Testens einer Anwendung durchgeführt.

Die Auswertung erfolgt in fünf Schritten:

1. Fügen Sie Tracing zu Ihrer LLM-Anwendung hinzu.
2. Definieren Sie die Bewertungsaufgabe.
3. Wählen Sie den Datensatz aus, anhand dessen Sie Ihre Bewerbung bewerten möchten.
4. Wählen Sie die Kennzahlen aus, mit denen Sie Ihre Bewerbung bewerten möchten.
5. Erstellen Sie das Bewertungsexperiment und führen Sie es aus.

Fügen Sie Tracing zu Ihrer LLM-Anwendung hinzu.

from opik import monitor

from opik.integrations.openai import track_openai

import openai

openai_client = track_openai(openai.OpenAI())

# This technique is the LLM utility that you simply need to consider

# Usually, this isn't up to date when creating evaluations

@monitor

def your_llm_application(enter: str) -> str:

    response = openai_client.chat.completions.create(

        mannequin="gpt-3.5-turbo",

        messages=({"position": "person", "content material": enter}),

    )

    return response.selections(0).message.content material

@monitor

def your_context_retriever(enter: str) -> str:

    return ("...")

• Obwohl dies nicht erforderlich ist, wird das Hinzufügen von Monitoring zu Ihrer LLM-Bewerbung empfohlen. Dies ermöglicht einen vollständigen Einblick in jeden Evaluierungslauf.
• Das Beispiel zeigt die Verwendung einer Kombination aus dem Monitor Decorator und der Funktion track_openai zum Verfolgen der LLM-Anwendung.

Dadurch wird sichergestellt, dass Antworten aus den Modell- und Kontextabrufprozessen während der Auswertung verfolgt werden.

Definieren Sie die Bewertungsaufgabe

def evaluation_task(x: DatasetItem):

    return {

        "enter": x.enter('user_question'),

        "output": your_llm_application(x.enter('user_question')),

        "context": your_context_retriever(x.enter('user_question'))

    }

• Sie können die Evaluierungsaufgabe definieren, nachdem Sie Ihrer LLM-Anwendung Instrumentierung hinzugefügt haben.
• Die Auswertungsaufgabe verwendet ein Datensatzelement als Eingabe und gibt ein Wörterbuch zurück. Das Wörterbuch enthält Schlüssel, die den Parametern entsprechen, die von den von Ihnen verwendeten Metriken erwartet werden.
• In diesem Beispiel ruft die Funktion „evaluation_task“ die Eingabe aus dem Datensatz (x.enter(‚user_question‘)) ab, führt sie durch die LLM-Anwendung und ruft den Kontext mithilfe der Methode „your_context_retriever“ ab.

Mit dieser Methode werden die Auswertungsdaten für die weitere Analyse strukturiert.

Wählen Sie die Auswertungsdaten

Wenn Sie bereits einen Datensatz erstellt haben:

Sie können die Funktion Opik.get_dataset verwenden, um es abzurufen:

Codebeispiel:

from opik import Opik

consumer = Opik()

dataset = consumer.get_dataset(identify="your-dataset-name")

Wenn Sie noch keinen Datensatz haben:

Sie können eines mit der Funktion Opik.create_dataset erstellen:

Codebeispiel:

from opik import Opik

from opik.datasets import DatasetItem

consumer = Opik()

dataset = consumer.create_dataset(identify="your-dataset-name")

dataset.insert((

    DatasetItem(enter="Hiya, world!", expected_output="Hiya, world!"),

    DatasetItem(enter="What's the capital of France?", expected_output="Paris"),

))

• Um einen vorhandenen Datensatz abzurufen, verwenden Sie get_dataset mit dem Datensatznamen.
• Um einen neuen Datensatz zu erstellen, verwenden Sie create_dataset. Mit der Einfügefunktion können Sie Datenelemente in den Datensatz einfügen.

Wählen Sie die Bewertungsmetriken

Im selben Bewertungsexperiment können Sie mehrere Metriken verwenden, um Ihre Anwendung zu bewerten:

from opik.analysis.metrics import Equals, Hallucination

equals_metric= Equals()

hallucination_metric=Hallucination()

Opik bietet eine Reihe integrierter Bewertungsmetriken, aus denen Sie auswählen können. Diese sind in zwei Hauptkategorien unterteilt:

1. Heuristische Metriken: Diese Metriken sind deterministischer Natur, zum Beispiel gleich oder enthält
2. LLM als Richter: Diese Metriken verwenden ein LLM, um die Qualität der Ausgabe zu beurteilen. Typischerweise werden diese zur Erkennung von Halluzinationen oder Kontextrelevanz verwendet

Führen Sie die Auswertung durch

analysis= consider(experiment_name=”My experiment”,dataset=dataset,activity=evaluation_task,scoring_metrics=(hallucination_metric),experiment_config={”mannequin”: Mannequin})

Nachdem wir nun die Aufgabe, die wir auswerten möchten, den auszuwertenden Datensatz und die Metriken, mit denen wir auswerten möchten, haben, können wir die Auswertung durchführen.

Abschluss

Opik stellt einen bedeutenden Fortschritt bei den verfügbaren Instruments zur Bewertung und Überwachung von LLM-Anwendungen dar. Entwickler können sicher vertrauenswürdige KI-Systeme aufbauen, indem sie umfassende Funktionen zum Verfolgen, Bewerten und Debuggen von LLMs in einem benutzerfreundlichen Rahmen anbieten. Mit der Weiterentwicklung der KI-Technologie werden Instruments wie Opik von entscheidender Bedeutung sein, um sicherzustellen, dass diese Systeme in realen Anwendungen effektiv und zuverlässig funktionieren.

Wenn Sie außerdem on-line nach einem Generative-KI-Kurs suchen, dann schauen Sie sich Folgendes an: GenAI Pinnacle-Programm

Häufig gestellte Fragen

Hallo, ich bin Janvi Kumari und derzeit Affiliate Insights bei Analytics Vidhya. Meine Leidenschaft liegt in der Nutzung von Daten für Erkenntnisse und Innovationen. Neugierig, motiviert und lernbegierig. Wenn Sie sich vernetzen möchten, können Sie mich gerne auf LinkedIn kontaktieren