Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Penguatan Fine-Tuning (RFT) dengan model Amazon Nova
## Ikhtisar
**Apa itu RFT?**
Reinforcement fine-tuning (RFT) meningkatkan kinerja model dengan melatih sinyal umpan balik — skor atau penghargaan yang dapat diukur yang menunjukkan seberapa baik kinerja model — daripada jawaban yang benar dan tepat. Tidak seperti fine-tuning yang diawasi (SFT) yang belajar dari pasangan input-output, RFT menggunakan fungsi hadiah untuk mengevaluasi respons model dan mengoptimalkan model secara iteratif untuk memaksimalkan penghargaan ini. Pendekatan ini unggul ketika mendefinisikan output yang benar secara tepat merupakan tantangan, tetapi Anda dapat mengukur kualitas respons dengan andal.
**Kapan menggunakan RFT**
Gunakan RFT ketika Anda dapat menentukan kriteria keberhasilan yang jelas dan terukur tetapi sulit untuk memberikan output yang tepat untuk pelatihan. RFT sangat ideal untuk:
+ Tugas di mana kualitas bersifat subjektif atau beragam (penulisan kreatif, pengoptimalan kode, penalaran kompleks)
+ Skenario dengan beberapa solusi valid di mana beberapa jelas lebih baik daripada yang lain
+ Aplikasi yang membutuhkan perbaikan berulang, personalisasi, atau kepatuhan terhadap aturan bisnis yang kompleks
+ Kasus di mana mengumpulkan contoh berlabel berkualitas tinggi mahal atau tidak praktis
**Kasus penggunaan terbaik**
RFT unggul dalam domain di mana kualitas output dapat diukur secara objektif tetapi respons optimal sulit untuk didefinisikan di muka:
+ Pemecahan masalah matematika dan pembuatan kode
+ Penalaran ilmiah dan analisis data terstruktur
+ Tugas yang membutuhkan penalaran langkah demi langkah atau pemecahan masalah multi-putaran
+ Aplikasi menyeimbangkan berbagai tujuan (akurasi, efisiensi, gaya)
+ Skenario di mana keberhasilan dapat diverifikasi secara terprogram melalui hasil eksekusi atau metrik kinerja
**Model yang didukung**
Nova Lite 2.0
## Ikhtisar format data
[Data pelatihan RFT harus mengikuti format Penguatan OpenAI Fine-Tuning .](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input) Setiap contoh pelatihan adalah objek JSON yang berisi:
+ `messages`Array dengan giliran percakapan menggunakan `system` dan peran `user`
+ `reference_answer`Bidang yang berisi output yang diharapkan atau kriteria evaluasi untuk perhitungan hadiah
**Keterbatasan saat ini**
+ Teks saja
### Contoh format data
Setiap contoh harus pada satu baris dalam file JSONL Anda, dengan satu objek JSON per baris.
------
#### [ Chemistry problem ]
```
{
"id": "chem-01",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Calculate the molecular weight of caffeine (C8H10N4O2)"
}
],
"reference_answer": {
"molecular_weight": 194.19,
"unit": "g/mol",
"calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19"
}
}
```
------
#### [ Math problem ]
```
{
"id": "sample-001", // Optional
"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"]
}
}
```
------
#### [ Code problem ]
```
{
"id": "code-002",
"messages": [
{
"role": "system",
"content": "You are a helpful programming assistant"
},
{
"role": "user",
"content": "Write a Python function that reverses a string without using built-in reverse methods"
}
],
"reference_answer": {
"code": "def reverse_string(s): \n result = '' \n for i in range(len(s) - 1, -1, -1): \n result += s[i] \n return result",
"test_cases": [
{
"input": "hello",
"expected_output": "olleh"
},
{
"input": "",
"expected_output": ""
},
{
"input": "a",
"expected_output": "a"
},
{
"input": "Python123",
"expected_output": "321nohtyP"
}
],
"all_tests_pass": true
}
}
```
------
`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.
## Rekomendasi ukuran set data
**Titik awal**
+ Minimal 100 contoh pelatihan
+ Minimal 100 contoh evaluasi
**Evaluation-first pendekatan**
Sebelum berinvestasi dalam pelatihan RFT skala besar, evaluasi kinerja dasar model Anda:
+ **Kinerja tinggi (hadiah > 95%)** — RFT mungkin tidak perlu — model Anda sudah berkinerja baik
+ **Kinerja sangat buruk (hadiah 0%)** - Beralih ke SFT terlebih dahulu untuk membangun kemampuan dasar
+ **Performa moderat** — RFT kemungkinan tepat
Dimulai dengan kumpulan data kecil memungkinkan Anda untuk:
+ Validasi fungsi reward Anda bebas bug
+ Konfirmasikan RFT adalah pendekatan yang tepat untuk kasus penggunaan Anda
+ Identifikasi dan perbaiki masalah lebih awal
+ Uji alur kerja sebelum meningkatkan
Setelah divalidasi, Anda dapat memperluas ke kumpulan data yang lebih besar untuk lebih meningkatkan kinerja.
## Karakteristik data pelatihan yang efektif
**Kejelasan dan konsistensi**
Contoh RFT yang baik membutuhkan data input yang jelas dan tidak ambigu yang memungkinkan perhitungan hadiah yang akurat di berbagai output model. Hindari kebisingan dalam data Anda, termasuk:
+ Pemformatan yang tidak konsisten
+ Label atau instruksi yang kontradiktif
+ Petunjuk ambigu
+ Jawaban referensi yang bertentangan
Ambiguitas apa pun akan menyesatkan proses pelatihan dan menyebabkan model mempelajari perilaku yang tidak diinginkan.
**Keanekaragaman**
Dataset Anda harus menangkap keragaman penuh kasus penggunaan produksi untuk memastikan kinerja dunia nyata yang kuat. Termasuk:
+ Format input dan kasus tepi yang berbeda
+ Memetakan pola penggunaan produksi aktual dari log dan analisis pengguna
+ Sampel di seluruh jenis pengguna, wilayah geografis, dan variasi musiman
+ Sertakan tingkat kesulitan dari masalah sederhana hingga yang kompleks
**Pertimbangan fungsi penghargaan**
Rancang fungsi hadiah Anda untuk pelatihan yang efisien:
+ Jalankan dalam hitungan detik (bukan menit)
+ Paralelisasi secara efektif dengan Lambda
+ Kembalikan skor yang konsisten dan andal
+ Tangani berbagai jenis keluaran model dengan anggun
Fungsi hadiah yang cepat dan dapat diskalakan memungkinkan iterasi cepat dan eksperimen hemat biaya.
## Properti tambahan
Format data RFT mendukung bidang khusus di luar persyaratan skema inti (`messages`dan`reference_answer`). Fleksibilitas ini memungkinkan Anda 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**
Contoh bidang metadata:
+ `task_id`— Pengidentifikasi unik untuk melacak
+ `difficulty_level`— Indikator kompleksitas masalah
+ `domain`— Bidang subjek atau kategori
+ `expected_reasoning_steps`— Jumlah langkah dalam solusi
**Contoh dengan properti tambahan**
```
{
"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
}
```
Bidang tambahan ini diteruskan ke fungsi hadiah Anda selama evaluasi, memungkinkan logika penilaian canggih yang disesuaikan dengan kasus penggunaan spesifik Anda.
## Konfigurasi pelatihan
**Resep sampel**
```
# Note:
# This recipe can run on p5.48xlarge, p5e.48xlarge, and p5en.48xlarge instance types.
run:
name: "my-rft-run" # Unique run name (appears in logs and artifacts).
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3:/// # Training dataset in JSONL format.
replicas: 4 # Number of total training instances.
generation_replicas: 2 # Number of total instances dedicated to response generation.
reward_lambda_arn: arn:aws:lambda:::function:
## MLFlow configs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty
## SMTJ RFT training configs
training_config:
max_length: 8192 # Context window (tokens) for inputs and prompt.
global_batch_size: 32 # Total samples per optimizer step across all replicas (16/32/64/128/256).
reasoning_effort: high # Reasoning mode: high, low, or null for non-reasoning.
data:
shuffle: true # Shuffle training data each epoch.
rollout: # Controls how responses are generated for advantage calculation.
rollout_strategy:
type: off_policy_async # Asynchronous rollout for higher throughput.
age_tolerance: 2 # Maximum policy age before regeneration.
advantage_strategy:
number_generation: 4 # Samples per prompt to estimate advantages (higher = lower variance but higher cost).
generator:
max_new_tokens: 6000 # Cap on tokens generated per sample.
set_random_seed: true # Seed generation for reproducibility across runs.
temperature: 1 # Softmax temperature for sampling.
rewards:
preset_reward_function: null # Preset reward functions: exact_match or null for custom.
api_endpoint:
lambda_arn: arn:aws:lambda:::function:
lambda_concurrency_limit: 12 # Max concurrent Lambda invocations (throughput vs. throttling).
lambda_batch_size: 128 # Number of samples per Lambda invocation.
trainer:
max_steps: 2 # Steps to train for. One step = global_batch_size samples.
save_steps: 5 # Save a checkpoint every N steps.
test_steps: 1 # Run validation every N reference model updates.
refit_freq: 4 # Frequency of reference model updates.
clip_ratio_high: 0.2 # PPO clip ratio for policy updates.
loss_scale: 1.0 # Scaling factor for the policy loss.
# RL parameters
ent_coeff: 0.0 # Entropy bonus added to the policy loss (higher = more exploration).
kl_loss_coef: 0.0 # Weight on the KL penalty between the current and reference policy.
optim_config: # Optimizer settings.
lr: 1e-6 # Learning rate.
weight_decay: 0.0 # L2 regularization strength (0.0 to 1.0).
adam_beta1: 0.9
adam_beta2: 0.95
peft: # Parameter-efficient fine-tuning (LoRA).
peft_scheme: "lora" # Enable LoRA for PEFT.
lora_tuning:
alpha: 64 # LoRA scaling factor.
lora_plus_lr_ratio: 64.0 # LoRA+ learning rate scaling factor (0.0 to 100.0).
```
## Pelatihan RFT menggunakan LLM sebagai juri
### Ikhtisar
Model bahasa besar (LLM) semakin banyak digunakan sebagai juri dalam alur kerja penyempurnaan penguatan (RFT), memberikan sinyal hadiah otomatis yang memandu pengoptimalan model. Dalam pendekatan ini, LLM mengevaluasi keluaran model terhadap kriteria yang ditentukan—apakah menilai kebenaran, kualitas, kepatuhan gaya, atau kesetaraan semantik—dan memberikan penghargaan yang mendorong proses pembelajaran penguatan.
Ini sangat berharga untuk tugas-tugas di mana fungsi hadiah tradisional sulit untuk didefinisikan secara terprogram, seperti menentukan apakah representasi yang berbeda (seperti "1/3“, “0.333", dan “sepertiga”) setara secara semantik, atau mengevaluasi kualitas bernuansa seperti koherensi dan relevansi. Dengan menggunakan LLM-based juri sebagai fungsi penghargaan, Anda dapat menskalakan RFT ke domain kompleks tanpa memerlukan anotasi manusia yang ekstensif, memungkinkan iterasi cepat dan peningkatan berkelanjutan model Anda di berbagai kasus penggunaan di luar masalah penyelarasan tradisional.
### Pemilihan mode penalaran
**Mode yang tersedia**
+ none - Tidak ada alasan (hilangkan bidang reasing\_effort)
+ rendah — Overhead penalaran minimal
+ tinggi - Kemampuan penalaran maksimum (default saat reasing\_effort ditentukan)
**catatan**
Tidak ada opsi medium untuk RFT. Jika bidang reasing\_effort tidak ada dalam konfigurasi Anda, penalaran akan dinonaktifkan. Saat penalaran diaktifkan, Anda harus menyetel `max_new_tokens` ke 32768 untuk mengakomodasi output penalaran yang diperpanjang.
**Kapan menggunakan setiap mode**
Gunakan penalaran tinggi untuk:
+ Tugas analitis yang kompleks
+ Pemecahan masalah matematika
+ Multi-step deduksi logis
+ Tugas di mana pemikiran langkah demi langkah menambah nilai
Gunakan none (hilangkan reasing\_effort) atau alasan rendah untuk:
+ Pertanyaan faktual sederhana
+ Klasifikasi langsung
+ Optimalisasi kecepatan dan biaya
+ Menjawab pertanyaan langsung
**Pengorbanan biaya dan kinerja**
Mode penalaran yang lebih tinggi meningkat:
+ Waktu dan biaya pelatihan
+ Latensi inferensi dan biaya
+ Kemampuan model untuk tugas penalaran yang kompleks
### Memvalidasi hakim LLM Anda
Sebelum menerapkan LLM-as-a-judge dalam produksi, validasi bahwa evaluasi model hakim selaras dengan penilaian manusia. Ini melibatkan:
+ Mengukur tingkat kesepakatan antara hakim LLM dan evaluator manusia pada sampel yang representatif dari tugas Anda
+ Memastikan bahwa perjanjian LLM dengan manusia memenuhi atau melampaui tingkat perjanjian antar manusia
+ Mengidentifikasi bias potensial dalam model hakim
+ Membangun kepercayaan bahwa sinyal hadiah memandu model Anda ke arah yang diinginkan
Langkah validasi ini membantu memastikan proses evaluasi otomatis akan menghasilkan model yang memenuhi kriteria kualitas produksi Anda.
### Konfigurasi Lambda untuk hakim LLM
Menggunakan LLM sebagai juri adalah perpanjangan dari penggunaan fungsi Lambda untuk Pembelajaran Penguatan dengan Hadiah yang Dapat Diverifikasi (RLVR). Di dalam fungsi Lambda, Anda melakukan panggilan ke salah satu model yang dihosting di Amazon Bedrock.
**Persyaratan konfigurasi penting:**
| Konfigurasi | Persyaratan | Detail |
| --- | --- | --- |
| Throughput Amazon Bedrock | Kuota yang cukup | Pastikan kuota throughput Anda untuk model Amazon Bedrock yang digunakan cukup untuk beban kerja pelatihan Anda |
| Batas waktu Lambda | Batas waktu diperpanjang | Konfigurasikan batas waktu fungsi Lambda Anda hingga maksimum 15 menit. Pengaturan default adalah 3 detik, yang tidak cukup untuk respons model Amazon Bedrock |
| Konkurensi Lambda | Peningkatan konkurensi | Lambda dipanggil secara paralel selama pelatihan. Meningkatkan konkurensi untuk memaksimalkan throughput yang tersedia |
| Konfigurasi resep | Cocokkan pengaturan Lambda | Batas konkurensi harus dikonfigurasi dalam resep Anda |
## Menciptakan dan menjalankan pekerjaan
**Memulai pekerjaan pelatihan**
Gunakan templat buku catatan pekerjaan SageMaker pelatihan: [https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook)
**Persyaratan instans**
Wadah mendukung pelatihan keduanya Full-Rank dan LoRa:
+ **Pelatihan LoRa** — 2/4/6/8 × p5.48xlarge atau p5en.48xlarge instance
+ **Full-Rank pelatihan** — 2/4/6/8 × contoh p5.48xlarge (wajib)
## Pelatihan pemantauan
Log pelatihan mencakup metrik komprehensif di setiap langkah. Kategori metrik utama:
**Metrik skor**
+ `critic/rewards/mean`,`critic/rewards/max`, `critic/rewards/min` — Distribusi hadiah
+ `val-score/rewards/mean@1`— Hadiah validasi
**Perilaku model**
+ `actor/entropy`— Variasi kebijakan (lebih tinggi = lebih eksplorasi)
**Pelatihan kesehatan**
+ `actor/pg_loss`— Kehilangan gradien kebijakan
+ `actor/pg_clipfrac`— Frekuensi pembaruan terpotong
+ `actor/grad_norm`— Besaran gradien
**Karakteristik respons**
+ `prompt_length/mean`,`prompt_length/max`, `prompt_length/min` — Masukan statistik token
+ `response_length/mean`,`response_length/max`, `response_length/min` — Statistik token keluaran
+ `response/aborted_ratio`— Tingkat generasi tidak lengkap (0 = semua selesai)
**Performa**
+ `perf/throughput`— Throughput pelatihan
+ `perf/time_per_step`— Waktu per langkah pelatihan
+ `timing_per_token_ms/*`— waktu Per-token pemrosesan
**Penggunaan sumber daya**
+ `perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` — Memori GPU
+ `perf/cpu_memory_used_gb`— Memori CPU
## Menggunakan model yang disetel dengan baik
Setelah pelatihan selesai, pos pemeriksaan model akhir disimpan ke lokasi keluaran yang Anda tentukan. Jalur pos pemeriksaan tersedia di:
+ Log pelatihan
+ `manifest.json`berkas di lokasi keluaran Amazon S3 (ditentukan oleh `output_s3_uri` di buku catatan Anda)
## Keterbatasan dan praktik terbaik
**Batasan**
+ Batas **waktu Lambda** - Fungsi hadiah harus selesai dalam waktu 15 menit (mencegah proses pelarian dan mengelola biaya)
+ **Single-turn hanya** — Multi-turn percakapan tidak didukung
+ **Persyaratan data** - Membutuhkan keragaman yang cukup; berjuang dengan imbalan yang jarang (< 5% contoh positif)
+ **Biaya komputasi** — Lebih mahal daripada fine-tuning yang diawasi
+ **Tidak ada data multi-modal** - Hanya tipe data teks yang didukung
**Praktik terbaik**
**Mulai dari yang kecil**
+ Mulailah dengan 100-200 contoh
+ Validasi kebenaran fungsi hadiah
+ Skala secara bertahap berdasarkan hasil
**Pre-training evaluasi**
+ Uji kinerja model dasar sebelum RFT
+ Jika hadiah secara konsisten 0%, gunakan SFT terlebih dahulu untuk membangun kemampuan dasar
+ Jika hadiah> 95%, RFT mungkin tidak diperlukan
**Pantau pelatihan**
+ Lacak skor dan distribusi hadiah rata-rata
+ Perhatikan overfitting (hadiah pelatihan meningkat sementara imbalan validasi berkurang)
+ Cari tentang pola:
+ Hadiah yang berada di bawah 0,15
+ Meningkatkan varians hadiah dari waktu ke waktu
+ Menurunnya kinerja validasi
**Optimalkan fungsi hadiah**
+ Jalankan dalam hitungan detik (bukan menit)
+ Minimalkan panggilan API eksternal
+ Gunakan algoritma yang efisien
+ Menerapkan penanganan kesalahan yang tepat
+ Manfaatkan penskalaan paralel Lambda
**Strategi iterasi**
Jika hadiah tidak membaik:
+ Sesuaikan desain fungsi hadiah
+ Meningkatkan keragaman dataset
+ Tambahkan lebih banyak contoh yang representatif
+ Verifikasi sinyal hadiah jelas dan konsisten
## Pembelajaran kurikulum adaptif
Pembelajaran kurikulum adaptif adalah fitur opsional yang secara dinamis memilih pelatihan mana yang diminta untuk disajikan kepada model selama RFT. Alih-alih melatih semua petunjuk secara seragam, pelatih menggunakan model itu sendiri untuk memprediksi kesulitan yang cepat dan memilih petunjuk dalam rentang kesulitan produktif—di mana model terkadang berhasil dan terkadang gagal. Ini memaksimalkan varians hasil dalam setiap grup peluncuran GRPO, menghasilkan sinyal keunggulan yang lebih tinggi, konvergensi yang lebih cepat, dan stabilitas pelatihan RL yang lebih baik dengan mengurangi pembaruan gradien yang bising dari petunjuk yang terlalu mudah atau terlalu sulit.
### Cara kerja kurikulum adaptif
Ketika kurikulum adaptif diaktifkan, loop pelatihan menambahkan fase prediksi dan seleksi sebelum setiap langkah peluncuran:
1. **Prediksi** — Model memprediksi tingkat kelulusan (atau spread hadiah) untuk setiap prompt kandidat menggunakan format prediksi beberapa tembakan. Tiga contoh dari langkah pelatihan sebelumnya (satu mudah, satu sedang, satu keras) memberikan konteks kalibrasi.
1. **Seleksi** — Prompt diberi peringkat berdasarkan seberapa dekat kesulitan prediksi mereka dengan target pemilihan (default: tingkat kelulusan 50%). Petunjuk terbaik disetujui untuk peluncuran; sisanya dibuang tanpa mengkonsumsi komputasi peluncuran.
1. **Pelatihan — Pelatihan** GRPO standar berlangsung pada petunjuk yang dipilih.
1. **Umpan balik** — Tingkat kelulusan aktual dari peluncuran dibandingkan dengan prediksi. Target seleksi dikalibrasi secara otomatis untuk memperbaiki bias prediksi sistematis. Gradien REINFORCE melatih prediktor untuk meningkatkan prediksi masa depan.
### Kapan menggunakan kurikulum adaptif
Kurikulum adaptif paling efektif dalam skenario berikut:
+ Anda ingin meningkatkan stabilitas pelatihan RL dengan memastikan setiap batch pelatihan berisi petunjuk dengan varians hadiah yang berarti, mengurangi pembaruan gradien berisik yang dapat mengacaukan pembelajaran.
+ Anda telah mengonfirmasi bahwa RFT dasar meningkatkan metrik target Anda.
+ Anda ingin mempercepat konvergensi dengan memfokuskan komputasi pelatihan pada petunjuk yang paling produktif.
+ Dataset Anda besar (5.000\+ petunjuk) dan berisi banyak petunjuk di luar rentang kesulitan produktif yang jika tidak akan membuang komputasi.
### Mengkonfigurasi kurikulum adaptif
Tambahkan `adaptive_curriculum` blok `trainer` di bawah resep Anda untuk mengaktifkan pembelajaran kurikulum adaptif:
```
training_config:
trainer:
adaptive_curriculum:
enable: true # Enable adaptive curriculum prompt selection.
selection_pool_multiplier: 8 # Score 8 x global_batch_size candidates, keep best global_batch_size.
prediction_mode: pass_rate # "pass_rate" for discrete rewards; "spread" for continuous rewards.
exemplar_history_steps: 1 # Previous training steps kept in the rolling exemplar history buffer.
reinforce_coef: 0.01 # Scale factor for the REINFORCE loss that trains the predictor (0 disables).
predictor_prompt_column: predictor_prompt # Dataset field with clean problem text used by the predictor.
selection_lookahead_steps: 4 # Future training batches pre-approved per curriculum screening pass.
```
Tabel berikut menjelaskan setiap parameter kurikulum adaptif:
| Parameter | Tipe | Default | Deskripsi |
| --- | --- | --- | --- |
| enable | Boolean | false | Apakah akan mengaktifkan pemilihan cepat kurikulum adaptif. |
| selection\_pool\_multiplier | Bilangan bulat (1—32) | 8 | Mengontrol berapa banyak prompt kandidat yang dinilai relatif terhadap ukuran batch pelatihan. Nilai 8 berarti 8 × global\_batch\_size prompt dinilai, dan yang terbaik global\_batch\_size dipilih. Nilai yang lebih tinggi memberikan kualitas seleksi yang lebih baik tetapi biaya komputasi inferensi lebih banyak. |
| prediction\_mode | String | pass\_rate | Mode prediksi untuk estimasi kesulitan yang cepat. Gunakan pass\_rate untuk tugas hadiah diskrit (misalnya, pemeriksaan kebenaran) di mana prediktor memperkirakan probabilitas jawaban yang benar. Gunakan spread untuk tugas hadiah berkelanjutan di mana prediktor memperkirakan hadiah maksim-menit yang tersebar di seluruh peluncuran. |
| exemplar\_history\_steps | Bilangan bulat (≥1) | 1 | Jumlah langkah pelatihan sebelumnya yang harus disimpan dalam buffer riwayat bergulir untuk pemilihan contoh. Prediktor menggunakan contoh dari sejarah ini untuk mengkalibrasi prediksi beberapa bidikan. |
| reinforce\_coef | Jumlah (≥0) | 0.01 | Faktor skala untuk kerugian REINFORCE yang melatih prediktor pass-rate. Ini memungkinkan pembelajaran loop tertutup di mana prediktor meningkatkan akurasinya selama pelatihan. Setel ke 0 untuk menonaktifkan pelatihan prediktor. |
| predictor\_prompt\_column | String | predictor\_prompt | Nama bidang dalam kumpulan data yang berisi teks masalah bersih yang digunakan sebagai prompt prediktor. Ini harus menjadi versi ringkas dari masalah tanpa prompt sistem atau pemformatan, sehingga prediktor dapat dengan cepat menilai kesulitan. |
| selection\_lookahead\_steps | Bilangan bulat (1—16) | 4 | Jumlah batch pelatihan future yang harus disetujui sebelumnya dalam satu pass penyaringan kurikulum per langkah. Setiap pass mencetak selection\_pool\_multiplier × global\_batch\_size kandidat per langkah; nilai selection\_lookahead\_steps pengulangan yang lebih tinggi yang lulus beberapa kali untuk membangun antrian prompt yang disetujui, yang mengurangi overhead prediktor per langkah pada kumpulan data prompt pendek. Untuk kumpulan data konteks panjang di mana prediktor itu sendiri mahal (lihat bagian rekomendasi), setel ini 1 agar prediktor berjalan hanya sekali per langkah. |
### Rekomendasi untuk kumpulan data konteks panjang
Kurikulum adaptif bekerja dengan menjalankan prediktor pass-rate ringan pada kumpulan petunjuk kandidat dan memilih batch yang paling produktif untuk diluncurkan. Ketika `max_prompt_length` pendek (beberapa ribu token atau kurang), prediktor berjalan dalam beberapa detik per pass skrining dan overhead kurikulum dapat diabaikan. Ketika panjang prompt tumbuh, waktu inferensi prediktor tumbuh kira-kira secara kuadratis (perhatian adalah O (n²) dalam panjang urutan), sehingga penyaringan dapat mendominasi waktu langkah pada kumpulan data di mana petunjuknya melebihi sekitar 8.000 token.
**catatan**
Kurikulum adaptif didukung `max_prompt_length` hingga 32.768 token (32K). Mengaktifkannya pada kumpulan data yang melebihi panjang ini tidak didukung; nonaktifkan kurikulum adaptif atau persingkat petunjuk Anda sebelum pelatihan.
Pengaturan di bawah ini menjaga kurikulum adaptif dapat digunakan dan hemat biaya pada kumpulan data konteks panjang. Terapkan bersama-sama; mereka menangani berbagai komponen biaya penyaringan.
| Khas `max_prompt_length` | Pengaturan kurikulum adaptif yang direkomendasikan |
| --- | --- |
| Hingga 8K token | Gunakan default:,. selection\_pool\_multiplier: 8 selection\_lookahead\_steps: 4 Overhead skrining kecil dan tidak perlu disetel. |
| Lebih dari 8K dan hingga 16K token | Atur selection\_lookahead\_steps: 2. Ini mengurangi separuh jumlah lintasan prediktor per langkah sambil menjaga cukup banyak petunjuk yang telah disetujui sebelumnya dalam antrian untuk menghindari kelaparan peluncuran. |
| Lebih dari 16K dan hingga 24K token | Simpan selection\_lookahead\_steps: 2 dan turunkan selection\_pool\_multiplier ke4. Kumpulan yang lebih kecil membagi dua ukuran batch prediktor dengan biaya tertentu untuk kualitas pemilihan; bersama-sama ini menjaga waktu penyaringan per langkah tetap terbatas. |
| Lebih dari 24K dan hingga 32K token | Gunakan selection\_pool\_multiplier: 4 denganselection\_lookahead\_steps: 1. Prediktor berjalan sekali per langkah pelatihan pada kolam berukuran minimum. Ini adalah pengaturan yang didukung paling agresif; melampaui 32K tidak didukung. |
Contoh konfigurasi yang disetel untuk kumpulan data konteks panjang (sekitar 24K — 32K petunjuk token):
```
training_config:
max_length: 32768
global_batch_size: 32
trainer:
adaptive_curriculum:
enable: true
selection_pool_multiplier: 4 # Smaller pool keeps predictor prefill bounded.
selection_lookahead_steps: 1 # Predictor runs once per training step.
prediction_mode: pass_rate
exemplar_history_steps: 1
reinforce_coef: 0.01
predictor_prompt_column: predictor_prompt
```
### Persiapan data untuk kurikulum adaptif
Saat menggunakan kurikulum adaptif, data pelatihan Anda harus menyertakan `predictor_prompt` bidang (atau nama bidang yang ditentukan dalam`predictor_prompt_column`) yang berisi versi singkat dari teks masalah. Bidang ini digunakan oleh prediktor pass-rate untuk menilai kesulitan yang cepat dengan cepat tanpa memproses konteks percakapan lengkap.
Contoh entri JSONL dengan prompt prediktor:
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor. Show your work step by step."
},
{
"role": "user",
"content": "A train travels 120 miles in 2 hours. If it then increases speed by 50%, how far will it travel in the next 3 hours?"
}
],
"reference_answer": "270 miles",
"predictor_prompt": "A train travels 120 miles in 2 hours. Speed increases 50%. Distance in next 3 hours?"
}
```
Jika `predictor_prompt` bidang tidak ada, sistem akan kembali menggunakan prompt penuh dari `messages` bidang.
### Contoh resep lengkap dengan kurikulum adaptif
Contoh berikut menunjukkan resep RFT LoRa lengkap dengan kurikulum adaptif diaktifkan:
```
run:
name: "my-rft-adaptive-curriculum"
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3:///
replicas: 4
generation_replicas: 2
reward_lambda_arn: arn:aws:lambda:::function:
training_config:
max_length: 8192
global_batch_size: 32
reasoning_effort: null # Non-reasoning mode.
data:
shuffle: true
rollout:
rollout_strategy:
type: off_policy_async
age_tolerance: 2
advantage_strategy:
number_generation: 16 # Higher n for better advantage estimates.
generator:
max_new_tokens: 6000
temperature: 1.0
rewards:
preset_reward_function: exact_match # Or null for custom Lambda reward.
api_endpoint:
lambda_arn: ${oc.select:run.reward_lambda_arn} # Reuse the top-level run.reward_lambda_arn so the two stay in sync.
lambda_concurrency_limit: 12
lambda_batch_size: 128
trainer:
max_steps: 500
save_steps: 50
test_steps: 25
refit_freq: 4
clip_ratio_high: 0.2
ent_coeff: 0.0
kl_loss_coef: 0.0
optim_config:
lr: 1e-6
weight_decay: 0.0
peft:
peft_scheme: "lora"
lora_tuning:
alpha: 64
lora_plus_lr_ratio: 64.0
adaptive_curriculum:
enable: true
selection_pool_multiplier: 8
prediction_mode: pass_rate
exemplar_history_steps: 1
reinforce_coef: 0.01
predictor_prompt_column: predictor_prompt
```
### Memantau kurikulum adaptif
Saat kurikulum adaptif diaktifkan, metrik tambahan dicatat pada setiap langkah pelatihan:
+ Tingkat **kelulusan yang diprediksi vs. aktual - Tingkat** kelulusan rata-rata yang diprediksi untuk permintaan yang dipilih dibandingkan dengan tingkat kelulusan aktual yang diamati setelah peluncuran. Kesenjangan yang besar menunjukkan prediktor membutuhkan lebih banyak waktu kalibrasi.
+ **Target pemilihan - Target pemilihan** yang dikalibrasi otomatis saat ini. Ini dimulai pada 0,5 dan menyesuaikan berdasarkan akurasi prediksi.
+ **Jumlah filter penguasaan** — Jumlah prompt yang dikecualikan karena model telah secara konsisten menguasainya.
**catatan**
Langkah pelatihan 1-2 pertama berjalan tanpa seleksi adaptif (prediktor membutuhkan setidaknya satu langkah sejarah untuk membangun contoh). Seleksi adaptif penuh dimulai pada langkah 3.
## Kemampuan lanjutan: Nova Forge
Untuk pengguna yang membutuhkan kemampuan canggih di luar batasan RFT standar, Nova Forge tersedia sebagai penawaran layanan berlangganan berbayar:
+ Multi-turn dukungan percakapan
+ Fungsi hadiah dengan> 15 menit waktu eksekusi
+ Algoritma tambahan dan opsi penyetelan
+ Modifikasi resep pelatihan khusus
+ State-of-the-art Teknik AI
Nova Forge berjalan SageMaker HyperPod dan dirancang untuk mendukung pelanggan perusahaan untuk membangun model perbatasan mereka sendiri.
## Perintah dan tips yang berguna
Kumpulan [skrip observabilitas](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring) tersedia untuk membantu memantau status dan kemajuan pekerjaan pelatihan.
Skrip yang tersedia adalah:
+ Mengaktifkan pemberitahuan email untuk pembaruan status pekerjaan pelatihan
+ Memperoleh perkiraan waktu pelatihan berdasarkan konfigurasi pekerjaan
+ Memperoleh perkiraan berapa lama pelatihan yang diharapkan untuk pekerjaan yang sedang berlangsung
**Instalasi**
**catatan**
Pastikan untuk menyegarkan AWS kredensil Anda sebelum menggunakan salah satu skrip berikut.
```
pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/
```
**Penggunaan dasar**
```
# Enabling email notifications for training job status updates
python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ
Creating resources........
Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications!
You'll receive the confirmation email within a few minutes.
```
```
# Obtaining training time estimates based on job configurations
python get_training_time_estimate.py
```
```
# Obtaining approximations for how long training is expected to take for in-progress jobs
python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000
```
Silakan lihat [di sini](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md) untuk detail dan contoh tambahan.