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

Valutazioni della verità fondamentale

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

Con le valutazioni di base, fornisci input di riferimento insieme alla durata della sessione quando chiami l'API Evaluate. 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 Ground Truth lo ignorano e segnalano quali campi non sono stati utilizzati nella risposta.

Argomenti

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

Valutatori integrati e campi di base supportati

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

Valutatore	Livello	Campo della verità fondamentale	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 nell'intera sessione. Utilizza il punteggio. LLM-as-a-Judge
`Builtin.TrajectoryExactOrderMatch`	Sessione	`expectedTrajectory`	Verifica che l'effettiva sequenza di chiamata dell'utensile corrisponda esattamente alla sequenza prevista: stessi strumenti, 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'uso 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 Ground Truth tramite segnaposto nelle loro istruzioni di valutazione. Per maggiori dettagli, consulta Ground truth nei valutatori personalizzati.

La tabella seguente descrive i campi di Ground Truth.

Campo	Tipo	Scope	Description
`expectedResponse`	Stringa	Traccia	La risposta prevista dell'agente per un turno specifico. Ambito a una traccia utilizzando il `traceId` 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 opzionali. Se li ometti, i valutatori tornano alla loro modalità di base priva di verità (ad esempio, funziona Builtin.Correctness ancora senzaexpectedResponse, la valutazione si basa solo sul contesto).
Puoi fornire tutti i campi di Ground Truth 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 creato con un framework e una libreria di strumentazione supportati. Per ulteriori informazioni sui framework e sulle librerie di strumentazione supportati, vedere Frameworks per agenti supportati. Framework per agenti supportati
Un agente distribuito su AgentCore Runtime con l'osservabilità abilitata o un agente creato con un framework supportato configurato con Observability, inclusa Transaction Search. AgentCore Per ulteriori informazioni sulla configurazione della telemetria, vedere Configurazione e consegna della telemetria. Configurazione e consegna della telemetria
AWS credenziali configurate con le autorizzazioni per, e () bedrock-agentcore bedrock-agentcore-control logs CloudWatch

Per istruzioni su come scaricare gli intervalli delle sessioni, consulta Guida introduttiva alla valutazione su richiesta.

Informazioni sugli esempi

Gli esempi in questa pagina utilizzano l'agente di esempio tratto dai tutorial sulle AgentCore valutazioni. L'agente dispone di due strumenti, e, calculator 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 con le condizioni meteorologiche attuali.

Prima di eseguire le valutazioni, richiama il tuo agente e attendi 2-5 minuti per CloudWatch acquisire i dati di telemetria.

Le seguenti costanti vengono utilizzate in tutti gli 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 fornisciexpectedResponse, il valutatore confronta la risposta effettiva dell'agente con la tua verità fondamentale utilizzando un 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, passate expected_response come dict mappando gli 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 \
  --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}")

Per indirizzare una traccia specifica, passate 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"),
    ),
)

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 con asserzioni

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

Nota

Gli esempi seguenti utilizzano asserzioni che convalidano l'utilizzo degli strumenti, 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 \
  --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']}")

Corrispondenza della traiettoria con la traiettoria prevista

I valutatori di traiettoria confrontano la sequenza effettiva di chiamata dell'utensile dell'agente con una sequenza prevista di nomi degli strumenti. Sono disponibili tre varianti, ognuna con una diversa rigidità di abbinamento. Tutti e tre sono valutatori a livello di sessione e utilizzano un punteggio programmatico (nessuna chiamata LLM, quindi l'utilizzo dei token è pari a zero).

Valutatore	Regola di corrispondenza	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, sono consentiti gli extra	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 un elenco separato da virgole:


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

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


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

Combinazione di tutti i campi di Ground Truth in un'unica richiesta

Puoi riunire tutti i campi di Ground Truth 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 puoi creare i tuoi input di riferimento una 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 \
  --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}")

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 un 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 utilizza) e restituisce:


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

Questo comportamento è stato progettato: consente di creare un unico set di input di riferimento e utilizzarli su più valutatori senza regolare il carico utile per ciascuno di essi.

La verità fondamentale nei valutatori personalizzati

I valutatori personalizzati possono utilizzare i campi di Ground Truth 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 personalizzato a livello di traccia 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 richiamato expectedResponse negli input di riferimento, il servizio sostituisce il segnaposto con il valore effettivo di verità fondamentale prima del punteggio.

Per informazioni dettagliate sulla creazione di valutatori personalizzati, vedere Valutatori personalizzati. Valutatori personalizzati

Nota

I valutatori personalizzati che utilizzano segnaposti di ground truth ({assertions},,{expected_tool_trajectory}) non possono essere utilizzati nelle configurazioni di valutazione online{expected_response}, perché le valutazioni online monitorano il traffico di produzione in tempo reale laddove i valori di ground truth 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

Valutazione dei lotti