Avaliação

As avaliações são uma forma de teste que ajuda a validar as respostas do LLM e garantir que elas atendam aos seus critérios de qualidade.

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

Por exemplo, se você tiver um fluxo RAG, o Genkit vai extrair o conjunto de documentos retornados pelo recuperador para que você possa avaliar a qualidade dele enquanto ele é executado no contexto do fluxo, conforme mostrado abaixo, com as métricas de confiabilidade e relevância da resposta do 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

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

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

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

genkit eval:flow menuQA --input testQuestions.json

Para ver os resultados da avaliação na interface do desenvolvedor, execute:

genkit start

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

Outra opção é fornecer um arquivo JSON para inspecionar a saída.

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

Avaliadores compatíveis

Avaliadores do Genkit

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

  • Fidelidade
  • Relevância da resposta
  • Comportamento malicioso

Plug-ins do avaliador

O Genkit é compatível com outros avaliadores 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 biblioteca diferente e já tiver uma saída que gostaria de avaliar. É possível realizar toda a etapa executada pelo eval:flow 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 da 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 localizará automaticamente os recuperadores e adicionará 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 para eval:run aparecerão 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 serem usados nos comandos eval:extractData e eval:flow. Extratores personalizados permitem substituir a lógica de extração padrão, proporcionando mais poder na criação e avaliação de conjuntos de dados.

Para configurar extratores personalizados, adicione um arquivo de configuração de ferramentas chamado genkit-tools.conf.js à raiz do projeto, se você 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 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, que têm o escopo definido por 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 os seguintes:
    • string: precisa ser o nome de uma etapa, especificado como 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 ter mais flexibilidade, forneça uma função que aceite um rastro 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 ver o esquema exato de TraceData.

Como executar em conjuntos de dados atuais

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

genkit eval:run customLabel_dataset.json

Para enviar a saída para um local diferente, use a flag --output.

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

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

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

Como sintetizar dados de teste usando um LLM

Confira um exemplo de fluxo que usa um arquivo PDF para gerar possíveis perguntas que os usuários possam fazer 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: geminiPro,
        prompt: {
          text: `Generate one question about the text below: ${chunks[i]}`,
        },
      });
      questions.push(qResponse.text());
    }
    return questions;
  }
);

Depois, use esse comando para exportar os dados para um arquivo e usá-los na avaliação.

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