Evaluación

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

Firebase Genkit admite herramientas de evaluación de terceros mediante 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 como entradas, información y salidas de pasos intermedios para evaluar la calidad de extremo a extremo de las respuestas de LLM y comprender el rendimiento de los componentes básicos de tu sistema.

Por ejemplo, si tienes un flujo RAV, Genkit extrae el conjunto de documentos que muestra el retriever para que puedas evaluar la calidad de tu retriever mientras se ejecuta en el contexto del flujo, como se muestra a continuación con las métricas de fidelidad y para responder a las métricas de Genkit:

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

export default configureGenkit({
  plugins: [
    genkitEval({
      judge: geminiPro,
      metrics: [GenkitMetric.FAITHFULNESS, GenkitMetric.ANSWER_RELEVANCY],
      embedder: textEmbeddingGecko, // GenkitMetric.ANSWER_RELEVANCY requires an embedder
    }),
  ],
  // ...
});

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

Para comenzar, define un conjunto de entradas que desees usar como un conjunto de datos de entrada llamado testQuestions.json. Este conjunto de datos de entrada representa los casos de prueba que usarás para generar resultados para la evaluación.

[
  "What is on the menu?",
  "Does the restaurant have clams?",
  "What is the special of the day?"
]

Luego, puedes usar el comando eval:flow para evaluar el flujo en comparación con los casos de prueba proporcionados en testQuestions.json.

genkit eval:flow menuQA --input testQuestions.json

Luego, puedes ver los resultados de la evaluación en la IU para desarrolladores si ejecutas lo siguiente:

genkit start

Luego, navega a localhost:4000/evaluate.

Como alternativa, puedes proporcionar un archivo de salida para inspeccionarlo en un archivo JSON.

genkit eval:flow menuQA --input testQuestions.json --output eval-result.json

Evaluadores compatibles

Evaluadores de Genkit

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

  • Fidelidad
  • Relevancia de las respuestas
  • Contenido malicioso

Complementos del evaluador

Genkit admite evaluadores adicionales a través de complementos:

Uso avanzado

eval:flow es una forma conveniente de evaluar el flujo con rapidez, pero a veces es posible que necesites más control sobre los pasos de evaluación. Esto puede ocurrir si usas un framework diferente y ya tienes algún resultado que deseas evaluar. Puedes realizar todos los pasos que realiza eval:flow 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 sobre las 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 caso de prueba 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 retrievers y agregará los documentos producidos al array de contexto. De forma predeterminada, eval:run se ejecutará para 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 usar en los comandos eval:extractData y eval:flow. Los extractores personalizados te permiten anular la lógica de extracción predeterminada, lo que te da más poder para crear conjuntos de datos y evaluarlos.

Para configurar los extractores personalizados, agrega un archivo de configuración de herramientas llamado genkit-tools.conf.js a la raíz del 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: [
    {
      flowName: 'myFlow',
      extractors: {
        context: { outputOf: 'foo-step' },
        output: 'bar-step',
      },
    },
  ],
};

En esta muestra, configurarás un extractor para el flujo de myFlow. La configuración anula los extractores para 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, cuyo alcance es flowName.
  • extractors es un objeto que especifica las anulaciones del extractor. Las claves admitidas actualmente en extractors son [input, output, context]. Los tipos de valores aceptables son los siguientes:
    • string: Este debe ser un nombre de paso, especificado como una mezcla. Se extrae el resultado de este paso 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 registro de Genkit y muestre un string, y especifica 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.

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 resultados en una ubicación diferente, usa la marca --output.

genkit eval:flow menuQA --input testQuestions.json --output customLabel_evalresult.json

Para realizar la ejecución en un subconjunto de 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

Sintetizar datos de prueba con un LLM

A continuación, se muestra un flujo de ejemplo que usa un archivo PDF para generar las posibles preguntas que los usuarios podrían hacer al respecto.

export const synthesizeQuestions = defineFlow(
  {
    name: 'synthesizeQuestions',
    inputSchema: z.string().describe('PDF file path'),
    outputSchema: z.array(z.string()),
  },
  async (filePath) => {
    filePath = path.resolve(filePath);
    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 generate({
        model: geminiPro,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text());
    }
    return questions;
  }
);

A continuación, puedes usar este comando para exportar los datos a un archivo y utilizarlos para evaluación.

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