Evaluación

Las evaluaciones son una forma de prueba que te ayuda a validar las respuestas de tu LLM y a garantizar que cumplan con tu nivel de calidad.

Firebase Genkit admite herramientas de evaluación de terceros a través de complementos, junto con funciones de observabilidad potentes que proporcionan estadísticas sobre el estado del entorno de ejecución de tus aplicaciones potenciadas por LLM. Las herramientas de Genkit te ayudan a extraer automáticamente datos, incluidas las entradas, las salidas y la información de los pasos intermedios para evaluar la calidad de extremo a extremo de las respuestas de LLM, así como comprender el rendimiento de los componentes básicos de tu sistema.

Por ejemplo, si tienes un flujo de RAG, Genkit extraerá el conjunto de documentos que mostró el recuperador para que puedas evaluar la calidad de tu recuperador mientras se ejecuta en el contexto del flujo, como se muestra a continuación con las métricas de fidelidad y relevancia de las respuestas de Genkit:

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

Nota: La configuración anterior requiere la instalación de los paquetes genkit, @genkit-ai/googleai, @genkit-ai/evaluator y @genkit-ai/vertexai.

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

Comienza por definir un conjunto de entradas que deseas usar como conjunto de datos de entrada llamado testInputs.json. Este conjunto de datos de entrada representa los casos de prueba que usarás para generar resultados para la evaluación.

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

Si el evaluador requiere un resultado de referencia para evaluar un flujo, puedes pasar la entrada y el resultado de referencia con este formato:

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

Ten en cuenta que puedes usar cualquier tipo de datos JSON en el archivo JSON de entrada. Genkit los pasará junto con el mismo tipo de datos a tu flujo.

Luego, puedes usar el comando eval:flow para evaluar tu flujo en función de los casos de prueba proporcionados en testInputs.json.

genkit eval:flow menuSuggestionFlow --input testInputs.json

Si tu flujo requiere autenticación, puedes especificarla con el argumento --auth:

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

Luego, puedes ejecutar el siguiente comando para ver los resultados de la evaluación en la IU para desarrolladores:

genkit start

Luego, navega a localhost:4000/evaluate.

Como alternativa, puedes proporcionar un archivo de salida para inspeccionar el resultado en un archivo JSON.

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

Nota: A continuación, puedes ver un ejemplo de cómo un LLM puede ayudarte a generar los casos de prueba.

Evaluadores admitidos

Evaluadores de Genkit

Genkit incluye una pequeña cantidad de evaluadores nativos, inspirados en RAGAS, para ayudarte a comenzar:

• Fidelidad
• Relevancia de la respuesta
• Maliciosa

Complementos de evaluación

Genkit admite evaluadores adicionales a través de complementos, como los evaluadores rápidos de VertexAI a través del complemento de VertexAI.

Uso avanzado

eval:flow es una forma conveniente de evaluar rápidamente el flujo, pero, a veces, es posible que necesites más control sobre los pasos de evaluación. Esto puede ocurrir si usas un marco de trabajo diferente y ya tienes algunos resultados que te gustaría evaluar. Puedes realizar todos los pasos que eval:flow realiza de forma semimanual.

Puedes ejecutar por lotes tu flujo de Genkit y agregar una etiqueta única a la ejecución, que luego se usará para extraer un conjunto de datos de evaluación (un conjunto de entradas, salidas y contextos).

Ejecuta el flujo en tus entradas de prueba:

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

Extrae los datos de evaluación:

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

Los datos exportados se mostrarán como un archivo JSON con cada testCase en el siguiente formato:

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

El extractor de datos ubicará automáticamente los recuperadores y agregará los documentos producidos al array de contexto. De forma predeterminada, eval:run se ejecutará en todos los evaluadores configurados y, al igual que eval:flow, los resultados de eval:run aparecerán en la página de evaluación de la IU para desarrolladores, ubicada en localhost:4000/evaluate.

Extractores personalizados

También puedes proporcionar extractores personalizados para usarlos en los comandos eval:extractData y eval:flow. Los extractores personalizados te permiten anular la lógica de extracción predeterminada, lo que te brinda más poder para crear conjuntos de datos y evaluarlos.

Para configurar extractores personalizados, agrega un archivo de configuración de herramientas llamado genkit-tools.conf.js a la raíz de tu proyecto si aún no tienes uno.

cd $GENKIT_PROJECT_HOME
touch genkit-tools.conf.js

En el archivo de configuración de herramientas, agrega el siguiente código:

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

En este ejemplo, configuras un extractor para el flujo de myFlow. La configuración anula los extractores de los campos context y output, y usa la lógica predeterminada para el campo input.

La especificación de los extractores de evaluación es la siguiente:

• El campo evaluators acepta un array de objetos EvaluatorConfig, que se asignan a flowName.
• extractors es un objeto que especifica las anulaciones del extractor. Las claves compatibles actuales en extractors son [input, output, context]. Los tipos de valor aceptables son los siguientes:
  • string: Debe ser un nombre de paso especificado como una cadena. El resultado de este paso se extrae para esta clave.
  • { inputOf: string } o { outputOf: string }: Estos objetos representan canales específicos (entrada o salida) de un paso. Por ejemplo, { inputOf: 'foo-step' } extraería la entrada del paso foo-step para esta clave.
  • (trace) => string;: Para obtener mayor flexibilidad, puedes proporcionar una función que acepte un registro de Genkit y muestre un string, y especificar la lógica de extracción dentro de esta función. Consulta genkit/genkit-tools/common/src/types/trace.ts para obtener el esquema exacto de TraceData.

Nota: Los datos extraídos para todos estos pasos serán una cadena JSON. Las herramientas analizarán esta cadena JSON automáticamente en el momento de la evaluación. Si proporcionas un extractor de funciones, asegúrate de que el resultado sea una cadena JSON válida. Por ejemplo, "Hello, world!" no es un JSON válido, pero "\"Hello, world!\"" sí lo es.

Ejecución en conjuntos de datos existentes

Para ejecutar la evaluación en un conjunto de datos ya extraído, haz lo siguiente:

genkit eval:run customLabel_dataset.json

Para generar un resultado en una ubicación diferente, usa la marca --output.

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

Para ejecutarlo en un subconjunto de los evaluadores configurados, usa la marca --evaluators y proporciona una lista de evaluadores separados por comas por nombre:

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

Cómo sintetizar datos de prueba con un LLM

Este es un flujo de ejemplo que usa un archivo PDF para generar posibles preguntas que los usuarios podrían hacer al respecto.

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

Luego, puedes usar este comando para exportar los datos a un archivo y usarlos para la evaluación.

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