Configurer un modèle de juge de base (partie 1)

Exécutez des évaluations subjectives avec un modèle d'évaluation de base.

Maud Nalpas

Les évaluations basées sur des règles peuvent vérifier les réponses déterministes. Pour évaluer les qualités subjectives, utilisez la technique LLM-as-a-judge.

Dans ce module, vous allez apprendre à créer votre premier juge en étiquetant vous-même des données ou avec votre équipe, à l'aide de métriques statistiques de base.

Créer votre premier modèle de juge

1. Choisissez une méthode de personnalisation du modèle. Vous pouvez affiner ou concevoir des requêtes.
2. Sélectionnez un modèle. Il peut s'agir d'un modèle de fondation ou d'un autre LLM sans expertise du domaine.
3. Choisissez une méthode de notation. Déterminez si le juge doit utiliser une échelle binaire ou numérique pour évaluer les thèmes générés par ThemeBuilder.
4. Configurez le juge. Modifiez les paramètres du modèle (comme la température et la sortie structurée) pour l'adapter aux tâches de jugement.
5. Rédigez la requête initiale. Concevez une première version des instructions et du prompt du système de notation, y compris une grille d'évaluation et des exemples.
6. Créez un ensemble de données d'alignement. Créez ou assemblez un ensemble diversifié et de haute qualité de bons et mauvais résultats ThemeBuilder, et étiquetez-les en conséquence (par exemple, une bonne devise, une devise toxique et une palette de couleurs hors marque).
7. Aligner et tester le juge Utilisez l'ensemble de données d'alignement pour affiner de manière itérative l'invite du juge (instructions système et invite principale). Répétez cette procédure jusqu'à ce que les verdicts du juge correspondent systématiquement à ceux des humains. Enfin, testez le juge pour confirmer sa fiabilité et sa capacité à généraliser son approche à de nouvelles entrées.

Choisir une méthode de personnalisation

La plupart des modèles de fondation sont généralistes. Un modèle de jugement agit comme un spécialiste du domaine.

Voici les principales options pour créer un modèle de juge :

1. Concevez des requêtes pour un LLM.
2. Ajustez un modèle.
3. Utilisez un LLM affiné et optimisé pour les évaluations, par exemple JudgeLM. Cette option vous oblige à héberger des poids de modèle personnalisés ou à utiliser un fournisseur de services cloud compatible avec l'hébergement de modèles Open Source.

Pour les évaluations ThemeBuilder de ce cours, nous vous recommandons d'utiliser le prompt engineering. Le prompt engineering peut générer d'excellents résultats avec moins d'efforts de développement que les autres méthodes.

Sélectionnez un modèle

Lorsque vous sélectionnez un modèle pour l'évaluateur, recherchez des capacités de raisonnement solides. Étant donné que vous exécutez des évaluations dans le pipeline CI/CD, la vitesse et le coût sont également essentiels.

Testez différents modèles et techniques pour trouver la solution optimale.

• Commencez par un modèle plus grand et plus puissant pour établir une référence élevée, puis réduisez progressivement la taille des modèles. Vous pouvez également commencer par des modèles plus petits et les étendre.
• Combinez les modèles : utilisez un modèle rapide et économique pour les vérifications quotidiennes des demandes d'extraction, et un modèle plus puissant pour vos tests de version finale. Vous pouvez également combiner un LLM général avec un petit modèle spécialisé pour des tâches spécifiques comme la détection de toxicité, afin de gagner en rapidité.

Ce cours utilise Gemini 3 Flash comme modèle évaluateur. Gemini 3 Flash offre la rapidité et la profondeur de raisonnement requises pour l'exemple de cas d'utilisation de l'évaluation des résultats ThemeBuilder. Toutefois, les modèles de ce cours peuvent être appliqués à n'importe quel modèle que vous sélectionnez.

Choisir une méthode de notation

Vous pouvez évaluer les résultats subjectifs avec des libellés binaires PASS et FAIL, ou avec un score numérique (par exemple, "Sur une échelle de 1 à 5, dans quelle mesure cette devise est-elle conforme à la marque ?").

Nous vous recommandons d'utiliser des libellés binaires.

Bien qu'un score numérique puisse sembler intuitif, les recherches montrent que les LLM (et les humains) ont tendance à regrouper leurs scores au milieu ou à les gonfler par politesse. Les catégories ou les libellés binaires tels que PASS et FAIL donnent souvent de meilleurs résultats, car ils obligent le modèle à prendre une décision claire. Pour les humains, on parle d'effet d'évaluateur.

Configurer le juge

Utilisez des paramètres et des instructions pour aider votre juge à créer des résultats cohérents et structurés.

• Définissez des instructions système : Donnez au juge un persona d'expert strict.
• Définir la température ou le niveau de réflexion : le juge doit être cohérent. Si vous utilisez un modèle de raisonnement comme Gemini Flash, qui nécessite une légère part d'aléatoire pour passer d'une étape logique à l'autre, conservez la température par défaut, mais définissez thinking_level sur HIGH. Si vous utilisez un autre modèle, définissez la température sur 0 ou une valeur proche de 0. Dans tous les cas, utilisez la technique de la chaîne de pensée pour que le modèle réfléchisse avant de prendre une décision.
• Structurez la sortie du juge : un objet JSON prévisible est beaucoup plus facile à réutiliser dans le reste de votre code. Utilisez un schéma EvalResult qui nécessite un label (PASS ou FAIL) et une chaîne rationale.

Dans votre exemple 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"
}

Consultez l'exemple de code complet.

Rédiger la requête initiale

Vous avez déjà configuré les instructions système. Maintenant, concevez la requête principale du juge. À ce stade, créez votre première version de cette requête. Vous l'affinerez de manière itérative lorsque vous alignerez le juge à l'étape suivante.

L'efficacité du juge dépend des instructions fournies. Évitez de poser une question générique, comme "Cette devise est-elle bonne ?", où bonne n'est pas défini. Au lieu de cela, structurez votre requête pour obtenir des résultats clairs et cohérents.

• Définissez la grille d'évaluation : fournissez au juge des consignes de notation détaillées. Quel est le ton attendu pour un résultat idéal ? Un LLM peut vous aider à rédiger la grille d'évaluation.
• Utilisez le prompting few-shot : incluez des exemples PASS et FAIL.
• Utilisez le prompting par chaîne de pensée : demandez au modèle d'écrire la justification avant d'attribuer un libellé, car cela peut améliorer considérablement la justesse. Ce n'est pas aussi important en mode réflexion HIGH, mais cela reste une bonne pratique.

Rédigez trois requêtes de notation distinctes pour les trois critères spécifiques :

• Adéquation de la marque avec la devise.
• Couleurs adaptées à la marque.
• Toxicité. L'invite de toxicité peut être amorcée à partir des attributs de toxicité issus du crowdsourcing.

Dans chaque requête, incluez une grille d'évaluation claire et des exemples few-shot avec une explication. Dans les exemples few-shot, listez la justification avant le score réel pour appliquer le modèle de chaîne de pensée et montrer comment le juge raisonne.

Vous trouverez les invites complètes dans le dépôt de code. Par exemple, la requête de juge de pertinence de la devise de la marque se présente comme suit :

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}"`;
}

Aligner et tester

Lisez Configurer un juge de base, partie 2 pour terminer de créer le juge avec l'alignement et les tests.