Evaluator bawaan yang didukung dan bidang kebenaran dasar Prasyarat Kebenaran dengan respons yang diharapkan GoalSuccessRate dengan pernyataan Pencocokan lintasan dengan lintasan yang diharapkan Menggabungkan semua bidang kebenaran dasar dalam satu permintaan Memahami bidang input referensi yang diabaikan Kebenaran dasar dalam evaluator khusus

Evaluasi kebenaran dasar

Kebenaran dasar adalah jawaban benar yang diketahui atau perilaku yang diharapkan untuk masukan yang diberikan — “standar emas” yang Anda bandingkan dengan hasil aktual. Untuk evaluasi agen, kebenaran dasar mengubah penilaian kualitas subjektif menjadi pengukuran objektif, memungkinkan deteksi regresi, kumpulan data benchmark, dan kebenaran spesifik domain yang tidak dapat disediakan sendiri oleh evaluator generik.

Dengan evaluasi kebenaran dasar, Anda memberikan input referensi di samping rentang sesi Anda saat memanggil Evaluate API. Layanan menggunakan input referensi ini untuk menilai perilaku aktual agen Anda terhadap perilaku yang diharapkan. Evaluator yang tidak menggunakan bidang kebenaran dasar tertentu mengabaikannya dan melaporkan bidang mana yang tidak digunakan dalam respons.

Topik

Evaluator bawaan yang didukung dan bidang kebenaran dasar
Prasyarat
Kebenaran dengan respons yang diharapkan
GoalSuccessRate dengan pernyataan
Pencocokan lintasan dengan lintasan yang diharapkan
Menggabungkan semua bidang kebenaran dasar dalam satu permintaan
Memahami bidang input referensi yang diabaikan
Kebenaran dasar dalam evaluator khusus

Evaluator bawaan yang didukung dan bidang kebenaran dasar

Tabel berikut menunjukkan evaluator bawaan mana yang mendukung kebenaran dasar dan bidang mana yang mereka gunakan.

Evaluator	Tingkat	Bidang kebenaran dasar	Deskripsi
`Builtin.Correctness`	Jejak	`expectedResponse`	Mengukur seberapa akurat respons agen cocok dengan jawaban yang diharapkan. Menggunakan LLM-as-a-Judge penilaian.
`Builtin.GoalSuccessRate`	Sesi	`assertions`	Memvalidasi apakah perilaku agen memenuhi pernyataan bahasa alami di seluruh sesi. Menggunakan LLM-as-a-Judge penilaian.
`Builtin.TrajectoryExactOrderMatch`	Sesi	`expectedTrajectory`	Memeriksa apakah urutan panggilan alat yang sebenarnya cocok dengan urutan yang diharapkan persis — alat yang sama, urutan yang sama, tidak ada tambahan. Penilaian terprogram (tidak ada panggilan LLM).
`Builtin.TrajectoryInOrderMatch`	Sesi	`expectedTrajectory`	Memeriksa apakah semua alat yang diharapkan muncul secara berurutan dalam urutan aktual, tetapi memungkinkan alat tambahan di antara mereka. Penilaian terprogram.
`Builtin.TrajectoryAnyOrderMatch`	Sesi	`expectedTrajectory`	Memeriksa apakah semua alat yang diharapkan hadir dalam urutan aktual, terlepas dari urutannya. Alat tambahan diperbolehkan. Penilaian terprogram.

catatan

Evaluator kustom juga mendukung bidang kebenaran dasar melalui placeholder dalam instruksi evaluasi mereka. Lihat kebenaran dasar di evaluator khusus untuk detailnya.

Tabel berikut menjelaskan bidang kebenaran dasar.

Bidang	Tipe	Lingkup	Deskripsi
`expectedResponse`	String	Jejak	Respons agen yang diharapkan untuk giliran tertentu. Dicakup ke jejak menggunakan `traceId` dalam konteks input referensi.
`assertions`	Daftar string	Sesi	Pernyataan bahasa alami yang seharusnya benar tentang perilaku agen di seluruh sesi.
`expectedTrajectory`	Daftar nama alat	Sesi	Urutan panggilan alat yang diharapkan untuk sesi.

Bidang kebenaran dasar bersifat opsional. Jika Anda menghilangkannya, evaluator kembali ke mode bebas kebenaran dasar mereka (misalnya, Builtin.Correctness masih berfungsi tanpanyaexpectedResponse, itu hanya mengevaluasi berdasarkan konteks saja).
Anda dapat menyediakan semua bidang kebenaran dasar dalam satu permintaan. Layanan memilih bidang yang relevan untuk setiap evaluator dan melaporkan ignoredReferenceInputFields dalam tanggapan untuk bidang apa pun yang tidak digunakan.
Anda tidak perlu menyediakan expectedResponse setiap jejak. Jejak tanpa kebenaran dasar dievaluasi menggunakan varian bebas kebenaran dasar dari evaluator.

Prasyarat

Python 3.10+
Agen yang dibangun dengan kerangka kerja yang didukung dan pustaka instrumentasi. Untuk informasi selengkapnya tentang kerangka kerja dan pustaka instrumentasi yang didukung, lihat Kerangka kerja agen yang didukung.
Agen yang digunakan pada AgentCore Runtime dengan pengamatan diaktifkan, atau agen yang dibangun dengan kerangka kerja yang didukung dikonfigurasi dengan AgentCore Observability, termasuk Pencarian Transaksi. Untuk informasi selengkapnya tentang pengaturan telemetri, lihat Pengaturan dan pengiriman telemetri.
AWS kredenSIAL dikonfigurasi dengan izin untuk bedrock-agentcorebedrock-agentcore-control,, dan logs (CloudWatch)

Untuk petunjuk tentang cara mengunduh rentang sesi, lihat Memulai evaluasi sesuai permintaan.

Tentang contohnya

Contoh di halaman ini menggunakan agen sampel dari tutorial AgentCore Evaluasi. Agen memiliki dua alat — calculator dan weather — dan digunakan pada AgentCore Runtime dengan pengamatan diaktifkan.

Contoh-contoh mengasumsikan sesi dua putaran:

Putaran 1: “Apa itu 15 + 27?” — agen menggunakan calculator alat dan merespons dengan hasilnya.
Putaran 2: “Bagaimana cuacanya?” — agen menggunakan weather alat dan merespons dengan cuaca saat ini.

Sebelum menjalankan evaluasi, hubungi agen Anda dan tunggu 2-5 menit untuk menyerap data CloudWatch telemetri.

Konstanta berikut digunakan di seluruh contoh di halaman ini. Ganti dengan nilai-nilai Anda sendiri:


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

Kebenaran dengan respons yang diharapkan

Builtin.Correctnessadalah evaluator tingkat jejak yang mengukur seberapa akurat respons agen cocok dengan jawaban yang diharapkan. Ketika Anda memberikanexpectedResponse, evaluator membandingkan respons aktual agen dengan kebenaran dasar Anda menggunakan LLM-as-a-Judge penilaian.

contoh

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

Untuk menargetkan jejak tertentu, berikan expected_response sebagai dict pemetaan ID jejak ke jawaban yang diharapkan:


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

Untuk menargetkan jejak tertentu, berikan tupel: (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 dengan pernyataan

Builtin.GoalSuccessRateadalah evaluator tingkat sesi yang memvalidasi apakah perilaku agen memenuhi serangkaian pernyataan bahasa alami. Pernyataan dapat memeriksa penggunaan alat, konten respons, urutan tindakan, atau perilaku lain yang dapat diamati di seluruh percakapan.

catatan

Contoh di bawah ini menggunakan pernyataan yang memvalidasi penggunaan alat, tetapi pernyataan adalah bahasa alami bentuk bebas - Anda dapat menggunakannya untuk menegaskan aspek perilaku agen apa pun, seperti nada respons, akurasi faktual, kepatuhan keselamatan, atau logika bisnis.

contoh

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

Pencocokan lintasan dengan lintasan yang diharapkan

Evaluator lintasan membandingkan urutan panggilan alat aktual agen dengan urutan nama alat yang diharapkan. Tiga varian tersedia, masing-masing dengan ketetatan pencocokan yang berbeda. Ketiganya adalah evaluator tingkat sesi dan menggunakan penilaian terprogram (tidak ada panggilan LLM, jadi penggunaan token nol).

Evaluator	Aturan pencocokan	Contoh
`Builtin.TrajectoryExactOrderMatch`	Aktual harus sesuai dengan yang diharapkan persis — alat yang sama, urutan yang sama, tidak ada tambahan	Diharapkan:`[calculator, weather]`, Aktual: `[calculator, weather]` → Lulus. Aktual: `[calculator, weather, calculator]` → Gagal.
`Builtin.TrajectoryInOrderMatch`	Alat yang diharapkan harus muncul secara berurutan, tetapi alat tambahan diperbolehkan di antara mereka	Diharapkan:`[calculator, weather]`, Aktual: `[calculator, some_tool, weather]` → Lulus.
`Builtin.TrajectoryAnyOrderMatch`	Semua alat yang diharapkan harus ada, pesanan tidak masalah, tambahan diperbolehkan	Diharapkan:`[calculator, weather]`, Aktual: `[weather, calculator]` → Lulus.

contoh

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

Nama alat diteruskan sebagai daftar yang dipisahkan koma:


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

Nama alat diteruskan sebagai daftar yang dipisahkan koma:


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

Menggabungkan semua bidang kebenaran dasar dalam satu permintaan

Anda dapat meneruskan semua bidang kebenaran dasar bersama-sama dalam satu panggilan evaluasi. Layanan merutekan setiap bidang ke evaluator yang sesuai dan mengabaikan bidang yang tidak digunakan evaluator tertentu. Ini berarti Anda dapat membuat input referensi Anda sekali dan menggunakannya kembali di evaluator yang berbeda tanpa memodifikasi muatan.

contoh

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

Memahami bidang input referensi yang diabaikan

Saat Anda memberikan bidang kebenaran dasar yang tidak digunakan evaluator, respons menyertakan ignoredReferenceInputFields array yang mencantumkan bidang yang tidak digunakan. Ini informasi, bukan kesalahan - evaluasi masih berhasil diselesaikan.

Misalnya, jika Anda menelep Builtin.Helpfulness on dengan expectedResponse disediakan, evaluator mengabaikan kebenaran dasar (Bantuan tidak menggunakannya) dan mengembalikan:


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

Perilaku ini dirancang - ini memungkinkan Anda untuk membuat satu set input referensi dan menggunakannya di beberapa evaluator tanpa menyesuaikan muatan untuk masing-masing.

Kebenaran dasar dalam evaluator khusus

Evaluator kustom dapat menggunakan bidang kebenaran dasar melalui placeholder dalam instruksi evaluasi mereka. Saat membuat evaluator kustom, Anda dapat mereferensikan placeholder berikut:

Session-level evaluator kustom:{context},,{available_tools},{actual_tool_trajectory}, {expected_tool_trajectory} {assertions}
Trace-level evaluator kustom:{context},, {assistant_turn} {expected_response}

Misalnya, evaluator tingkat jejak khusus yang memeriksa kesamaan respons mungkin menggunakan:


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.

Ketika evaluator ini dipanggil dengan expectedResponse input referensi, layanan menggantikan placeholder dengan nilai kebenaran dasar aktual sebelum penilaian.

Untuk detail tentang membuat evaluator kustom, lihat Evaluator kustom.

catatan

Evaluator kustom yang menggunakan placeholder kebenaran dasar ({assertions},{expected_response},{expected_tool_trajectory}) tidak dapat digunakan dalam konfigurasi evaluasi online, karena evaluasi online memantau lalu lintas produksi langsung di mana nilai kebenaran dasar tidak tersedia.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Memulai evaluasi sesuai permintaan

Evaluasi batch