Avaliação

As avaliações são uma forma de teste que ajuda a validar as respostas do LLM e garantir que elas atendam ao seu padrão de qualidade.

O Firebase Genkit é compatível com ferramentas de avaliação de terceiros por meio de plug-ins, combinado com recursos avançados de observabilidade que fornecem insights sobre o estado do ambiente de execução de seus aplicativos com LLM. As ferramentas do Genkit ajudam a extrair automaticamente dados, incluindo entradas, saídas e informações de etapas intermediárias, para avaliar a qualidade de ponta a ponta das respostas do LLM, bem como entender o desempenho dos elementos básicos do seu sistema.

Por exemplo, se você tiver um fluxo RAG, o Genkit extrairá o conjunto de documentos retornado pelo recuperador para que você possa avaliar a qualidade do recuperador enquanto ele é executado no contexto do fluxo, conforme mostrado abaixo com a fidelidade do Genkit e responder às métricas de relevância:

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

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

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

Comece definindo um conjunto de entradas que você quer usar como um conjunto de dados de entrada chamado testInputs.json. Esse conjunto de dados de entrada representa os casos de teste que você vai usar para gerar saídas para avaliação.

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

Em seguida, use o comando eval:flow para avaliar seu fluxo em relação aos casos de teste fornecidos em testInputs.json.

genkit eval:flow menuSuggestionFlow --input testInputs.json

Veja os resultados da avaliação na interface do desenvolvedor executando:

genkit start

Em seguida, navegue até localhost:4000/evaluate.

Como alternativa, forneça um arquivo de saída para inspecionar a saída em um arquivo json.

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

Avaliadores aceitos

Avaliadores do Genkit

O Genkit tem um pequeno número de avaliadores nativos, inspirados no RAGAS, para ajudar você a começar:

  • Lealdade
  • Relevância da resposta
  • Mal-estar

Plug-ins do Evaluator

O Genkit oferece suporte a avaliadores adicionais por meio de plug-ins:

Uso avançado

eval:flow é uma maneira conveniente de avaliar rapidamente o fluxo, mas às vezes você pode precisar de mais controle sobre as etapas de avaliação. Isso pode ocorrer se você estiver usando uma estrutura diferente e já tiver algum resultado que gostaria de avaliar. É possível executar toda a etapa que eval:flow executa semimanualmente.

É possível executar em lote seu fluxo do Genkit e adicionar um rótulo exclusivo à execução que será usado para extrair um conjunto de dados de avaliação (um conjunto de entradas, saídas e contextos).

Execute o fluxo nas entradas de teste:

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

Extraia os dados de avaliação:

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

Os dados exportados serão gerados como um arquivo json com cada testCase no seguinte formato:

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

O extrator de dados localiza automaticamente os recuperadores e adiciona os documentos produzidos à matriz de contexto. Por padrão, eval:run será executado em todos os avaliadores configurados e, assim como eval:flow, os resultados de eval:run serão exibidos na página de avaliação da interface do desenvolvedor, localizada em localhost:4000/evaluate.

Extratores personalizados

Você também pode fornecer extratores personalizados para uso nos comandos eval:extractData e eval:flow. Os extratores personalizados permitem substituir a lógica de extração padrão, oferecendo mais poder para criar e avaliar conjuntos de dados.

Para configurar extratores personalizados, adicione um arquivo de configuração de ferramentas chamado genkit-tools.conf.js à raiz do projeto, se ainda não tiver um.

cd $GENKIT_PROJECT_HOME
touch genkit-tools.conf.js

No arquivo de configuração das ferramentas, adicione o seguinte código:

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

Neste exemplo, você configura um extrator para o fluxo de myFlow. A configuração substitui os extratores para os campos context e output e usou a lógica padrão para o campo input.

A especificação dos extratores de avaliação é a seguinte:

  • O campo evaluators aceita uma matriz de objetos EvaluatorConfig, com escopo flowName
  • extractors é um objeto que especifica as substituições do extrator. As chaves atualmente aceitas em extractors são [input, output, context]. Os tipos de valor aceitáveis são:
    • string: precisa ser o nome da etapa, especificado como um stirng. A saída desta etapa é extraída para essa chave.
    • { inputOf: string } ou { outputOf: string }: esses objetos representam canais específicos (entrada ou saída) de uma etapa. Por exemplo, { inputOf: 'foo-step' } extrairia a entrada da etapa foo-step para essa chave.
    • (trace) => string;: para mais flexibilidade, você pode fornecer uma função que aceite um rastro do Genkit e retorne um string, além de especificar a lógica de extração dentro dessa função. Consulte genkit/genkit-tools/common/src/types/trace.ts para saber o esquema exato do TraceData.

Como executar em conjuntos de dados atuais

Para executar uma avaliação em um conjunto de dados já extraído:

genkit eval:run customLabel_dataset.json

Para enviar para um local diferente, use a sinalização --output.

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

Para executar em um subconjunto dos avaliadores configurados, use a flag --evaluators e forneça uma lista separada por vírgulas de avaliadores por nome:

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

Sintetizar dados de teste usando um LLM

Veja um exemplo de fluxo que usa um arquivo PDF para gerar possíveis perguntas que os usuários possam estar fazendo sobre ele.

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: gemini15Flash,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text());
    }
    return questions;
  }
);

Você pode usar esse comando para exportar os dados para um arquivo e usá-los para avaliação.

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