Beta: Firebase Genkit is in Beta, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Beta period, Firebase Genkit and its documentation will be updated and improved.

Questa pagina è stata tradotta dall'API Cloud Translation.

Valutazione

La valutazione è una forma di test che ti aiuta a convalidare le risposte dell'LLM e a garantire che soddisfino i tuoi standard di qualità.

Firebase Genkit supporta gli strumenti di valutazione di terze parti tramite plug-in, abbinati a potenti funzionalità di osservabilità che forniscono informazioni sullo stato di runtime delle applicazioni basate su LLM. Gli strumenti di Genkit ti aiutano a estrarre automaticamente i dati, inclusi input, output e informazioni, dai passaggi intermedi per valutare la qualità end-to-end delle risposte dell'LLM e comprendere le prestazioni dei componenti di base del sistema.

Tipi di valutazione

Genkit supporta due tipi di valutazione:

Valutazione basata sull'inferenza: questo tipo di valutazione viene eseguito su una raccolta di input predeterminati, valutando la qualità degli output corrispondenti.

Si tratta del tipo di valutazione più comune, adatto alla maggior parte dei casi d'uso. Questo approccio testa l'output effettivo di un sistema per ogni esecuzione di valutazione.

Puoi eseguire la valutazione della qualità manualmente, ispezionando visivamente i risultati. In alternativa, puoi automatizzare la valutazione utilizzando una metrica di valutazione.
Valutazione non elaborata: questo tipo di valutazione valuta direttamente la qualità degli input senza alcuna inferenza. Questo approccio viene in genere utilizzato con la valutazione automatica utilizzando le metriche. Tutti i campi obbligatori per la valutazione (ad es. input, context, output e reference) devono essere presenti nel set di dati di input. Questa funzionalità è utile quando hai dati provenienti da una fonte esterna (ad es. raccolti dalle tracce di produzione) e vuoi avere una misurazione oggettiva della qualità dei dati raccolti.

Per ulteriori informazioni, consulta la sezione Utilizzo avanzato di questa pagina.

Questa sezione spiega come eseguire una valutazione basata sull'inferenza utilizzando Genkit.

Guida rapida

Configurazione

Utilizza un'app Genkit esistente o creane una nuova seguendo la nostra guida [Introduzione](introduzione).
Aggiungi il seguente codice per definire una semplice applicazione RAG da valutare. Per questa guida, utilizziamo un recuperatore simulato che restituisce sempre gli stessi documenti. ```js import { genkit, z, Document } from "genkit"; import { googleAI, gemini15Flash, gemini15Pro, } from "@genkit-ai/googleai"; // Inizializza Genkit export const ai = genkit ({ plugins: [ googleAI(), ] }); // Ricercatore simulato che restituisce sempre gli stessi documenti export const dummyRetriever = ai.defineRetriever( { name: "dummyRetriever", }, async (i) => { const facts = [ "Il cane è il migliore amico dell'uomo", "I cani si sono evoluti e sono stati addomesticati dai lupi", ]; // Restituisce semplicemente i fatti come documenti. return { documents: facts.map((t) => Document.fromText(t)) }; } ); // Un semplice flusso di risposta alle domande export const qaFlow = ai.defineFlow({ name: 'qaFlow', inputSchema: z.string(), outputSchema: z.string(), }, async (query) => { const factDocs = await ai.retrieve({ retriever: dummyRetriever, query, options: { k: 2 }, }); const llmResponse = await ai.generate({ model: gemini15Flash, prompt: `Rispondi a questa domanda con il contesto dato ${query}`, docs: factDocs, }); return llmResponse.text; } ); ```
(Facoltativo) Aggiungi le metriche di valutazione all'applicazione da utilizzare durante la valutazione. Questa guida utilizza la metrica "MALICIOUSNESS" del plug-in "genkitEval". ```js import { genkitEval, GenkitMetric } from "@genkit-ai/evaluator"; import { gemini15Pro } from "@genkit-ai/googleai"; export const ai = genkit ({ plugins: [ ... // Aggiungi questo plug-in al blocco di inizializzazione di Genkit genkitEval({ judge: gemini15Pro, metrics: [GenkitMetric.MALICIOUSNESS], }), ] }); ``` **Nota:** la configurazione riportata sopra richiede l'installazione del pacchetto [`@genkit-ai/evaluator`](https://www.npmjs.com/package/@genkit-ai/evaluator). ```posix-terminal npm install @genkit-ai/evaluator ```
Avvia l'applicazione Genkit ```terminale posix genkit start -- ```

Crea un set di dati

Crea un set di dati per definire gli esempi che vuoi utilizzare per valutare il flusso.

Vai all'interfaccia utente di sviluppo all'indirizzo http://localhost:4000 e fai clic sul pulsante Set di dati per aprire la pagina Set di dati.
Fai clic sul pulsante Crea set di dati per aprire la finestra di dialogo di creazione del set di dati.

a. Fornisci un datasetId per il nuovo set di dati. Questa guida utilizzamyFactsQaDataset.

b. Seleziona il tipo di set di dati Flow.

c. Lascia vuoto il campo Destinazione convalida e fai clic su Salva.
Viene visualizzata la pagina del nuovo set di dati, che mostra un set di dati vuoto. Aggiungi esempi tramite i seguenti passaggi:

a. Fai clic sul pulsante Aggiungi esempio per aprire il riquadro dell'editor di esempi.

b. È obbligatorio solo il campo input. Inserisci "Who is man's best friend?" nel campo input e fai clic su Salva per aggiungere l'esempio al set di dati.

c. Ripeti i passaggi (a) e (b) altre un paio di volte per aggiungere altri esempi. Questa guida aggiunge al set di dati i seguenti input di esempio:
```
"Can I give milk to my cats?"
"From which animals did dogs evolve?"
```
Al termine di questo passaggio, il set di dati dovrebbe contenere 3 esempi con i valori sopra indicati.

Esegui la valutazione e visualizza i risultati

Per iniziare a valutare il flusso, fai clic sulla scheda Evaluations nell'interfaccia utente di sviluppo e poi sul pulsante Esegui nuova valutazione.

Seleziona il pulsante di opzione Flow per valutare un flusso.
Seleziona qaFlow come flusso target da valutare.
Seleziona myFactsQaDataset come set di dati di destinazione da utilizzare per la valutazione.
(Facoltativo) Se hai installato una metrica di valutazione utilizzando i plug-in Genkit, puoi visualizzarla in questa pagina. Seleziona le metriche da utilizzare con questa esecuzione della valutazione. Questo passaggio è del tutto facoltativo: se lo ometti, verranno comunque restituiti i risultati nell'esecuzione della valutazione, ma senza le metriche associate.
Infine, fai clic su Esegui valutazione per avviarla. A seconda del flusso di cui stai eseguendo il test, l'operazione potrebbe richiedere del tempo. Al termine della valutazione, viene visualizzato un messaggio di conferma con un link per visualizzare i risultati. Fai clic sul link per accedere alla pagina Dettagli valutazione.

In questa pagina puoi visualizzare i dettagli della valutazione, inclusi input originali, contesto estratto e metriche (se presenti).

Concetti principali

Terminologia

Valutazione: una valutazione è un processo che valuta le prestazioni del sistema. In Genkit, un sistema di questo tipo è in genere una primitiva Genkit, ad esempio un flusso o un modello. Una valutazione può essere automatica o manuale (valutazione umana).
Inferenza collettiva L'inferenza è l'atto di eseguire un input su un flusso o un modello per ottenere l'output corrispondente. L'inferenza collettiva comporta l'esecuzione di inferenze su più input contemporaneamente.
Metrica Una metrica di valutazione è un criterio in base al quale viene assegnato un punteggio a un'inferenza. Alcuni esempi sono accuratezza, fedeltà, comportamento dannoso, se l'output è in inglese e così via.
Set di dati: un set di dati è una raccolta di esempi da utilizzare per la valutazione basata sull'inferenza. Un set di dati in genere è costituito da campi input e reference facoltativi. Il campo reference non influisce sul passaggio di inferenza della valutazione, ma viene passato alla lettera a qualsiasi metrica di valutazione. In Genkit, puoi creare un set di dati tramite l'interfaccia utente per sviluppatori. In Genkit sono disponibili due tipi di set di dati: set di dati Flow e set di dati Model.

Convalida dello schema

A seconda del tipo, i set di dati hanno il supporto della convalida dello schema nell'interfaccia utente di sviluppo:

I set di dati di flusso supportano la convalida dei campi input e reference del set di dati rispetto a un flusso nell'applicazione Genkit. La convalida dello schema è facoltativa e viene applicata solo se viene specificato uno schema nel flusso di destinazione.
I set di dati del modello hanno uno schema implicito che supporta sia i tipi di input string sia quelli GenerateRequest. La convalida delle stringhe offre un modo pratico per valutare prompt di testo semplici, mentre GenerateRequest offre il controllo completo per i casi d'uso avanzati (ad es. fornendo parametri del modello, cronologia dei messaggi, strumenti e così via). Puoi trovare lo schema completo di GenerateRequest nelle nostre documentazioni di riferimento dell'API.

Valutatori supportati

Valutatori Genkit

Genkit include un numero limitato di valutatori nativi, ispirati alle RAGAS, per aiutarti a iniziare:

Fedeltà: misura la coerenza fattuale della risposta generata rispetto al contesto specificato
Pertinenza della risposta: valuta la pertinenza della risposta generata al prompt fornito
Malevolezza: misura se l'output generato ha lo scopo di ingannare, danneggiare o sfruttare

Plug-in di valutazione

Genkit supporta valutatori aggiuntivi tramite plug-in, come Vertex Rapid evaluators, a cui puoi accedere tramite il plug-in VertexAI.

Utilizzo avanzato

Valutazione mediante l'interfaccia a riga di comando

Genkit CLI fornisce un'API completa per eseguire la valutazione. Questo è particolarmente utile in ambienti in cui l'interfaccia utente di sviluppo non è disponibile (ad es. in un flusso di lavoro CI/CD).

Genkit CLI fornisce tre comandi di valutazione principali: eval:flow, eval:extractData e eval:run.

Comando `eval:flow`

Il comando eval:flow esegue la valutazione basata sull'inferenza su un set di dati di input. Questo set di dati può essere fornito come file JSON o facendo riferimento a un set di dati esistente nel runtime di Genkit.

# Referencing an existing dataset
genkit eval:flow qaFlow --input myFactsQaDataset
# or, using a dataset from a file
genkit eval:flow qaFlow --input testInputs.json

In questo caso, testInputs.json deve essere un array di oggetti contenente un campo input e un campo reference facoltativo, come di seguito:

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

Se il flusso richiede l'autenticazione, puoi specificarla utilizzando l'argomento --auth:

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

Per impostazione predefinita, i comandi eval:flow e eval:run utilizzano tutte le metriche disponibili per la valutazione. Per eseguire l'operazione su un sottoinsieme di valutatori configurati, utilizza il flag --evaluators e fornisci un elenco separato da virgole dei valutatori per nome:

genkit eval:flow qaFlow --input testInputs.json --evaluators=genkit/faithfulness,genkit/answer_relevancy

Puoi visualizzare i risultati dell'esecuzione della valutazione nell'interfaccia utente per gli sviluppatori all'indirizzo localhost:4000/evaluate.

Comandi `eval:extractData` e `eval:run`

Per supportare la valutazione non elaborata, Genkit fornisce strumenti per estrarre i dati dalle tracce e eseguire metriche di valutazione sui dati estratti. Questa operazione è utile, ad esempio, se utilizzi un framework diverso per la valutazione o se raccogli inferenze da un ambiente diverso per testare localmente la qualità dell'output.

Puoi eseguire in batch il flusso Genkit e aggiungere un'etichetta univoca all'esecuzione, che poi può essere utilizzata per estrarre un set di dati di valutazione. Un set di dati di valutazione non elaborato è una raccolta di input per le metriche di valutazione, senza eseguire alcuna inferenza precedente.

Esegui il flusso sui dati di test:

genkit flow:batchRun qaFlow testInputs.json --label firstRunSimple

Estrai i dati di valutazione:

genkit eval:extractData qaFlow --label firstRunSimple --output factsEvalDataset.json

I dati esportati hanno un formato diverso da quello del set di dati presentato in precedenza. Questo perché questi dati sono destinati a essere utilizzati direttamente con le metriche di valutazione, senza alcun passaggio di deduzione. Ecco la sintassi dei dati estratti.

Array<{
  "testCaseId": string,
  "input": any,
  "output": any,
  "context": any[],
  "traceIds": string[],
}>;

L'estrattore di dati individua automaticamente i retriever e aggiunge i documenti prodotti all'array di contesto. Puoi eseguire le metriche di valutazione su questo set di dati estratto utilizzando il comando eval:run.

genkit eval:run factsEvalDataset.json

Per impostazione predefinita, eval:run viene eseguito su tutti i valutatori configurati e, come per eval:flow, i risultati di eval:run vengono visualizzati nella pagina di valutazione dell'UI sviluppatore, all'indirizzo localhost:4000/evaluate.

Estrattori personalizzati

Genkit fornisce una logica predefinita ragionevole per estrarre i campi necessari (input, output e context) durante una valutazione. Tuttavia, potresti dover avere un maggiore controllo sulla logica di estrazione per questi campi. Genkit supporta gli estrattori personalizzati per raggiungere questo obiettivo. Puoi fornire estrazione personalizzata per essere utilizzata nei comandi eval:extractData e eval:flow.

Innanzitutto, come passaggio preparatorio, introduci un passaggio ausiliario nel nostro qaFlow esempio:

export const qaFlow = ai.defineFlow({
    name: 'qaFlow',
    inputSchema: z.string(),
    outputSchema: z.string(),
  },
  async (query) => {
    const factDocs = await ai.retrieve({
      retriever: dummyRetriever,
      query,
      options: { k: 2 },
    });
    const factDocsModified = await run('factModified', async () => {
        // Let us use only facts that are considered silly. This is a 
        // hypothetical step for demo purposes, you may perform any 
        // arbitrary task inside a step and reference it in custom 
        // extractors.
        //
        // Assume you have a method that checks if a fact is silly
        return factDocs.filter(d => isSillyFact(d.text));
    });

    const llmResponse = await ai.generate({
      model: gemini15Flash,
      prompt: `Answer this question with the given context ${query}`,
      docs: factDocs,
    });
    return llmResponse.text;
  }
);

Successivamente, configura un'estrazione personalizzata per utilizzare l'output del passaggio factModified durante la valutazione di questo flusso.

Se non hai un file tools-config per configurare gli estrattori personalizzati, aggiungine uno denominato genkit-tools.conf.js alla directory principale del progetto.

cd /path/to/your/genkit/app
touch genkit-tools.conf.js

Nel file di configurazione degli strumenti, aggiungi il seguente codice:

module.exports = {
  evaluators: [
    {
      actionRef: '/flow/qaFlow',
      extractors: {
        context: { outputOf: 'factModified' },
      },
    },
  ],
};

Questa configurazione sostituisce gli estrattori predefiniti degli strumenti di Genkit, in particolare modificando ciò che viene considerato context durante la valutazione di questo flusso.

Se esegui di nuovo la valutazione, viene visualizzato che il contesto è ora compilato come output del passaggio factModified.

genkit eval:flow qaFlow --input testInputs.json

Gli estrattori di valutazione sono specificati come segue:

Il campo evaluators accetta un array di oggetti EvaluatorConfig, il cui ambito è definito da flowName
extractors è un oggetto che specifica le sostituzioni dell'estrattore. Le chiavi supportate attualmente in extractors sono [input, output, context]. I tipi di valore accettabili sono:
- string: deve essere il nome di un passaggio, specificato come stringa. L'output di questo passaggio viene estratto per questa chiave.
- { inputOf: string } o { outputOf: string }: questi oggetti rappresentano canali specifici (di input o di output) di un passaggio. Ad esempio, { inputOf: 'foo-step' } estrarrebbe l'input del passaggio foo-step per questa chiave.
- (trace) => string;: per una maggiore flessibilità, puoi fornire una funzione che accetti una traccia Genkit e restituisca un valore di tipo any, nonché specificare la logica di estrazione all'interno di questa funzione. Consulta genkit/genkit-tools/common/src/types/trace.ts per lo schema esatto di TraceData.

Nota:i dati estratti per tutti questi estrattori sono del tipo corrispondente all'estrattore. Ad esempio, se utilizzi il contesto: { outputOf: 'foo-step' } e foo-step restituisce un array di oggetti, il contesto estratto è anche un array di oggetti.

Sintesi dei dati di test utilizzando un LLM

Ecco un esempio di flusso che utilizza un file PDF per generare potenziali domande degli utenti.

import { genkit, run, z } from "genkit";
import { googleAI, gemini15Flash } from "@genkit-ai/googleai";
import { chunk } from "llm-chunk"; // npm i llm-chunk
import path from "path";
import { readFile } from "fs/promises";
import pdf from "pdf-parse"; // npm i pdf-parse

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;

async function extractText(filePath: string) {
  const pdfFile = path.resolve(filePath);
  const dataBuffer = await readFile(pdfFile);
  const data = await pdf(dataBuffer);
  return data.text;
}

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.
    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;
  }
);

Puoi quindi utilizzare questo comando per esportare i dati in un file e utilizzarli per la valutazione.

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