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 yang benar yang diketahui atau perilaku yang diharapkan untuk masukan yang diberikan — “standar emas” yang Anda bandingkan dengan hasil aktual. Untuk evaluasi agen, ground truth mengubah penilaian kualitas subjektif menjadi pengukuran objektif, memungkinkan deteksi regresi, kumpulan data benchmark, dan kebenaran spesifik domain yang tidak dapat disediakan oleh evaluator generik sendiri.

Dengan evaluasi kebenaran dasar, Anda memberikan input referensi di samping rentang sesi Anda saat memanggil API Evaluate. 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 sesuai 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. Skor terprogram (tidak ada panggilan LLM).
`Builtin.TrajectoryInOrderMatch`	Sesi	`expectedTrajectory`	Memeriksa bahwa semua alat yang diharapkan muncul secara berurutan dalam urutan yang sebenarnya, tetapi memungkinkan alat tambahan di antara mereka. Penilaian terprogram.
`Builtin.TrajectoryAnyOrderMatch`	Sesi	`expectedTrajectory`	Memeriksa bahwa semua alat yang diharapkan ada dalam urutan yang sebenarnya, terlepas dari urutannya. Alat tambahan diperbolehkan. Penilaian terprogram.

catatan

Evaluator khusus 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	Respon agen yang diharapkan untuk giliran tertentu. Dicakup ke jejak menggunakan `traceId` dalam konteks input referensi.
`assertions`	Daftar string	Sesi	Pernyataan bahasa alami yang harus benar tentang perilaku agen di seluruh sesi.
`expectedTrajectory`	Daftar nama alat	Sesi	Urutan panggilan alat yang diharapkan untuk sesi tersebut.

Bidang kebenaran dasar adalah opsional. Jika Anda menghilangkannya, evaluator kembali ke mode bebas kebenaran dasar mereka (misalnya, Builtin.Correctness masih berfungsi tanpaexpectedResponse, 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 laporan ignoredReferenceInputFields dalam respons untuk bidang apa pun yang tidak digunakan.
Anda tidak perlu menyediakan expectedResponse untuk setiap jejak. Jejak tanpa kebenaran dasar dievaluasi menggunakan varian bebas kebenaran dasar dari evaluator.

Prasyarat

Python 3.10+
Agen yang digunakan pada AgentCore Runtime dengan kemampuan observabilitas diaktifkan, atau agen yang dibuat dengan kerangka kerja yang didukung yang dikonfigurasi dengan Observability. AgentCore Kerangka kerja yang didukung:
- Agen Helai
- LangGraph dengan opentelemetry-instrumentation-langchain atau openinference-instrumentation-langchain
Penelusuran Transaksi diaktifkan di CloudWatch — lihat Aktifkan Pencarian Transaksi
AWS kredensil yang dikonfigurasi dengan izin untukbedrock-agentcore,bedrock-agentcore-control, dan () logs CloudWatch

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

Tentang contoh-contohnya

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

Contoh-contoh mengasumsikan sesi dua putaran:

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

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

Konstanta berikut digunakan di seluruh contoh di halaman ini. Ganti dengan 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 sesuai dengan jawaban yang diharapkan. Ketika Anda memberikanexpectedResponse, evaluator membandingkan respons aktual agen terhadap 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, teruskan expected_response sebagai dict memetakan 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 \
  --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}")

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

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

Pencocokan lintasan dengan lintasan yang diharapkan

Evaluator lintasan membandingkan urutan panggilan alat agen yang sebenarnya dengan urutan nama alat yang diharapkan. Tiga varian tersedia, masing-masing dengan keketatan 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 sama persis dengan yang diharapkan — 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, ekstra diizinkan	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 dilewatkan sebagai daftar yang dipisahkan koma:


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

Nama alat dilewatkan sebagai daftar yang dipisahkan koma:


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

Menggabungkan semua bidang kebenaran dasar dalam satu permintaan

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

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

Memahami bidang input referensi yang diabaikan

Saat Anda menyediakan bidang kebenaran dasar yang tidak digunakan evaluator, responsnya menyertakan ignoredReferenceInputFields larik yang mencantumkan bidang yang tidak digunakan. Ini informasional, bukan kesalahan — evaluasi masih berhasil diselesaikan.

Misalnya, jika Anda menelepon Builtin.Helpfulness dengan expectedResponse disediakan, evaluator mengabaikan kebenaran dasar (Helpfulness 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 khusus 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 penelusuran 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 dalam input referensi, layanan mengganti placeholder dengan nilai kebenaran dasar yang sebenarnya sebelum mencetak skor.

Untuk detail tentang membuat evaluator kustom, lihat Evaluator kustom.

catatan

Evaluator khusus 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 dengan evaluasi sesuai permintaan

Memahami rentang masukan