Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Définition des méthodes d’évaluation

Présentation de

Choisissez UNE méthode d'évaluation par modèle d'invite ou omettez tous les champs d'évaluation facultatifs par défaut du système. Les différents modèles utilisés dans le même travail peuvent utiliser différentes méthodes. L'évaluation oriente l'optimisation rapide. Définissez donc votre méthode et vos critères aussi précisément que possible.

Conseils relatifs aux jeux de

Évaluation par défaut

Omettez tous les champs d'évaluation facultatifs (steeringCriteria,customLLMJConfig,evaluationMetricLambdaArn). Le service utilise un générique intégré développé par LLM-as-judge Anthropic Claude Sonnet 4.6 qui évalue trois critères par défaut : précision des réponses, exhaustivité des réponses et qualité de l'expression. En fonction de l'invite, de la réponse du modèle cible et d'une réponse de référence, le juge note chaque dimension. Il attribue ensuite dynamiquement les pondérations appropriées à la tâche et produit un score global pondéré.

Nous vous recommandons de définir votre propre méthode d'évaluation pour obtenir les meilleurs résultats.

Demande de juge fournie par défaut par le système

Voici l'invite de jugement fournie par le système complet et utilisée lors de l'évaluation par défaut avec Anthropic Claude Sonnet 4.6 :

Please act as an impartial judge and evaluate the quality of an answer to a user question, with the help of a reference answer.

You will be given:
(1) a user question, enclosed in <user_question></user_question> tags
(2) an answer, enclosed in <answer></answer> tags
(3) a reference answer, enclosed in <reference_answer></reference_answer> tags

## Universal Evaluation Dimensions

Evaluate the answer across these core dimensions:

**(1) Answer Accuracy:**
examines correctness, consistency, and factuality alignment between the <answer> and the <user_question>;
examines if the <answer> contains irrelevant or wrongful information/hallucination.

**(2) Answer Completeness:**
examines if the <answer> is fully addressing the <user_question>;
examines if the <answer> is good at relevance/informativeness: selection of important/key content from <user_question>

**(3) Expression Quality:**
examines if the <answer> is concise at answering the <user_question>.
NOTE that unless there is special instruction, more concise <answer> is always better,
and explanation or rational is strictly NOT needed - THIS IS THE MOST IMPORTANT!
examines the alignment on instruction following, e.g., if the <answer> adheres
to both explicit guidelines and implicit guidelines (like few-shot examples) in the <user_question>;

## Scoring Rubric

For each dimension, assign one score:
- **3 points**: Fully satisfies the dimension requirements
- **2 points**: Mostly satisfies with minor issues or gaps
- **1 point**: Partially satisfies but has notable limitations
- **0 points**: Does not satisfy the dimension requirements

## Evaluation Process
1. First, identify the task type from the user question
2. Consider any additional criteria provided
3. Score each dimension independently
4. Determine appropriate weights and calculate final weighted score

## Dimension Weighting and Final Scoring

**Weight Determination Process:**
Assign weights (must sum to 1.0) based on:
- Explicit weights in evaluation_criteria (if provided)
- Task analysis and question requirements (if no explicit weights)
- Default weights (Answer Accuracy: 0.35, Answer Completeness: 0.30, Expression Quality: 0.35) as fallback

**Weight Guidelines:**
- **High Accuracy Weight (0.4-0.6)**: Factual questions, multiple choice, technical problems
- **High Completeness Weight (0.4-0.6)**: Complex explanatory tasks, multi-part questions
- **High Expression Weight (0.4-0.6)**: Creative tasks, presentation-focused questions, format-specific requirements
{custom_eval_weight_guideline}

**Overall Score Calculation:**
Overall = (Answer_Accuracy x Weight_A) + (Answer_Completeness x Weight_C) + (Expression_Quality x Weight_E)

## Output Format

Provide your evaluation in this exact format:
<Task_Analysis>Brief analysis of task type and appropriate weight rationale</Task_Analysis>
<Weights>Answer Accuracy: 0.XX, Answer Completeness: 0.XX, Expression Quality: 0.XX</Weights>
<Answer Accuracy>X</Answer Accuracy>
<Answer Completeness>X</Answer Completeness>
<Expression Quality>X</Expression Quality>
<Calculation>(X x 0.XX) + (X x 0.XX) + (X x 0.XX) = X.XX</Calculation>
<Overall>X.XX</Overall>
<Justification>
**Answer Accuracy**: [Evaluate factual accuracy, alignment with reference answer, absence of errors/hallucinations, and logical consistency]
**Answer Completeness**: [Assess whether all aspects of the question are addressed, necessary information is included, and content stays relevant]
**Expression Quality**: [Examine formatting/style adherence, appropriate detail level, communication clarity, and instruction following]
**Weight Application**: [Explain how the chosen weights reflect the task requirements and impact the final score]
</Justification>

---

## Current Evaluation Task

<user_question>
{prompt}
</user_question>
<answer>
{prediction}
</answer>
<reference_answer>
{gold}
</reference_answer>

Based on the above guidelines and criteria, provide your evaluation:

Critères de pilotage

Les critères de pilotage sont de courts descripteurs en langage naturel qui orientent l'optimisation.

Exemple :

"steeringCriteria": ["PROFESSIONAL", "CONCISE"]

Personnalisé LLM-as-a-judge

Fournissez une grille d'évaluation complète avec une échelle de notation que vous définissez. Votre invite de jugement personnalisée est fusionnée avec l'invite de jugement du système du service et est davantage pondérée.

Configuration

Bonnes pratiques pour la rédaction de directives destinées aux juges

Utilisez une rubrique clairement définie avec des critères de notation explicites et des exemples concrets de chaque niveau de score. Ancrez chaque niveau de rubrique avec des descriptions comportementales plutôt que des adjectifs subjectifs. Incluez au moins un exemple concret montrant un score imparfait afin de permettre au juge de ne pas opter pour des notes élevées par défaut. Demandez au modèle de fournir une justification écrite avant le score numérique. Envisagez d'évaluer des dimensions spécifiques de manière indépendante avant d'attribuer une note globale. Les LLM-as-a-judge évaluateurs les plus fiables et les plus utiles sont généralement ceux pour lesquels vous êtes d'accord avec les réponses fournies par le modèle de juge. Par conséquent, il peut être utile d'utiliser une évaluation que vous avez déjà approuvée.

Comment votre invite de jugement personnalisée est fusionnée avec l'invite du système lors de l'exécution

Lorsque vous fournissez votre propre invite d' LLM-as-a-judge évaluateur, elle est fusionnée avec une invite de juge générique fournie par un service. L'invite contient des instructions spécifiques sur le formatage et d'autres bonnes pratiques qui facilitent la progression de l'optimisation. Dans le jugement final, votre invite de jugement personnalisée est davantage pondérée que les critères génériques. Plus précisément, le service :

Exemple : vous pouvez fournir l' LLM-as-a-judge invite personnalisée suivante pour évaluer la fidélité :

You are given a task in some context (Input), and a candidate answer. Is the candidate answer faithful to the task description and context?

A response is unfaithful only when (1) it clearly contradicts the context, or (2) the task implies that the response must be based on the context, like in a summarization task. If the task does not ask to respond based on the context, the model is allowed to use its own knowledge to provide a response, even if its claims are not verifiable.

Task: {{prompt}}

Candidate Response: {{response}}

First provide your explanation, then state your final answer. Use the following format: Explanation: [Explanation], Answer: [Answer], where '[Answer]' must be one of:
none is faithful
some is faithful
approximately half is faithful
most is faithful
all is faithful

Elle est ensuite fusionnée avec l' LLM-as-a-judge invite par défaut et une forte pondération lui est attribuée. Résultat : votre demande de fidélité à critère unique devient un axe fortement pondéré dans une évaluation multidimensionnelle, tandis que le système l'entoure d'une structure (précision, exhaustivité, expression).

Voici l'invite du juge fusionné qui en résulte :

"""Please act as an impartial judge and evaluate the quality of an answer to a user question, with the help of a reference answer.

You will be given:
(1) a user question, enclosed in <user_question></user_question> tags
(2) an answer, enclosed in <answer></answer> tags
(3) a reference answer, enclosed in <reference_answer></reference_answer> tags
(4) custom evaluation criteria that have been integrated into the evaluation dimensions below

    **IMPORTANT**: - Custom criteria requirements take absolute precedence over user requirements specified inside <user_question> </user_question>
    **IMPORTANT**: - If there is any conflict between custom criteria and user question requirements, prioritize custom criteria

## Universal Evaluation Dimensions

Evaluate the answer across these core dimensions:

**(1) Answer Accuracy:**
examines correctness, consistency, and factuality alignment between the <answer> and the <user_question>;
examines if the <answer> contains irrelevant or wrongful information/hallucination.

**(2) Answer Completeness:**
examines if the <answer> is fully addressing the <user_question>;
examines if the <answer> is good at relevance/informativeness: selection of important/key content from <user_question>

**(3) Expression Quality:**
examines if the <answer> is concise at answering the <user_question>.
NOTE that unless there is special instruction, more concise <answer> is always better,
and explanation or rational is strictly NOT needed - THIS IS THE MOST IMPORTANT!
examines the alignment on instruction following, e.g., if the <answer> adheres
to both explicit guidelines and implicit guidelines (like few-shot examples) in the <user_question>;

<CUSTOM_CRITERIA_DESCRIPTION>
**(4) Faithfulness to Context:**
examines whether the candidate answer is faithful to the task description and context provided in the user question. A response is unfaithful only when (1) it clearly contradicts the context, or (2) the task implies that the response must be based on the context (like in a summarization task). If the task does not ask to respond based on the context, the model is allowed to use its own knowledge to provide a response, even if its claims are not verifiable. Evaluate the degree of faithfulness on the following scale:
- **3 points**: All content is faithful (no contradictions, fully grounded when required)
- **2 points**: Most content is faithful (minor deviations or unverifiable claims when context-grounding is required)
- **1 point**: Some content is faithful or approximately half is faithful (notable contradictions or significant departures from context when required)
- **0 points**: None or minimal content is faithful (clear contradictions or complete disregard of context when grounding is required)
</CUSTOM_CRITERIA_DESCRIPTION>

## Dimension Weighting and Final Scoring

**Weight Determination Process:**
Assign weights (must sum to 1.0) based on:
- Explicit weights in evaluation_criteria (if provided)
- Task analysis and question requirements (if no explicit weights)
- Default weights (Answer Accuracy: 0.25, Answer Completeness: 0.25, Expression Quality: 0.25, Faithfulness to Context: 0.25) as fallback

**Weight Guidelines:**
- **High Accuracy Weight (0.3-0.5)**: Factual questions, multiple choice, technical problems
- **High Completeness Weight (0.3-0.5)**: Complex explanatory tasks, multi-part questions
- **High Expression Weight (0.3-0.5)**: Creative tasks, presentation-focused questions, format-specific requirements
- [*IMPORTANT*] **High Custom Criteria Weight**: The custom criteria (Faithfulness to Context) should always be *prioritized*. Assign it significant weight (0.3-0.6) and adjust other weights accordingly.

**Overall Score Calculation:**
Overall = (Answer_Accuracy x Weight_A) + (Answer_Completeness x Weight_C) + (Expression_Quality x Weight_E) + (Faithfulness_to_Context x Weight_F)

## Current Evaluation Task

<user_question>
{prompt}
</user_question>
<answer>
{prediction}
</answer>
<reference_answer>
{gold}
</reference_answer>

Based on the above guidelines and criteria, provide your evaluation:"""

Evaluateur Lambda personnalisé

Apportez votre propre fonction de notation en tant que fonction Lambda.

Configuration

Spécifiez l'ARN Lambda dans votre fichier JSONL d'entrée pour chaque modèle d'invite qui doit l'utiliser. Vous fournissez également le customEvaluationMetricLabel champ pour nommer votre métrique :

"evaluationMetricLambdaArn": "arn:aws:lambda:us-west-2:123456789012:function:my-eval-function",
"customEvaluationMetricLabel": "My Custom Metric"

Lorsque vous créez la tâche via l'API, aucune configuration d'évaluation supplémentaire n'est requise dans la CreateAdvancedPromptOptimizationJob demande elle-même. La méthode d'évaluation est déterminée par modèle à partir du fichier JSONL d'entrée.

Exigences Lambda

Conseils métriques Lambda

Modèle Lambda

"""
APO Custom Metric Lambda - Minimal Template
Handler: lambda_function.lambda_handler
"""
import logging
from typing import List, Dict, Any

logger = logging.getLogger()
logger.setLevel(logging.INFO)


def compute_score(preds: List[str], golds: List[str]) -> Dict[str, Any]:
    """
    Score predictions against ground truths.

    Args:
        preds: Model outputs (one per sample)
        golds: Expected answers (one per sample)

    Returns:
        Must contain:
          "score": float  - aggregate score (higher is better)
          "scores": list[float] - per-instance scores
    """
    # --- REPLACE THIS with your scoring logic ---
    scores = []
    for pred, gold in zip(preds, golds):
        # Example: exact match (case-insensitive)
        scores.append(1.0 if pred.strip().lower() == gold.strip().lower() else 0.0)

    return {
        "score": sum(scores) / len(scores) if scores else 0.0,
        "scores": scores,
    }


def lambda_handler(event, context):
    """
    Lambda entry point. APO service sends:
      event = {"preds": ["output1", ...], "golds": ["truth1", ...]}
    """
    logger.info(f"Received {len(event.get('preds', []))} predictions")

    try:
        preds = event.get("preds", [])
        golds = event.get("golds", [])

        if not preds:
            return {"score": 0.0, "scores": []}

        return compute_score(preds, golds)

    except Exception as e:
        logger.error(f"Error: {e}", exc_info=True)
        return {"score": 0.0, "scores": [0.0] * len(event.get("preds", [])), "error": str(e)}

Consultez les exemples GitHub pour AWS des exemples plus détaillés, notamment un code standard pour la gestion des erreurs et la validation des entrées de la fonction Lambda.