Évaluateurs intégrés et champs de vérité sur le terrain pris en charge Conditions préalables Exactitude par rapport à la réponse attendue GoalSuccessRate avec assertions Correspondance de la trajectoire avec la trajectoire attendue Combiner tous les champs de vérité sur le terrain en une seule demande Comprendre les champs de saisie de référence ignorés La vérité fondamentale dans les évaluateurs personnalisés

Évaluations de la vérité de terrain

La vérité fondamentale est la bonne réponse connue ou le comportement attendu pour une entrée donnée. Il s'agit de la « référence absolue » à laquelle vous comparez les résultats réels. Pour l'évaluation des agents, Ground Truth transforme l'évaluation subjective de la qualité en une mesure objective, permettant la détection de régressions, des ensembles de données de référence et une exactitude spécifique au domaine que les évaluateurs génériques ne peuvent pas fournir seuls.

Avec les évaluations de la vérité sur le terrain, vous fournissez des entrées de référence parallèlement à la durée de vos sessions lorsque vous appelez l'API Evaluate. Le service utilise ces entrées de référence pour évaluer le comportement réel de votre agent par rapport au comportement attendu. Les évaluateurs qui n'utilisent pas un champ de vérité de base particulier l'ignorent et indiquent quels champs n'ont pas été utilisés dans la réponse.

Rubriques

Évaluateurs intégrés et champs de vérité sur le terrain pris en charge
Conditions préalables
Exactitude par rapport à la réponse attendue
GoalSuccessRate avec assertions
Correspondance de la trajectoire avec la trajectoire attendue
Combiner tous les champs de vérité sur le terrain en une seule demande
Comprendre les champs de saisie de référence ignorés
La vérité fondamentale dans les évaluateurs personnalisés

Évaluateurs intégrés et champs de vérité sur le terrain pris en charge

Le tableau suivant indique quels évaluateurs intégrés prennent en charge la vérité sur le terrain et quels champs ils utilisent.

Évaluateur	Niveau	Champ de vérité sur le terrain	Description
`Builtin.Correctness`	Suivi	`expectedResponse`	Mesure la précision avec laquelle la réponse de l'agent correspond à la réponse attendue. Utilise la LLM-as-a-Judge notation.
`Builtin.GoalSuccessRate`	Session	`assertions`	Vérifie si le comportement de l'agent est conforme aux assertions en langage naturel tout au long de la session. Utilise la LLM-as-a-Judge notation.
`Builtin.TrajectoryExactOrderMatch`	Session	`expectedTrajectory`	Vérifie que la séquence d'appel d'outil réelle correspond exactement à la séquence attendue : mêmes outils, même ordre, pas de suppléments. Notation programmatique (pas d'appels LLM).
`Builtin.TrajectoryInOrderMatch`	Session	`expectedTrajectory`	Vérifie que tous les outils attendus apparaissent dans l'ordre dans la séquence réelle, mais autorise des outils supplémentaires entre eux. Notation programmatique.
`Builtin.TrajectoryAnyOrderMatch`	Session	`expectedTrajectory`	Vérifie que tous les outils attendus sont présents dans la séquence réelle, quel que soit l'ordre. Des outils supplémentaires sont autorisés. Notation programmatique.

Note

Les évaluateurs personnalisés prennent également en charge les champs de vérité de base grâce à des espaces réservés dans leurs instructions d'évaluation. Consultez Ground Truth dans les évaluateurs personnalisés pour plus de détails.

Le tableau suivant décrit les champs de vérité de base.

Champ	Type	Scope	Description
`expectedResponse`	Chaîne	Suivi	La réponse attendue de l'agent pour un tour spécifique. Étendue à une trace utilisée `traceId` dans le contexte d'entrée de référence.
`assertions`	Liste de chaînes	Session	Des déclarations en langage naturel qui devraient être vraies concernant le comportement de l'agent au cours de la session.
`expectedTrajectory`	Liste des noms d'outils	Session	La séquence d'appels d'outils attendue pour la session.

Les champs de vérité du sol sont facultatifs. Si vous les omettez, les évaluateurs retournent à leur mode de base sans vérité (par exemple, cela fonctionne Builtin.Correctness toujours sans véritéexpectedResponse, il évalue uniquement en fonction du contexte).
Vous pouvez fournir tous les champs de vérité de base dans une seule demande. Le service sélectionne les champs pertinents pour chaque évaluateur et indique ignoredReferenceInputFields dans la réponse tous les champs qui n'ont pas été utilisés.
Vous n'avez pas besoin expectedResponse de fournir chaque trace. Les traces sans vérité sur le terrain sont évaluées à l'aide de la variante sans vérité sur le terrain de l'évaluateur.

Conditions préalables

Python 3.10 et versions ultérieures
Un agent créé à l'aide d'un framework et d'une bibliothèque d'instruments pris en charge. Pour plus d'informations sur les frameworks et les bibliothèques d'instrumentation pris en charge, consultez Frameworks d'agents pris en charge.
Un agent déployé sur AgentCore Runtime avec l'observabilité activée, ou un agent construit avec un framework pris en charge configuré avec AgentCore Observability, y compris Transaction Search. Pour plus d'informations sur la configuration de la télémétrie, voir Configuration et livraison de la télémétrie.
AWS informations d'identification configurées avec des autorisations pour bedrock-agentcorebedrock-agentcore-control, et logs (CloudWatch)

Pour obtenir des instructions sur le téléchargement des périodes de session, voir Commencer à utiliser l'évaluation à la demande.

À propos des exemples

Les exemples de cette page utilisent l'exemple d'agent des didacticiels d'AgentCore évaluation. L'agent dispose de deux outils — calculator et weather — et est déployé sur AgentCore Runtime avec l'observabilité activée.

Les exemples supposent une session en deux tours :

Tour 1 : « Que font 15 + 27 ? » — l'agent utilise l'calculatoroutil et répond avec le résultat.
Tour 2 : « Quel temps fait-il ? » — l'agent utilise l'weatheroutil et répond en fonction de la météo actuelle.

Avant d'exécuter des évaluations, appelez votre agent et attendez 2 à 5 minutes pour CloudWatch ingérer les données de télémétrie.

Les constantes suivantes sont utilisées dans les exemples de cette page. Remplacez-les par vos propres valeurs :


REGION       = "<region-code>"
AGENT_ID     = "my-agent-id"
SESSION_ID   = "my-session-id"
TRACE_ID_1   = "<trace-id-1>"   # Turn 1: "What is 15 + 27?"
TRACE_ID_2   = "<trace-id-2>"   # Turn 2: "What's the weather?"

Exactitude par rapport à la réponse attendue

Builtin.Correctnessest un évaluateur de niveau de trace qui mesure la précision avec laquelle la réponse de l'agent correspond à la réponse attendue. Lorsque vous fournissezexpectedResponse, l'évaluateur compare la réponse réelle de l'agent à votre réalité sur le terrain en utilisant la LLM-as-a-Judge notation.

Exemple

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

# String form — matched against the last trace in the session
results = client.run(
    evaluator_ids=["Builtin.Correctness"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
    ),
)

for r in results:
    print(f"Trace: {r['context']['spanContext'].get('traceId', 'session')}")
    print(f"Score: {r['value']}, Label: {r['label']}")

Pour cibler une trace spécifique, transmettez expected_response sous forme de dict les ID de trace en mappant les ID de trace aux réponses attendues :


results = client.run(
    evaluator_ids=["Builtin.Correctness"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response={
            TRACE_ID_1: "15 + 27 = 42",
            TRACE_ID_2: "The weather is sunny",
        },
    ),
)

AgentCore CLI


# Expected response matched against the last trace
agentcore run eval \
  --runtime AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator Builtin.Correctness \
  --expected-response "The weather is sunny"

# Target a specific trace
agentcore run eval \
  --runtime AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator Builtin.Correctness \
  --trace-id TRACE_ID_1 \
  --expected-response "15 + 27 = 42"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --region <region-code> \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness \
  --expected-response "The weather is sunny"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

# String form — matched against the last trace
results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.Correctness"],
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
    ),
)

for r in results.get_successful_results():
    print(f"Score: {r.value:.2f}, Label: {r.label}")

Pour cibler une trace spécifique, transmettez un tuple de (trace_id, expected_response) :


results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.Correctness"],
    reference_inputs=ReferenceInputs(
        expected_response=(TRACE_ID_1, "15 + 27 = 42"),
    ),
)

AgentCore CLI


# Expected response matched against the last trace
agentcore run eval \
  --runtime-arn AGENT_RUNTIME_ARN \
  --region REGION \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness \
  --expected-response "The weather is sunny"

# Target a specific trace
agentcore run eval \
  --runtime-arn AGENT_RUNTIME_ARN \
  --region REGION \
  --session-id SESSION_ID \
  --trace-id TRACE_ID_1 \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness \
  --expected-response "15 + 27 = 42"

# Save results to a file
agentcore run eval \
  --runtime-arn AGENT_RUNTIME_ARN \
  --region REGION \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness \
  --expected-response "The weather is sunny" \
  --output results.json

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

response = client.evaluate(
    evaluatorId="Builtin.Correctness",
    evaluationInput={"sessionSpans": session_spans_and_log_events},
    evaluationReferenceInputs=[
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID,
                    "traceId": TRACE_ID_1
                }
            },
            "expectedResponse": {"text": "15 + 27 = 42"}
        },
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID,
                    "traceId": TRACE_ID_2
                }
            },
            "expectedResponse": {"text": "The weather is sunny"}
        }
    ]
)

for result in response["evaluationResults"]:
    print(f"Score: {result['value']}, Label: {result['label']}")

GoalSuccessRate avec assertions

Builtin.GoalSuccessRateest un évaluateur au niveau de la session qui valide si le comportement de l'agent répond à un ensemble d'assertions en langage naturel. Les assertions peuvent vérifier l'utilisation des outils, le contenu des réponses, l'ordre des actions ou tout autre comportement observable tout au long de la conversation.

Note

Les exemples ci-dessous utilisent des assertions qui valident l'utilisation de l'outil, mais les assertions sont rédigées en langage naturel sous forme libre. Vous pouvez les utiliser pour affirmer n'importe quel aspect du comportement des agents, comme le ton de réponse, l'exactitude des faits, la conformité en matière de sécurité ou la logique métier.

Exemple

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=["Builtin.GoalSuccessRate"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        assertions=[
            "Agent used the calculator tool to compute the result",
            "Agent returned the correct numerical answer of 42",
            "Agent used the weather tool when asked about weather",
        ],
    ),
)

for r in results:
    print(f"Score: {r['value']}, Label: {r['label']}")
    print(f"Explanation: {r['explanation'][:200]}")

AgentCore CLI


agentcore run eval \
  --runtime AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator Builtin.GoalSuccessRate \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42" \
  --assertion "Agent used the weather tool when asked about weather"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --region <region-code> \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.GoalSuccessRate"],
    reference_inputs=ReferenceInputs(
        assertions=[
            "Agent used the calculator tool to compute the result",
            "Agent returned the correct numerical answer of 42",
            "Agent used the weather tool when asked about weather",
        ],
    ),
)

for r in results.get_successful_results():
    print(f"Score: {r.value:.2f}, Label: {r.label}")

AgentCore CLI


agentcore run eval \
  --runtime-arn AGENT_RUNTIME_ARN \
  --region REGION \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42" \
  --assertion "Agent used the weather tool when asked about weather"

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

response = client.evaluate(
    evaluatorId="Builtin.GoalSuccessRate",
    evaluationInput={"sessionSpans": session_spans_and_log_events},
    evaluationReferenceInputs=[
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID
                }
            },
            "assertions": [
                {"text": "Agent used the calculator tool to compute the result"},
                {"text": "Agent returned the correct numerical answer of 42"},
                {"text": "Agent used the weather tool when asked about weather"}
            ]
        }
    ]
)

for result in response["evaluationResults"]:
    print(f"Score: {result['value']}, Label: {result['label']}")

Correspondance de la trajectoire avec la trajectoire attendue

Les évaluateurs de trajectoire comparent la séquence d'appels d'outils réelle de l'agent à une séquence attendue de noms d'outils. Trois variantes sont disponibles, chacune avec une rigueur d'adaptation différente. Tous les trois sont des évaluateurs au niveau de la session et utilisent une notation programmatique (pas d'appels LLM, donc l'utilisation des jetons est nulle).

Évaluateur	Règle de correspondance	Exemple
`Builtin.TrajectoryExactOrderMatch`	La réalité doit correspondre exactement à ce qui est attendu : mêmes outils, même commande, aucun supplément	Prévu :`[calculator, weather]`, Réel : `[calculator, weather]` → Passe. Actuel : `[calculator, weather, calculator]` → Échec.
`Builtin.TrajectoryInOrderMatch`	Les outils attendus doivent apparaître dans l'ordre, mais des outils supplémentaires sont autorisés entre eux	Prévu :`[calculator, weather]`, Réel : `[calculator, some_tool, weather]` → Passe.
`Builtin.TrajectoryAnyOrderMatch`	Tous les outils attendus doivent être présents, l'ordre n'a pas d'importance, les extras sont autorisés	Prévu :`[calculator, weather]`, Réel : `[weather, calculator]` → Passe.

Exemple

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=[
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results:
    print(f"{r['evaluatorId']}: {r['value']} ({r['label']})")
    print(f"  {r['explanation'][:150]}")

AgentCore CLI

Les noms des outils sont transmis sous forme de liste séparée par des virgules :


agentcore run eval \
  --runtime AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator Builtin.TrajectoryExactOrderMatch Builtin.TrajectoryInOrderMatch Builtin.TrajectoryAnyOrderMatch \
  --expected-trajectory "calculator,weather"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --region <region-code> \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch \
  --expected-trajectory "calculator,weather"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=[
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    reference_inputs=ReferenceInputs(
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results.get_successful_results():
    print(f"{r.evaluator_name}: {r.value:.2f} ({r.label})")

AgentCore CLI

Les noms des outils sont transmis sous forme de liste séparée par des virgules :


agentcore run eval \
  --runtime-arn AGENT_RUNTIME_ARN \
  --region REGION \
  --session-id SESSION_ID \
  --evaluator-arn arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryInOrderMatch arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryAnyOrderMatch \
  --expected-trajectory "calculator,weather"

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

for evaluator in [
    "Builtin.TrajectoryExactOrderMatch",
    "Builtin.TrajectoryInOrderMatch",
    "Builtin.TrajectoryAnyOrderMatch",
]:
    response = client.evaluate(
        evaluatorId=evaluator,
        evaluationInput={"sessionSpans": session_spans_and_log_events},
        evaluationReferenceInputs=[
            {
                "context": {
                    "spanContext": {
                        "sessionId": SESSION_ID
                    }
                },
                "expectedTrajectory": {
                    "toolNames": ["calculator", "weather"]
                }
            }
        ]
    )

    for result in response["evaluationResults"]:
        print(f"{result['evaluatorId']}: {result['value']} ({result['label']})")

Combiner tous les champs de vérité sur le terrain en une seule demande

Vous pouvez passer tous les champs de vérité de base en un seul appel d'évaluation. Le service achemine chaque champ vers l'évaluateur approprié et ignore les champs qu'un évaluateur donné n'utilise pas. Cela signifie que vous pouvez créer vos entrées de référence une seule fois et les réutiliser dans différents évaluateurs sans modifier la charge utile.

Exemple

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=[
        "Builtin.Correctness",
        "Builtin.GoalSuccessRate",
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
        assertions=[
            "Agent used the calculator tool for math",
            "Agent used the weather tool when asked about weather",
        ],
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results:
    ignored = r.get("ignoredReferenceInputFields", [])
    print(f"{r['evaluatorId']}: {r['value']} ({r['label']})")
    if ignored:
        print(f"  Ignored fields: {ignored}")

AgentCore CLI


agentcore run eval \
  --runtime AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator Builtin.Correctness Builtin.GoalSuccessRate Builtin.TrajectoryExactOrderMatch \
  --assertion "Agent used the calculator tool for math" \
  --assertion "Agent used the weather tool when asked about weather" \
  --expected-trajectory "calculator,weather" \
  --expected-response "The weather is sunny" \
  --output results.json

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=[
        "Builtin.Correctness",
        "Builtin.GoalSuccessRate",
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
        assertions=[
            "Agent used the calculator tool for math",
            "Agent used the weather tool when asked about weather",
        ],
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results.get_successful_results():
    print(f"{r.evaluator_name}: {r.value:.2f} ({r.label})")

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

reference_inputs = [
    {
        "context": {
            "spanContext": {"sessionId": SESSION_ID}
        },
        "assertions": [
            {"text": "Agent used the calculator tool for math"},
            {"text": "Agent used the weather tool when asked about weather"}
        ],
        "expectedTrajectory": {
            "toolNames": ["calculator", "weather"]
        }
    },
    {
        "context": {
            "spanContext": {
                "sessionId": SESSION_ID,
                "traceId": TRACE_ID_2
            }
        },
        "expectedResponse": {"text": "The weather is sunny"}
    }
]

for evaluator in ["Builtin.Correctness", "Builtin.GoalSuccessRate",
                   "Builtin.TrajectoryExactOrderMatch"]:
    response = client.evaluate(
        evaluatorId=evaluator,
        evaluationInput={"sessionSpans": session_spans_and_log_events},
        evaluationReferenceInputs=reference_inputs
    )
    for result in response["evaluationResults"]:
        ignored = result.get("ignoredReferenceInputFields", [])
        print(f"{result['evaluatorId']}: {result['value']} ({result['label']})")
        if ignored:
            print(f"  Ignored fields: {ignored}")

Comprendre les champs de saisie de référence ignorés

Lorsque vous fournissez des champs de référence qu'un évaluateur n'utilise pas, la réponse inclut un ignoredReferenceInputFields tableau répertoriant les champs non utilisés. Il s'agit d'une information et non d'une erreur : l'évaluation se termine toujours correctement.

Par exemple, si vous appelez Builtin.Helpfulness avec expectedResponse provided, l'évaluateur ignore la vérité fondamentale (Helpfulness ne l'utilise pas) et renvoie :


{
  "evaluatorId": "Builtin.Helpfulness",
  "value": 0.83,
  "label": "Very Helpful",
  "explanation": "...",
  "ignoredReferenceInputFields": ["expectedResponse"]
}

Ce comportement est dû à sa conception : il vous permet de créer un ensemble unique d'entrées de référence et de les utiliser sur plusieurs évaluateurs sans ajuster la charge utile de chacun d'entre eux.

La vérité fondamentale dans les évaluateurs personnalisés

Les évaluateurs personnalisés peuvent utiliser des champs de vérité de base grâce à des espaces réservés dans leurs instructions d'évaluation. Lorsque vous créez un évaluateur personnalisé, vous pouvez référencer les espaces réservés suivants :

Session-level évaluateurs personnalisés :{context},,{available_tools},{actual_tool_trajectory}, {expected_tool_trajectory} {assertions}
Trace-level évaluateurs personnalisés :{context},, {assistant_turn} {expected_response}

Par exemple, un évaluateur de niveau de trace personnalisé qui vérifie la similarité des réponses peut utiliser :


Compare the agent's response with the expected response.
Agent response: {assistant_turn}
Expected response: {expected_response}
Rate how closely the agent's response matches the expected response on a scale of 0 to 1.

Lorsque cet évaluateur est appelé expectedResponse dans les entrées de référence, le service remplace l'espace réservé par la valeur de vérité réelle avant de noter.

Pour plus d'informations sur la création d'évaluateurs personnalisés, voir Évaluateurs personnalisés.

Note

Les évaluateurs personnalisés qui utilisent des balises de référence de base ({assertions},{expected_response},{expected_tool_trajectory}) ne peuvent pas être utilisés dans les configurations d'évaluation en ligne, car les évaluations en ligne surveillent le trafic de production en direct lorsque les valeurs de vérité de base ne sont pas disponibles.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Commencer à utiliser l'évaluation à la demande

Évaluation des lots