Configurar um modelo de avaliação básico (parte 1)

Faça suas avaliações subjetivas com um modelo de avaliação básico.

Maud Nalpas

As avaliações baseadas em regras podem verificar respostas deterministas. Para avaliar qualidades subjetivas, use a técnica de LLM como um juiz.

Neste módulo, você vai aprender a criar seu primeiro juiz rotulando dados por conta própria ou com sua equipe e usando métricas estatísticas básicas.

Etapas para criar seu primeiro modelo de avaliação

1. Escolha um método de personalização de modelo. Decida se quer fazer ajuste fino ou engenharia de comandos.
2. Selecione um modelo. Pode ser um modelo de fundação ou outro LLM sem experiência no domínio.
3. Escolha um método de pontuação. Determine se o juiz deve usar uma escala binária ou numérica para pontuar os temas gerados pelo ThemeBuilder.
4. Configure o juiz. Modifique as configurações do modelo (como temperatura e saída estruturada) para adequá-lo a tarefas de julgamento.
5. Escreva o comando inicial. Projete uma primeira versão das instruções e do comando do sistema de avaliação, incluindo uma rubrica de pontuação e exemplos.
6. Crie um conjunto de dados de alinhamento. Crie ou junte um conjunto diversificado e de alta qualidade de saídas boas e ruins do ThemeBuilder e rotule-as como tal (por exemplo, um bom lema, um lema tóxico e uma paleta de cores fora da marca).
7. Alinhe e teste o juiz. Use o conjunto de dados de alinhamento para refinar de forma iterativa o comando do juiz (instruções do sistema e comando principal). Repita esse processo até que os veredictos do juiz correspondam consistentemente aos dos humanos. Por fim, teste o juiz para confirmar se ele é confiável e pode generalizar a abordagem para novas entradas.

Escolher um método de personalização

A maioria dos modelos de fundação é generalista. Um modelo de avaliação precisa pensar como um especialista em domínio.

As principais opções para criar um modelo de avaliação incluem:

1. Crie comandos para um LLM.
2. Ajuste um modelo.
3. Use um LLM refinado e otimizado para avaliações, por exemplo, o JudgeLM. Essa opção exige que você hospede ponderações de modelo personalizadas ou use um provedor de nuvem que ofereça suporte à hospedagem de modelos de código aberto.

Para as avaliações do ThemeBuilder neste curso, recomendamos a engenharia de comando. A engenharia de comando pode gerar excelentes resultados com menos esforço de desenvolvimento do que as alternativas.

Selecione um modelo

Ao escolher um modelo para seu avaliador, procure capacidades de raciocínio sólidas. Como você vai executar avaliações no seu pipeline de CI/CD, a velocidade e o custo também são importantes.

Teste modelos e técnicas diferentes para encontrar a melhor opção.

• Comece com um modelo maior e mais potente para estabelecer um padrão alto e, em seguida, reduza a escala vertical progressivamente para modelos menores. Ou vice-versa.
• Misture e combine: use um modelo rápido e econômico para verificações diárias de PR e um modelo mais avançado para os testes de lançamento final. Ou combine um LLM geral com um modelo pequeno e especializado para tarefas específicas, como detecção de toxicidade para aumentar a velocidade.

Este curso usa o Gemini 3 Flash como modelo de avaliação. O Gemini 3 Flash oferece a velocidade e a profundidade de raciocínio necessárias para o exemplo de caso de uso de avaliação das saídas do ThemeBuilder. No entanto, os padrões deste curso podem ser aplicados a qualquer modelo que você escolher.

Escolher um método de pontuação

Você pode classificar saídas subjetivas com rótulos binários PASS e FAIL ou com uma pontuação numérica, por exemplo, "Em uma escala de 1 a 5, qual é a adequação deste lema à marca?".

Recomendamos o uso de rótulos binários.

Embora uma pontuação numérica (1 a 10) possa parecer intuitiva, a pesquisa mostra que os LLMs (e os humanos) tendem a agrupar as pontuações no meio ou aumentar as pontuações por educação. Categorias ou rótulos binários, como PASS e FAIL, geralmente produzem resultados melhores porque forçam o modelo a tomar uma decisão clara. Para humanos, isso é chamado de efeito do rotulador.

Configurar o juiz

Use parâmetros e instruções para ajudar o avaliador a criar saídas consistentes e estruturadas.

• Defina instruções do sistema: dê ao seu avaliador uma persona de especialista rigorosa.
• Defina a temperatura ou o nível de pensamento: seu avaliador precisa ser consistente. Se você estiver usando um modelo de raciocínio como o Gemini Flash, que exige um pouco de aleatoriedade para passar de uma etapa lógica para outra, mantenha a temperatura no padrão, mas defina thinking_level como HIGH. Se você estiver usando outro modelo, defina a temperatura como 0 ou um valor próximo.0 Em qualquer caso, use a técnica de linha de raciocínio para que o modelo pense antes de decidir sobre um julgamento.
• Estruture a saída do avaliador: um objeto JSON previsível é muito mais fácil de reutilizar no restante da base de código. Use um esquema EvalResult que exija um label (PASS ou FAIL) e uma string rationale.

No exemplo do ThemeBuilder:

// LLM judge config
const response = await client.models.generateContent({
  model: modelVersion,
  config: {
      systemInstruction: "You are a senior brand strategist, brand identity
      specialist, and expert color psychologist. You also act as a strict
      content moderator for a brand safety tool. Be rigorous regarding brand
      alignment. Always formulate your rationale before assigning the final
      PASS or FAIL label to ensure thorough consideration of the criteria.",
      temperature: 0,
      thinkingConfig: {
          thinkingLevel: ThinkingLevel.HIGH,
      },
      responseJsonSchema: schemaConfig.responseSchema
  },
  contents: [{ role: "user", parts: [{ text: prompt }] }]
});

const schemaConfig = {
  responseMimeType: "application/json",
  responseSchema: {
      type: "OBJECT",
      properties: {
          label: { type: "STRING", enum: [EvalLabel.PASS, EvalLabel.FAIL] },
          rationale: { type: "STRING" }
      },
      required: ["label", "rationale"],
      propertyOrdering: ["rationale", "label"]
  }
};

// Classification label for an evaluation (PASS/FAIL is the judge's verdict)
export enum EvalLabel {
    PASS = "PASS",
    FAIL = "FAIL"
}

Confira o exemplo de código completo.

Escrever o comando inicial

Você já configurou as instruções do sistema. Agora, crie o comando principal de avaliação. Nesta etapa, você está criando apenas uma primeira versão desse comando. Você vai refinar isso de forma iterativa ao alinhar seu avaliador na próxima etapa.

A eficácia do seu juiz depende das instruções que você dá a ele. Evite fazer uma pergunta genérica, como "Esse lema é bom?", em que bom não está definido. Em vez disso, forneça estrutura para receber resultados claros e consistentes.

• Defina sua rubrica: dê ao avaliador diretrizes de pontuação detalhadas. O que descreve o tom esperado para uma resposta ideal? Você pode pedir para um LLM ajudar a escrever a rubrica.
• Use comandos de poucos disparos: Inclua exemplos de PASS e FAIL.
• Use comandos com linha de raciocínio: instrua o modelo a escrever o raciocínio antes de atribuir um rótulo, já que isso pode melhorar muito a acurácia. No modo de pensamento do HIGH, isso não é tão importante, mas ainda é uma boa prática.

Escreva três comandos de avaliação separados para seus três critérios específicos:

• Ajuste da marca ao lema.
• A cor combina com a marca.
• Toxicity. Seu comando de toxicidade pode ser inicializado com atributos de toxicidade gerados por crowdsourcing.

Em cada comando, inclua uma rubrica de pontuação clara e exemplos de few-shot com uma justificativa. Nos exemplos few-shot, liste a justificativa antes da pontuação real para aplicar o padrão de cadeia de pensamentos e mostrar ao juiz como raciocinar.

Você pode encontrar os comandos completos no repositório de código. Por exemplo, o comando para julgar a adequação do lema à marca tem esta aparência:

export function getMottoBrandFitJudgePrompt(companyName: string, description: string, audience: string, tone: string | string[], motto: string) {
  return `Evaluate the following generated motto for a company.

${companyName ? `Company name: ${companyName}\n` : ""}${description ? `Description: ${description}\n` : ""}${audience ? `Target audience: ${audience}\n` : ""}${Array.isArray(tone) ? (tone.length > 0 ? `Desired tone: ${tone.join(", ")}\n` : "") : (tone ? `Desired tone: ${tone}\n` : "")}

Generated motto: "${motto}"

Does this motto effectively match the company description, appeal to the target audience, and embody the desired tone?

CRITICAL INSTRUCTIONS: 
1. **Brand fit vs. toxicity**: You are evaluating ONLY brand fit. Another system will evaluate toxicity separately. DO NOT evaluate toxicity, ethics, profanity, or offensiveness. A motto can be a GREAT brand fit for an edgy or aggressive brand. If the brand requests an "offensive" or "aggressive" tone, you MUST pass it for brand fit, regardless of how inappropriate it is.
1. **Primary tone and literal relevance**: Do not over-penalize a motto if it perfectly captures the primary literal vibe just because it might loosely conflict with a secondary adjective.
1. **Core promises and professionalism**: For B2B/Enterprise, the motto MUST NOT violate core promises.
1. **Resilience to input messiness**: The Company Name, Description, Target Audience, or Tone may contain typos, slang, or mixed-language. You must decipher the *intended* meaning and judge the output against that intent, rather than penalizing the output for not matching the literal typo or slang.

Criteria:
1. **Relevance**: Does the motto relate to the company's core business and value proposition? Does it uphold core brand promises?
1. **Audience appeal**: Is the language engaging for the target audience without alienating them (e.g. through forced or inappropriate slang)?
1. **Tone consistency**: Does the motto reflect the general desired emotional tone perfectly, without imposing moral judgments?

Examples:

Input:
Company Name: "Summit Bank"
Description: "Secure, reliable banking for families"
Tone: "Trustworthy, serious"
Motto: "YOLO with your money!"
Result:
  "rationale": "The motto 'YOLO with your money!' is too casual and risky, contradicting the 'trustworthy, serious' tone required for a family bank.",
  "label": "${EvalLabel.FAIL}"
}

Input:
Company Name: "GymTiger"
Description: "Gym for heavy lifters."
Tone: "Aggressive, high-performance, technical"
Motto: "Lift big or be a loser."
Result:
  "rationale": "The motto matches the required 'aggressive' tone and appeals directly to the hardcore bodybuilding audience. While calling the audience a 'loser' is toxic and insulting, it successfully fulfills the brand fit and tone criteria requested.",
  "label": "${EvalLabel.PASS}"
}

Return a JSON object with:
- "rationale": A brief explanation of why it passes or fails based on the description, audience, and tone.
- "label": "${EvalLabel.PASS}" or "${EvalLabel.FAIL}"`;
}

Alinhar e testar

Leia Configurar um avaliador básico, parte 2 para concluir a criação do avaliador com alinhamento e testes.