Bewertung

Bewertungen sind eine Form von Tests, mit denen Sie die Antworten Ihres LLM validieren und dafür sorgen können, dass sie Ihre Qualitätsanforderungen erfüllen.

Firebase Genkit unterstützt Bewertungstools von Drittanbietern über Plug-ins, kombiniert mit leistungsstarken Observability-Funktionen, die Einblicke in den Laufzeitstatus Ihrer LLM-gestützten Anwendungen bieten. Mit Genkit-Tools können Sie automatisch Daten wie Eingaben, Ausgaben und Informationen aus Zwischenschritten extrahieren, um die End-to-End-Qualität von LLM-Antworten zu bewerten und die Leistung der Bausteine Ihres Systems zu verstehen.

Wenn Sie beispielsweise einen RAG-Flow haben, extrahiert Genkit die vom Retriever zurückgegebenen Dokumente, damit Sie die Qualität des Retrievers bewerten können, während er im Kontext des Flows ausgeführt wird, wie unten mit den Genkit-Messwerten für Treue und Relevanz der Antwort dargestellt:

import { genkit } from 'genkit';
import { genkitEval, GenkitMetric } from '@genkit-ai/evaluator';
import { vertexAI, textEmbedding004, gemini15Flash } from '@genkit-ai/vertexai';

const ai = genkit({
  plugins: [
    vertexAI(),
    genkitEval({
      judge: gemini15Flash,
      metrics: [GenkitMetric.FAITHFULNESS, GenkitMetric.ANSWER_RELEVANCY],
      embedder: textEmbedding004, // GenkitMetric.ANSWER_RELEVANCY requires an embedder
    }),
  ],
  // ...
});

Hinweis:Für die oben beschriebene Konfiguration müssen die Pakete genkit, @genkit-ai/googleai, @genkit-ai/evaluator und @genkit-ai/vertexai installiert werden.

  npm install @genkit-ai/evaluator @genkit-ai/vertexai

Definieren Sie zuerst eine Reihe von Eingaben, die Sie als Eingabedatensatz namens testInputs.json verwenden möchten. Dieser Eingabedatensatz stellt die Testfälle dar, mit denen Sie Ausgabedaten zur Bewertung generieren.

["Cheese", "Broccoli", "Spinach and Kale"]

Wenn der Evaluator für die Bewertung eines Ablaufs eine Referenzausgabe benötigt, können Sie stattdessen sowohl Eingabe als auch Referenzausgabe in diesem Format übergeben:

{
  "samples": [
    {
      "input": "What is the French word for Cheese?",
      "reference": "Fromage"
    },
    {
      "input": "What green vegetable looks like cauliflower?",
      "reference": "Broccoli"
    }
  ]
}

Sie können in der Eingabe-JSON-Datei jeden JSON-Datentyp verwenden. Genkit gibt sie mit demselben Datentyp an Ihren Flow weiter.

Anschließend können Sie mit dem Befehl eval:flow Ihren Ablauf anhand der in testInputs.json bereitgestellten Testfälle bewerten.

genkit eval:flow menuSuggestionFlow --input testInputs.json

Wenn für deinen Ablauf eine Authentifizierung erforderlich ist, kannst du sie mit dem Argument --auth angeben:

genkit eval:flow menuSuggestionFlow --input testInputs.json --auth "{\"email_verified\": true}"

Sie können sich die Bewertungsergebnisse dann in der Entwickler-UI ansehen. Führen Sie dazu Folgendes aus:

genkit start

Rufen Sie dann localhost:4000/evaluate auf.

Alternativ können Sie eine Ausgabedatei angeben, um die Ausgabe in einer JSON-Datei zu prüfen.

genkit eval:flow menuSuggestionFlow --input testInputs.json --output eval-result.json

Hinweis:Unten sehen Sie ein Beispiel dafür, wie Sie mit einem LLM Testfälle generieren können.

Unterstützte Prüfer

Genkit-Bewerter

Genkit enthält eine kleine Anzahl von nativen Bewertern, die von RAGAS inspiriert sind, um Ihnen den Einstieg zu erleichtern:

• Treue
• Relevanz der Antwort
• Böswilligkeit

Plug-ins für Bewerter

Genkit unterstützt zusätzliche Bewerter über Plug-ins wie die Vertex AI-Schnellbewerter über das Vertex AI-Plug-in.

Erweiterte Nutzung

eval:flow ist eine praktische Möglichkeit, den Ablauf schnell zu bewerten. Manchmal benötigen Sie jedoch mehr Kontrolle über die Bewertungsschritte. Das kann passieren, wenn Sie ein anderes Framework verwenden und bereits einige Ergebnisse haben, die Sie auswerten möchten. Sie können alle Schritte ausführen, die eval:flow halbautomatisch ausführt.

Sie können Ihren Genkit-Flow im Batch ausführen und der Ausführung ein eindeutiges Label hinzufügen, das dann zum Extrahieren eines Bewertungsdatensatzes (eines Satzes von Eingaben, Ausgaben und Kontexten) verwendet wird.

Führen Sie den Ablauf mit Ihren Testinputs aus:

genkit flow:batchRun myRagFlow test_inputs.json --output flow_outputs.json --label customLabel

Bewertungsdaten extrahieren:

genkit eval:extractData myRagFlow --label customLabel --output customLabel_dataset.json

Die exportierten Daten werden als JSON-Datei mit jedem Testfall im folgenden Format ausgegeben:

[
  {
    "testCaseId": string,
    "input": string,
    "output": string,
    "context": array of strings,
    "traceIds": array of strings,
  }
]

Der Datenextractor sucht automatisch nach Retrievern und fügt die erstellten Dokumente dem Kontext-Array hinzu. Standardmäßig wird eval:run für alle konfigurierten Prüfer ausgeführt. Wie bei eval:flow werden die Ergebnisse für eval:run auf der Bewertungsseite der Entwickleroberfläche unter localhost:4000/evaluate angezeigt.

Benutzerdefinierte Extrahierer

Sie können auch benutzerdefinierte Extraktoren für die Befehle eval:extractData und eval:flow bereitstellen. Mit benutzerdefinierten Extraktoren können Sie die Standardlogik für die Datenextraktion überschreiben. So haben Sie mehr Möglichkeiten, Datasets zu erstellen und zu analysieren.

Wenn Sie benutzerdefinierte Extraktoren konfigurieren möchten, fügen Sie dem Stammverzeichnis Ihres Projekts eine Tools-Konfigurationsdatei mit dem Namen genkit-tools.conf.js hinzu, falls noch keine vorhanden ist.

cd $GENKIT_PROJECT_HOME
touch genkit-tools.conf.js

Fügen Sie der Konfigurationsdatei für Tools den folgenden Code hinzu:

module.exports = {
  evaluators: [
    {
      actionRef: '/flow/myFlow',
      extractors: {
        context: { outputOf: 'foo-step' },
        output: 'bar-step',
      },
    },
  ],
};

In diesem Beispiel konfigurieren Sie einen Extractor für den myFlow-Datenfluss. In der Konfiguration werden die Extraktoren für die Felder context und output überschrieben und die Standardlogik für das Feld input verwendet.

Die Spezifikation der Bewertungsextractors ist wie folgt:

• Das Feld evaluators akzeptiert ein Array von EvaluatorConfig-Objekten, die durch flowName begrenzt sind.
• extractors ist ein Objekt, das die Extractor-Überschreibungen angibt. Die derzeit unterstützten Schlüssel in extractors sind [input, output, context]. Zulässige Werttypen sind:
  • string: Dies sollte der Name eines Schritts sein, der als String angegeben wird. Die Ausgabe dieses Schritts wird für diesen Schlüssel extrahiert.
  • { inputOf: string } oder { outputOf: string }: Diese Objekte stellen bestimmte Kanäle (Eingabe- oder Ausgabe) eines Schritts dar. Mit { inputOf: 'foo-step' } wird beispielsweise die Eingabe von Schritt foo-step für diesen Schlüssel extrahiert.
  • (trace) => string;: Für mehr Flexibilität können Sie eine Funktion angeben, die einen Genkit-Trace akzeptiert und einen string zurückgibt. Die Extraktionslogik können Sie in dieser Funktion angeben. Das genaue TraceData-Schema finden Sie unter genkit/genkit-tools/common/src/types/trace.ts.

Hinweis:Die extrahierten Daten für alle diese Schritte sind ein JSON-String. Das Tool analysiert diesen JSON-String bei der Auswertung automatisch. Wenn Sie einen Funktionsextraktor bereitstellen, muss die Ausgabe ein gültiger JSON-String sein. Beispiel: "Hello, world!" ist kein gültiges JSON-Format, "\"Hello, world!\"" ist gültig.

Auf vorhandenen Datasets ausführen

So führen Sie eine Bewertung für ein bereits extrahiertes Dataset aus:

genkit eval:run customLabel_dataset.json

Wenn Sie die Ausgabe an einem anderen Speicherort platzieren möchten, verwenden Sie das Flag --output.

genkit eval:flow menuSuggestionFlow --input testInputs.json --output customLabel_evalresult.json

Wenn Sie die Ausführung auf einen Teil der konfigurierten Bewerter beschränken möchten, verwenden Sie das Flag --evaluators und geben Sie eine durch Kommas getrennte Liste der Bewerter nach Namen an:

genkit eval:run customLabel_dataset.json --evaluators=genkit/faithfulness,genkit/answer_relevancy

Testdaten mit einem LLM synthetisieren

Hier ist ein Beispielablauf, bei dem anhand einer PDF-Datei mögliche Fragen generiert werden, die Nutzer dazu stellen könnten.

import { genkit, run, z } from "genkit";
import { googleAI, gemini15Flash } from "@genkit-ai/googleai";
import { chunk } from "llm-chunk";
import path from 'path';

const ai = genkit({ plugins: [googleAI()] });

const chunkingConfig = {
  minLength: 1000, // number of minimum characters into chunk
  maxLength: 2000, // number of maximum characters into chunk
  splitter: 'sentence', // paragraph | sentence
  overlap: 100, // number of overlap chracters
  delimiters: '', // regex for base split method
} as any;

export const synthesizeQuestions = ai.defineFlow(
  {
    name: "synthesizeQuestions",
    inputSchema: z.string().describe("PDF file path"),
    outputSchema: z.array(z.string()),
  },
  async (filePath) => {
    filePath = path.resolve(filePath);
    // `extractText` loads the PDF and extracts its contents as text.
    // See our RAG documentation for more details. 
    const pdfTxt = await run("extract-text", () => extractText(filePath));

    const chunks = await run("chunk-it", async () =>
      chunk(pdfTxt, chunkingConfig)
    );

    const questions: string[] = [];
    for (var i = 0; i < chunks.length; i++) {
      const qResponse = await ai.generate({
        model: gemini15Flash,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text);
    }
    return questions;
  }
);

Mit diesem Befehl können Sie die Daten dann in eine Datei exportieren und zur Auswertung verwenden.

genkit flow:run synthesizeQuestions '"my_input.pdf"' --output synthesizedQuestions.json