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

Fazer avaliações subjetivas com um modelo de juiz básico

Maud Nalpas

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

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

Criar seu primeiro modelo de juiz

1. Escolha um método de personalização do modelo. Você pode ajustar ou fazer 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 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. Crie uma primeira versão das instruções do sistema de juiz e do comando, incluindo uma rubrica de pontuação e exemplos.
6. Crie um conjunto de dados de alinhamento. Crie ou monte um conjunto diversificado e de alta qualidade de saídas boas e ruins do ThemeBuilder e rotule-as de acordo com o contexto. 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 iterativamente o comando do juiz (instruções do sistema e comando principal). Repita esse processo até que os vereditos do juiz correspondam consistentemente aos vereditos humanos. Por fim, teste o juiz para confirmar a confiabilidade e a capacidade de generalizar a abordagem para novas entradas.

Escolher um método de personalização

A maioria dos modelos de base são generalistas. Um modelo de juiz atua como um especialista no domínio.

As principais opções para criar um modelo de juiz incluem:

1. Fazer engenharia de comandos em um LLM.
2. Ajustar um modelo.
3. Usar um LLM ajustado otimizado para avaliações, por exemplo, JudgeLM. Essa opção exige que você hospede pesos de modelos personalizados 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 comandos. A engenharia de comandos pode oferecer excelentes resultados com menos esforço de desenvolvimento do que as alternativas.

Selecionar um modelo

Ao selecionar um modelo para o juiz, procure recursos de raciocínio fortes. Como você executa avaliações no pipeline de CI/CD, a velocidade e o custo também são essenciais.

Teste diferentes modelos e técnicas para encontrar o ajuste ideal.

• 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. Como alternativa, comece com modelos menores e escale verticalmente.
• Misture e combine: use um modelo rápido e econômico para verificações diárias de solicitação de pull e um modelo mais potente 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 velocidade.

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

Escolher um método de pontuação

É possível pontuar 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, quão bem esse lema adere à marca?".

Recomendamos o uso de rótulos binários.

Embora uma pontuação numérica possa parecer intuitiva, pesquisas mostram que os LLMs (e os humanos) tendem a agrupar as pontuações no meio ou inflacionar as pontuações para serem educados. Categorias ou rótulos binários, como PASS e FAIL geralmente produzem melhores resultados porque forçam o modelo a tomar uma decisão clara. Para os humanos, isso é chamado de efeito de avaliador.

Configurar o juiz

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

• Definir instruções do sistema: Dê ao juiz uma persona de especialista rigorosa.
• Defina a temperatura ou o nível de pensamento: o juiz precisa ser consistente. Se você usar um modelo de raciocínio como o Gemini Flash, que exige uma pequena aleatoriedade para passar entre etapas lógicas, mantenha a temperatura padrão mas defina thinking_level como HIGH. Se você usar outro modelo, defina a temperatura como 0 ou próxima de 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 juiz: 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 completo de código.

Escrever o comando inicial

Você já configurou as instruções do sistema. Agora, crie o comando principal do juiz. Nesta fase, crie sua primeira versão desse comando. Ele será refinado iterativamente ao alinhar o juiz na próxima etapa.

O juiz só é eficaz se as instruções fornecidas forem eficazes. Evite fazer uma pergunta genérica, como "Esse lema é bom?", em que bom não está definido. Em vez disso, forneça uma estrutura para receber saídas claras e consistentes.

• Defina a rubrica: forneça ao juiz diretrizes detalhadas de pontuação. O que descreve o tom esperado para uma saída ideal? Um LLM pode ajudar você a escrever a rubrica.
• Use comandos few-shot: inclua exemplos de PASS e FAIL.
• Use comandos com linha de raciocínio: instrua o modelo a escrever a lógica antes de atribuir um rótulo, já que isso pode melhorar drasticamente a acurácia. No modo de pensamento HIGH, isso não é tão crítico, mas ainda é uma boa prática.

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

• Ajuste da marca do lema.
• Ajuste da marca de cor.
• Toxicidade. O comando de toxicidade pode ser inicializado a partir de atributos de toxicidade de crowdsourcing.

Em cada comando, inclua uma rubrica de pontuação clara e exemplos few-shot com uma lógica. Nos exemplos few-shot, liste a lógica antes da pontuação real para aplicar o padrão de cadeia de pensamento e demonstrar como o juiz raciocina.

Você pode encontrar os comandos completos no repositório de código. Por exemplo, o comando de juiz de ajuste da marca do lema é assim:

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 (such as 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 juiz básico, parte 2 para terminar de criar o juiz com alinhamento e testes.