Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Sesuaikan model dengan fine-tuning tulangan di Amazon Bedrock
Reinforcement fine-tuning adalah teknik penyesuaian model di Amazon Bedrock yang meningkatkan kinerja model pondasi dengan mengajarkan model apa yang merupakan respons “baik” melalui sinyal umpan balik yang disebut penghargaan. Tidak seperti metode fine-tuning tradisional yang bergantung pada kumpulan data berlabel, penyempurnaan penguatan menggunakan pendekatan berbasis umpan balik yang secara iteratif mengoptimalkan model untuk memaksimalkan imbalan ini.
## Aplikasi dan skenario fine-tuning penguatan
Gunakan fine-tuning penguatan ketika Anda dapat menentukan kriteria keberhasilan yang jelas dan terukur untuk mengevaluasi kualitas respons. Penyetelan halus penguatan unggul dalam domain di mana kualitas keluaran dapat diukur secara objektif, terutama ketika ada beberapa respons yang valid atau ketika respons optimal sulit untuk didefinisikan di muka. Ini ideal untuk:
+ Pemecahan masalah matematika dan pembuatan kode (menggunakan grader berbasis aturan untuk evaluasi objektif)
+ Penalaran ilmiah dan analisis data terstruktur
+ Tugas subyektif seperti mengikuti instruksi, moderasi konten, dan penulisan kreatif (menggunakan juri berbasis AI)
+ Tugas yang membutuhkan step-by-step penalaran atau pemecahan masalah multi-putaran
+ Skenario dengan beberapa solusi valid di mana beberapa jelas lebih baik daripada yang lain
+ Aplikasi menyeimbangkan berbagai tujuan (akurasi, efisiensi, gaya)
+ Aplikasi yang membutuhkan perbaikan berulang, personalisasi, atau kepatuhan terhadap aturan bisnis yang kompleks
+ Skenario di mana keberhasilan dapat diverifikasi secara terprogram melalui hasil eksekusi atau metrik kinerja
+ Kasus di mana mengumpulkan contoh berlabel berkualitas tinggi mahal atau tidak praktis
## Manfaat fine-tuning penguatan
+ **Peningkatan kinerja model** - Penyetelan halus penguatan meningkatkan akurasi model hingga rata-rata 66% dibandingkan dengan model dasar. Hal ini memungkinkan optimalisasi harga dan kinerja dengan menyempurnakan varian model yang lebih kecil, lebih cepat, dan lebih efisien.
+ **Kemudahan penggunaan** - Amazon Bedrock mengotomatiskan kompleksitas penyempurnaan penguatan, membuatnya dapat diakses oleh pengembang yang membangun aplikasi AI. Anda dapat menyempurnakan model menggunakan kumpulan data yang diunggah atau log pemanggilan API yang ada. Anda dapat menentukan fungsi reward yang menilai output model dengan kode kustom menggunakan Lambda model-as-a-judge atau grader, dengan templat bawaan yang membantu penyiapan cepat.
+ **Keamanan dan kepatuhan** — Data kepemilikan Anda tidak pernah meninggalkan AWS lingkungan yang aman dan diatur selama proses penyesuaian.
## Model yang didukung untuk fine-tuning penguatan
Tabel berikut menunjukkan model pondasi yang dapat Anda sesuaikan dengan fine-tuning tulangan:
**Model yang didukung untuk fine-tuning penguatan**
| Penyedia | Model | ID Model | Nama wilayah | Region |
| --- | --- | --- | --- | --- |
| Amazon | Nova 2 Lite | amazon.nova-2-lite-v 1:0:256 k | US East (Northern Virginia) | us-east-1 |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | AS Barat (Oregon) | us-west-2 |
| Qwen | Qwen3 32B | qwen.qwen3-32b | AS Barat (Oregon) | us-west-2 |
## Cara kerja fine-tuning penguatan
Amazon Bedrock sepenuhnya mengotomatiskan alur kerja fine-tuning penguatan. Model menerima petunjuk dari kumpulan data pelatihan Anda dan menghasilkan beberapa respons per prompt. Tanggapan ini kemudian dinilai oleh fungsi hadiah. Amazon Bedrock menggunakan pasangan prompt respons dengan skor untuk melatih model melalui pembelajaran berbasis kebijakan menggunakan Group Relative Policy Optimization (GRPO). Loop pelatihan berlanjut hingga mencapai akhir data pelatihan Anda atau Anda menghentikan pekerjaan di pos pemeriksaan yang dipilih, menghasilkan model yang dioptimalkan untuk metrik yang penting bagi Anda.
## Praktik terbaik fine-tuning penguatan
+ **Mulai dari yang kecil** - Mulailah dengan 100-200 contoh, validasi kebenaran fungsi hadiah, dan skala secara bertahap berdasarkan hasil
+ **Evaluasi pra-fine-tuning** - Uji kinerja model dasar sebelum fine-tuning penguatan. Jika hadiah secara konsisten 0 persen, gunakan fine-tuning yang diawasi terlebih dahulu untuk membangun kemampuan dasar. Jika hadiah lebih besar dari 95 persen, penyetelan penguatan mungkin tidak diperlukan
+ **Monitor pelatihan** — Lacak skor dan distribusi hadiah rata-rata. Perhatikan overfitting (hadiah pelatihan meningkat sementara imbalan validasi berkurang). Cari pola terkait seperti imbalan yang berada di bawah 0,15, meningkatkan varians hadiah dari waktu ke waktu, dan penurunan kinerja validasi
+ **Optimalkan fungsi reward** — Jalankan dalam hitungan detik (bukan menit), minimalkan panggilan API eksternal, gunakan algoritme yang efisien, terapkan penanganan kesalahan yang tepat, dan manfaatkan penskalaan paralel Lambda
+ **Strategi iterasi** - Jika hadiah tidak membaik, sesuaikan desain fungsi hadiah, tingkatkan keragaman kumpulan data, tambahkan lebih banyak contoh yang representatif, dan verifikasi sinyal hadiah jelas dan konsisten
**Topics**
+ [Aplikasi dan skenario fine-tuning penguatan](#reinforcement-fine-tuning-when)
+ [Manfaat fine-tuning penguatan](#reinforcement-fine-tuning-benefits)
+ [Model yang didukung untuk fine-tuning penguatan](#rft-supported-models)
+ [Cara kerja fine-tuning penguatan](#rft-how-it-works)
+ [Praktik terbaik fine-tuning penguatan](#rft-best-practices)
+ [Sempurnakan model Amazon Nova dengan penyetelan penguatan](rft-nova-models.md)
+ [Sempurnakan model bobot terbuka menggunakan -kompatibel OpenAI APIs](fine-tuning-openai-apis.md)
+ [Evaluasi model RFT Anda](rft-evaluate-model.md)
# Sempurnakan model Amazon Nova dengan penyetelan penguatan
Sebelum melakukan fine-tuning, pastikan Anda memiliki prasyarat karena Amazon Bedrock memerlukan izin khusus untuk membuat dan mengelola proses fine-tuning. Untuk informasi keamanan dan izin yang komprehensif, lihat[Akses dan keamanan untuk model Amazon Nova](rft-access-security.md).
Jalankan fine-tuning penguatan untuk model Amazon Nova dalam 5 langkah:
1. **Menyediakan Dataset Pelatihan** — Unggah petunjuk dalam format yang diperlukan (misalnya, JSONL) sebagai kumpulan data pelatihan fine-tuning penguatan. Untuk informasi selengkapnya, lihat [Siapkan data untuk model Amazon Nova](rft-prepare-data.md).
1. **Konfigurasi Fungsi Hadiah (grader)** - Tentukan grader untuk menilai respons model berdasarkan kebenaran, struktur, nada, atau tujuan lainnya. Fungsi hadiah dapat dijalankan menggunakan Lambda untuk menghitung skor objektif. Anda juga dapat memilih model sebagai juri (melalui konsol) dan menilai respons berdasarkan kriteria dan prinsip yang Anda konfigurasikan (konsol mengonversinya menjadi fungsi Lambda secara otomatis). Untuk informasi selengkapnya, lihat [Menyiapkan fungsi hadiah untuk model Amazon Nova](reward-functions.md).
1. **Submit reinforcement fine-tuning Job** — Luncurkan pekerjaan fine-tuning tulangan dengan menentukan model dasar, dataset, fungsi reward, dan pengaturan opsional lainnya seperti hyperparameters. Untuk informasi selengkapnya, lihat [Buat dan kelola pekerjaan fine-tuning untuk model Amazon Nova](rft-submit-job.md).
1. **Pantau Pelatihan** — Lacak status pekerjaan, metrik hadiah, dan kemajuan pelatihan hingga selesai. Untuk informasi selengkapnya, lihat [Pantau pekerjaan pelatihan RFT Anda](rft-submit-job.md#rft-monitor-job).
1. **Gunakan Model Fine-Tuned** — Setelah pekerjaan selesai, terapkan model RFT yang dihasilkan dengan satu klik untuk inferensi sesuai permintaan. Anda juga dapat menggunakan Provisioned Throughput untuk beban kerja penting misi yang memerlukan kinerja yang konsisten. Lihat [Siapkan inferensi untuk model khusus](model-customization-use.md). Gunakan **Test in Playground** untuk mengevaluasi dan membandingkan respons dengan model dasar.
**penting**
Anda dapat memberikan maksimum 20K petunjuk ke Amazon Bedrock untuk penguatan menyempurnakan model.
## Model Nova yang didukung
Tabel berikut menunjukkan model Amazon Nova yang dapat Anda sesuaikan dengan fine-tuning tulangan:
**catatan**
Untuk informasi tentang model tambahan yang didukung termasuk model berat terbuka, lihat[Sempurnakan model bobot terbuka menggunakan -kompatibel OpenAI APIs](fine-tuning-openai-apis.md).
**Model yang didukung untuk fine-tuning penguatan**
| Penyedia | Model | ID Model | Dukungan model wilayah tunggal |
| --- | --- | --- | --- |
| Amazon | Nova 2 Lite | amazon.nova-2-lite-v 1:0:256 k | us-east-1 |
# Akses dan keamanan untuk model Amazon Nova
Sebelum Anda memulai fine-tuning penguatan, pastikan Anda memahami jenis akses apa yang dibutuhkan Amazon Bedrock untuk operasi khusus RFT. RFT memerlukan izin tambahan di luar fine-tuning standar karena kemampuan eksekusi fungsi reward.
Untuk pengaturan keamanan kustomisasi model dasar termasuk hubungan kepercayaan, izin Amazon S3, dan enkripsi KMS, lihat. [Buat peran layanan IAM untuk kustomisasi model](custom-model-job-access-security.md#custom-model-job-service-role)
## Prasyarat
Sebelum menambahkan izin IAM khusus RFT, Anda harus menambahkan peran layanan IAM berikut:
+ [Hubungan kepercayaan](custom-model-job-access-security.md#custom-model-job-service-role-trust-relationship)
+ [Izin untuk mengakses file pelatihan dan validasi dan untuk menulis file output di S3](custom-model-job-access-security.md#custom-model-job-service-role-s3-permissions)
## Izin IAM khusus RFT
Tambahkan izin ini ke peran layanan penyesuaian model yang ada untuk fungsionalitas RFT.
### Izin Lambda untuk fungsi hadiah
Anda harus menambahkan izin pemanggilan Lambda. Berikut ini menunjukkan contoh kebijakan yang dapat Anda gunakan:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
### Akses log pemanggilan
Untuk menggunakan log pemanggilan model Amazon Bedrock yang ada sebagai data pelatihan, tambahkan izin untuk mengakses bucket Amazon S3 tempat log pemanggilan disimpan.
Anda harus memberikan izin akses bucket Amazon S3 untuk bucket input. Berikut ini menunjukkan contoh kebijakan yang dapat Anda gunakan:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::s3-invocation-logs-bucket",
"arn:aws:s3:::s3-invocation-logs-bucket/*"
]
}
]
}
```
Untuk pengaturan keamanan termasuk peran IAM dasar, izin Amazon S3, dan enkripsi, lihat. [Buat peran layanan IAM untuk kustomisasi model](custom-model-job-access-security.md#custom-model-job-service-role)
## Izin fungsi Grader Lambda untuk RLAIF
Jika Anda membuat fungsi Lambda sendiri untuk fungsi reward Reinforcement Learning from AI Feedback (RLAIF), Anda perlu menambahkan izin khusus ke peran eksekusi Lambda.
### Izin dasar dasar untuk juri LLM
Untuk fungsi LLM-as-Judge reward (RLAIF), tambahkan izin untuk memanggil model foundation. Berikut ini menunjukkan contoh kebijakan yang dapat Anda gunakan untuk peran eksekusi Lambda Anda.
**catatan**
Hanya tambahkan izin ini ke peran eksekusi Lambda Anda jika Anda membuat fungsi Lambda Anda sendiri. Konsol menangani ini secara otomatis saat membuat fungsi Lambda melalui konsol.
Berikut ini adalah contoh untuk LLM batuan dasar sebagai pemanggilan hakim menggunakan model pondasi:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
Berikut ini adalah contoh untuk batuan dasar LLM sebagai pemanggilan hakim menggunakan profil inferensi:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-premier-v1:0",
"arn:aws:bedrock:us-east-2::foundation-model/amazon.nova-premier-v1:0",
"arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-premier-v1:0"
],
"Condition": {
"StringLike": {
"bedrock:InferenceProfileArn": "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
}
}
},
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
]
}
]
}
```
[Untuk informasi tentang prasyarat profil inferensi, lihat Prasyarat untuk profil inferensi.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html)
# Siapkan data untuk model Amazon Nova
Saat menyempurnakan model Amazon Nova dengan penyempurnaan penguatan, Anda dapat membawa petunjuk sendiri atau menggunakan log pemanggilan Amazon Bedrock API yang ada sebagai data pelatihan.
## Persyaratan dan sumber data pelatihan
Anda dapat memberikan data pelatihan melalui salah satu opsi berikut:
**catatan**
Kami hanya mendukung format penyelesaian obrolan OpenAI.
### Opsi 1: Berikan petunjuk Anda sendiri
Kumpulkan petunjuk Anda dan simpan dalam format `.jsonl` file. Anda dapat mengunggah kumpulan data khusus dalam format JSONL atau memilih kumpulan data yang ada dari Amazon S3. Setiap catatan di JSONL harus menggunakan format penyelesaian obrolan OpenAI dalam struktur berikut:
+ `messages`: Di bidang ini, sertakan peran pengguna, sistem atau asisten yang berisi prompt input yang diberikan kepada model.
+ `reference_answer`: Di bidang ini, harus berisi output yang diharapkan atau kriteria evaluasi yang digunakan fungsi hadiah Anda untuk menilai respons model. Ini tidak terbatas pada output terstruktur—dapat berisi format apa pun yang membantu fungsi hadiah Anda mengevaluasi kualitas.
+ [Opsional] Anda dapat menambahkan bidang yang digunakan oleh grader Lambda untuk penilaian.
**Persyaratan:**
+ Format JSONL dengan petunjuk dalam format penyelesaian obrolan OpenAI (satu prompt per baris)
+ Minimal 100 catatan dalam dataset pelatihan
+ Amazon Bedrock secara otomatis memvalidasi format kumpulan data pelatihan
------
#### [ Example: General question-answering ]
```
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
role": "user",
"content": "What is machine learning?"}
],
"reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed."
}
```
------
#### [ Example: Math problem ]
```
{
"id": "sample-001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
### Opsi 2: Gunakan log pemanggilan
Saat membuat pekerjaan fine-tuning penguatan, Anda dapat meminta Amazon Bedrock menggunakan log pemanggilan yang ada dari bucket S3 sebagai data pelatihan. Untuk Amazon Bedrock, log pemanggilan adalah catatan rinci tentang pemanggilan model.
Anda dapat menggunakan log pemanggilan Invoke/Converse API yang disimpan di sisi pelanggan dari Amazon S3 untuk pelatihan.
**Persyaratan:**
+ Pencatatan API harus diaktifkan untuk penggunaan Amazon Bedrock Anda
+ Log harus dalam format yang didukung (Amazon Bedrock Invoke/Converse API)
+ Minimal 100 contoh prompt
Untuk menggunakan log pemanggilan untuk fine-tuning penguatan, setel log pemanggilan model, gunakan salah satu operasi pemanggilan model, dan pastikan Anda telah menyiapkan bucket Amazon S3 sebagai tujuan log. Untuk informasi selengkapnya tentang menyiapkan log pemanggilan, lihat [Memantau pemanggilan model menggunakan Log dan CloudWatch Amazon](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) S3.
Sebelum Anda dapat memulai pekerjaan fine-tuning reinforcement dengan log pemanggilan dari bucket S3 sebagai input, Anda harus memberikan izin Amazon Bedrock untuk mengakses log dari Bucket S3. Untuk informasi selengkapnya, lihat [Akses dan keamanan kustomisasi model](custom-model-job-access-security.md).
Anda dapat menambahkan metadata permintaan secara opsional ke pasangan prompt respons dalam log pemanggilan menggunakan salah satu operasi pemanggilan model dan kemudian menggunakannya untuk memfilter log. Amazon Bedrock dapat menggunakan log yang difilter untuk menyempurnakan model.
#### Tambahkan metadata permintaan ke prompt dan tanggapan di log pemanggilan Anda
Dengan log pemanggilan, Anda dapat mengidentifikasi permintaan kumpulan data pelatihan yang ingin digunakan Amazon Bedrock untuk penyempurnaan penguatan menggunakan metadata permintaan yang dilampirkan ke log pemanggilan.
Berikut ini adalah contoh log pemanggilan dari `InvokeModel` panggilan dengan: `requestMetadata`
```
{
"schemaType": "ModelInvocationLog",
"schemaVersion": "1.0",
"timestamp": "2024-09-11T17:16:18Z",
"accountId": "XXXXX",
"identity": {
"arn": "arn:aws:sts::XXXXXXX:assumed-role/Admin/XXXXXX"
},
"region": "us-east-1",
"requestId": "7ee514f3-9eff-467c-af75-8fd564ce58e5",
"operation": "InvokeModel",
"modelId": "meta.llama3-1-405b-instruct-v1:0",
"input": {
"inputContentType": "application/json",
"inputBodyJson": {
"prompt": "story of two dogs",
"max_tokens_to_sample": 300
},
"inputTokenCount": 13
},
"output": {
"outputContentType": "application/json",
"outputBodyJson": {
"type": "completion",
"completion": " Here is a story about two dogs:\n\nRex and Charlie were best friends who lived next door to each other. Every morning, their owners would let them out into the backyard to play. Rex was a golden retriever with long, shaggy fur. He loved to run and chase sticks. Charlie was a corgi with short legs and a big smile. He was happy just sniffing the grass and rolling around. \n\nThe two dogs spent every day playing together. Rex would grab a stick and bring it over to Charlie, wagging his tail excitedly. Charlie would take the other end of the stick in his mouth and they'd have a friendly game of tug-of-war. After tiring themselves out, they'd flop down in the warm sunshine for a nap. \n\nAt lunchtime, their owners would call them in for food. Rex would gobble up his kibble hungrily while Charlie ate his at a more leisurely pace. After lunch, it was right back outside for more playtime. The afternoon sunbeams would light up their fur as they chased each other around the yard. \n\nWhen it started getting late, their owners called them in for the night. Rex and Charlie would head inside, tired but happy after another fun day of play. After slurping up fresh water from their bowls, they'd curl up on their beds, Rex's fluffy golden tail tucked over his nose and little",
"stop_reason": "max_tokens",
"stop": null
},
"outputTokenCount": 300
},
"requestMetadata": {
"project": "CustomerService",
"intent": "ComplaintResolution",
"priority": "High"
}
}
```
Anda dapat menentukan log pemanggilan sebagai sumber data input saat memulai pekerjaan fine-tuning penguatan. Anda dapat memulai pekerjaan fine-tuning penguatan melalui konsol Amazon Bedrock, menggunakan API, AWS CLI atau SDK.
##### Persyaratan untuk menyediakan metadata permintaan
Metadata permintaan harus memenuhi persyaratan berikut:
+ Disediakan dalam `key:value` format JSON.
+ Pasangan kunci dan nilai harus berupa string maksimum 256 karakter.
+ Berikan maksimal 16 pasangan kunci-nilai.
##### Menggunakan filter metadata permintaan
Setelah log pemanggilan dengan metadata permintaan tersedia, Anda dapat menerapkan filter berdasarkan metadata permintaan untuk memilih secara selektif permintaan mana yang akan disertakan untuk menyempurnakan model. Misalnya, Anda mungkin hanya ingin menyertakan metadata yang memiliki `"project": "CustomerService"` dan `"priority": "High"` meminta metadata.
Untuk memfilter log menggunakan beberapa metadata permintaan, gunakan satu operator Boolean atau. `AND` `OR` Anda tidak dapat menggabungkan operator ini. Untuk pemfilteran metadata permintaan tunggal, gunakan operator or. `Equals` `Not Equals`
## Karakteristik data pelatihan yang efektif
Data pelatihan RFT yang efektif membutuhkan tiga karakteristik utama:
+ **Kejelasan dan konsistensi** - Gunakan petunjuk yang jelas dan tidak ambigu dengan pemformatan yang konsisten. Hindari label yang kontradiktif, instruksi yang ambigu, atau jawaban referensi yang bertentangan yang menyesatkan pelatihan.
+ **Keragaman** — Sertakan beragam format input, kasus tepi, dan tingkat kesulitan yang mencerminkan pola penggunaan produksi di berbagai jenis dan skenario pengguna.
+ **Fungsi hadiah yang efisien** — Merancang fungsi yang dijalankan dengan cepat (detik, bukan menit), sejajar dengan AWS Lambda, dan mengembalikan skor yang konsisten untuk pelatihan hemat biaya.
## Properti tambahan
Format data RFT mendukung bidang khusus di luar persyaratan skema inti (`messages`dan`reference_answer`). Fleksibilitas ini memungkinkan Anda untuk menambahkan data tambahan apa pun yang dibutuhkan fungsi hadiah Anda untuk evaluasi yang tepat.
**catatan**
Anda tidak perlu mengonfigurasi ini dalam resep Anda. Format data secara inheren mendukung bidang tambahan. Cukup sertakan mereka dalam data pelatihan Anda JSON, dan mereka akan diteruskan ke fungsi hadiah Anda di `metadata` lapangan.
**Properti tambahan umum**
+ `task_id`— Pengidentifikasi unik untuk melacak
+ `difficulty_level`— Indikator kompleksitas masalah
+ `domain`— Bidang subjek atau kategori
+ `expected_reasoning_steps`— Jumlah langkah dalam solusi
Bidang tambahan ini diteruskan ke fungsi hadiah Anda selama evaluasi, memungkinkan logika penilaian canggih yang disesuaikan dengan kasus penggunaan spesifik Anda.
**Contoh dengan properti tambahan**
------
#### [ Chemistry problem ]
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4
}
}
```
`reference_answer`Bidang berisi output yang diharapkan atau kriteria evaluasi yang digunakan fungsi hadiah Anda untuk menilai respons model. Ini tidak terbatas pada output terstruktur—dapat berisi format apa pun yang membantu fungsi hadiah Anda mengevaluasi kualitas.
------
#### [ Math problem with metadata ]
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
------
# Menyiapkan fungsi hadiah untuk model Amazon Nova
Fungsi penghargaan mengevaluasi kualitas respons dan memberikan sinyal umpan balik untuk pelatihan model. Anda dapat mengatur fungsi reward menggunakan fungsi Lambda kustom atau model foundation yang dihosting Amazon Bedrock sebagai juri. Template terpandu tersedia untuk menyederhanakan pembuatan fungsi hadiah untuk tugas-tugas umum seperti mengikuti instruksi dan validasi format. Pilih pendekatan yang sesuai dengan persyaratan tugas Anda.
## Pembelajaran Penguatan melalui Hadiah yang Dapat Diverifikasi (RLVR)
RLVR mengoptimalkan model untuk tugas objektif seperti pembuatan kode atau penalaran matematika menggunakan grader atau templat berbasis aturan yang dapat diverifikasi. ready-to-use
Anda memiliki dua opsi untuk RLVR (Kode Kustom):
### Opsi 1: Gunakan templat yang disediakan konsol
Konsol Amazon Bedrock menyediakan contoh template untuk fungsi Lambda grader:
+ Penalaran matematis dengan verifikasi kebenaran dasar
+ Format validasi dan pemeriksaan kendala
+ Template Lambda grader generik dengan kode boilerplate
Ikuti petunjuk dalam templat yang disediakan di halaman **pekerjaan Buat RFT** di konsol [Amazon Bedrock](https://console.aws.amazon.com/bedrock).
### Opsi 2: Bawa fungsi Lambda Anda sendiri
Buat fungsi hadiah khusus menggunakan Lambda ARN Anda sendiri untuk logika kompleks, perhitungan eksternal, multi-langkah APIs, atau menggabungkan beberapa kriteria evaluasi.
**catatan**
Jika Anda membawa fungsi Lambda Anda sendiri, ingatlah hal berikut:
Tingkatkan batas waktu Lambda dari default 3 detik menjadi maksimum 15 menit untuk evaluasi kompleks.
Peran eksekusi Lambda memerlukan izin untuk memanggil model seperti yang dijelaskan dalam. [Akses dan keamanan untuk model Amazon Nova](rft-access-security.md)
## Pembelajaran Penguatan melalui Umpan Balik AI (RLAIF)
RLAIF mengoptimalkan model untuk tugas subjektif seperti mengikuti instruksi atau interaksi chatbot menggunakan juri berbasis AI dengan templat. ready-to-use
**Untuk RLAIF (Model sebagai Hakim):**
+ Pilih Model dasar yang dihosting Amazon Bedrock sebagai Hakim
+ Konfigurasikan instruksi untuk evaluasi
+ Tentukan kriteria evaluasi dan pedoman penilaian
Templat LLM-as-Judge prompt yang tersedia di konsol Amazon Bedrock:
+ Instruksi berikut (Pelatihan model hakim)
+ Ringkasan (Dialog multi-putaran)
+ Evaluasi penalaran (CoT untuk domain khusus)
+ Kesetiaan RAG (Tanya Jawab berdasarkan konteks)
**catatan**
Opsi **Model sebagai Hakim** konsol secara otomatis mengubah konfigurasi Anda menjadi fungsi Lambda selama pelatihan.
## Detail implementasi fungsi Lambda
Saat menerapkan fungsi hadiah Lambda khusus, fungsi Anda harus menerima dan mengembalikan data dalam format berikut.
------
#### [ Input structure ]
```
[{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
"metadata": {
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_key": "sample-001"
}
}]
```
------
#### [ Output structure ]
```
[{
"id": "123",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "accuracy",
"value": 0.9,
"type": "Reward"
},
{
"name": "policy_compliance",
"value": 0.8,
"type": "Metric"
}
]
}]
```
------
**Pedoman desain**
+ **Tanggapan peringkat** — Berikan jawaban terbaik dengan skor yang jelas lebih tinggi
+ **Gunakan pemeriksaan yang konsisten** — Evaluasi penyelesaian tugas, kepatuhan format, keamanan, dan panjang yang wajar
+ **Pertahankan penskalaan yang stabil** - Jaga skor tetap normal dan tidak dapat dieksploitasi
# Buat dan kelola pekerjaan fine-tuning untuk model Amazon Nova
Anda dapat membuat pekerjaan reinforcement fine-tuning (RFT) menggunakan konsol Amazon Bedrock atau API. Pekerjaan RFT dapat memakan waktu beberapa jam tergantung pada ukuran data pelatihan Anda, jumlah zaman, dan kompleksitas fungsi hadiah Anda.
## Prasyarat
+ Buat peran layanan IAM dengan izin yang diperlukan. Untuk informasi keamanan dan izin yang komprehensif termasuk izin khusus RFT, lihat. [Akses dan keamanan untuk model Amazon Nova](rft-access-security.md)
+ (Opsional) Enkripsi data input dan output, pekerjaan RFT Anda, atau permintaan inferensi yang dibuat untuk model kustom. Untuk informasi selengkapnya, lihat [Enkripsi model kustom](https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html).
## Buat pekerjaan RFT Anda
Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ Console ]
Untuk mengirimkan pekerjaan RFT di konsol, lakukan langkah-langkah berikut:
1. Buka konsol Amazon Bedrock dan navigasikan ke **model Kustom** di bawah **Tune**.
1. Pilih **Buat**, lalu **Buat pekerjaan fine-tuning tulangan**.
1. Di bagian **Detail model**, pilih **Amazon Nova 2 Lite** sebagai model dasar Anda.
1. Di bagian **Detail kustomisasi**, masukkan nama kustomisasi.
1. Di bagian **Data pelatihan**, pilih sumber data Anda. Pilih dari log pemanggilan yang tersedia yang disimpan di Amazon S3, atau pilih lokasi Amazon S3 dari file kumpulan data pelatihan Anda, atau unggah file langsung dari perangkat Anda.
**catatan**
Dataset pelatihan Anda harus dalam format data Penyelesaian Obrolan OpenAI. Jika Anda memberikan log pemanggilan dalam format pemanggilan atau percakapan Amazon Bedrock, Amazon Bedrock secara otomatis mengonversinya ke format Penyelesaian Obrolan.
1. Di bagian **fungsi Reward**, siapkan mekanisme reward Anda:
+ **Model sebagai hakim (RLAIF)** - Pilih model dasar yang dihosting Bedrock sebagai hakim dan konfigurasikan instruksi untuk evaluasi. Gunakan ini untuk tugas subjektif seperti moderasi konten.
**catatan**
Opsi **Model sebagai hakim** konsol secara otomatis mengubah konfigurasi Anda menjadi fungsi Lambda selama pelatihan.
+ **Kode kustom (RLVR)** - Buat fungsi hadiah khusus menggunakan kode Python yang dijalankan melalui fungsi Lambda. Gunakan ini untuk tugas-tugas objektif seperti pembuatan kode.
Untuk informasi selengkapnya, lihat [Menyiapkan fungsi hadiah untuk model Amazon Nova](reward-functions.md).
1. (Opsional) Di bagian **Hyperparameters**, sesuaikan parameter pelatihan atau gunakan nilai default.
1. Di bagian **Data keluaran**, masukkan lokasi Amazon S3 tempat Amazon Bedrock harus menyimpan output pekerjaan.
1. Di bagian **Konfigurasi peran**, pilih peran yang ada dari daftar tarik-turun atau masukkan nama untuk peran layanan yang akan dibuat.
1. (Opsional) Di bagian **Konfigurasi tambahan**, konfigurasikan data validasi dengan menunjuk ke bucket Amazon S3, setelan enkripsi KMS, serta tag job dan model.
1. Pilih **Buat pekerjaan fine-tuning tulangan untuk memulai pekerjaan**.
------
#### [ API ]
Kirim CreateModelCustomizationJob permintaan dengan `customizationType` set ke`REINFORCEMENT_FINE_TUNING`.
**Bidang yang diperlukan:** `roleArn``baseModelIdentifier`,`customModelName`,`jobName`,,`trainingDataConfig`,`outputDataConfig`, `rftConfig`
**Permintaan contoh:**
```
{
"roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
"baseModelIdentifier": "amazon.nova-2.0",
"customModelName": "my-rft-model",
"jobName": "my-rft-job",
"customizationType": "REINFORCEMENT_FINE_TUNING",
"trainingDataConfig": {
"s3Uri": "s3://my-bucket/training-data.jsonl"
},
"customizationConfig": {
"rftConfig" : {
"graderConfig": {
"lambdaGrader": {
"lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
}
},
"hyperParameters": {
"batchSize": 64,
"epochCount": 2,
"evalInterval": 10,
"inferenceMaxTokens": 8192,
"learningRate": 0.00001,
"maxPromptLength": 4096,
"reasoningEffort": "high",
"trainingSamplePerPrompt": 4
}
}
},
"outputDataConfig": {
"s3Uri": "s3://my-bucket/rft-output/"
}
}
```
**Permintaan sampel API Python:**
```
import boto3
bedrock = boto3.client(service_name='bedrock')
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"
customizationConfig = {
'rftConfig' : {
'graderConfig': {
'lambdaGrader': {
'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
}
},
'hyperParameters': {
'batchSize': 64,
'epochCount': 2,
'evalInterval': 10,
'inferenceMaxTokens': 8192,
'learningRate':0.00001,
'maxPromptLength': 4096,
'reasoningEffort': 'high',
'trainingSamplePerPrompt':4
}
}
}
trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}
# Create job
response_ft = bedrock.create_model_customization_job(
jobName=jobName,
customModelName=customModelName,
roleArn=roleArn,
baseModelIdentifier=baseModelIdentifier,
customizationConfig=customizationConfig,
trainingDataConfig=trainingDataConfig,
outputDataConfig=outputDataConfig,
customizationType=customizationType
)
jobArn = response_ft['jobArn']
```
------
## Pantau pekerjaan pelatihan RFT Anda
Amazon Bedrock menyediakan pemantauan real-time dengan grafik dan metrik visual selama pelatihan RFT. Metrik ini membantu Anda memahami apakah model menyatu dengan benar dan apakah fungsi hadiah secara efektif memandu proses pembelajaran.
### Pelacakan status Job
Anda dapat memantau status pekerjaan RFT Anda melalui fase validasi dan pelatihan di konsol Amazon Bedrock.
**Indikator penyelesaian:**
+ Status Job berubah menjadi **Selesai** saat pelatihan berhasil diselesaikan
+ Model khusus ARN menjadi tersedia untuk penerapan
+ Metrik pelatihan mencapai ambang konvergensi
### Metrik pelatihan waktu nyata
Amazon Bedrock menyediakan pemantauan waktu nyata selama pelatihan RFT dengan grafik visual yang menampilkan metrik pelatihan dan validasi.
#### Metrik pelatihan inti
+ **Kehilangan pelatihan** - Mengukur seberapa baik model belajar dari data pelatihan
+ **Statistik hadiah pelatihan** - Menampilkan skor hadiah yang ditetapkan oleh fungsi hadiah Anda
+ **Margin hadiah** - Mengukur perbedaan antara imbalan respons baik dan buruk
+ **Akurasi pada set pelatihan dan validasi** - Menunjukkan kinerja model pada data pelatihan dan held-out
**Kategori metrik terperinci**
+ **Metrik hadiah** —`critic/rewards/mean`,`critic/rewards/max`, `critic/rewards/min` (distribusi hadiah), dan `val-score/rewards/mean@1` (hadiah validasi)
+ **Perilaku model** — `actor/entropy` (variasi kebijakan; lebih tinggi sama dengan lebih eksplorasi)
+ **Kesehatan pelatihan** — `actor/pg_loss` (kehilangan gradien kebijakan), `actor/pg_clipfrac` (frekuensi pembaruan terpotong), dan `actor/grad_norm` (besarnya gradien)
+ **Karakteristik respons** — `prompt_length/mean``prompt_length/max`,, `prompt_length/min` (statistik token masukan)`response_length/mean`,,`response_length/max`, `response_length/min` (statistik token keluaran), dan `response/aborted_ratio` (tingkat pembangkitan tidak lengkap; 0 sama dengan semua selesai)
+ **Kinerja** — `perf/throughput` (throughput pelatihan), `perf/time_per_step` (waktu per langkah pelatihan), dan `timing_per_token_ms/*` (waktu pemrosesan per token)
+ **Penggunaan sumber daya** —`perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` (memori GPU), dan `perf/cpu_memory_used_gb` (memori CPU)
#### Visualisasi kemajuan pelatihan
Konsol menampilkan grafik interaktif yang diperbarui secara real-time saat pekerjaan RFT Anda berlangsung. Visualisasi ini dapat membantu Anda:
+ Lacak konvergensi menuju kinerja optimal
+ Identifikasi potensi masalah pelatihan lebih awal
+ Tentukan titik berhenti yang optimal
+ Bandingkan kinerja di berbagai zaman
## Mengatur inferensi
Setelah pekerjaan selesai, terapkan model RFT untuk inferensi sesuai permintaan atau gunakan Provisioned Throughput untuk kinerja yang konsisten. Untuk menyiapkan inferensi, lihat[Siapkan inferensi untuk model khusus](model-customization-use.md).
Gunakan **Test in Playground** untuk mengevaluasi dan membandingkan respons dengan model dasar. Untuk mengevaluasi model RFT Anda yang telah selesai, lihat. [Evaluasi model RFT Anda](rft-evaluate-model.md)
# Sempurnakan model bobot terbuka menggunakan -kompatibel OpenAI APIs
Amazon Bedrock menyediakan endpoint API yang OpenAI kompatibel untuk model foundation fine-tuning. Titik akhir ini memungkinkan Anda menggunakan alat yang familiar OpenAI SDKs dan alat untuk membuat, memantau, dan mengelola pekerjaan fine-tuning dengan model Amazon Bedrock. Halaman ini menyoroti penggunaan ini APIs untuk fine-tuning penguatan.
## Kemampuan kunci
+ **Unggah file pelatihan** — Gunakan Files API untuk mengunggah dan mengelola data pelatihan untuk pekerjaan fine-tuning
+ **Buat pekerjaan fine-tuning — Mulai fine-tuning pekerjaan** dengan data pelatihan khusus dan fungsi hadiah
+ **Daftar dan ambil pekerjaan** — Lihat semua pekerjaan fine-tuning dan dapatkan informasi rinci tentang pekerjaan tertentu
+ **Pantau acara pekerjaan** - Lacak kemajuan fine-tuning melalui log peristiwa terperinci
+ **Akses pos pemeriksaan** - Ambil pos pemeriksaan model menengah yang dibuat selama pelatihan
+ **Inferensi langsung** — Setelah fine-tuning selesai, gunakan model fine-tuned yang dihasilkan untuk inferensi sesuai permintaan melalui Amazon Bedrock yang kompatibel dengan OpenAI (API respons/penyelesaian obrolan) tanpa langkah penerapan tambahan APIs
+ **Migrasi mudah** - Kompatibel dengan basis kode OpenAI SDK yang ada
## Alur kerja fine-tuning penguatan untuk model bobot terbuka
Sebelum melakukan fine-tuning, pastikan Anda memiliki prasyarat karena Amazon Bedrock memerlukan izin khusus untuk membuat dan mengelola proses fine-tuning. Untuk informasi keamanan dan izin yang komprehensif, lihat[Akses dan keamanan untuk model berbobot terbuka](rft-open-weight-access-security.md).
Jalankan fine-tuning penguatan untuk model berbobot terbuka dalam 5 langkah:
1. **Unggah Dataset Pelatihan** — Gunakan Files API untuk mengunggah prompt dalam format yang diperlukan (misalnya, JSONL) dengan tujuan “fine-tune” sebagai kumpulan data pelatihan fine-tuning penguatan. Untuk informasi selengkapnya, lihat [Siapkan data untuk model berbobot terbuka](rft-prepare-data-open-weight.md).
1. **Konfigurasi Fungsi Hadiah** — Tentukan grader untuk menilai respons model berdasarkan kebenaran, struktur, nada, atau tujuan lain menggunakan fungsi Lambda. Untuk informasi selengkapnya, lihat [Menyiapkan fungsi hadiah untuk model berbobot terbuka](reward-functions-open-weight.md).
1. **Buat Fine-tuning Job** — Luncurkan pekerjaan fine-tuning penguatan menggunakan OpenAI API yang kompatibel dengan menentukan model dasar, kumpulan data, fungsi reward, dan pengaturan opsional lainnya seperti hyperparameters. Untuk informasi selengkapnya, lihat [Buat pekerjaan fine-tuning](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. **Pantau Kemajuan Pelatihan** — Lacak status pekerjaan, acara, dan metrik pelatihan menggunakan pekerjaan fine-tuning. APIs Untuk informasi selengkapnya, lihat [Daftar acara fine-tuning](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Akses pos pemeriksaan model perantara untuk mengevaluasi kinerja pada tahap pelatihan yang berbeda, lihat[Daftar pos pemeriksaan fine-tuning](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints).
1. **Jalankan Inferensi** — Gunakan ID model yang disetel dengan baik secara langsung untuk inferensi melalui Respons atau Penyelesaian Obrolan yang kompatibel dengan Amazon Bedrock. OpenAI APIs Untuk informasi selengkapnya, lihat [Jalankan inferensi dengan model yang disetel dengan baik](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Wilayah dan titik akhir yang didukung
Tabel berikut menunjukkan model pondasi dan wilayah yang mendukung APIs fine-tuning yang OpenAI kompatibel:
**Model dan wilayah yang didukung untuk fine-tuning yang OpenAI kompatibel APIs**
| Penyedia | Model | ID Model | Nama wilayah | Wilayah | Titik akhir |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | AS Barat (Oregon) | us-west-2 | batuan-mantle.us-west-2.api.aws |
| Qwen | Qwen3 32B | qwen.qwen3-32b | AS Barat (Oregon) | us-west-2 | batuan-mantle.us-west-2.api.aws |
# Akses dan keamanan untuk model berbobot terbuka
Sebelum Anda memulai reinforcement fine-tuning (RFT), pastikan Anda memahami jenis akses yang dibutuhkan Amazon Bedrock untuk operasi khusus RFT. RFT memerlukan izin tambahan di luar fine-tuning standar karena kemampuan eksekusi fungsi reward.
## Prasyarat
Sebelum menggunakan fine-tuning yang OpenAI kompatibel dengan Amazon Bedrock APIs, pastikan Anda memiliki yang berikut:
1. AWS Akun dengan izin yang sesuai untuk mengakses Amazon Bedrock
1. **Otentikasi** - Anda dapat mengautentikasi menggunakan:
+ Kunci Amazon Bedrock API (diperlukan untuk OpenAI SDK dan tersedia untuk permintaan HTTP)
+ AWS kredensil (didukung untuk permintaan HTTP)
**catatan**
[Jika Anda menggunakan kunci API jangka pendek/jangka panjang Amazon Bedrock, pastikan peran Anda memiliki akses ke izin kebijakan IAM berikut: dan Peran. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (opsional)** - Instal SDK OpenAI Python jika menggunakan permintaan berbasis SDK.
1. **Variabel lingkungan** - Mengatur variabel lingkungan berikut:
+ `OPENAI_API_KEY`— Setel ke kunci API Amazon Bedrock Anda
+ `OPENAI_BASE_URL`— Setel ke titik akhir Amazon Bedrock untuk wilayah Anda (misalnya,) `https://bedrock-mantle.us-west-2.api.aws/v1`
Untuk informasi selengkapnya, lihat [Respons API](bedrock-mantle.md#bedrock-mantle-responses).
1. **Data pelatihan** diformat sebagai file JSONL dengan tujuan. `fine-tune` Untuk informasi selengkapnya, lihat [Siapkan data untuk model berbobot terbuka](rft-prepare-data-open-weight.md).
## Izin Lambda untuk fungsi hadiah
Anda harus menambahkan izin pemanggilan Lambda. Berikut ini menunjukkan contoh kebijakan yang dapat Anda gunakan:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
Anda juga dapat menggunakan model yang dihosting Amazon Bedrock sebagai Hakim untuk menyiapkan fungsi hadiah. Anda perlu menambahkan izin khusus untuk memanggil model dasar ke peran eksekusi Lambda. Di peran lambda, Anda dapat mengonfigurasi kebijakan terkelola ini LLMs untuk penilaian. Lihat [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
Berikut ini adalah contoh untuk menjalankan model foundation Amazon Bedrock sebagai hakim menggunakan Invoke API:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Siapkan data untuk model berbobot terbuka
Saat Anda menyempurnakan model bobot terbuka dengan penyetelan penguatan menggunakan OpenAI yang kompatibel dengan OpenAI APIs, berikan data pelatihan dengan membawa petunjuk Anda sendiri dalam format JSONL dengan tujuan tersebut. `fine-tune`
## Format dan persyaratan data pelatihan
Data pelatihan harus mengikuti format penyelesaian obrolan OpenAI dengan contoh 100-20K. Setiap contoh pelatihan berisi:
+ `messages`: Di bidang ini, sertakan peran pengguna, sistem atau asisten yang berisi prompt input yang diberikan kepada model.
+ `reference_answer`: Di bidang ini, harus berisi output yang diharapkan atau kriteria evaluasi yang digunakan fungsi hadiah Anda untuk menilai respons model. Ini tidak terbatas pada output terstruktur—dapat berisi format apa pun yang membantu fungsi hadiah Anda mengevaluasi kualitas.
+ [Opsional] Anda dapat menambahkan bidang yang digunakan oleh grader Lambda untuk penilaian.
**Persyaratan:**
+ Format JSONL dengan petunjuk dalam format penyelesaian obrolan OpenAI (satu prompt per baris)
+ Tujuan harus diatur ke `fine-tune`
+ Minimal 100 catatan dalam dataset pelatihan
+ Amazon Bedrock secara otomatis memvalidasi format kumpulan data pelatihan
------
#### [ Example: General question-answering ]
```
{
"messages": [
{
"role": "system",
"content": "You are a helpful assistant"
},
{
role": "user",
"content": "What is machine learning?"}
],
"reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed."
}
```
------
#### [ Example: Math problem ]
```
{
"id": "sample-001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
## File API
Anda dapat menggunakan api file yang kompatibel dengan OpenAI untuk mengunggah data pelatihan Anda untuk pekerjaan fine-tuning. File disimpan dengan aman di Amazon Bedrock, dan digunakan saat membuat pekerjaan fine-tuning. Untuk detail API selengkapnya, lihat [dokumentasi OpenAI File](https://platform.openai.com/docs/api-reference/files).
### Unggah file pelatihan
Untuk mengunggah file pelatihan, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Upload training file
with open(TRAINING_FILE_PATH, 'rb') as f:
file_response = client.files.create(
file=f,
purpose='fine-tune'
)
# Store file ID for next steps
training_file_id = file_response.id
print(f"✅ Training file uploaded successfully: {training_file_id}")
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F purpose="fine-tune" \
-F file="@training_data.jsonl"
```
------
### Ambil detail file
Untuk mengambil detail tentang file tertentu, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve file details
file_details = client.files.retrieve(training_file_id)
# Print raw response
print(json.dumps(file_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/files/{file_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Daftar file
Untuk mencantumkan file yang diunggah, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List files
files_response = client.files.list(purpose='fine-tune')
# Print raw response
print(json.dumps(files_response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Hapus berkas
Untuk menghapus file, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Delete file
delete_response = client.files.delete(training_file_id)
```
------
#### [ HTTP request ]
Buat permintaan DELETE ke`/v1/files/{file_id}`:
```
curl -X DELETE https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Karakteristik data pelatihan yang efektif
Data pelatihan RFT yang efektif membutuhkan tiga karakteristik utama:
+ **Kejelasan dan konsistensi** - Gunakan petunjuk yang jelas dan tidak ambigu dengan pemformatan yang konsisten. Hindari label yang kontradiktif, instruksi ambigu, atau jawaban referensi yang bertentangan yang menyesatkan pelatihan.
+ **Keragaman** — Sertakan beragam format input, kasus tepi, dan tingkat kesulitan yang mencerminkan pola penggunaan produksi di berbagai jenis dan skenario pengguna.
+ **Fungsi hadiah yang efisien** — Merancang fungsi yang dijalankan dengan cepat (detik, bukan menit), sejajar dengan AWS Lambda, dan mengembalikan skor yang konsisten untuk pelatihan hemat biaya.
## Properti tambahan
Format data RFT mendukung bidang khusus di luar persyaratan skema inti (`messages`dan`reference_answer`). Fleksibilitas ini memungkinkan Anda untuk menambahkan data tambahan apa pun yang dibutuhkan fungsi hadiah Anda untuk evaluasi yang tepat.
**catatan**
Anda tidak perlu mengonfigurasi ini dalam resep Anda. Format data secara inheren mendukung bidang tambahan. Cukup sertakan mereka dalam data pelatihan Anda JSON, dan mereka akan diteruskan ke fungsi hadiah Anda di `metadata` lapangan.
**Properti tambahan umum**
+ `task_id`— Pengidentifikasi unik untuk melacak
+ `difficulty_level`— Indikator kompleksitas masalah
+ `domain`— Bidang subjek atau kategori
+ `expected_reasoning_steps`— Jumlah langkah dalam solusi
Bidang tambahan ini diteruskan ke fungsi hadiah Anda selama evaluasi, memungkinkan logika penilaian canggih yang disesuaikan dengan kasus penggunaan spesifik Anda.
**Contoh dengan properti tambahan**
------
#### [ Chemistry problem ]
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4
}
}
```
`reference_answer`Bidang berisi output yang diharapkan atau kriteria evaluasi yang digunakan fungsi hadiah Anda untuk menilai respons model. Ini tidak terbatas pada output terstruktur—dapat berisi format apa pun yang membantu fungsi hadiah Anda mengevaluasi kualitas.
------
#### [ Math problem with metadata ]
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
------
# Menyiapkan fungsi hadiah untuk model berbobot terbuka
Fungsi penghargaan mengevaluasi kualitas respons dan memberikan sinyal umpan balik untuk pelatihan model. Anda dapat mengatur fungsi hadiah menggunakan fungsi Lambda khusus. Pilih pendekatan yang sesuai dengan persyaratan tugas Anda.
## Fungsi Lambda Kustom untuk Evaluasi Hadiah
Anda dapat mengatur fungsi hadiah menggunakan fungsi Lambda khusus. Dalam fungsi Lambda Anda, Anda memiliki fleksibilitas dalam cara Anda menerapkan logika evaluasi:
+ **Tugas obyektif** — Untuk tugas obyektif seperti pembuatan kode atau penalaran matematika, gunakan grader berbasis aturan yang dapat diverifikasi yang memeriksa kebenaran terhadap standar atau kasus uji yang diketahui.
+ **Tugas subyektif** — Untuk tugas subjektif seperti mengikuti instruksi atau interaksi chatbot, hubungi model yayasan Amazon Bedrock sebagai juri dalam fungsi Lambda Anda untuk mengevaluasi kualitas respons berdasarkan kriteria Anda.
Fungsi Lambda Anda dapat menerapkan logika kompleks, mengintegrasikan eksternal APIs, melakukan perhitungan multi-langkah, atau menggabungkan beberapa kriteria evaluasi tergantung pada persyaratan tugas Anda.
**catatan**
Saat menggunakan fungsi Lambda khusus:
Tingkatkan batas waktu Lambda dari default 3 detik menjadi maksimum 15 menit untuk evaluasi kompleks.
Peran eksekusi Lambda memerlukan izin untuk menjalankan fungsi Lambda seperti yang dijelaskan dalam. [Izin Lambda untuk fungsi hadiah](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Detail implementasi fungsi Lambda
Saat menerapkan fungsi hadiah Lambda khusus, fungsi Anda harus menerima dan mengembalikan data dalam format berikut.
------
#### [ Input structure ]
```
[{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
"metadata": {
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_key": "sample-001"
}
}]
```
------
#### [ Output structure ]
```
[{
"id": "123",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "accuracy",
"value": 0.9,
"type": "Reward"
},
{
"name": "policy_compliance",
"value": 0.8,
"type": "Metric"
}
]
}]
```
------
**Pedoman desain**
+ **Tanggapan peringkat** — Berikan jawaban terbaik dengan skor yang jelas lebih tinggi
+ **Gunakan pemeriksaan yang konsisten** — Evaluasi penyelesaian tugas, kepatuhan format, keamanan, dan panjang yang wajar
+ **Pertahankan penskalaan yang stabil** - Jaga skor tetap normal dan tidak dapat dieksploitasi
# Buat dan kelola pekerjaan fine-tuning untuk model berbobot terbuka menggunakan OpenAI APIs
Pekerjaan fine-tuning yang kompatibel dengan OpenAI APIs memungkinkan Anda membuat, memantau, dan mengelola pekerjaan fine-tuning. Halaman ini menyoroti penggunaan ini APIs untuk fine-tuning penguatan. Untuk detail API selengkapnya, lihat dokumentasi [OpenAIFine-tuning](https://platform.openai.com/docs/api-reference/fine-tuning).
## Buat pekerjaan fine-tuning
Membuat pekerjaan fine-tuning yang memulai proses pembuatan model baru dari kumpulan data tertentu. Untuk detail API selengkapnya, lihat dokumentasi [OpenAICreate fine-tuning jobs.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create)
### Contoh
Untuk membuat pekerjaan fine-tuning dengan metode RFT, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Create fine-tuning job with RFT method
job_response = client.fine_tuning.jobs.create(
model=MODEL_ID,
training_file=training_file_id,
# Suffix field is not supported so commenting for now.
# suffix="rft-example", # Optional: suffix for fine-tuned model name
extra_body={
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-reward-function" # Replace with your Lambda ARN
}
},
"hyperparameters": {
"n_epochs": 1, # Number of training epochs
"batch_size": 4, # Batch size
"learning_rate_multiplier": 1.0 # Learning rate multiplier
}
}
}
}
)
# Store job ID for next steps
job_id = job_response.id
print({job_id})
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/fine_tuning/jobs`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"training_file": "file-abc123",
"model": "gpt-4o-mini",
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-grader"
}
},
"hyperparameters": {
"n_epochs": 1,
"batch_size": 4,
"learning_rate_multiplier": 1.0
}
}
}
}'
```
------
## Daftar acara fine-tuning
Daftar acara untuk pekerjaan fine-tuning. Acara fine-tuning memberikan informasi terperinci tentang kemajuan pekerjaan Anda, termasuk metrik pelatihan, pembuatan pos pemeriksaan, dan pesan kesalahan. Untuk detail API selengkapnya, lihat dokumentasi [OpenAIDaftarkan acara fine-tuning.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events)
### Contoh
Untuk membuat daftar acara fine-tuning, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning events
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=50
)
for event in events.data:
print(f"[{event.created_at}] {event.level}: {event.message}")
if event.data:
print(f" Metrics: {event.data}")
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/fine_tuning/jobs/{fine_tuning_job_id}/events`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=50
```
------
Acara mencakup informasi seperti:
+ Pelatihan dimulai dan menyelesaikan pesan
+ Pemberitahuan pembuatan pos pemeriksaan
+ Metrik pelatihan (kehilangan, akurasi) di setiap langkah
+ Pesan galat jika pekerjaan gagal
Untuk melakukan paginasi melalui semua acara, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Paginate through all events
all_events = []
after = None
while True:
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=100,
after=after
)
all_events.extend(events.data)
if not events.has_more:
break
after = events.data[-1].id
```
------
#### [ HTTP request ]
Buat beberapa permintaan GET dengan `after` parameter:
```
# First request
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100
# Subsequent requests with 'after' parameter
curl "https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100&after=ft-event-abc123"
```
------
## Ambil pekerjaan fine-tuning
Dapatkan informasi terperinci tentang pekerjaan fine-tuning. Untuk detail API selengkapnya, lihat [OpenAIMendapatkan dokumentasi lowongan fine-tuning](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve).
### Contoh
Untuk mengambil detail pekerjaan tertentu, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve specific job details
job_details = client.fine_tuning.jobs.retrieve(job_id)
# Print raw response
print(json.dumps(job_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/fine_tuning/jobs/{fine_tuning_job_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Daftar pekerjaan fine-tuning
Daftar pekerjaan fine-tuning organisasi Anda dengan dukungan pagination. Untuk detail API selengkapnya, lihat [OpenAIdaftar dokumentasi fine-tuning jobs.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list)
### Contoh
Untuk membuat daftar pekerjaan fine-tuning dengan limit dan pagination, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning jobs with limit and pagination
response = client.fine_tuning.jobs.list(
limit=20 # Maximum number of jobs to return
)
# Print raw response
print(json.dumps(response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/fine_tuning/jobs`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs?limit=20 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Batalkan pekerjaan fine-tuning
Membatalkan pekerjaan fine-tuning yang sedang berlangsung. Setelah dibatalkan, pekerjaan tidak dapat dilanjutkan. Untuk detail API selengkapnya, lihat dokumentasi [OpenAICancel fine-tuning job.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel)
### Contoh
Untuk membatalkan pekerjaan fine-tuning, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Cancel fine-tuning job
cancel_response = client.fine_tuning.jobs.cancel("ftjob-abc123")
print(f"Job ID: {cancel_response.id}")
print(f"Status: {cancel_response.status}") # Should be "cancelled"
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/fine_tuning/jobs/{fine_tuning_job_id}/cancel`:
```
curl -X POST https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/cancel \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Daftar pos pemeriksaan fine-tuning
Daftar pos pemeriksaan untuk pekerjaan fine-tuning. Checkpoint adalah snapshot model perantara yang dibuat selama fine-tuning yang dapat digunakan untuk inferensi guna mengevaluasi kinerja pada tahap pelatihan yang berbeda. Untuk informasi selengkapnya, lihat dokumentasi [OpenAIdaftar fine-tuning checkpoints.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list)
### Contoh
Untuk membuat daftar pos pemeriksaan untuk pekerjaan fine-tuning, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List checkpoints for a fine-tuning job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id="ftjob-abc123",
limit=10
)
for checkpoint in checkpoints.data:
print(f"Checkpoint ID: {checkpoint.id}")
print(f"Step: {checkpoint.step_number}")
print(f"Model: {checkpoint.fine_tuned_model_checkpoint}")
print(f"Metrics: {checkpoint.metrics}")
print("---")
```
------
#### [ HTTP request ]
Buat permintaan GET untuk`/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/checkpoints?limit=10
```
------
Setiap pos pemeriksaan meliputi:
+ **Checkpoint ID** - Pengidentifikasi unik untuk pos pemeriksaan
+ **Nomor langkah** — Langkah pelatihan di mana pos pemeriksaan dibuat
+ **Pos pemeriksaan model** — Pengidentifikasi model yang dapat digunakan untuk inferensi
+ **Metrik — Kehilangan** dan akurasi validasi di pos pemeriksaan ini
Untuk menggunakan model pos pemeriksaan untuk inferensi, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Test inference with a checkpoint
response = client.chat.completions.create(
model=checkpoint.fine_tuned_model_checkpoint,
messages=[{"role": "user", "content": "What is AI?"}],
max_tokens=100
)
print(response.choices[0].message.content)
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/chat/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom:7p4lURel:ckpt-step-1000",
"messages": [{"role": "user", "content": "What is AI?"}],
"max_tokens": 100
}'
```
------
## Jalankan inferensi dengan model yang disetel dengan baik
Setelah pekerjaan fine-tuning selesai, Anda dapat menggunakan model fine-tuned untuk inferensi melalui Responses API atau Chat Completions API. Untuk detail API selengkapnya, lihat[Hasilkan tanggapan menggunakan OpenAI APIs](bedrock-mantle.md).
### Respons API
Gunakan Responses API untuk pembuatan teks satu putaran dengan model yang disetel dengan baik:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference with Responses API
response = client.completions.create(
model=fine_tuned_model,
prompt="What is the capital of France?",
max_tokens=100,
temperature=0.7
)
print(f"Response: {response.choices[0].text}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"prompt": "What is the capital of France?",
"max_tokens": 100,
"temperature": 0.7
}'
```
------
### API Penyelesaian Obrolan
Gunakan API Penyelesaian Obrolan untuk interaksi percakapan dengan model yang disetel dengan baik:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference
inference_response = client.chat.completions.create(
model=fine_tuned_model,
messages=[
{"role": "user", "content": "What is the capital of France?"}
],
max_tokens=100
)
print(f"Response: {inference_response.choices[0].message.content}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Buat permintaan POST untuk`/v1/chat/completions`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"messages": [
{"role": "user", "content": "What is the capital of France?"}
],
"max_tokens": 100
}'
```
------
# Evaluasi model RFT Anda
Setelah pekerjaan fine-tuning penguatan Anda berhasil diselesaikan, Anda dapat mengevaluasi kinerja model kustom Anda menggunakan beberapa metode penilaian. Amazon Bedrock menyediakan alat evaluasi bawaan untuk membantu Anda membandingkan model RFT Anda dengan model dasar dan memvalidasi peningkatan.
**Topics**
+ [Metode evaluasi](#rft-evaluation-methods)
+ [Menyiapkan inferensi untuk evaluasi](#rft-setup-inference-evaluation)
+ [Praktik terbaik evaluasi](#rft-evaluation-best-practices)
## Metode evaluasi
Amazon Bedrock menawarkan beberapa cara untuk menilai kinerja model RFT Anda.
### Metrik validasi
Jika Anda mengunggah kumpulan data validasi, Anda akan melihat dua grafik tambahan dalam metrik pelatihan.
+ **Hadiah validasi** - Menunjukkan seberapa baik model Anda menggeneralisasi di luar contoh pelatihan. Skor yang lebih rendah dari hadiah pelatihan adalah normal dan diharapkan.
+ **Panjang episode validasi - Panjang** respons rata-rata pada data validasi yang tidak terlihat. Menunjukkan seberapa efisien model Anda merespons input baru dibandingkan dengan contoh pelatihan.
### Tes di Playground
Gunakan fitur Test in Playground untuk evaluasi cepat dan ad-hoc. Untuk menggunakan fitur Test in Playground, inferensi perlu diatur. Untuk informasi selengkapnya, lihat [Menyiapkan inferensi untuk evaluasi](#rft-setup-inference-evaluation).
Alat interaktif ini memungkinkan Anda untuk:
+ Permintaan uji langsung dengan model RFT Anda
+ Bandingkan tanggapan side-by-side antara model kustom Anda dan model dasar
+ Mengevaluasi peningkatan kualitas respons secara real-time
+ Bereksperimenlah dengan petunjuk yang berbeda untuk menilai kemampuan model
### Evaluasi Model Batuan Dasar
Gunakan Evaluasi Model Amazon Bedrock untuk menilai model RFT Anda menggunakan kumpulan data Anda sendiri. Ini memberikan analisis kinerja yang komprehensif dengan metrik dan tolok ukur standar. Berikut adalah beberapa contoh manfaat Evaluasi Model Batuan Dasar Amazon.
+ Evaluasi sistematis menggunakan kumpulan data uji kustom
+ Perbandingan kinerja kuantitatif
+ Metrik standar untuk penilaian yang konsisten
+ Integrasi dengan alur kerja evaluasi Amazon Bedrock yang ada
## Menyiapkan inferensi untuk evaluasi
Sebelum mengevaluasi model RFT Anda, siapkan inferensi menggunakan salah satu opsi ini:
### Inferensi sesuai permintaan
Buat penerapan sesuai permintaan model khusus untuk evaluasi yang fleksibel. pay-per-use Opsi ini mencakup harga berbasis token yang mengenakan biaya berdasarkan jumlah token yang diproses selama inferensi.
## Praktik terbaik evaluasi
+ **Bandingkan secara sistematis** - Selalu evaluasi model RFT Anda terhadap model dasar menggunakan petunjuk pengujian dan kriteria evaluasi yang sama.
+ **Gunakan beragam kasus uji** - Sertakan berbagai jenis dan skenario prompt yang mewakili kasus penggunaan dunia nyata Anda.
+ **Validasi penyelarasan hadiah** - Pastikan peningkatan model Anda selaras dengan fungsi hadiah yang digunakan selama pelatihan.
+ **Kasus tepi uji** - Evaluasi perilaku model pada input yang menantang atau tidak biasa untuk menilai ketahanan.
+ **Memantau konsistensi respons** - Periksa apakah model Anda memberikan kualitas yang konsisten di beberapa proses dengan petunjuk serupa.