Evaluación

La evaluación es una forma de prueba que te ayuda a validar las respuestas de tu LLM y asegurarte de 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.

Tipos de evaluación

Genkit admite dos tipos de evaluación:

  • Evaluación basada en inferencias: Este tipo de evaluación se ejecuta en una recopilación de entradas predeterminadas y evalúa los resultados correspondientes en cuanto a calidad.

    Este es el tipo de evaluación más común y adecuado para la mayoría de los casos de uso. Este enfoque prueba el resultado real de un sistema para cada ejecución de evaluación.

    Puedes realizar la evaluación de calidad de forma manual inspeccionando visualmente los resultados. Como alternativa, puedes automatizar la evaluación con una métrica de evaluación.

  • Evaluación sin procesar: Este tipo de evaluación evalúa directamente la calidad de las entradas sin ninguna inferencia. Por lo general, este enfoque se usa con la evaluación automática mediante métricas. Todos los campos obligatorios para la evaluación (p.ej., input, context, output y reference) deben estar presentes en el conjunto de datos de entrada. Esto es útil cuando tienes datos que provienen de una fuente externa (p.ej., recopilados de tus registros de producción) y deseas tener una medición objetiva de la calidad de los datos recopilados.

    Para obtener más información, consulta la sección Uso avanzado de esta página.

En esta sección, se explica cómo realizar una evaluación basada en inferencias con Genkit.

Inicio rápido

Configuración

  1. Usa una app de Genkit existente o crea una nueva siguiendo nuestra guía de [Introducción](get-started).
  2. Agrega el siguiente código para definir una aplicación de RAG simple que se evaluará. En esta guía, usamos un recuperador simulado que siempre muestra los mismos documentos. ```js import { genkit, z, Document } from "genkit"; import { googleAI, gemini15Flash, gemini15Pro, } from "@genkit-ai/googleai"; // Initialize Genkit export const ai = genkit ({ plugins: [ googleAI(), ] }); // Dummy retriever that always returns the same docs export const dummyRetriever = ai.defineRetriever( { name: "dummyRetriever", }, async (i) => { const facts = [ "Dog is man's best friend", "Dogs have evolved and were domesticated from wolves", ]; // Just return facts as documents. return { documents: facts.map((t) => Document.fromText(t)) }; } ); // Un flujo simple de respuesta a preguntas 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: `Answer this question with the given context ${query}`, docs: factDocs, }); return llmResponse.text; } ); ```
  3. Agrega métricas de evaluación a tu aplicación para usarlas durante la evaluación (opcional). En esta guía, se usa la métrica "MALICIOUSNESS" del complemento "genkitEval". ```js import { genkitEval, GenkitMetric } from "@genkit-ai/evaluator"; import { gemini15Pro } from "@genkit-ai/googleai"; export const ai = genkit ({ plugins: [ ... // Add this plugin to your Genkit initialization block genkitEval({ judge: gemini15Pro, metrics: [GenkitMetric.MALICIOUSNESS], }), ] }); ``` **Nota:** La configuración anterior requiere la instalación del paquete [`@genkit-ai/evaluator`](https://www.npmjs.com/package/@genkit-ai/evaluator). ```posix-terminal npm install @genkit-ai/evaluator ```
  4. Inicia tu aplicación de Genkit ```posix-terminal genkit start -- ```

Crea un conjunto de datos

Crea un conjunto de datos para definir los ejemplos que queremos usar para evaluar nuestro flujo.

  1. Ve a la IU de Dev en http://localhost:4000 y haz clic en el botón Conjuntos de datos para abrir la página Datasets.

  2. Haz clic en el botón Crear conjunto de datos para abrir el diálogo correspondiente.

    a. Proporciona un datasetId para tu nuevo conjunto de datos. En esta guía, se usa myFactsQaDataset.

    b. Selecciona el tipo de conjunto de datos Flow.

    c. Deja el campo de objetivo de validación vacío y haz clic en Guardar.

  3. Aparecerá la página del nuevo conjunto de datos, que mostrará un conjunto de datos vacío. Para agregar ejemplos, sigue estos pasos:

    a. Haz clic en el botón Agregar ejemplo para abrir el panel del editor de ejemplos.

    b. Solo se requiere el campo input. Ingresa "Who is man's best friend?" en el campo input y haz clic en Guardar para agregar el ejemplo a tu conjunto de datos.

    c. Repite los pasos (a) y (b) un par de veces más para agregar más ejemplos. En esta guía, se agregan las siguientes entradas de ejemplo al conjunto de datos:

    "Can I give milk to my cats?"
"From which animals did dogs evolve?"

    Al final de este paso, tu conjunto de datos debería tener 3 ejemplos, con los valores mencionados anteriormente.

Ejecuta la evaluación y visualiza los resultados

Para comenzar a evaluar el flujo, haz clic en la pestaña Evaluations de la IU para desarrolladores y, luego, en el botón Run new evaluation.

  1. Selecciona el botón de selección Flow para evaluar un flujo.

  2. Selecciona qaFlow como el flujo objetivo que se evaluará.

  3. Selecciona myFactsQaDataset como el conjunto de datos de destino que se usará para la evaluación.

  4. Si instalaste una métrica de evaluador con complementos de Genkit, puedes ver estas métricas en esta página (opcional). Selecciona las métricas que deseas usar con esta ejecución de evaluación. Esto es completamente opcional: si omites este paso, se mostrarán los resultados en la ejecución de evaluación, pero sin ninguna métrica asociada.

  5. Por último, haz clic en Run evaluation para iniciar la evaluación. Según el flujo que estés probando, esto puede tardar un poco. Una vez que se complete la evaluación, aparecerá un mensaje de éxito con un vínculo para ver los resultados. Haz clic en el vínculo para ir a la página Detalles de la evaluación.

En esta página, puedes ver los detalles de tu evaluación, incluida la entrada original, el contexto extraído y las métricas (si las hay).

Conceptos básicos

Terminología

  • Evaluación: Una evaluación es un proceso que evalúa el rendimiento del sistema. En Genkit, ese sistema suele ser una primitiva de Genkit, como un flujo o un modelo. Una evaluación puede ser automática o manual (evaluación humana).

  • Inferencia masiva: La inferencia es el acto de ejecutar una entrada en un flujo o modelo para obtener el resultado correspondiente. La inferencia masiva implica realizar inferencias en varias entradas de forma simultánea.

  • Métrica: Una métrica de evaluación es un criterio en el que se obtiene una puntuación de inferencia. Entre los ejemplos, se incluyen la exactitud, la fidelidad, la maliciosidad, si el resultado está en inglés, etcétera.

  • Conjunto de datos: Un conjunto de datos es una colección de ejemplos que se usan para la evaluación basada en inferencias. Por lo general, un conjunto de datos consta de campos input y reference opcionales. El campo reference no afecta el paso de inferencia de la evaluación, pero se pasa textualmente a cualquier métrica de evaluación. En Genkit, puedes crear un conjunto de datos a través de la IU para desarrolladores. Hay dos tipos de conjuntos de datos en Genkit: conjuntos de datos de flujo y conjuntos de datos de modelo.

Validación de esquema

Según el tipo, los conjuntos de datos admiten la validación de esquemas en la IU para desarrolladores:

  • Los conjuntos de datos de flujo admiten la validación de los campos input y reference del conjunto de datos en función de un flujo en la aplicación de Genkit. La validación de esquemas es opcional y solo se aplica si se especifica un esquema en el flujo de destino.

  • Los conjuntos de datos de modelos tienen un esquema implícito que admite tipos de entrada string y GenerateRequest. La validación de cadenas proporciona una forma conveniente de evaluar instrucciones de texto simples, mientras que GenerateRequest proporciona un control completo para casos de uso avanzados (p. ej., proporcionar parámetros de modelos, historial de mensajes, herramientas, etc.). Puedes encontrar el esquema completo de GenerateRequest en nuestros documentos de referencia de la API.

Evaluadores admitidos

Evaluadores de Genkit

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

  • Fidelidad: Mide la coherencia fáctica de la respuesta generada en función del contexto determinado.
  • Relevancia de la respuesta: Evalúa qué tan pertinente es la respuesta generada para la instrucción proporcionada.
  • Maliciosa: Mide si el resultado generado tiene la intención de engañar, dañar o explotar.

Complementos de evaluación

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

Uso avanzado

Evaluación con la CLI

La CLI de Genkit proporciona una API enriquecida para realizar evaluaciones. Esto es útil, en particular, en entornos en los que la IU para desarrolladores no está disponible (p.ej., en un flujo de trabajo de CI/CD).

Genkit CLI proporciona 3 comandos de evaluación principales: eval:flow, eval:extractData y eval:run.

Comando eval:flow

El comando eval:flow ejecuta una evaluación basada en inferencias en un conjunto de datos de entrada. Este conjunto de datos se puede proporcionar como un archivo JSON o haciendo referencia a un conjunto de datos existente en tu entorno de ejecución de 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

Aquí, testInputs.json debe ser un array de objetos que contenga un campo input y un campo reference opcional, como se muestra a continuación:

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

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

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

De forma predeterminada, los comandos eval:flow y eval:run usan todas las métricas disponibles para la evaluación. 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:flow qaFlow --input testInputs.json --evaluators=genkit/faithfulness,genkit/answer_relevancy

Puedes ver los resultados de la ejecución de evaluación en la IU para desarrolladores en localhost:4000/evaluate.

Comandos eval:extractData y eval:run

Para admitir la evaluación sin procesar, Genkit proporciona herramientas para extraer datos de los seguimientos y ejecutar métricas de evaluación en los datos extraídos. Esto es útil, por ejemplo, si usas un framework diferente para la evaluación o si recopilas inferencias de un entorno diferente para probar la calidad de los resultados de forma local.

Puedes ejecutar por lotes tu flujo de Genkit y agregar una etiqueta única a la ejecución, que luego se puede usar para extraer un conjunto de datos de evaluación. Un conjunto de datos de evaluación sin procesar es una recopilación de entradas para las métricas de evaluación, sin ejecutar ninguna inferencia previa.

Ejecuta el flujo en las entradas de prueba:

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

Extrae los datos de evaluación:

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

Los datos exportados tienen un formato diferente al formato del conjunto de datos que se presentó antes. Esto se debe a que estos datos están diseñados para usarse directamente con las métricas de evaluación, sin ningún paso de inferencia. Esta es la sintaxis de los datos extraídos.

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

El extractor de datos localiza automáticamente los recuperadores y agrega los documentos generados al array de contexto. Puedes ejecutar métricas de evaluación en este conjunto de datos extraído con el comando eval:run.

genkit eval:run factsEvalDataset.json

De forma predeterminada, eval:run se ejecuta en todos los evaluadores configurados y, al igual que con eval:flow, los resultados de eval:run aparecen en la página de evaluación de la IU de desarrollador, ubicada en localhost:4000/evaluate.

Extractores personalizados

Genkit proporciona una lógica predeterminada razonable para extraer los campos necesarios (input, output y context) mientras se realiza una evaluación. Sin embargo, es posible que necesites más control sobre la lógica de extracción de estos campos. Genkit admite extractores personalizados para lograr esto. Puedes proporcionar extractores personalizados para usar en los comandos eval:extractData y eval:flow.

Primero, como paso preparatorio, introduce un paso auxiliar en nuestro ejemplo de qaFlow:

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

A continuación, configura un extractor personalizado para usar el resultado del paso factModified cuando evalúes este flujo.

Si no tienes un archivo tools-config para configurar extractores personalizados, agrega uno llamado genkit-tools.conf.js a la raíz de tu proyecto.

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

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

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

Esta configuración anula los extractores predeterminados de las herramientas de Genkit y, en particular, cambia lo que se considera context cuando se evalúa este flujo.

Si vuelves a ejecutar la evaluación, se revela que el contexto ahora se propaga como el resultado del paso factModified.

genkit eval:flow qaFlow --input testInputs.json

Los extractores de evaluación se especifican de la siguiente manera:

  • 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 mayor flexibilidad, puedes proporcionar una función que acepte un seguimiento de Genkit y muestre un valor de tipo any, 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 de todos estos extractores son del tipo correspondiente al extractor. Por ejemplo, si usas context: { outputOf: 'foo-step' } y foo-step muestra un array de objetos, el contexto extraído también es un array de objetos.

Cómo sintetizar datos de prueba con un LLM

Este es un flujo de ejemplo que usa un archivo PDF para generar posibles preguntas del usuario.

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

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