Valutatori integrati e campi di verità fondamentali supportati Prerequisiti Correttezza rispetto alla risposta prevista GoalSuccessRate con asserzioni Corrispondenza della traiettoria alla traiettoria prevista Combinazione di tutti i campi di verità fondamentali in un'unica richiesta Comprensione dei campi di input di riferimento ignorati Fondamenta la verità nei valutatori personalizzati

Valutazioni fondamentali della verità

La verità fondamentale è la risposta corretta nota o il comportamento previsto per un determinato input, il «gold standard» con cui si confrontano i risultati effettivi. Per quanto riguarda la valutazione degli agenti, ground truth trasforma la valutazione soggettiva della qualità in una misurazione oggettiva, consentendo il rilevamento della regressione, set di dati di benchmark e una correttezza specifica del dominio che i valutatori generici non sono in grado di fornire da soli.

Con Ground Truth Evaluations, quando si chiama l'API Evaluate, è possibile fornire input di riferimento parallelamente alla durata delle sessioni. Il servizio utilizza questi input di riferimento per valutare il comportamento effettivo dell'agente rispetto al comportamento previsto. I valutatori che non utilizzano un particolare campo di verità fondamentale lo ignorano e segnalano quali campi non sono stati utilizzati nella risposta.

Argomenti

Valutatori integrati e campi di verità fondamentali supportati
Prerequisiti
Correttezza rispetto alla risposta prevista
GoalSuccessRate con asserzioni
Corrispondenza della traiettoria alla traiettoria prevista
Combinazione di tutti i campi di verità fondamentali in un'unica richiesta
Comprensione dei campi di input di riferimento ignorati
Fondamenta la verità nei valutatori personalizzati

Valutatori integrati e campi di verità fondamentali supportati

La tabella seguente mostra quali valutatori integrati supportano Ground Truth e quali campi utilizzano.

Valutatore	Livello	Campo fondamentale di verità	Description
`Builtin.Correctness`	Traccia	`expectedResponse`	Misura la precisione con cui la risposta dell'agente corrisponde alla risposta prevista. Utilizza il LLM-as-a-Judge punteggio.
`Builtin.GoalSuccessRate`	Sessione	`assertions`	Verifica se il comportamento dell'agente soddisfa le asserzioni in linguaggio naturale durante l'intera sessione. LLM-as-a-Judge Utilizza il punteggio.
`Builtin.TrajectoryExactOrderMatch`	Sessione	`expectedTrajectory`	Verifica che la sequenza effettiva di chiamata degli utensili corrisponda esattamente alla sequenza prevista: stessi utensili, stesso ordine, nessun extra. Punteggio programmatico (nessuna chiamata LLM).
`Builtin.TrajectoryInOrderMatch`	Sessione	`expectedTrajectory`	Verifica che tutti gli strumenti previsti appaiano in ordine all'interno della sequenza effettiva, ma consente l'utilizzo di strumenti aggiuntivi tra di essi. Punteggio programmatico.
`Builtin.TrajectoryAnyOrderMatch`	Sessione	`expectedTrajectory`	Verifica che tutti gli strumenti previsti siano presenti nella sequenza effettiva, indipendentemente dall'ordine. Sono consentiti strumenti aggiuntivi. Punteggio programmatico.

Nota

I valutatori personalizzati supportano anche i campi di base relativi alla verità tramite segnaposto nelle istruzioni di valutazione. Per maggiori dettagli, consulta Ground Truth nei valutatori personalizzati.

La tabella seguente descrive i campi di base della verità.

Campo	Tipo	Scope	Description
`expectedResponse`	Stringa	Traccia	La risposta prevista dell'agente per un turno specifico. Limitato a una traccia utilizzando `traceId` nel contesto di input di riferimento.
`assertions`	Elenco di stringhe	Sessione	Dichiarazioni in linguaggio naturale che dovrebbero essere vere sul comportamento dell'agente durante la sessione.
`expectedTrajectory`	Elenco dei nomi degli strumenti	Sessione	La sequenza prevista di chiamate agli strumenti per la sessione.

I campi Ground Truth sono facoltativi. Se li ometti, i valutatori tornano alla loro modalità di base priva di verità (ad esempio, funziona Builtin.Correctness ancora senzaexpectedResponse, ma valuta solo in base al contesto).
È possibile fornire tutti i campi di verità fondamentali in un'unica richiesta. Il servizio seleziona i campi pertinenti per ogni valutatore e riporta ignoredReferenceInputFields nella risposta tutti i campi che non sono stati utilizzati.
Non è necessario fornire ogni expectedResponse traccia. Le tracce senza verità fondamentale vengono valutate utilizzando la variante priva di verità fondamentale del valutatore.

Prerequisiti

Python 3.10+
Un agente distribuito su AgentCore Runtime con l'osservabilità abilitata o un agente creato con un framework supportato configurato con Observability. AgentCore Framework supportati:
- Agenti Strands
- LangGraph con opentelemetry-instrumentation-langchain o openinference-instrumentation-langchain
Ricerca nelle transazioni abilitata in CloudWatch : vedi Abilita la ricerca nelle transazioni
AWS credenziali configurate con autorizzazioni per bedrock-agentcorebedrock-agentcore-control, e logs () CloudWatch

Per istruzioni su come scaricare gli intervalli di sessione, consulta Guida introduttiva alla valutazione su richiesta.

Informazioni sugli esempi

Gli esempi in questa pagina utilizzano l'agente di esempio dei tutorial EvaluationsAgentCore . L'agente dispone di due strumenti, calculator e, ed weather è distribuito su AgentCore Runtime con l'osservabilità abilitata.

Gli esempi presuppongono una sessione a due turni:

Turno 1: «Quanto fa 15+ 27?» — l'agente utilizza lo calculator strumento e risponde con il risultato.
Turno 2: «Che tempo fa?» — l'agente utilizza lo weather strumento e risponde in base alle condizioni meteorologiche attuali.

Prima di eseguire le valutazioni, richiama l'agente e attendi 2-5 minuti per inserire i dati di CloudWatch telemetria.

Le seguenti costanti vengono utilizzate negli esempi di questa pagina. Sostituiscile con i tuoi valori:


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?"

Correttezza rispetto alla risposta prevista

Builtin.Correctnessè un valutatore a livello di traccia che misura la precisione con cui la risposta dell'agente corrisponde alla risposta prevista. Quando forniteexpectedResponse, il valutatore confronta la risposta effettiva dell'agente con la vostra realtà reale utilizzando il punteggio. LLM-as-a-Judge

Esempio

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']}")

Per indirizzare una traccia specifica, passa expected_response come dict la mappatura degli ID di traccia alle risposte previste:


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 \
  --agent AGENT_NAME \
  --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 \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::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> \
  --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}")

Per indirizzare una traccia specifica, passa una tupla di: (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"),
    ),
)

Starter Toolkit CLI


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

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

# Save results to a file
agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --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 con asserzioni

Builtin.GoalSuccessRateè un valutatore a livello di sessione che verifica se il comportamento dell'agente soddisfa un insieme di asserzioni in linguaggio naturale. Le asserzioni possono controllare l'utilizzo degli strumenti, il contenuto della risposta, l'ordine delle azioni o qualsiasi altro comportamento osservabile durante l'intera conversazione.

Nota

Gli esempi seguenti utilizzano asserzioni che convalidano l'utilizzo dello strumento, ma le asserzioni sono un linguaggio naturale in formato libero: puoi utilizzarle per affermare qualsiasi aspetto del comportamento degli agenti, come il tono di risposta, l'accuratezza dei fatti, la conformità alla sicurezza o la logica aziendale.

Esempio

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 \
  --agent AGENT_NAME \
  --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"

# 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> \
  --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}")

Starter Toolkit CLI


agentcore eval run \
  --agent-id AGENT_ID \
  --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"

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']}")

Corrispondenza della traiettoria alla traiettoria prevista

I valutatori della traiettoria confrontano l'effettiva sequenza di chiamata degli utensili da parte dell'agente con una sequenza prevista di nomi degli utensili. Sono disponibili tre varianti, ognuna con un diverso grado di rigore di abbinamento. Tutti e tre sono valutatori a livello di sessione e utilizzano il punteggio programmatico (nessuna chiamata LLM, quindi l'utilizzo dei token è zero).

Valutatore	Regola di abbinamento	Esempio
`Builtin.TrajectoryExactOrderMatch`	Il valore effettivo deve corrispondere esattamente a quello previsto: stessi strumenti, stesso ordine, nessun extra	Previsto:`[calculator, weather]`, Effettivo: `[calculator, weather]` → Passato. Effettivo: `[calculator, weather, calculator]` → Fallito.
`Builtin.TrajectoryInOrderMatch`	Gli strumenti previsti devono apparire in ordine, ma tra di essi sono consentiti strumenti aggiuntivi	Previsto:`[calculator, weather]`, Effettivo: `[calculator, some_tool, weather]` → Passato.
`Builtin.TrajectoryAnyOrderMatch`	Tutti gli strumenti previsti devono essere presenti, l'ordine non ha importanza, gli extra sono consentiti	Previsto:`[calculator, weather]`, Effettivo: `[weather, calculator]` → Passato.

Esempio

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

I nomi degli strumenti vengono passati come elenco separato da virgole:


agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryInOrderMatch" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/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> \
  --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})")

Starter Toolkit CLI

I nomi degli utensili vengono passati come elenco separato da virgole:


agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --evaluator "Builtin.TrajectoryExactOrderMatch" \
  --evaluator "Builtin.TrajectoryInOrderMatch" \
  --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']})")

Combinazione di tutti i campi di verità fondamentali in un'unica richiesta

È possibile passare insieme tutti i campi di verità fondamentali in un'unica chiamata di valutazione. Il servizio indirizza ogni campo al valutatore appropriato e ignora i campi che un determinato valutatore non utilizza. Ciò significa che è possibile creare gli input di riferimento una sola volta e riutilizzarli su diversi valutatori senza modificare il payload.

Esempio

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 \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/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}")

Comprensione dei campi di input di riferimento ignorati

Quando fornisci campi di verità fondamentali che un valutatore non utilizza, la risposta include un ignoredReferenceInputFields array che elenca i campi non utilizzati. Si tratta di informazioni, non di errore: la valutazione viene comunque completata correttamente.

Ad esempio, se chiami Builtin.Helpfulness con expectedResponse provided, il valutatore ignora la verità fondamentale (Helpfulness non la usa) e restituisce:


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

Questo comportamento è dovuto alla progettazione: consente di costruire un unico set di input di riferimento e di utilizzarli su più valutatori senza modificare il carico utile per ciascuno di essi.

Fondamenta la verità nei valutatori personalizzati

I valutatori personalizzati possono utilizzare campi di verità fondamentali tramite segnaposto nelle loro istruzioni di valutazione. Quando crei un valutatore personalizzato, puoi fare riferimento ai seguenti segnaposto:

Session-level valutatori personalizzati:{context},,, {available_tools} {actual_tool_trajectory} {expected_tool_trajectory} {assertions}
Trace-level valutatori personalizzati:{context},, {assistant_turn} {expected_response}

Ad esempio, un valutatore a livello di traccia personalizzato che verifica la somiglianza delle risposte potrebbe utilizzare:


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.

Quando questo valutatore viene chiamato expectedResponse negli input di riferimento, il servizio sostituisce il segnaposto con il valore effettivo della verità fondamentale prima di assegnare il punteggio.

Per i dettagli sulla creazione di valutatori personalizzati, consulta Valutatori personalizzati.

Nota

I valutatori personalizzati che utilizzano segnaposto fondamentali ({assertions},,{expected_tool_trajectory}) non possono essere utilizzati nelle configurazioni di valutazione online{expected_response}, poiché le valutazioni online monitorano il traffico di produzione in tempo reale laddove i valori di base non sono disponibili.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Guida introduttiva alla valutazione su richiesta

Comprendere gli intervalli di input