Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Benchmark titik akhir inferensi AI generatif
<a name="generative-ai-inference-recommendations-benchmark"></a>

Layanan benchmarking SageMaker AI mengukur kinerja model bahasa besar (LLM) yang dihosting di titik akhir SageMaker AI. Ini menjalankan tolok ukur menggunakan NVIDIA AiPerf, menghasilkan metrik seperti latensi permintaan, throughput, token waktu ke pertama, dan latensi antar-token.

## Prasyarat
<a name="generative-ai-inference-recommendations-benchmark-prereqs"></a>

Sebelum Anda membuat pekerjaan benchmark, Anda memerlukan yang berikut:
+ Titik akhir SageMaker AI dalam `InService` status hosting LLM yang mendukung API penyelesaian OpenAI-compatible obrolan
+ Bucket Amazon S3 untuk output benchmark
+ Peran eksekusi IAM yang memberikan akses SageMaker AI ke endpoint dan bucket keluaran Anda

## Langkah 1: Buat pekerjaan benchmark
<a name="generative-ai-inference-recommendations-benchmark-create"></a>

Pekerjaan benchmark menargetkan titik akhir SageMaker AI tertentu dan mereferensikan konfigurasi beban kerja.

**Python (boto3)**

```
response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-sagemaker-endpoint"
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"
    },
    AIWorkloadConfigIdentifier="my-benchmark-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
print(response["AIBenchmarkJobArn"])
```

**AWS CLI**

```
aws sagemaker create-ai-benchmark-job \
  --ai-benchmark-job-name "my-benchmark-job" \
  --benchmark-target '{"Endpoint": {"Identifier": "my-sagemaker-endpoint"}}' \
  --output-config '{"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"}' \
  --ai-workload-config-identifier "my-benchmark-config" \
  --role-arn "arn:aws:iam::111122223333:role/ExampleRole" \
  --region us-west-2
```

Jika titik akhir Anda meng-host beberapa model melalui komponen inferensi, Anda dapat menentukannya dalam `InferenceComponents` parameter. `BenchmarkTarget`

Jika titik akhir Anda ada di VPC, teruskan `NetworkConfig` parameter dengan pengaturan `VpcConfig` Anda, termasuk ID grup keamanan dan subnet.

Untuk melacak hasil benchmark dengan MLFlow yang dikelola sepenuhnya pada SageMaker AI, tambahkan `MlflowConfig` objek ke. `OutputConfig` Untuk informasi selengkapnya, lihat [Lacak rekomendasi inferensi dan hasil benchmark dengan MLFlow](generative-ai-inference-recommendations-mlflow.md).

## Komponen inferensi benchmark
<a name="generative-ai-inference-recommendations-benchmark-inference-components"></a>

Jika titik akhir Anda menggunakan *komponen inferensi* alih-alih menerapkan model secara langsung, Anda harus menentukan komponen inferensi untuk benchmark di. `BenchmarkTarget` Ketika komponen inferensi ditentukan, layanan benchmarking merutekan permintaan ke komponen spesifik tersebut daripada model default titik akhir.

Lulus satu atau lebih nama komponen inferensi atau ARN dalam daftar: `InferenceComponents`

**Python (boto3)**

```
response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="my-ic-benchmark",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-multi-model-endpoint",
            "InferenceComponents": [
                {"Identifier": "my-inference-component-llama"}
            ]
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"
    },
    AIWorkloadConfigIdentifier="my-benchmark-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
```

**AWS CLI**

```
aws sagemaker create-ai-benchmark-job \
  --ai-benchmark-job-name "my-ic-benchmark" \
  --benchmark-target '{
    "Endpoint": {
      "Identifier": "my-multi-model-endpoint",
      "InferenceComponents": [
        {"Identifier": "my-inference-component-llama"}
      ]
    }
  }' \
  --output-config '{"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/benchmark-results/"}' \
  --ai-workload-config-identifier "my-benchmark-config" \
  --role-arn "arn:aws:iam::111122223333:role/ExampleRole" \
  --region us-west-2
```

**catatan**  
Jika titik akhir Anda dikonfigurasi untuk komponen inferensi tetapi Anda tidak menentukan `InferenceComponents` dalam target benchmark, pekerjaan gagal dengan kesalahan yang menunjukkan bahwa tidak ada model yang diterapkan langsung di titik akhir. Selalu sertakan `InferenceComponents` parameter saat membandingkan titik akhir berbasis komponen inferensi.

## Benchmark titik akhir Multi-lora
<a name="generative-ai-inference-recommendations-benchmark-multi-lora"></a>

Untuk membandingkan titik akhir yang melayani beberapa adaptor LoRa, tentukan setiap adaptor sebagai komponen inferensi di. `BenchmarkTarget` Anda dapat menggunakan parameter `model_selection_strategy` beban kerja secara opsional untuk mengontrol bagaimana benchmark mendistribusikan permintaan di seluruh adaptor. Jika Anda tidak menentukan strategi, defaultnya adalah`round_robin`.

Pertama, buat konfigurasi beban kerja. Contoh berikut mencakup `model_selection_strategy` parameter opsional:

```
# Create a workload config for multi-LoRA benchmarking
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "prompt_input_tokens_mean": 550,
        "output_tokens_mean": 150,
        "concurrency": 10,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B",
        "model_selection_strategy": "round_robin"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    },
    "tooling": {"api_standard": "openai"}
}

import json
client.create_ai_workload_config(
    AIWorkloadConfigName="multi-lora-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)
```

Kemudian, buat pekerjaan benchmark yang menargetkan semua komponen inferensi adaptor LoRa:

```
response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="multi-lora-benchmark",
    BenchmarkTarget={
        "Endpoint": {
            "Identifier": "my-lora-endpoint",
            "InferenceComponents": [
                {"Identifier": "lora-adapter-customer-support"},
                {"Identifier": "lora-adapter-code-generation"},
                {"Identifier": "lora-adapter-summarization"}
            ]
        }
    },
    OutputConfig={
        "S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/multi-lora-results/"
    },
    AIWorkloadConfigIdentifier="multi-lora-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
```

`model_selection_strategy`Parameternya opsional dan menentukan bagaimana alat benchmark mendistribusikan permintaan di seluruh komponen inferensi yang ditentukan. Nilai yang valid adalah:
+ `round_robin`(default) - setiap adaptor menerima permintaan secara berurutan. Permintaan ke-n dikirim ke adaptor (n mod nomber-of-models).
+ `random`— setiap permintaan ditugaskan ke adaptor secara seragam secara acak.

Jika Anda tidak menentukan`model_selection_strategy`, benchmark menggunakan secara `round_robin` default.

## Benchmark titik akhir multimodal dengan gambar sintetis
<a name="generative-ai-inference-recommendations-benchmark-image"></a>

Anda dapat membandingkan model bahasa penglihatan dengan menghasilkan gambar sintetis sebagai bagian dari konfigurasi beban kerja. Layanan benchmarking menggunakan AiPerf untuk membuat gambar dengan dimensi dan format yang dapat dikonfigurasi, lalu mengirimkannya sebagai muatan yang dikodekan base64 ke titik akhir Anda.

Contoh berikut membuat konfigurasi beban kerja untuk membandingkan model bahasa visi dengan gambar sintetis:

```
import json

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "image_width_mean": 640,
        "image_height_mean": 480,
        "prompt_input_tokens_mean": 100,
        "output_tokens_mean": 150,
        "concurrency": 8,
        "request_count": 100,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    }
}

client.create_ai_workload_config(
    AIWorkloadConfigName="image-benchmark-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)
```

Parameter berikut mengontrol pembuatan gambar sintetis:


| Parameter | Tipe | Default | Deskripsi | 
| --- | --- | --- | --- | 
| image\_width\_mean | float | Tidak ada | Lebar gambar rata-rata dalam piksel. | 
| image\_width\_stddev | float | Tidak ada | Standar deviasi lebar gambar. Setel untuk memvariasikan dimensi gambar di seluruh permintaan. | 
| image\_height\_mean | float | Tidak ada | Rata-rata tinggi gambar dalam piksel. | 
| image\_height\_stddev | float | Tidak ada | Standar deviasi tinggi gambar. | 
| image\_batch\_size | int | 1 | Jumlah gambar per permintaan. | 
| image\_format | string | png | Format gambar. Nilai yang valid: png (lossless), jpeg (lossy, file yang lebih kecil), random (secara acak memilih PNG atau JPEG per gambar). | 

**Variable-size gambar**

Gunakan parameter standar deviasi untuk menghasilkan gambar dengan dimensi yang bervariasi, mensimulasikan beban kerja dunia nyata di mana ukuran gambar berbeda:

```
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "image_width_mean": 800,
        "image_width_stddev": 200,
        "image_height_mean": 600,
        "image_height_stddev": 150,
        "image_batch_size": 2,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}
```

## Benchmark titik akhir multimodal dengan video sintetis
<a name="generative-ai-inference-recommendations-benchmark-video"></a>

Anda dapat membandingkan model multimodal yang memproses input video dengan menghasilkan video sintetis sebagai bagian dari konfigurasi beban kerja. Layanan benchmarking menggunakan pembuatan video sintetis AiPerf untuk membuat video dengan resolusi, kecepatan bingkai, durasi, dan pengkodean yang dapat dikonfigurasi, lalu mengirimkannya sebagai muatan berenkode base64 ke titik akhir Anda.

**catatan**  
Pembuatan video dinonaktifkan secara default. Anda harus menentukan keduanya `video_width` dan `video_height` dalam konfigurasi beban kerja Anda untuk mengaktifkannya.

Contoh berikut membuat konfigurasi beban kerja untuk benchmarking model multimodal dengan video sintetis pada resolusi 640 × 480:

```
import json

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "output_tokens_mean": 150,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    },
    "secrets": {
        "hf_token": "arn:aws:secretsmanager:us-west-2:111122223333:secret:my-hf-token-AbCdEf"
    }
}

client.create_ai_workload_config(
    AIWorkloadConfigName="video-benchmark-config",
    WorkloadSpec={"Inline": json.dumps(workload_spec)}
)
```

### Parameter video
<a name="generative-ai-inference-recommendations-benchmark-video-params"></a>

Parameter berikut mengontrol pembuatan video sintetis:


| Parameter | Tipe | Default | Deskripsi | 
| --- | --- | --- | --- | 
| video\_width | int | Tidak ada | Lebar bingkai dalam piksel. Harus diatur dengan video\_height untuk mengaktifkan pembuatan video. | 
| video\_height | int | Tidak ada | Tinggi bingkai dalam piksel. Harus diatur dengan video\_width untuk mengaktifkan pembuatan video. | 
| video\_fps | int | 4 | Bingkai per detik. | 
| video\_duration | float | 5.0 | Durasi klip dalam hitungan detik. | 
| video\_batch\_size | int | 1 | Jumlah video per permintaan. | 
| video\_synth\_type | string | bergerak\_shapes | Pola sintesis. Nilai yang valid: moving\_shapes (bentuk geometris animasi), grid\_clock (kisi dengan animasi jam), noise (noise piksel acak). | 
| video\_format | string | webm | Format wadah. Nilai valid: webm. | 
| video\_codec | string | libvpx-vp9 | Codec video. Nilai yang didukung: libvpx-vp9 (VP9, WebM). | 

**catatan**  
Layanan benchmarking mendukung pengkodean VP9 dengan format WebM saja.

### Trek audio tertanam
<a name="generative-ai-inference-recommendations-benchmark-video-audio"></a>

Untuk model yang memproses video dan audio bersama-sama, Anda dapat menyematkan trek audio sintetis dalam video yang dihasilkan. Audio dinonaktifkan secara default. Setel `video_audio_num_channels` ke `1` (mono) atau `2` (stereo) untuk mengaktifkannya.


| Parameter | Tipe | Default | Deskripsi | 
| --- | --- | --- | --- | 
| video\_audio\_num\_channels | int | 0 | 0 = dinonaktifkan, 1 = mono, 2 = stereo. | 
| video\_audio\_sample\_rate | int | 44100 | Tingkat sampel dalam Hz (8000—96000). | 
| video\_audio\_codec | string | auto | Codec audio. Auto-selects libvorbisuntuk WebM dan aac untuk MP4. Anda dapat mengganti denganaac,libvorbis, ataulibopus. | 
| video\_audio\_depth | int | 16 | Kedalaman bit per sampel (8, 16, 24, atau 32). | 

### Contoh pembandingan video
<a name="generative-ai-inference-recommendations-benchmark-video-examples"></a>

**Low-resolution pemahaman video**

```
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 320,
        "video_height": 240,
        "video_fps": 2,
        "video_duration": 3.0,
        "video_synth_type": "moving_shapes",
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}
```

**Pembandingan video HD**

```
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 1920,
        "video_height": 1080,
        "video_fps": 8,
        "video_duration": 10.0,
        "concurrency": 2,
        "request_count": 20,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}
```

**Video dengan audio untuk model multimodal**

```
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "video_audio_num_channels": 1,
        "video_audio_sample_rate": 16000,
        "concurrency": 4,
        "request_count": 50,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}
```

**Teks dan video campuran**

Gabungkan video dengan petunjuk teks untuk menjawab pertanyaan video atau beban kerja teks:

```
workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "video_width": 640,
        "video_height": 480,
        "video_fps": 4,
        "video_duration": 5.0,
        "prompt_input_tokens_mean": 100,
        "output_tokens_mean": 50,
        "concurrency": 8,
        "request_count": 100,
        "streaming": True,
        "tokenizer": "meta-llama/Llama-3.2-1B"
    }
}
```

### Pertimbangan performa
<a name="generative-ai-inference-recommendations-benchmark-video-considerations"></a>
+ Resolusi dan frame rate yang lebih tinggi meningkatkan waktu pengkodean video dan ukuran muatan. Untuk pengujian throughput tinggi, gunakan resolusi yang lebih rendah (320 × 240 atau 640 × 480).
+ VP9 (`libvpx-vp9`) dengan format WebM adalah satu-satunya codec yang didukung dan memberikan kompresi yang baik untuk benchmarking payload.
+ Audio menambahkan overhead minimal dibandingkan dengan streaming video. Gunakan mono (`1`) pada 16 kHz untuk beban kerja yang berfokus pada ucapan.

## Langkah 2: Pantau status pekerjaan
<a name="generative-ai-inference-recommendations-benchmark-monitor"></a>

Polling status pekerjaan hingga mencapai status terminal.

**Python (boto3)**

```
import time

while True:
    response = client.describe_ai_benchmark_job(
        AIBenchmarkJobName="my-benchmark-job"
    )
    status = response["AIBenchmarkJobStatus"]
    print(f"Status: {status}")
    if status in ("Completed", "Failed", "Stopped"):
        break
    time.sleep(30)

if status == "Completed":
    print(f"Results at: {response['OutputConfig']['S3OutputLocation']}")
elif status == "Failed":
    print(f"Job failed: {response.get('FailureReason', 'unknown')}")
```

**AWS CLI**

```
aws sagemaker describe-ai-benchmark-job \
  --ai-benchmark-job-name "my-benchmark-job" \
  --region us-west-2
```

## Langkah 3: Tinjau hasil benchmark
<a name="generative-ai-inference-recommendations-benchmark-results"></a>

Hasil benchmark ditulis ke lokasi keluaran Amazon S3 yang Anda tentukan. Hasilnya meliputi metrik utama berikut:

`request_throughput`  
Permintaan per detik.

`request_latency`  
End-to-end minta latensi dengan kerusakan persentil (P50, P90, P99).

`time_to_first_token`  
Waktu dari pengiriman permintaan ke token pertama yang diterima.

`inter_token_latency`  
Waktu antara token keluaran berturut-turut.

`output_token_throughput`  
Token keluaran yang dihasilkan per detik.

Setiap metrik mencakup ringkasan statistik: rata-rata, minimum, maksimum, P50, P90, P99, dan standar deviasi.

## Benchmark titik akhir format khusus
<a name="generative-ai-inference-recommendations-benchmark-custom-format"></a>

Jika titik akhir Anda menggunakan format permintaan atau respons khusus (misalnya, penangan kustom DJL, format TensorRT-LLM asli, atau kerangka kerja penyajian lainnya yang tidak mendukung API penyelesaian obrolan OpenAI), Anda dapat melakukan benchmark menggunakan template Jinja2 untuk menentukan bentuk payload titik akhir Anda.

Layanan benchmarking merender template per permintaan dengan prompt sintetis atau kustom, lalu meneruskan payload ke titik akhir AI Anda. SageMaker Anda juga menentukan kueri JMESPath untuk mengekstrak teks yang dihasilkan dari respons titik akhir Anda.

### Buat template payload
<a name="generative-ai-inference-recommendations-benchmark-custom-format-template"></a>

Tentukan format permintaan titik akhir Anda sebagai file template Jinja2. Variabel berikut tersedia dalam template:


| Variabel | Deskripsi | 
| --- | --- | 
| text | Konten teks pertama (sintetis atau dari dataset). | 
| texts | Daftar semua isi teks. | 
| model | Nama model. | 
| max\_tokens | Batas token keluaran. | 
| stream | Apakah streaming diaktifkan. | 

Gunakan `|tojson` filter untuk melarikan diri JSON yang tepat dari nilai string. Contoh berikut menunjukkan template untuk titik akhir DJL dengan format pemanggilan alat:

```
{
  "messages": [{"role": "user", "content": {{ text|tojson }}}],
  "tools": [
    {"function": {"name": "Chit_Chat", "description": "casual conversation",
      "parameters": {"type": "object", "properties": {}}}}
  ],
  "max_tokens": {{ max_tokens }}
}
```

Unggah file template ke Amazon S3 (misalnya,`s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja`).

### Buat konfigurasi beban kerja
<a name="generative-ai-inference-recommendations-benchmark-custom-format-config"></a>

Buat konfigurasi beban kerja yang mereferensikan file template. Gunakan `extra_inputs` parameter untuk menentukan path template dan query ekstraksi respon. Kirimkan file template ke wadah benchmark melalui `DatasetConfig` saluran.

```
import json

TEMPLATE_LOCAL_PATH = "/opt/ml/input/data/template/my_endpoint_template.jinja"
RESPONSE_FIELD = "generation_details.generations[0].content"

workload_spec = {
    "benchmark": {"type": "aiperf"},
    "parameters": {
        "extra_inputs": f"payload_template:{TEMPLATE_LOCAL_PATH} response_field:{RESPONSE_FIELD}",
        "tokenizer": "meta-llama/Llama-3.2-1B",
        # ... other benchmark parameters (concurrency, request_count, etc.)
    },
}

response = client.create_ai_workload_config(
    AIWorkloadConfigName="custom-format-config",
    AIWorkloadConfigs={"WorkloadSpec": {"Inline": json.dumps(workload_spec)}},
    DatasetConfig={
        "InputDataConfig": [
            {
                "ChannelName": "template",
                "DataSource": {
                    "S3DataSource": {
                        "S3Uri": "s3://DOC-EXAMPLE-BUCKET/templates/my_endpoint_template.jinja",
                    }
                },
            }
        ]
    },
)
```

Ini `ChannelName` menentukan di mana file muncul di dalam wadah benchmark. Saluran bernama `template` membuat file tersedia di`/opt/ml/input/data/template/<filename>`.

`response_field`Nilainya adalah kueri [JMESPath](https://jmespath.org/) yang mengekstrak teks yang dihasilkan dari respons titik akhir Anda. Pola umum meliputi:
+ `choices[0].message.content`— Format OpenAI
+ `generation_details.generations[0].content`— Format DJL
+ `output.text`— respon teks sederhana

Jika Anda menghilangkan`response_field`, alat benchmarking otomatis mendeteksi format respons.

### Jalankan benchmark
<a name="generative-ai-inference-recommendations-benchmark-custom-format-run"></a>

Buat pekerjaan benchmark yang menargetkan titik akhir Anda. Layanan secara otomatis mendeteksi mode template dari `payload_template` kunci masuk `extra_inputs` dan merutekan permintaan melalui jalur proxy yang sesuai.

```
response = client.create_ai_benchmark_job(
    AIBenchmarkJobName="custom-format-benchmark",
    BenchmarkTarget={"Endpoint": {"Identifier": "my-custom-endpoint"}},
    OutputConfig={"S3OutputLocation": "s3://DOC-EXAMPLE-BUCKET/results/"},
    AIWorkloadConfigIdentifier="custom-format-config",
    RoleArn="arn:aws:iam::111122223333:role/ExampleRole",
)
```

### Pertimbangan-pertimbangan
<a name="generative-ai-inference-recommendations-benchmark-custom-format-notes"></a>
+ Template harus dikirim sebagai file melalui Amazon S3. Template JSON sebaris dalam `extra_inputs` string tidak didukung karena koma di JSON bertentangan dengan parser parameter.
+ Titik akhir dengan komponen inferensi tunggal didukung. Titik akhir dengan beberapa komponen inferensi tidak didukung dalam mode templat karena layanan tidak dapat menentukan komponen mana yang akan merutekan setiap permintaan dari format payload arbitrer.
+ Baik titik akhir streaming dan non-streaming didukung. Atur `"streaming": true` atau `"streaming": false` dalam parameter beban kerja.

## Korelasikan petunjuk dan tanggapan benchmark
<a name="generative-ai-inference-recommendations-benchmark-correlate-io"></a>

Setelah pekerjaan benchmark selesai, artefak keluaran menyertakan data input dan output per permintaan yang dapat Anda gabungkan bersama untuk pasca-pemrosesan. Hal ini memungkinkan kasus penggunaan seperti evaluasi kualitas, audit keselamatan, perbandingan respons di seluruh konfigurasi, dan men-debug perilaku model yang tidak terduga.

### Artefak keluaran benchmark
<a name="generative-ai-inference-recommendations-benchmark-correlate-io-artifacts"></a>

`output.tar.gz`Arsip di lokasi keluaran Amazon S3 berisi file berikut yang relevan dengan korelasi prompt respons:

`inputs.json`  
Kumpulan data sintetis lengkap dari percakapan yang dihasilkan. Setiap catatan memiliki `session_id` dan payload permintaan lengkap (pesan, max\_tokens, model).

`outputs.json`  
Per-request metadata respons untuk permintaan yang dikirim ke titik akhir. Setiap catatan mencakup teks respons model, latensi per permintaan, jumlah token keluaran, dan `conversation_id` yang memetakan kembali ke input.

### Bergabunglah dengan input ke output
<a name="generative-ai-inference-recommendations-benchmark-correlate-io-join"></a>

Korelasikan prompt dengan tanggapan mereka menggunakan `conversation_id` bidang di `outputs.json` dan `session_id` bidang di: `inputs.json`

```
import json

# Load the artifacts extracted from output.tar.gz in your S3 output location
with open("inputs.json") as f:
    inputs = json.load(f)
with open("outputs.json") as f:
    outputs = json.load(f)

# Build lookup tables and join
inputs_by_id = {rec["session_id"]: rec for rec in inputs["data"]}
outputs_by_id = {rec["conversation_id"]: rec for rec in outputs["data"]}

matched_ids = set(inputs_by_id.keys()) & set(outputs_by_id.keys())
print(f"Matched: {len(matched_ids)} prompt-response pairs")

# Display a correlated sample
for sid in sorted(matched_ids)[:3]:
    in_rec = inputs_by_id[sid]
    out_rec = outputs_by_id[sid]
    prompt = in_rec["payloads"][0]["messages"][0]["content"][:100]
    response = out_rec.get("response_text", "")[:100]
    latency = out_rec["metrics"]["request_latency"]
    print(f"\n[{sid}] Latency: {latency:.0f}ms")
    print(f"  Prompt:   {prompt}...")
    print(f"  Response: {response}...")
```

### Catatan penting
<a name="generative-ai-inference-recommendations-benchmark-correlate-io-notes"></a>
+ **Bergabunglah dengan kunci.** Gunakan `conversation_id` dalam `outputs.json` untuk mencocokkan melawan `session_id` dalam`inputs.json`. Jangan gunakan `session_num` sebagai indeks posisi — ini mewakili perintah eksekusi, yang berbeda dari urutan pembuatan input ketika konkurensi lebih besar dari 1.
+ **Tidak semua input memiliki output.** `inputs.json`File berisi kumpulan kumpulan data yang dihasilkan penuh. Bila `request_count` kurang dari ukuran pool, hanya sebagian percakapan yang dikirim ke endpoint. Input yang tak tertandingi adalah percakapan yang dihasilkan tetapi tidak digunakan.
+ **Skema keluaran.** Setiap catatan `outputs.json` termasuk`conversation_id`,`response_text`, `metrics` (dengan `request_latency` dan`output_sequence_length`), dan bidang waktu (`request_start_ns`,`request_end_ns`).

## Kelola sumber daya tolok ukur
<a name="generative-ai-inference-recommendations-benchmark-manage"></a>

Gunakan operasi berikut untuk mengelola pekerjaan benchmark dan konfigurasi beban kerja Anda.

```
# List benchmark jobs
response = client.list_ai_benchmark_jobs(MaxResults=10)
for job in response["AIBenchmarkJobs"]:
    print(f"{job['AIBenchmarkJobName']} - {job['AIBenchmarkJobStatus']}")

# Stop a running job
client.stop_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job"
)

# Delete a job (must be in a terminal state)
client.delete_ai_benchmark_job(
    AIBenchmarkJobName="my-benchmark-job"
)

# List workload configurations
response = client.list_ai_workload_configs(MaxResults=10)
for config in response["AIWorkloadConfigs"]:
    print(f"{config['AIWorkloadConfigName']} - {config['AIWorkloadConfigArn']}")

# Delete a workload configuration
client.delete_ai_workload_config(
    AIWorkloadConfigName="my-benchmark-config"
)
```