Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kustomisasi Amazon Nova pada Pekerjaan SageMaker Pelatihan
SageMaker Training Jobs adalah lingkungan yang memungkinkan Anda melatih model pembelajaran mesin dalam skala besar. Ini secara otomatis menyediakan dan menskalakan sumber daya komputasi, memuat data pelatihan dari sumber seperti Amazon S3, mengeksekusi kode pelatihan Anda, dan menyimpan artefak model yang dihasilkan.
Tujuan pelatihan adalah untuk menyesuaikan model Amazon Nova dasar menggunakan data milik Anda. Proses pelatihan biasanya melibatkan langkah-langkah untuk menyiapkan data Anda, memilih [resep](nova-model-recipes.md), memodifikasi parameter konfigurasi dalam file YAMM, dan mengirimkan pekerjaan pelatihan. Proses pelatihan akan menampilkan pos pemeriksaan model terlatih dalam bucket Amazon S3 yang dikelola layanan. Anda dapat menggunakan lokasi pos pemeriksaan ini untuk pekerjaan evaluasi. Kustomisasi Nova pada pekerjaan pelatihan SageMaker AI menyimpan artefak model dalam ember Amazon S3 yang dikelola layanan. Artefak dalam bucket yang dikelola layanan dienkripsi dengan kunci KMS yang dikelola AI. SageMaker Bucket Amazon S3 yang dikelola layanan saat ini tidak mendukung enkripsi data menggunakan kunci KMS yang dikelola pelanggan.
## Praktik Terbaik untuk kustomisasi Amazon Nova
### Ikhtisar
Bagian ini memberikan ikhtisar teknik penyesuaian dan membantu Anda memilih pendekatan terbaik untuk kebutuhan dan data yang tersedia.
#### Dua tahap pelatihan LLM
Pelatihan model bahasa besar terdiri dari dua tahap utama: pra-pelatihan dan pasca pelatihan. Selama pra-pelatihan, model memproses token teks mentah dan mengoptimalkan prediksi token berikutnya. Proses ini menciptakan pelengkap pola yang menyerap sintaks, semantik, fakta, dan pola penalaran dari web dan teks yang dikuratori. Namun, model yang telah dilatih sebelumnya tidak memahami instruksi, tujuan pengguna, atau perilaku yang sesuai dengan konteks. Ini melanjutkan teks dalam gaya apa pun yang sesuai dengan distribusi pelatihannya. Model pra-terlatih melengkapi secara otomatis daripada mengikuti petunjuk, menghasilkan pemformatan yang tidak konsisten, dan dapat mencerminkan bias yang tidak diinginkan atau konten yang tidak aman dari data pelatihan. Pra-pelatihan membangun kompetensi umum, bukan kegunaan tugas.
Pasca-pelatihan mengubah pelengkap pola menjadi asisten yang berguna. Anda menjalankan beberapa putaran Supervised Fine-Tuning (SFT) untuk mengajarkan model mengikuti instruksi, mematuhi skema dan kebijakan, memanggil alat, dan menghasilkan output yang andal dengan meniru demonstrasi berkualitas tinggi. Penyelarasan ini mengajarkan model untuk menanggapi permintaan sebagai tugas daripada teks untuk melanjutkan. Anda kemudian menerapkan Reinforcement Fine-Tuning (RFT) untuk mengoptimalkan perilaku menggunakan umpan balik yang terukur (seperti verifier atau an LLM-as-a-judge), menyeimbangkan trade-off seperti akurasi versus singkatnya, keamanan versus cakupan, atau penalaran multi-langkah di bawah kendala. Dalam praktiknya, Anda mengganti SFT dan RFT dalam siklus untuk membentuk model yang telah dilatih sebelumnya menjadi sistem yang andal dan selaras dengan kebijakan yang melakukan tugas-tugas kompleks secara konsisten.
### Pilih pendekatan kustomisasi yang tepat
Pada bagian ini kita akan membahas strategi penyesuaian pasca pelatihan: RFT dan SFT.
#### Penyetelan halus penguatan (RFT)
Penyetelan halus penguatan meningkatkan kinerja model melalui sinyal umpan balik — skor terukur atau penghargaan yang menunjukkan kualitas respons — daripada pengawasan langsung dengan jawaban yang benar dan tepat. Tidak seperti fine-tuning tradisional yang diawasi yang belajar dari pasangan input-output, RFT menggunakan fungsi hadiah untuk mengevaluasi respons model dan secara iteratif mengoptimalkan model untuk memaksimalkan penghargaan ini. Pendekatan ini bekerja dengan baik untuk tugas-tugas di mana mendefinisikan output yang benar secara tepat menantang, tetapi Anda dapat mengukur kualitas respons dengan andal. RFT memungkinkan model untuk mempelajari perilaku dan preferensi yang kompleks melalui uji coba dan umpan balik, menjadikannya ideal untuk aplikasi yang memerlukan pengambilan keputusan bernuansa, pemecahan masalah yang kreatif, atau kepatuhan terhadap kriteria kualitas tertentu yang dapat Anda evaluasi secara terprogram. Misalnya, menjawab pertanyaan hukum yang kompleks adalah kasus penggunaan yang ideal untuk RFT karena Anda ingin mengajarkan model bagaimana bernalar lebih baik untuk menjawab pertanyaan dengan lebih akurat.
##### Cara kerjanya
Dalam penyempurnaan penguatan, Anda mulai dari garis dasar yang disetel instruksi dan memperlakukan setiap prompt seperti turnamen kecil. Untuk masukan yang diberikan, Anda mengambil sampel beberapa jawaban kandidat dari model, menilai masing-masing dengan fungsi hadiah, lalu memberi peringkat dalam kelompok itu. Langkah pembaruan mendorong model untuk membuat kandidat dengan skor lebih tinggi lebih mungkin di lain waktu dan yang mendapat skor lebih rendah lebih kecil kemungkinannya, sementara stay-close-to-baseline kendala membuat perilaku tidak melayang atau menjadi bertele-tele atau eksploitatif. Anda mengulangi loop ini melalui banyak petunjuk, menyegarkan hard case, mengencangkan verifier atau menilai rubrik saat Anda melihat eksploitasi, dan terus melacak metrik tugas.
##### Kapan menggunakan RFT
Tugas yang paling diuntungkan dari RFT memiliki beberapa sifat. Mereka memiliki sinyal keberhasilan yang terukur bahkan ketika satu output yang benar sulit ditentukan. Mereka mengakui kredit sebagian atau kualitas bertingkat sehingga Anda dapat memberi peringkat yang lebih baik dibandingkan jawaban yang lebih buruk dalam prompt atau menggunakan fungsi hadiah. Mereka melibatkan beberapa tujuan yang harus seimbang (seperti akurasi dengan singkatnya, kejelasan, keamanan, atau biaya). Mereka membutuhkan kepatuhan terhadap batasan eksplisit yang dapat Anda periksa secara terprogram. Mereka beroperasi dalam pengaturan yang dimediasi alat atau berbasis lingkungan di mana hasil dapat diamati (keberhasilan atau kegagalan, latensi, penggunaan sumber daya). Mereka terjadi dalam rezim label rendah di mana mengumpulkan target emas mahal tetapi umpan balik otomatis atau berbasis rubrik berlimpah. RFT bekerja paling baik ketika Anda dapat mengubah kualitas menjadi skalar atau peringkat yang andal dan ingin model tersebut secara istimewa memperkuat perilaku dengan skor lebih tinggi tanpa memerlukan target berlabel lengkap.
**Pertimbangkan metode lain ketika:**
+ Anda memiliki pasangan input-output berlabel yang berlimpah dan andal - Gunakan SFT
+ Kesenjangan utama adalah pengetahuan atau jargon — Gunakan retrieval-augmented generation (RAG)
+ Sinyal hadiah Anda berisik atau tidak dapat diandalkan dan Anda tidak dapat memperbaikinya dengan rubrik atau catur yang lebih baik — Stabilkan itu terlebih dahulu sebelum RFT
##### Kapan tidak menggunakan RFT
Hindari RFT dalam situasi ini:
+ Anda dapat dengan murah menghasilkan pasangan input-output berlabel yang andal (SFT lebih sederhana, lebih murah, dan lebih stabil)
+ Kesenjangan adalah pengetahuan atau jargon daripada perilaku (gunakan RAG)
+ Sinyal hadiah Anda berisik, jarang, mudah dimainkan, atau mahal atau lambat untuk dihitung (perbaiki evaluator terlebih dahulu)
+ Kinerja dasar mendekati nol (bootstrap dengan SFT sebelum mengoptimalkan preferensi)
+ Tugas ini memiliki skema deterministik, pemformatan ketat, atau satu jawaban yang benar (SFT atau validasi berbasis aturan bekerja lebih baik)
+ Latensi ketat atau anggaran biaya tidak dapat menyerap pengambilan sampel tambahan atau eksplorasi yang dibutuhkan RFT
+ Kendala keamanan atau kebijakan tidak ditentukan secara jelas dan dapat ditegakkan dalam hadiah
Jika Anda dapat menunjuk ke “jawaban yang benar,” gunakan SFT. Jika Anda membutuhkan pengetahuan baru, gunakan RAG. Gunakan RFT hanya setelah Anda memiliki baseline yang solid dan fungsi hadiah yang kuat, hard-to-exploit cepat.
#### Penyetelan halus yang diawasi (SFT)
Penyetelan halus yang diawasi melatih LLM pada kumpulan data pasangan input-output berlabel manusia untuk tugas Anda. Anda memberikan contoh petunjuk (pertanyaan, instruksi, dan sebagainya) dengan tanggapan yang benar atau diinginkan, dan terus melatih model pada contoh-contoh ini. Model menyesuaikan bobotnya untuk meminimalkan kerugian yang diawasi (biasanya lintas entropi antara prediksi dan token keluaran target). Ini adalah pelatihan yang sama yang digunakan dalam sebagian besar tugas pembelajaran mesin yang diawasi, diterapkan untuk mengkhususkan LLM.
SFT mengubah perilaku, bukan pengetahuan. Itu tidak mengajarkan model fakta atau jargon baru yang tidak dilihatnya dalam pra-pelatihan. Ini mengajarkan model bagaimana menjawab, bukan apa yang harus diketahui. Jika Anda membutuhkan pengetahuan domain baru (seperti terminologi internal), gunakan retrieval-augmented generation (RAG) untuk menyediakan konteks itu pada waktu inferensi. SFT kemudian menambahkan perilaku mengikuti instruksi yang diinginkan di atas.
##### Cara kerjanya
SFT mengoptimalkan LLM dengan meminimalkan kerugian lintas entropi rata-rata pada token respons, memperlakukan token prompt sebagai konteks dan menutupinya dari kerugian. Model menginternalisasi gaya target, struktur, dan aturan keputusan Anda, belajar untuk menghasilkan penyelesaian yang benar untuk setiap prompt. Misalnya, untuk mengklasifikasikan dokumen ke dalam kategori kustom, Anda menyempurnakan model dengan petunjuk (teks dokumen) dan pelengkapan berlabel (label kategori). Anda melatih pasangan tersebut sampai model mengeluarkan label yang tepat untuk setiap prompt dengan probabilitas tinggi.
Anda dapat melakukan SFT dengan sedikitnya beberapa ratus contoh dan skala hingga beberapa ratus ribu. Sampel SFT harus berkualitas tinggi dan langsung selaras dengan perilaku model yang diinginkan.
##### Kapan menggunakan SFT
Gunakan SFT ketika Anda memiliki tugas yang terdefinisi dengan baik dengan output yang diinginkan dengan jelas. Jika Anda dapat secara eksplisit menyatakan “Diberikan input X, output yang benar adalah Y” dan mengumpulkan contoh pemetaan tersebut, fine-tuning yang diawasi adalah pilihan yang baik. SFT unggul dalam skenario ini:
+ **Tugas klasifikasi terstruktur atau kompleks** - Klasifikasi dokumen atau kontrak internal ke dalam banyak kategori khusus. Dengan SFT, model mempelajari kategori spesifik ini lebih baik daripada mendorong saja.
+ **Tugas penjawab pertanyaan atau transformasi dengan jawaban yang diketahui - Sempurnakan** model untuk menjawab pertanyaan dari basis pengetahuan perusahaan, atau mengonversi data antar format di mana setiap input memiliki respons yang benar.
+ **Pemformatan dan konsistensi gaya** - Latih model untuk selalu merespons dalam format atau nada tertentu dengan menyempurnakan contoh format atau nada yang benar. Misalnya, pelatihan pada pasangan respons cepat yang menunjukkan suara merek tertentu mengajarkan model untuk menghasilkan output dengan gaya itu. Perilaku mengikuti instruksi sering kali awalnya diajarkan melalui SFT pada contoh perilaku asisten yang baik yang dikuratori.
SFT adalah cara paling langsung untuk mengajarkan LLM keterampilan atau perilaku baru ketika Anda dapat menentukan seperti apa perilaku yang benar. Ini menggunakan pemahaman bahasa model yang ada dan memfokuskannya pada tugas Anda. Gunakan SFT ketika Anda ingin model melakukan hal tertentu dan Anda memiliki atau dapat membuat kumpulan data contoh.
Gunakan SFT saat Anda dapat merakit pasangan prompt dan respons berkualitas tinggi yang mencerminkan perilaku yang Anda inginkan. Ini cocok dengan tugas dengan target yang jelas atau format deterministik seperti skema, fungsi atau panggilan alat, dan jawaban terstruktur di mana imitasi adalah sinyal pelatihan yang sesuai. Tujuannya adalah membentuk perilaku: mengajarkan model untuk memperlakukan petunjuk sebagai tugas, mengikuti instruksi, mengadopsi kebijakan nada dan penolakan, dan menghasilkan pemformatan yang konsisten. Rencanakan setidaknya ratusan demonstrasi, dengan kualitas data, konsistensi, dan deduplikasi lebih penting daripada volume mentah. Untuk pembaruan yang mudah dan hemat biaya, gunakan metode hemat parameter seperti Adaptasi Peringkat Rendah untuk melatih adaptor kecil sambil membiarkan sebagian besar tulang punggung tidak tersentuh.
##### Kapan tidak menggunakan SFT
Jangan gunakan SFT ketika kesenjangan adalah pengetahuan daripada perilaku. Itu tidak mengajarkan model fakta baru, jargon, atau peristiwa baru-baru ini. Dalam kasus tersebut, gunakan generasi tambahan pengambilan untuk membawa pengetahuan eksternal pada kesimpulan. Hindari SFT ketika Anda dapat mengukur kualitas tetapi tidak dapat memberi label satu jawaban yang benar. Gunakan penyetelan penguatan dengan imbalan yang dapat diverifikasi atau untuk mengoptimalkan hadiah tersebut LLM-as-a-judge secara langsung. Jika kebutuhan atau konten Anda sering berubah, andalkan pengambilan dan penggunaan alat daripada melatih ulang model.
**Topics**
+ [Praktik Terbaik untuk kustomisasi Amazon Nova](#best-practices)
+ [Nova Forge SDK](nova-forge-sdk.md)
+ [Pelatihan untuk model Amazon Nova](smtj-training.md)
+ [Memantau Kemajuan di Seluruh Iterasi](nova-model-monitor.md)
+ [Mengevaluasi model terlatih SageMaker AI Anda](nova-model-evaluation.md)
+ [Pelatihan berulang](smtj-iterative-training.md)
# Nova Forge SDK
Nova Forge SDK adalah SDK Python komprehensif untuk menyesuaikan model Amazon Nova. SDK menyediakan antarmuka terpadu untuk pelatihan, evaluasi, pemantauan, penyebaran, dan inferensi model Amazon Nova di berbagai platform termasuk SageMaker AI dan Amazon Bedrock. Baik Anda mengadaptasi model ke tugas khusus domain atau mengoptimalkan kinerja untuk kasus penggunaan Anda, SDK ini menyediakan semua yang Anda butuhkan dalam satu antarmuka terpadu.
## Manfaat
+ Satu SDK untuk seluruh siklus hidup kustomisasi model—mulai dari persiapan data hingga penerapan dan pemantauan.
+ Dukungan untuk beberapa metode pelatihan termasuk lanjutan pra-pelatihan (CPT), penyetelan halus yang diawasi (SFT), optimasi preferensi langsung (DPO), dan penyetelan halus penguatan (RFT), baik putaran tunggal maupun multi-putaran, dengan LoRa dan pendekatan peringkat penuh.
+ Dukungan bawaan untuk Pekerjaan SageMaker Pelatihan, SageMaker HyperPod, dan Amazon Bedrock, dengan manajemen sumber daya otomatis.
+ Tidak perlu lagi menemukan resep atau URI wadah yang tepat untuk teknik pelatihan Anda.
+ Bawa resep pelatihan Anda sendiri atau gunakan default cerdas SDK dengan penggantian parameter.
+ SDK memvalidasi konfigurasi Anda terhadap kombinasi model dan instance yang didukung dan menyediakan dukungan validasi, mencegah kesalahan sebelum pelatihan dimulai.
+ CloudWatch Pemantauan Amazon terintegrasi memungkinkan Anda melacak kemajuan pelatihan secara real-time.
+ Terintegrasi MLFlow untuk melacak eksperimen pelatihan dengan server MLFlow pelacak SageMaker AI.
## Persyaratan
SDK membutuhkan setidaknya Python 3.12.
## Penginstalan
Untuk menginstal SDK ini, ikuti perintah di bawah ini.
```
pip install amzn-nova-forge
```
## Model dan Teknik yang Didukung
SDK mendukung model dan teknik berikut dalam keluarga Amazon Nova:
****
| Metode | Model yang Didukung |
| --- | --- |
| Lanjutan Pra-pelatihan | [Semua Model Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) (hanya SMHP) |
| LoRa Fine-tuning yang diawasi | [Semua Model Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) |
| Peringkat Penuh Fine-tuning yang Diawasi | [Semua Model Nova](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) (hanya SMHP dan SMTJ) |
| Optimasi Preferensi Langsung LoRa | Model Nova 1.0 (hanya SMHP dan SMTJ) |
| Optimasi Preferensi Langsung Peringkat Penuh | Model Nova 1.0 (hanya SMHP dan SMTJ) |
| Penguatan Fine-tuning LoRa | Nova Lite 2.0 |
| Penguatan Fine-tuning Peringkat Penuh | Nova Lite 2.0 (hanya SMHP dan SMTJ) |
| LoRa Fine-tuning Penguatan Multi-putaran | Nova Lite 2.0 (Hanya SMHP) |
| Penguatan Multi-putaran Fine-tuning Peringkat Penuh | Nova Lite 2.0 (Hanya SMHP) |
## Memulai
**Topics**
+ [1. Siapkan Data Anda](#nova-forge-sdk-prepare-data)
+ [2. Konfigurasikan Infrastruktur Anda](#nova-forge-sdk-configure-infrastructure)
+ [3. Melatih](#nova-forge-sdk-train)
+ [4. Memantau](#nova-forge-sdk-monitor)
+ [5. Evaluasi](#nova-forge-sdk-evaluate)
+ [6. Deploy](#nova-forge-sdk-deploy)
### 1. Siapkan Data Anda
Muat kumpulan data Anda dari file lokal atau S3, dan biarkan SDK menangani transformasi ke format yang benar untuk metode pelatihan yang Anda pilih. Atau, berikan data yang diformat dan segera mulai.
```
from amzn_nova_forge.dataset.dataset_loader import JSONLDatasetLoader
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
loader = JSONLDatasetLoader(question="input", answer="output")
loader.load("s3://your-bucket/training-data.jsonl")
loader.transform(method=TrainingMethod.SFT_LORA, model=Model.NOVA_LITE)
```
### 2. Konfigurasikan Infrastruktur Anda
Pilih sumber daya komputasi Anda—SDK memvalidasi konfigurasi dan memastikan penyiapan yang optimal.
```
from amzn_nova_forge.manager.runtime_manager import BedrockRuntimeManager, SMTJRuntimeManager, SMHPRuntimeManager
# Bedrock
runtime = BedrockRuntimeManager(
execution_role="arn:aws:iam::123456789012:role/ExampleRole"
)
# SageMaker Training Jobs
runtime = SMTJRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4
)
# SageMaker HyperPod
runtime = SMHPRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4,
cluster_name="my-hyperpod-cluster",
namespace="kubeflow"
)
```
### 3. Melatih
Mulai pelatihan hanya dengan beberapa baris kode.
```
from amzn_nova_forge.model import NovaModelCustomizer
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
customizer = NovaModelCustomizer(
model=Model.NOVA_LITE_2,
method=TrainingMethod.SFT_LORA,
infra=runtime,
data_s3_path="s3://your-bucket/prepared-data.jsonl"
)
result = customizer.train(job_name="my-training-job")
```
### 4. Memantau
Lacak kemajuan latihan Anda langsung dari SDK.
```
from amzn_nova_forge.monitor.log_monitor import CloudWatchLogMonitor
# Monitor training logs
customizer.get_logs()
# Or monitor directly via CloudWatchLogMonitor
monitor = CloudWatchLogMonitor.from_job_result(result)
monitor.show_logs(limit=10)
# Check job status
result.get_job_status() # InProgress, Completed, Failed
```
### 5. Evaluasi
Evaluasi kinerja model dengan berbagai [tolok ukur bawaan](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-benchmark), atau rancang evaluasi Anda sendiri.
```
from amzn_nova_forge.recipe_config.eval_config import EvaluationTask
# Evaluate on benchmark tasks
eval_result = customizer.evaluate(
job_name="model-eval",
eval_task=EvaluationTask.MMLU,
model_path=result.model_artifacts.checkpoint_s3_path
)
```
### 6. Deploy
Terapkan model khusus Anda ke produksi dengan dukungan bawaan untuk Amazon Bedrock atau. SageMaker
```
from amzn_nova_forge.model.model_enums import DeployPlatform
# Bedrock provisioned throughput
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_PT,
pt_units=10
)
# Bedrock On-Demand
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_OD,
pt_units=10
)
# Sagemaker Real-time Inference
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.SAGEMAKER,
unit_count=10,
sagemaker_instance_type="ml.p5.48xlarge",
sagemaker_environment_variables={
"CONTEXT_LENGTH": "12000",
"MAX_CONCURRENCY": "16",
}
)
```
## Kemampuan Kunci
### Penciptaan Resep On The Fly
SDK menghilangkan kebutuhan untuk mencari resep atau URI wadah yang sesuai untuk teknik tertentu.
### Pemrosesan Data Cerdas
SDK secara otomatis mengubah data Anda menjadi format yang benar untuk pelatihan. Baik Anda bekerja dengan file JSON, JSONL, atau CSV, pemuat data menangani konversi dengan mulus. Data Loader mendukung teks serta data multimodal (gambar dan video).
### Dukungan Infrastruktur Perusahaan
SDK bekerja dengan kedua Pekerjaan SageMaker Pelatihan dan SageMaker HyperPod, secara otomatis mengelola:
+ Validasi tipe instans
+ Validasi resep
+ Validasi kumpulan data
+ Orkestrasi dan pemantauan Job
SDK juga mendukung SageMaker Training Jobs tanpa server dan kustomisasi Bedrock.
### Evaluasi komprehensif
Evaluasi model khusus Anda terhadap [tolok ukur standar](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-evaluate.html) termasuk:
+ MMLU (Pemahaman Bahasa Multitask Besar-besaran)
+ BBH (Tugas Penalaran Tingkat Lanjut)
+ GPQA (Tanya Jawab Bukti Google Tingkat Pascasarjana)
Baik menggunakan default benchmark, atau memodifikasinya agar sesuai dengan kebutuhan Anda:
+ BYOM (Bawa Metrik Anda Sendiri)
+ BYOD (Bawa Dataset Anda Sendiri)
### Penyebaran Produksi
Terapkan model Anda ke Amazon Bedrock atau SageMaker AI dengan opsi untuk:
+ **Bedrock Provisioned Throughput** - Kapasitas khusus untuk kinerja yang konsisten
+ **Bedrock On-Demand (hanya berlaku untuk kustomisasi berbasis LoRa**) - harga Pay-per-use
+ **SageMaker Inferensi Real-time AI** - Kapasitas khusus untuk kinerja yang konsisten
### Inferensi Batch
Jalankan pekerjaan inferensi skala besar secara efisien:
+ Memproses ribuan permintaan secara paralel
+ Agregasi hasil otomatis
+ Pemrosesan batch hemat biaya
### Nova Forge
Untuk pelanggan Nova Forge, SDK mendukung resep pencampuran data.
## Pelajari Lebih Lanjut
Siap untuk mulai menyesuaikan model Nova dengan Nova Forge SDK? Lihat GitHub repositori kami untuk panduan terperinci, referensi API, dan contoh tambahan: [https://github.com/aws/nova-forge-sdk](https://github.com/aws/nova-forge-sdk)
# Pelatihan untuk model Amazon Nova
Melatih model Amazon Nova tentang Pekerjaan SageMaker Pelatihan mendukung Supervised Fine-Tuning (SFT) dan Reinforcement Fine-Tuning (RFT). Setiap teknik melayani kebutuhan kustomisasi yang berbeda dan dapat diterapkan ke versi model Amazon Nova yang berbeda.
**Topics**
+ [Sempurnakan Nova 2.0](nova-fine-tune-2.md)
+ [Reinforcement Fine-Tuning (RFT) dengan model Amazon Nova](nova-reinforcement-fine-tuning.md)
# Sempurnakan Nova 2.0
## Prasyarat
Sebelum Anda memulai pekerjaan pelatihan, perhatikan hal berikut.
+ Bucket Amazon S3 untuk menyimpan data input dan output pekerjaan pelatihan Anda. Anda dapat menggunakan satu bucket untuk keduanya atau ember terpisah untuk setiap jenis data. Pastikan ember Anda berada di tempat yang sama di Wilayah AWS mana Anda membuat semua sumber daya lain untuk pelatihan. Untuk informasi selengkapnya, lihat [Membuat bucket tujuan umum](https://docs.aws.amazon.com//AmazonS3/latest/userguide/create-bucket-overview.html).
+ Peran IAM dengan izin untuk menjalankan pekerjaan pelatihan. Pastikan Anda melampirkan kebijakan IAM dengan`AmazonSageMakerFullAccess`. Untuk informasi selengkapnya, lihat [Cara menggunakan peran eksekusi SageMaker AI](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html).
+ Resep dasar Amazon Nova, lihat[Mendapatkan resep Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).
## Apa itu SFT?
Supervised fine-tuning (SFT) melatih model bahasa menggunakan pasangan input-output berlabel. Model belajar dari contoh demonstrasi yang terdiri dari petunjuk dan tanggapan, menyempurnakan kemampuannya untuk menyelaraskan dengan tugas, instruksi, atau perilaku yang diinginkan tertentu.
## Persiapan data
### Ikhtisar
Data Nova 2.0 SFT menggunakan format Converse API yang sama dengan Nova 1.0, dengan penambahan bidang konten penalaran opsional. Untuk spesifikasi format lengkap, lihat:
+ Konten penalaran: [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html)
+ [Skema API Converse: API Converse](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html)
+ [Kendala set data: Kendala set data](https://docs.aws.amazon.com/nova/latest/userguide/fine-tune-prepare-data-understanding.html)
### Fitur yang didukung
+ **Jenis input** - Teks, gambar, atau video di blok konten pengguna
+ **Konten asisten** - Tanggapan khusus teks dan konten penalaran
+ **Komposisi dataset** — Harus homogen. Pilih salah satu dari:
+ Giliran hanya teks
+ Teks\$1gambar berubah
+ Teks\$1video berubah (mendukung pemahaman dokumen)
**penting**
Anda tidak dapat mencampur gambar dan video dalam kumpulan data yang sama atau di belokan yang berbeda.
### Keterbatasan saat ini
+ **Konten penalaran multimodal - Meskipun format Converse mendukung konten** penalaran berbasis gambar, Nova 2.0 SFT hanya mendukung konten penalaran berbasis teks di bidang ReasoningText.
+ **Set validasi** - Anda tidak dapat memberikan kumpulan data validasi untuk SFT dengan Nova 2.0. Jika Anda memberikan kumpulan data validasi, itu akan diabaikan selama pelatihan. Batasan ini berlaku untuk pengajuan pekerjaan berbasis UI dan terprogram.
### Format media yang didukung
+ **Gambar** - PNG, JPEG, GIF
+ **Video** - MOV, MKV, MP4
### Contoh format data
------
#### [ Text-only (Nova 1.0 compatible) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"text": "The closest country is New Zealand"
}
]
}
]
}
```
------
#### [ Text with reasoning (Nova 2.0) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to use my world knowledge of geography to answer this question"
}
}
},
{
"text": "The closest country to Australia is New Zealand, located to the southeast across the Tasman Sea."
}
]
}
]
}
```
------
#### [ Image \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"image": {
"format": "jpeg",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-image.jpg",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "Which country is highlighted in the image?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will determine the highlighted country by examining its location on the map and using my geographical knowledge"
}
}
},
{
"text": "The highlighted country is New Zealand"
}
]
}
]
}
```
------
#### [ Video \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-video.mp4",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "What is shown in this video?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will analyze the video content to identify key elements"
}
}
},
{
"text": "The video shows a map with New Zealand highlighted"
}
]
}
]
}
```
------
## Panggilan alat
Nova 2.0 SFT mendukung model pelatihan tentang pola pemanggilan alat, memungkinkan model Anda mempelajari kapan dan bagaimana memanggil alat atau fungsi eksternal.
### Format data untuk pemanggilan alat
Data pelatihan pemanggilan alat mencakup `toolConfig` bagian yang mendefinisikan alat yang tersedia, bersama dengan giliran percakapan yang menunjukkan pola penggunaan alat.
**Masukan sampel**
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are an expert in composing function calls."
}
],
"toolConfig": {
"tools": [
{
"toolSpec": {
"name": "getItemCost",
"description": "Retrieve the cost of an item from the catalog",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"item_name": {
"type": "string",
"description": "The name of the item to retrieve cost for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to retrieve cost for"
}
},
"required": [
"item_id"
]
}
}
}
},
{
"toolSpec": {
"name": "getItemAvailability",
"description": "Retrieve whether an item is available in a given location",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"zipcode": {
"type": "string",
"description": "The zipcode of the location to check in"
},
"quantity": {
"type": "integer",
"description": "The number of items to check availability for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to check availability for"
}
},
"required": [
"item_id", "zipcode"
]
}
}
}
}
]
},
"messages": [
{
"role": "user",
"content": [
{
"text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"
}
}
},
{
"toolUse": {
"toolUseId": "getItemAvailability_0",
"name": "getItemAvailability",
"input": {
"zipcode": "94086",
"quantity": 20,
"item_id": "id-123"
}
}
}
]
},
{
"role": "user",
"content": [
{
"toolResult": {
"toolUseId": "getItemAvailability_0",
"content": [
{
"text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"
}
]
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"
}
]
}
]
}
```
### Persyaratan panggilan alat
Saat membuat data pelatihan pemanggilan alat, ikuti persyaratan ini:
| Persyaratan | Deskripsi |
| --- | --- |
| ToolUse penempatan | ToolUse harus muncul di asisten giliran saja |
| ToolResult penempatan | ToolResult harus muncul di giliran pengguna saja |
| ToolResult format | ToolResult harus berupa teks atau JSON saja. Modalitas lain tidak didukung untuk model Nova |
| Format InputSkema | InputSchema dalam ToolSpec harus berupa objek Skema JSON yang valid |
| toolUseId pencocokan | Masing-masing ToolResult harus mereferensikan yang valid toolUseId dari asisten sebelumnya ToolUse, dengan masing-masing toolUseId digunakan tepat sekali per percakapan |
### Catatan penting
+ Pastikan definisi alat Anda konsisten di semua sampel pelatihan
+ Model mempelajari pola pemanggilan alat dari demonstrasi yang Anda berikan
+ Sertakan beragam contoh kapan harus menggunakan setiap alat dan kapan tidak menggunakan alat
## Pemahaman dokumen
Nova 2.0 SFT mendukung pelatihan tentang tugas berbasis dokumen, memungkinkan model Anda mempelajari cara menganalisis dan menanggapi pertanyaan tentang dokumen PDF.
### Format data untuk pemahaman dokumen
Data pelatihan pemahaman dokumen mencakup referensi dokumen di blok konten pengguna, dengan model pembelajaran untuk mengekstrak dan memberi alasan atas konten dokumen.
**Masukan sampel**
```
{
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"document": {
"format": "pdf",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the document to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
}
```
### Keterbatasan pemahaman dokumen
| Batasan | Detail |
| --- | --- |
| Format yang didukung | Hanya file PDF |
| Ukuran dokumen maksimum | 10 MB |
| Pencampuran modalitas | Sampel dapat memiliki dokumen dan teks, tetapi tidak dapat memiliki dokumen yang dicampur dengan modalitas lain (gambar, video) |
### Praktik terbaik untuk memahami dokumen
+ Pastikan dokumen diformat dengan jelas dan teks dapat diekstraksi
+ Berikan beragam contoh yang mencakup berbagai jenis dokumen dan format pertanyaan
+ Sertakan konten penalaran untuk membantu model mempelajari pola analisis dokumen
## Pemahaman video
Nova 2.0 SFT mendukung pelatihan tentang tugas berbasis video, memungkinkan model Anda mempelajari cara menganalisis dan menanggapi pertanyaan tentang konten video.
### Format data untuk pemahaman video
Data pelatihan pemahaman video mencakup referensi video di blok konten pengguna, dengan model pembelajaran untuk mengekstrak informasi dan alasan atas konten video.
**Masukan sampel**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the video to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
```
### Keterbatasan pemahaman video
| Batasan | Detail |
| --- | --- |
| Ukuran video maksimal | 50 MB |
| Durasi video maksimum | 15 menit |
| Video per sampel | Hanya satu video yang diizinkan per sampel. Beberapa video dalam sampel yang sama tidak didukung |
| Pencampuran modalitas | Sampel dapat memiliki video dan teks, tetapi tidak dapat memiliki video yang digabungkan dengan modalitas lain (gambar, dokumen) |
### Format video yang didukung
+ MOV
+ MKV
+ MP4
### Praktik terbaik untuk memahami video
+ Jaga agar video tetap ringkas dan fokus pada konten yang relevan dengan tugas Anda
+ Pastikan kualitas video cukup bagi model untuk mengekstrak informasi yang bermakna
+ Berikan pertanyaan yang jelas yang mereferensikan aspek-aspek spesifik dari konten video
+ Sertakan beragam contoh yang mencakup berbagai jenis video dan format pertanyaan
## Mode penalaran vs non-penalaran
### Memahami konten penalaran
Konten penalaran (juga disebut chain-of-thought) menangkap langkah-langkah pemikiran menengah model sebelum menghasilkan jawaban akhir. Pada `assistant` gilirannya, gunakan `reasoningContent` bidang untuk memasukkan jejak penalaran ini.
**Bagaimana kerugian dihitung**
+ **Dengan konten penalaran** — Kerugian pelatihan mencakup token penalaran dan token keluaran akhir
+ **Tanpa penalaran konten** - Kerugian pelatihan dihitung hanya pada token keluaran akhir
Anda dapat menyertakan `reasoningContent` beberapa giliran asisten dalam percakapan multi-putaran.
**Pedoman pemformatan**
+ Gunakan teks biasa untuk konten penalaran
+ Hindari tag markup seperti `` dan `` kecuali secara khusus diperlukan oleh tugas Anda
+ Pastikan konten penalaran jelas dan relevan dengan proses pemecahan masalah
### Kapan mengaktifkan mode penalaran
Setel `reasoning_enabled: true` dalam konfigurasi latihan Anda saat:
+ Data pelatihan Anda memiliki token penalaran
+ Anda ingin model menghasilkan token pemikiran sebelum menghasilkan output akhir
+ Anda membutuhkan peningkatan kinerja pada tugas penalaran yang kompleks
Melatih Nova pada dataset non-penalaran dengan `reasoning_enabled = true` diizinkan. Namun, melakukan hal itu dapat menyebabkan model kehilangan kemampuan penalarannya, karena Nova terutama belajar untuk menghasilkan respons yang disajikan dalam data tanpa menerapkan penalaran. Jika Anda ingin melatih Nova pada kumpulan data non-penalaran tetapi masih mengharapkan penalaran selama inferensi, Anda dapat menonaktifkan penalaran selama pelatihan (`reasoning_enabled = false`) tetapi mengaktifkannya untuk inferensi. Meskipun pendekatan ini memungkinkan penalaran digunakan pada waktu inferensi, pendekatan ini tidak menjamin peningkatan kinerja dibandingkan dengan inferensi tanpa penalaran. Secara umum, aktifkan penalaran untuk pelatihan dan inferensi saat menggunakan kumpulan data penalaran, dan nonaktifkan keduanya saat menggunakan kumpulan data non-penalaran.
Atur `reasoning_enabled: false` kapan:
+ Data pelatihan Anda tidak memiliki token penalaran
+ Anda melatih tugas-tugas langsung yang tidak mendapat manfaat dari langkah-langkah penalaran eksplisit
+ Anda ingin mengoptimalkan kecepatan dan mengurangi penggunaan token
### Menghasilkan data penalaran
Jika kumpulan data Anda tidak memiliki jejak penalaran, Anda dapat membuatnya menggunakan model berkemampuan penalaran seperti Nova Premier. Berikan pasangan input-output Anda ke model dan tangkap proses penalarannya untuk membangun kumpulan data yang diperbesar dengan alasan.
### Menggunakan token penalaran untuk pelatihan
Ketika pelatihan dengan mode penalaran diaktifkan, model belajar untuk memisahkan penalaran internal dari jawaban akhir. Proses pelatihan:
+ Mengatur data sebagai tiga kali lipat: masukan, penalaran, dan jawaban
+ Mengoptimalkan menggunakan kerugian prediksi token berikutnya standar dari token penalaran dan jawaban
+ Mendorong model untuk bernalar secara internal sebelum menghasilkan tanggapan
### Konten penalaran yang efektif
Konten penalaran berkualitas tinggi harus mencakup:
+ Pikiran dan analisis menengah
+ Pengurangan logis dan langkah inferensi
+ Step-by-step pendekatan pemecahan masalah
+ Hubungan eksplisit antara langkah dan kesimpulan
Ini membantu model mengembangkan kemampuan untuk “berpikir sebelum menjawab.”
## Pedoman persiapan kumpulan data
### Ukuran dan kualitas
+ **Ukuran yang disarankan** - 2.000-10.000 sampel
+ **Sampel minimum** - 200
+ **Prioritas** - Kualitas di atas kuantitas. Pastikan contoh akurat dan beranotasi dengan baik
+ **Penyelarasan aplikasi** — Dataset harus mencerminkan kasus penggunaan produksi Anda
### Keanekaragaman
Sertakan beragam contoh yang:
+ Tutupi berbagai input yang diharapkan
+ Mewakili tingkat kesulitan yang berbeda
+ Sertakan kasus tepi dan variasi
+ Cegah overfitting ke pola yang sempit
### Pemformatan keluaran
Tentukan dengan jelas format output yang diinginkan dalam tanggapan asisten:
+ Struktur JSON
+ Tabel
+ Format CSV
+ Format khusus khusus untuk aplikasi Anda
### Percakapan multi-giliran
Untuk kumpulan data multi-putaran, ingat:
+ Kerugian dihitung hanya pada giliran asisten, bukan putaran pengguna
+ Setiap respons asisten harus diformat dengan benar
+ Pertahankan konsistensi di seluruh belokan percakapan
### Daftar periksa kualitas
+ Ukuran dataset yang memadai (sampel 2K-10K)
+ Beragam contoh yang mencakup semua kasus penggunaan
+ Pemformatan keluaran yang jelas dan konsisten
+ Label dan anotasi yang akurat
+ Perwakilan skenario produksi
+ Bebas dari kontradiksi atau ambiguitas
### Mengunggah data Anda
Kumpulan data harus diunggah ke bucket yang dapat diakses oleh SageMaker pekerjaan pelatihan. Untuk informasi tentang menyetel izin yang tepat, lihat [Prasyarat](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-general-prerequisites.html).
## Memulai pekerjaan pelatihan
### Memilih hyperparameters dan memperbarui resep
Pengaturan untuk Nova 2.0 sebagian besar sama dengan Nova 1.0. Setelah data input diunggah ke S3, gunakan resep dari [SageMaker HyperPod Resep](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova) di bawah Fine tuning folder. Untuk Nova 2.0, berikut ini adalah beberapa hyperparameter kunci yang dapat Anda perbarui berdasarkan kasus penggunaan. Berikut ini adalah contoh resep Nova 2.0 SFT PEFT. Untuk URI image container, gunakan `708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-SFT-V2-latest` untuk menjalankan tugas fine-tuning SFT.
Silakan gunakan v2.254.1 SageMaker AI pySDK untuk kompatibilitas ketat dengan pelatihan Nova. Memutakhirkan SDK ke versi v3.0 akan menghasilkan perubahan yang melanggar. Support untuk v3 dari SageMaker AI pySDK akan segera hadir.
**Masukan Sampel**
```
!pip install sagemaker==2.254.1
```
```
run:
name: {peft_recipe_job_name}
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: {peft_model_name_or_path}
data_s3_path: {train_dataset_s3_path} # SageMaker HyperPod (SMHP) only and not compatible with SageMaker Training jobs. Note replace my-bucket-name with your real bucket name for SMHP job
replicas: 4 # Number of compute instances for training, allowed values are 4, 8, 16, 32
output_s3_path: "" # Output artifact path (Hyperpod job-specific; not compatible with standard SageMaker Training jobs). Note replace my-bucket-name with your real bucket name for SMHP job
training_config:
max_steps: 10 # Maximum training steps. Minimal is 4.
save_steps: 10 # How many training steps the checkpoint will be saved. Should be less than or equal to max_steps
save_top_k: 1 # Keep top K best checkpoints. Note supported only for SageMaker HyperPod jobs. Minimal is 1.
max_length: 32768 # Sequence length (options: 8192, 16384, 32768 [default], 65536)
global_batch_size: 32 # Global batch size (options: 32, 64, 128)
reasoning_enabled: true # If data has reasoningContent, set to true; otherwise False
lr_scheduler:
warmup_steps: 15 # Learning rate warmup steps. Recommend 15% of max_steps
min_lr: 1e-6 # Minimum learning rate, must be between 0.0 and 1.0
optim_config: # Optimizer settings
lr: 1e-5 # Learning rate, must be between 0.0 and 1.0
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Exponential decay rate for first-moment estimates, must be between 0.0 and 1.0
adam_beta2: 0.95 # Exponential decay rate for second-moment estimates, must be between 0.0 and 1.0
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "lora" # Enable LoRA for PEFT
lora_tuning:
alpha: 64 # Scaling factor for LoRA weights ( options: 32, 64, 96, 128, 160, 192),
lora_plus_lr_ratio: 64.0
```
Resepnya juga mengandung sebagian besar hiperparameter yang sama dengan Nova 1.0. Hyperparameter yang menonjol adalah:
+ `max_steps`— Jumlah langkah yang Anda inginkan untuk menjalankan pekerjaan. Umumnya, untuk satu zaman (satu kali berjalan melalui seluruh kumpulan data Anda), jumlah langkah = jumlah sampel data/ukuran batch global. Semakin besar jumlah langkah dan semakin kecil ukuran batch global Anda, semakin lama pekerjaan yang dibutuhkan untuk dijalankan.
+ `reasoning_enabled`— Mengontrol mode penalaran untuk dataset Anda. Opsi:
+ `true`: Mengaktifkan mode penalaran (setara dengan penalaran tinggi)
+ `false`: Menonaktifkan mode penalaran
Catatan: Untuk SFT, tidak ada kontrol granular atas tingkat upaya penalaran. Pengaturan `reasoning_enabled: true` memungkinkan kemampuan penalaran penuh.
+ `peft.peft_scheme`— Mengatur ini ke “lora” memungkinkan penyetelan halus berbasis PEFT. Mengaturnya ke null (tanpa tanda kutip) memungkinkan penyetelan halus Peringkat Penuh.
### Mulai pekerjaan pelatihan
```
from sagemaker.pytorch import PyTorch
# define OutputDataConfig path
if default_prefix:
output_path = f"s3://{bucket_name}/{default_prefix}/{sm_training_job_name}"
else:
output_path = f"s3://{bucket_name}/{sm_training_job_name}"
output_kms_key = "" # optional, leave blank for Amazon managed encryption
recipe_overrides = {
"run": {
"replicas": instance_count, # Required
"output_s3_path": output_path
},
}
estimator = PyTorch(
output_path=output_path,
base_job_name=sm_training_job_name,
role=role,
disable_profiler=True,
debugger_hook_config=False,
instance_count=instance_count,
instance_type=instance_type,
training_recipe=training_recipe,
recipe_overrides=recipe_overrides,
max_run=432000,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key,
tags=[
{'Key': 'model_name_or_path', 'Value': model_name_or_path},
]
)
print(f"\nsm_training_job_name:\n{sm_training_job_name}\n")
print(f"output_path:\n{output_path}")
```
```
from sagemaker.inputs import TrainingInput
train_input = TrainingInput(
s3_data=train_dataset_s3_path,
distribution="FullyReplicated",
s3_data_type="Converse",
)
estimator.fit(inputs={"validation": val_input}, wait=False)
```
**catatan**
Melewati kumpulan data validasi tidak didukung untuk fine tuning Nova 2.0 yang diawasi.
Untuk memulai pekerjaan:
+ Perbarui resep dengan jalur dataset dan hyperparameters Anda
+ Jalankan sel yang ditentukan di buku catatan untuk mengirimkan pekerjaan pelatihan
Notebook menangani pengiriman pekerjaan dan menyediakan pelacakan status.
# Reinforcement 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 yang belajar dari pasangan input-output, RFT menggunakan fungsi hadiah untuk mengevaluasi respons model dan secara iteratif mengoptimalkan model untuk memaksimalkan penghargaan ini. Pendekatan ini unggul ketika mendefinisikan output yang benar secara tepat menantang, tetapi Anda dapat mengukur kualitas respons dengan andal.
**Kapan menggunakan RFT**
Gunakan RFT ketika Anda dapat menentukan kriteria keberhasilan yang jelas dan terukur tetapi berjuang untuk memberikan output yang tepat untuk pelatihan. Ini 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 step-by-step penalaran 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 Fine-Tuning Penguatan OpenAI.](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**
+ Hanya teks
### 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
**Pendekatan evaluasi-pertama**
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 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 and p5en.48xlarge instance types.
run:
name: "my-rft-run" # Unique run name (appears in logs/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;
replicas: 4
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 GRPO Training specific configs
training_config:
max_length: 8192 # Context window (tokens) for inputs+prompt;
global_batch_size: 16 # Total samples per optimizer step across all replicas (16/32/64/128/256).
reasoning_effort: high # Enables reasoning mode high / low / or null for non-reasoning
rollout: # How responses are generated for GRPO/advantage calc.
advantage_strategy:
number_generation: 2 # N samples per prompt to estimate advantages (variance vs 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;
top_k: 1 # Sample only from top-K logits
rewards:
preset_reward_function: null # Usage of preset reward functions [exact_match]
api_endpoint:
lambda_arn: arn:aws:lambda:::function:
lambda_concurrency_limit: 12 # Max concurrent Lambda invocations (throughput vs. throttling).
trainer:
max_steps: 2 # Steps to train for. One Step = global_batch_size
save_steps: 5
test_steps: 1
# RL parameters
ent_coeff: 0.0 # A bonus added to the policy loss that rewards higher-output entropy.
kl_loss_coef: 0.001 # Weight on the KL penalty between the actor (trainable policy) and a frozen reference model
optim_config: # Optimizer settings
lr: 5e-5 # Learning rate
weight_decay: 0.0 # L2 regularization strength (0.0–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: 32
lora_plus_lr_ratio: 64.0 # LoRA+ learning rate scaling factor (0.0–100.0)
```
## Pelatihan RFT menggunakan LLM sebagai juri
### Ikhtisar
Model bahasa besar (LLMs) semakin banyak digunakan sebagai juri dalam alur kerja penyempurnaan penguatan (RFT), menyediakan 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 juri berbasis LLM 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\$1effort)
+ rendah — Overhead penalaran minimal
+ tinggi - Kemampuan penalaran maksimum (default saat reasing\$1effort ditentukan)
**catatan**
Tidak ada opsi media untuk RFT. Jika bidang reasing\$1effort tidak ada dalam konfigurasi Anda, penalaran akan dinonaktifkan. Saat penalaran diaktifkan, Anda harus mengatur `max_new_tokens` ke 32768 untuk mengakomodasi output penalaran yang diperluas.
**Kapan menggunakan setiap mode**
Gunakan penalaran tinggi untuk:
+ Tugas analitis yang kompleks
+ Pemecahan masalah matematika
+ Pengurangan logis multi-langkah
+ Tugas di mana step-by-step berpikir menambah nilai
Gunakan none (hilangkan reasing\$1effort) 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 latihan 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 Peringkat Penuh dan LoRa:
+ **Pelatihan LoRa** - 2/4/6/8 × p5.48xlarge atau instans p5en.48xlarge
+ **Pelatihan Peringkat Penuh** - 2/4/6/8 × instans 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 pemrosesan per token
**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)
+ **Hanya satu putaran** - Percakapan multi-putaran 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
**Evaluasi pra-pelatihan**
+ Uji kinerja model dasar sebelum RFT
+ Jika hadiah 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 pola yang menyangkut:
+ 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
## Kemampuan lanjutan: Nova Forge
Untuk pengguna yang membutuhkan kemampuan canggih di luar batasan RFT standar, Nova Forge tersedia sebagai penawaran layanan berlangganan berbayar:
+ Dukungan percakapan multi-giliran
+ 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.
# Memantau Kemajuan di Seluruh Iterasi
Anda dapat melacak metrik melalui MLflow.
## Kustomisasi Nova - MLFlow pengaturan untuk SageMaker HyperPod
Untuk mengaktifkan SageMaker HyperPod lingkungan Anda menghasilkan metrik MLFlow, Anda perlu melakukan beberapa pengaturan tambahan.
1. Buka Amazon SageMaker AI
1. Pilih SageMaker Studio
1. Jika ada profil yang sudah dibuat, pilih “Open Studio”.
1. Jika tidak ada profil yang dibuat, pilih “Buat SageMaker Domain” untuk mengaturnya
1. Pilih MLFlow. Jika tidak ada MLFlow Aplikasi yang dibuat, pilih “Buat MLFlow Aplikasi”
1. Klik copy/paste tombol atau item menu “Lihat Detail” di Aplikasi Aliran Ml untuk mendapatkan ARN. Anda akan membutuhkan ini ketika Anda mengirimkan pekerjaan pelatihan Anda.
![\[Tombol Lihat Detail di Aplikasi Aliran ML, dengan ARN.\]](http://docs.aws.amazon.com/id_id/nova/latest/nova2-userguide/images/how-it-works.png)
1. Pada peran eksekusi HyperPod klaster, tambahkan kebijakan berikut. Ini akan memungkinkan HyperPod cluster memanggil MLFlow API untuk menerbitkan metrik.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker-mlflow:*",
"Resource": [
"arn:aws:sagemaker:us-east-1:372836560492:mlflow-app/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListMlflowTrackingServers",
"sagemaker:CallMlflowAppApi"
],
"Resource": "*"
}
]
}
```
### Mengirimkan pekerjaan melalui CLI
Tentukan 4 parameter override baru, baik di baris perintah, atau di resep yaml.
1. `mlflow_tracking_uri`: ARN dari Aplikasi MLFlow
1. `mlflow_experiment_name`: Nama untuk percobaan ini
1. `mlflow_experiment_name`: Nama eksperimen tempat metrik akan disimpan MLFlow
1. `mlflow_run_name`: Nama untuk percobaan ini
Baris perintah
```
--override-parameters '{"recipes.run.mlflow_tracking_uri": "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W", "recipes.run.mlflow_experiment_name": "myuser-sft-lora-exp1", "recipes.run.mlflow_run_name": "myuser-sft-lora-exp1-202512181940"}'
```
yaml:
```
## Run config
run:
mlflow_tracking_uri: "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W"
mlflow_experiment_name: "myuser-sft-lora-exp1"
mlflow_run_name: "myuser-sft-lora-exp1-202512181940"
```
### Mengirimkan pekerjaan melalui UI Studio SageMaker
MLFlow integrasi sudah dibangun ke dalam pengalaman UI SageMaker Studio. Saat mengirimkan pekerjaan pelatihan, cukup tunjukkan instance MLFlow Aplikasi mana yang akan digunakan.
1. Di SageMaker Studio, navigasikan ke Models> Nova 2.0 Lite > Customize > Customize with UI.
1. Perluas bagian Konfigurasi Lanjutan
1. Pilih MLFlow Aplikasi tempat Anda ingin mengirim metrik pelatihan. Anda juga dapat mengatur nama eksperimen dan eksperimen yang dijalankan di sini.
![\[Aplikasi Aliran ML.\]](http://docs.aws.amazon.com/id_id/nova/latest/nova2-userguide/images/MLFlow-App.png)
### Mengirimkan pekerjaan melalui AWS AWS CLI
Jika Anda menggunakan AWS AWS CLI, Anda harus membuat MLflow aplikasi dan meneruskannya sebagai masukan ke permintaan API pekerjaan pelatihan.
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## Buat MLflow aplikasi
**Menggunakan UI Studio:** Jika Anda membuat pekerjaan pelatihan melalui UI Studio, MLflow aplikasi default dibuat secara otomatis dan dipilih secara default di bawah Opsi Lanjutan.
**Menggunakan CLI:** Jika Anda menggunakan CLI, Anda harus membuat MLflow aplikasi dan meneruskannya sebagai input ke permintaan API pekerjaan pelatihan.
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## Akses MLflow aplikasinya
**Menggunakan CLI:** Buat URL yang telah ditandatangani sebelumnya untuk mengakses UI aplikasi: MLflow
```
aws sagemaker create-presigned-mlflow-app-url \
--arn $mlflow_app_arn \
--region $region \
--output text
```
**Menggunakan UI Studio:** UI Studio menampilkan metrik kunci yang disimpan MLflow dan menyediakan tautan ke UI MLflow aplikasi.
## Metrik kunci untuk dilacak
Pantau metrik ini di seluruh iterasi untuk menilai peningkatan dan melacak kemajuan pekerjaan:
**Untuk SFT**
+ Kurva kehilangan pelatihan
+ Jumlah sampel yang dikonsumsi dan waktu untuk memproses sampel
+ Akurasi kinerja pada set uji yang diheld-out
+ Kepatuhan format (misalnya, tingkat keluaran JSON yang valid)
+ Kebingungan pada data evaluasi khusus domain
**Untuk RFT**
+ Skor hadiah rata-rata selama pelatihan
+ Distribusi hadiah (persentase respons hadiah tinggi)
+ Tren hadiah validasi (perhatikan pemasangan yang berlebihan)
+ Tingkat keberhasilan khusus tugas (misalnya, tingkat kelulusan eksekusi kode, akurasi masalah matematika)
**Umum**
+ Delta kinerja benchmark antara iterasi
+ Skor evaluasi manusia pada sampel yang representatif
+ Metrik produksi (jika menerapkan secara berulang)
## Menentukan kapan harus berhenti
Berhenti iterasi saat:
+ **Dataran tinggi kinerja**: Pelatihan tambahan tidak lagi meningkatkan metrik target secara bermakna
+ **Peralihan teknik membantu**: Jika satu teknik mencapai puncaknya, coba beralih (misalnya, SFT → RFT → SFT) untuk menerobos langit-langit kinerja
+ **Metrik target tercapai**: Kriteria keberhasilan Anda terpenuhi
+ **Regresi terdeteksi**: Iterasi baru menurunkan kinerja (lihat prosedur rollback di bawah)
Untuk prosedur evaluasi terperinci, lihat bagian **Evaluasi**.
# Mengevaluasi model terlatih SageMaker AI Anda
Tujuan dari proses evaluasi adalah untuk menilai kinerja model terlatih terhadap tolok ukur atau kumpulan data khusus. Proses evaluasi biasanya melibatkan langkah-langkah untuk membuat resep evaluasi yang menunjuk ke model terlatih, menentukan kumpulan data dan metrik evaluasi, menyerahkan pekerjaan terpisah untuk evaluasi, dan mengevaluasi terhadap tolok ukur standar atau data khusus. Proses evaluasi akan menampilkan metrik kinerja yang disimpan di bucket Amazon S3 Anda.
**catatan**
Proses evaluasi yang dijelaskan dalam topik ini adalah proses offline. Model ini diuji terhadap tolok ukur tetap dengan jawaban yang telah ditentukan, daripada dinilai secara real-time atau melalui interaksi pengguna langsung. [Untuk evaluasi waktu nyata, Anda dapat menguji model setelah diterapkan ke Amazon Bedrock dengan memanggil Amazon Bedrock Runtime.](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html) APIs
**Topics**
+ [Prasyarat](#nova-model-evaluation-prerequisites)
+ [Tugas benchmark yang tersedia](#nova-model-evaluation-benchmark)
+ [Evaluasi konfigurasi spesifik](#nova-model-evaluation-config)
+ [Menjalankan pekerjaan pelatihan evaluasi](#nova-model-evaluation-notebook)
+ [Menilai dan menganalisis hasil evaluasi](#nova-model-evaluation-assess)
+ [Evaluasi praktik terbaik dan pemecahan masalah](#nova-model-evaluation-best-practices)
+ [Subtugas yang tersedia](#nova-model-evaluation-subtasks)
+ [Evaluasi model penalaran](nova-reasoning-model-evaluation.md)
+ [Evaluasi RFT](nova-rft-evaluation.md)
+ [Menerapkan fungsi hadiah](nova-implementing-reward-functions.md)
## Prasyarat
Sebelum Anda memulai pekerjaan pelatihan evaluasi, perhatikan hal berikut.
+ Model Amazon Nova SageMaker terlatih AI yang ingin Anda evaluasi kinerjanya.
+ Resep dasar Amazon Nova untuk evaluasi. Untuk informasi selengkapnya, lihat [Mendapatkan resep Amazon Nova](nova-model-recipes.md#nova-model-get-recipes).
## Tugas benchmark yang tersedia
Paket kode sampel tersedia yang menunjukkan cara menghitung metrik tolok ukur menggunakan fitur evaluasi model SageMaker AI untuk Amazon Nova. Untuk mengakses paket kode, lihat [Sampel-N ova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/).
Berikut adalah daftar tolok ukur standar industri yang tersedia yang didukung. Anda dapat menentukan tolok ukur berikut dalam `eval_task` parameter.
**Tolok ukur yang tersedia untuk evaluasi model**
| Tolok Ukur | Modalitas | Deskripsi | Metrik-metrik | Strategi | Subtugas tersedia |
| --- | --- | --- | --- | --- | --- |
| mmlu | Teks | Pemahaman Bahasa Multi-tugas - Menguji pengetahuan di 57 mata pelajaran. | ketepatan | zs\$1cot | Ya |
| mmlu\$1pro | Teks | MMLU - Subset Profesional - Berfokus pada domain profesional seperti hukum, kedokteran, akuntansi, dan teknik. | ketepatan | zs\$1cot | Tidak |
| bbh | Teks | Tugas Penalaran Lanjutan - Kumpulan masalah menantang yang menguji keterampilan kognitif dan pemecahan masalah tingkat tinggi. | ketepatan | fs\$1cot | Ya |
| gpqa | Teks | Penjawab Pertanyaan Fisika Umum — Menilai pemahaman konsep fisika dan kemampuan pemecahan masalah terkait. | ketepatan | zs\$1cot | Tidak |
| matematika | Teks | Pemecahan Masalah Matematika — Mengukur penalaran matematis di seluruh topik termasuk aljabar, kalkulus, dan masalah kata. | exact\$1match | zs\$1cot | Ya |
| strong\$1tolak | Teks | Quality-Control Task — Menguji kemampuan model untuk mendeteksi dan menolak konten yang tidak pantas, berbahaya, atau salah. | defleksi | zs | Ya |
| ifeval | Teks | Instruksi-Mengikuti Evaluasi - Mengukur seberapa akurat model mengikuti instruksi yang diberikan dan menyelesaikan tugas untuk spesifikasi. | ketepatan | zs | Tidak |
| gen\$1qa | Multi-Modal (gambar) | Evaluasi Dataset Kustom - Memungkinkan Anda menyediakan kumpulan data Anda sendiri untuk benchmarking, membandingkan output model dengan jawaban referensi dengan metrik seperti ROUGE dan BLEU. `gen_qa`mendukung inferensi gambar untuk model berbasis Amazon Nova Lite atau Amazon Nova Pro. Juga mendukung Bring-Your-Own Metrik lambda. (Untuk evaluasi RFT, silakan gunakan resep eval RFT) | all | gen\$1qa | Tidak |
| mmmu | Multi-Modal | Pemahaman Multimodal Multidisiplin Besar (MMMU) - Tolok ukur tingkat perguruan tinggi yang terdiri dari pertanyaan pilihan ganda dan terbuka dari 30 disiplin ilmu.) | ketepatan | zs\$1cot | Ya |
| llm\$1hakim | Teks | LLM-as-a-Judge Perbandingan Preferensi — Menggunakan model Nova Judge untuk menentukan preferensi antara respons berpasangan (B dibandingkan dengan A) untuk petunjuk Anda, menghitung probabilitas B lebih disukai daripada A. | all | hakim | Tidak |
| mm\$1llm\$1hakim | Multi-Modal (gambar) | Tolok ukur baru ini berperilaku sama dengan berbasis teks `llm_judge` di atas. Satu-satunya perbedaan adalah mendukung inferensi gambar. | all | hakim | Tidak |
| rubric\$1llm\$1judge | Teks | Rubric Judge adalah model LLM-as-a-judge evaluasi yang disempurnakan yang dibangun di atas Nova 2.0 Lite. Berbeda dengan [model hakim asli](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/) yang hanya memberikan putusan preferensi, Rubric Judge secara dinamis menghasilkan kriteria evaluasi khusus yang disesuaikan dengan setiap prompt dan memberikan skor granular di berbagai dimensi. | all | hakim | Tidak |
| aime\$12024 | Teks | AIME 2024 - Ujian Matematika Undangan Amerika menguji penalaran matematika tingkat lanjut dan pemecahan masalah | exact\$1match | zs\$1cot | Tidak |
| calendar\$1scheduling | Teks | Rencana Alami - Kalender Penjadwalan tugas menguji kemampuan perencanaan untuk menjadwalkan rapat di beberapa hari dan orang | exact\$1match | fs | Tidak |
| kemanusiaan | Teks | HumanEval - Dataset benchmark yang dirancang untuk mengevaluasi kemampuan pembuatan kode model bahasa besar | lulus @1 | zs | Tidak |
## Evaluasi konfigurasi spesifik
Di bawah ini adalah rincian komponen kunci dalam resep dan panduan tentang cara memodifikasinya untuk kasus penggunaan Anda.
### Memahami dan memodifikasi resep Anda
**Konfigurasi run umum**
```
run:
name: eval_job_name
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
replicas: 1
data_s3_path: ""
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`: Nama deskriptif untuk pekerjaan evaluasi Anda.
+ `model_type`: Menentukan varian model Nova untuk digunakan. Jangan memodifikasi bidang ini secara manual. Opsinya meliputi:
+ Amazon. nova-micro-v1:0:128 k
+ Amazon. nova-lite-v1:0:300 k
+ Amazon. nova-pro-v1:0:300 k
+ amazon.nova-2-lite-v 1:0:256 k
+ `model_name_or_path`: Jalur ke model dasar atau jalur s3 untuk pos pemeriksaan pasca terlatih. Opsinya meliputi:
+ nova-mikro/prod
+ nova-lite/prod
+ nova-pro/prod
+ nova-lite-2/prod
+ Jalur S3 untuk jalur pos pemeriksaan pasca terlatih () `s3:customer-escrow-111122223333-smtj-/`
**catatan**
**Evaluasi model pasca-terlatih**
Untuk mengevaluasi model pasca-pelatihan setelah pekerjaan pelatihan Nova SFT, ikuti langkah-langkah ini setelah menjalankan pekerjaan pelatihan yang sukses. Di akhir log pelatihan, Anda akan melihat pesan log “Pelatihan selesai”. Anda juga akan menemukan `manifest.json` file di bucket keluaran Anda yang berisi lokasi pos pemeriksaan Anda. File ini akan berada di dalam `output.tar.gz` file di lokasi output S3 Anda. Untuk melanjutkan evaluasi, gunakan pos pemeriksaan ini dengan menyetelnya sebagai nilai untuk `run.model_name_or_path` konfigurasi resep Anda.
+ `replica`: Jumlah instance komputasi yang akan digunakan untuk inferensi terdistribusi (menjalankan inferensi di beberapa node). Setel `replica` > 1 untuk mengaktifkan inferensi multi-node, yang mempercepat evaluasi. Jika keduanya `instance_count` dan `replica` ditentukan, `instance_count` diutamakan. Perhatikan bahwa beberapa replika hanya berlaku untuk pekerjaan pelatihan SageMaker AI, bukan.
+ `data_s3_path`: Jalur dataset masukan Amazon S3. Bidang ini diperlukan tetapi harus selalu dibiarkan kosong.
+ `mlflow_tracking_uri`: (Opsional) Lokasi server MLflow pelacak (hanya diperlukan di SMHP)
+ `mlflow_experiment_name`: (Opsional) Nama percobaan untuk mengelompokkan ML terkait berjalan bersama
+ `mlflow_run_name`: (Opsional) Nama khusus untuk pelatihan tertentu yang dijalankan dalam eksperimen
**Konfigurasi evaluasi**
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: abstract_algebra
metric: accuracy
```
+ `task`: Menentukan benchmark evaluasi atau tugas untuk digunakan. Tugas yang didukung meliputi:
+ `mmlu`
+ `mmlu_pro`
+ `bbh`
+ `gpqa`
+ `math`
+ `strong_reject`
+ `gen_qa`
+ `ifeval`
+ `mmmu`
+ `llm_judge`
+ `mm_llm_judge`
+ `rubric_llm_judge`
+ `aime_2024`
+ `calendar_scheduling`
+ `humaneval`
+ `strategy`: Mendefinisikan pendekatan evaluasi.
+ `zs_cot`: Zero-shot Chain of Thought - pendekatan untuk mendorong model bahasa besar yang mendorong step-by-step penalaran tanpa memerlukan contoh eksplisit.
+ `fs_cot`: Few-shot Chain of Thought - pendekatan yang memberikan beberapa contoh step-by-step penalaran sebelum meminta model untuk memecahkan masalah baru.
+ `zs`: Zero-shot - pendekatan untuk memecahkan masalah tanpa contoh pelatihan sebelumnya.
+ `gen_qa`: Strategi khusus untuk membawa dataset Anda sendiri.
+ `judge`: Strategi khusus untuk Nova LLM sebagai Hakim dan`mm_llm_judge`.
+ `subtask`: Opsional. Komponen spesifik dari tugas evaluasi. Untuk daftar lengkap subtugas yang tersedia, lihat[Subtugas yang tersedia](#nova-model-evaluation-subtasks).
+ Periksa subtugas yang didukung dalam tugas benchmark yang tersedia.
+ Harus menghapus bidang ini jika tidak ada tolok ukur subtugas.
+ `metric`: Metrik evaluasi yang akan digunakan.
+ `accuracy`: Persentase jawaban yang benar.
+ `exact_match`: Untuk tolok ukur matematika, mengembalikan tingkat di mana string yang diprediksi input sama persis dengan referensi mereka.
+ `deflection`: Untuk tolok ukur penolakan yang kuat, kembalikan defleksi relatif ke model dasar dan metrik signifikansi perbedaan.
+ `all`:
Untuk`gen_qa`, bawa benchmark dataset Anda sendiri, kembalikan metrik berikut:
+ `rouge1`: Mengukur tumpang tindih unigram (kata tunggal) antara teks yang dihasilkan dan referensi.
+ `rouge2`: Mengukur tumpang tindih bigram (dua kata berturut-turut) antara teks yang dihasilkan dan referensi.
+ `rougeL`: Mengukur urutan umum terpanjang antara teks, memungkinkan celah dalam pencocokan.
+ `exact_match`: Skor biner (0 atau 1) menunjukkan apakah teks yang dihasilkan cocok dengan teks referensi persis, karakter demi karakter.
+ `quasi_exact_match`: Mirip dengan kecocokan persis tetapi lebih lunak, biasanya mengabaikan kasus, tanda baca, dan perbedaan ruang putih.
+ `f1_score`: Rata-rata harmonik presisi dan ingatan, mengukur tumpang tindih kata antara jawaban yang diprediksi dan referensi.
+ `f1_score_quasi`: Mirip dengan f1\$1score tetapi dengan pencocokan yang lebih lunak, menggunakan perbandingan teks yang dinormalisasi yang mengabaikan perbedaan kecil.
+ `bleu`: Mengukur presisi kecocokan n-gram antara teks yang dihasilkan dan referensi, yang biasa digunakan dalam evaluasi terjemahan.
Untuk `llm_judge` dan`mm_llm_judge`, bawa benchmark dataset Anda sendiri, kembalikan metrik berikut:
+ `a_scores`: Jumlah kemenangan untuk `response_A` lintasan evaluasi maju dan mundur.
+ `a_scores_stderr`: Kesalahan standar `response_A_scores` lintas penilaian berpasangan.
+ `b_scores`: Mengukur Jumlah kemenangan untuk `response_B` lintasan evaluasi maju dan mundur.
+ `a_scores_stderr`: Kesalahan standar `response_B_scores` lintas penilaian berpasangan.
+ `ties`: Jumlah penilaian di mana `response_A` dan `response_B` dievaluasi sebagai sama.
+ `ties_stderr`: Kesalahan standar `ties` lintas penilaian berpasangan.
+ `inference_error`: Hitungan penilaian yang tidak dapat dievaluasi dengan benar.
+ `score`: Skor agregat berdasarkan kemenangan dari umpan maju dan mundur untuk. `response_B`
+ `score_stderr`: Skor agregat berdasarkan kemenangan dari umpan maju dan mundur untuk. `response_B`
+ `inference_error_stderr`: Kesalahan standar skor agregat di seluruh penilaian berpasangan.
+ `winrate`Probabilitas yang `response_B` akan lebih disukai daripada `response_A` dihitung menggunakan probabilitas Bradley-Terry.
+ `lower_rate`: Batas bawah (persentil 2.5) dari perkiraan tingkat kemenangan dari pengambilan sampel bootstrap.
+ `upper_rate`: Batas atas (persentil 97,5) dari perkiraan tingkat kemenangan dari pengambilan sampel bootstrap.
**Konfigurasi inferensi (opsional)**
```
inference:
max_new_tokens: 2048
top_k: -1
top_p: 1.0
temperature: 0
top_logprobs: 10
reasoning_effort: null # options: low/high to enable reasoning or null to disable reasoning
```
+ `max_new_tokens`: Jumlah maksimum token yang akan dihasilkan. Harus berupa bilangan bulat. (Tidak tersedia untuk Hakim LLM)
+ `top_k`: Jumlah token probabilitas tertinggi untuk dipertimbangkan. Harus berupa bilangan bulat.
+ `top_p`: Ambang probabilitas kumulatif untuk pengambilan sampel token. Harus berupa float antara 1,0 hingga 0,0.
+ `temperature`: Keacakan dalam pemilihan token (lebih tinggi = lebih acak), pertahankan 0 untuk membuat hasilnya deterministik. Tipe float, nilai minimal adalah 0.
+ `top_logprobs`: Jumlah logprob teratas yang akan dikembalikan dalam respons inferensi. Nilai ini harus berupa bilangan bulat dari 0 hingga 20. Logprobs berisi token keluaran yang dipertimbangkan dan probabilitas log dari setiap token keluaran yang dikembalikan dalam konten pesan.
+ `reasoning_effort`: mengontrol perilaku penalaran untuk model yang mampu beralasan. Set `reasoning_effort` hanya ketika `model_type` menentukan model berkemampuan penalaran (saat ini). `amazon.nova-2-lite-v1:0:256k` Opsi yang tersedia adalah null (nilai default jika tidak disetel; menonaktifkan penalaran), rendah, atau tinggi.
### Format Keluaran Probabilitas Log
Ketika `top_logprobs` dikonfigurasi dalam pengaturan inferensi Anda, output evaluasi mencakup probabilitas log tingkat token dalam file parket. Setiap posisi token berisi kamus token kandidat teratas dengan probabilitas log mereka dalam struktur berikut:
```
{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}
```
Setiap entri token berisi:
+ `logprob_value`: Nilai probabilitas log untuk token
+ `decoded_value`: Representasi string decoded yang dapat dibaca manusia dari token
Token tokenizer mentah digunakan sebagai kunci kamus untuk memastikan keunikan, sekaligus `decoded_value` memberikan interpretasi yang dapat dibaca.
### Contoh resep evaluasi
Amazon Nova menyediakan empat jenis resep evaluasi yang berbeda. Semua resep tersedia di [ GitHub repositori SageMaker HyperPod resep](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection).
**Topics**
#### Resep tolok ukur teks umum
Resep-resep ini memungkinkan Anda untuk mengevaluasi kemampuan dasar model Amazon Nova di seluruh rangkaian tolok ukur khusus teks yang komprehensif.
Format resep:`xxx_general_text_benchmark_eval.yaml`.
#### Bawa resep benchmark dataset Anda sendiri
Resep-resep ini memungkinkan Anda untuk membawa dataset Anda sendiri untuk benchmarking dan membandingkan output model untuk referensi jawaban menggunakan berbagai jenis metrik.
Format resep:`xxx_ bring_your_own_dataset_eval.yaml`.
**Bawa persyaratan dataset Anda sendiri**
Format berkas:
+ `gen_qa.jsonl`File tunggal yang berisi contoh evaluasi. Nama file harus tepat`gen_qa.jsonl`.
+ Anda harus mengunggah kumpulan data Anda ke lokasi S3 tempat pekerjaan pelatihan SageMaker AI dapat diakses.
+ File harus mengikuti format skema yang diperlukan untuk kumpulan data Tanya Jawab umum.
Persyaratan format skema - Setiap baris dalam `.jsonl` file harus berupa objek JSON dengan bidang berikut.
+ Bidang yang diperlukan.
`query`: String yang berisi pertanyaan atau instruksi yang membutuhkan jawaban.
`response`: String yang berisi output model yang diharapkan.
+ Bidang opsional.
`system`String yang berisi prompt sistem yang mengatur perilaku, peran, atau kepribadian model AI sebelum memproses kueri.
`images`: Array berisi daftar objek dengan atribut data (string gambar yang dikodekan Base64).
`metadata`: String yang berisi metadata yang terkait dengan entri untuk tujuan penandaan.
**Entri contoh**
```
{
"system":"You are an English major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}{
"system":"You are a pattern analysis specialist who provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}{
"system":"You have great attention to detail and follow instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}{
"system": "Image inference: ",
"query": "What is the number in the image? Please just use one English word to answer.",
"response": "two",
"images": [
{
"data": "data:image/png;Base64,iVBORw0KGgoA ..."
}
]
}
```
Untuk menggunakan kumpulan data kustom Anda, ubah resep evaluasi Anda dengan menambahkan bidang wajib berikut tanpa mengubah konfigurasi yang ada:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
**Batasan**
+ Hanya satu `.jsonl` file yang diizinkan per evaluasi.
+ File harus benar-benar mengikuti skema yang ditentukan.
##### Bawa metrik Anda sendiri
Anda dapat membawa metrik Anda sendiri untuk sepenuhnya menyesuaikan alur kerja evaluasi model Anda dengan kemampuan pra-pemrosesan, pasca-pemrosesan, dan metrik khusus. Preprocessing memungkinkan Anda untuk memproses data input sebelum mengirimnya ke server inferensi, dan postprocessing memungkinkan Anda untuk menyesuaikan perhitungan metrik dan mengembalikan metrik kustom berdasarkan kebutuhan Anda.
Ikuti langkah-langkah ini untuk membawa metrik Anda sendiri dengan SDK evaluasi khusus.
1. Jika Anda belum melakukannya, [buat AWS Lambda fungsi](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) di tempat Akun AWS pertama Anda.
1. Unduh `nova-custom-eval-layer.zip` file pra-bangun dari [GitHub repositori](https://github.com/aws/nova-custom-eval-sdk/releases). Anda dapat menggunakan SDK evaluasi kustom Nova open-source ini untuk memvalidasi muatan input dan output untuk fungsi kustom Anda dan menyediakan antarmuka terpadu untuk diintegrasikan dengan Nova membawa evaluasi metrik Anda sendiri selama pelatihan.
1. Unggah layer Lambda kustom menggunakan perintah berikut:
```
aws lambda publish-layer-version \
--layer-name nova-custom-eval-layer \
--zip-file fileb://nova-custom-eval-layer.zip \
--compatible-runtimes python3.12 python3.11 python3.10 python3.9
```
1. Tambahkan layer ini sebagai layer kustom ke fungsi Lambda Anda, bersama dengan AWS layer yang diperlukan: `AWSLambdaPowertoolsPythonV3-python312-arm64` (diperlukan untuk `pydantic` ketergantungan).
1. Perbarui kode Lambda Anda menggunakan contoh yang disediakan, modifikasi kode sesuai kebutuhan. Kode contoh ini membuat fungsi Lambda untuk evaluasi kustom Nova dengan langkah-langkah preprocessing dan postprocessing untuk evaluasi model.
```
from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler
@preprocess
def preprocessor(event: dict, context) -> dict:
data = event.get('data', {})
return {
"statusCode": 200,
"body": {
"system": data.get("system"),
"prompt": data.get("prompt", ""),
"gold": data.get("gold", "")
}
}
@postprocess
def postprocessor(event: dict, context) -> dict:
# data is already validated and extracted from event
data = event.get('data', [])
inference_output = data.get('inference_output', '')
gold = data.get('gold', '')
metrics = []
inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
metrics.append({
"metric": "inverted_accuracy_custom",
"value": accuracy
})
# Add more metrics here
return {
"statusCode": 200,
"body": metrics
}
# Build Lambda handler
lambda_handler = build_lambda_handler(
preprocessor=preprocessor,
postprocessor=postprocessor
)
```
1. Berikan Lambda akses ke pekerjaan evaluasi. Pastikan peran eksekusi yang ditentukan untuk pekerjaan evaluasi mencakup kebijakan pemanggilan fungsi Lambda Anda. Berikut adalah contoh kebijakan.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LambdaAccess",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
}
}
},
{
"Sid": "DenyNonAWSEventSourcesForLambda",
"Effect": "Deny",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"Null": {
"lambda:EventSourceToken": false
}
}
}
]
}
```
------
1. Tinjau skema payload Lambda. Tabel berikut mencantumkan permintaan Lambda dan skema respons. Anda dapat memvalidasi skema Anda menggunakan SDK evaluasi kustom Nova.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/nova/latest/nova2-userguide/nova-model-evaluation.html)
1. Ubah file resep. Inilah contohnya.
```
processor:
lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
lambda_type: "custom_metrics"
preprocessing:
enabled: true
postprocessing:
enabled: true
aggregation: average
```
+ `lambda-arn`: Nama Sumber Daya Amazon (ARN) untuk fungsi Lambda Anda yang menangani preprocessing dan postprocessing.
+ `lambda_type`: “custom\$1metrics” atau “rft”.
+ `preprocessing`: Apakah akan mengaktifkan operasi pra-pemrosesan khusus.
+ `postprocessing`: Apakah akan mengaktifkan operasi pasca-pemrosesan khusus.
+ `aggregation`: Fungsi agregasi bawaan (opsi yang valid: min, maks, rata-rata, jumlah).
**Batasan**
+ Bawa metrik Anda sendiri hanya berlaku untuk kumpulan data input teks.
+ Kumpulan data masukan multi-modal tidak didukung.
+ Langkah preprocessing tidak memproses bidang metadata.
#### Nova LLM sebagai resep tolok ukur Hakim
Nova LLM Judge adalah fitur evaluasi model yang memungkinkan Anda membandingkan kualitas respons dari satu model dengan respons model dasar menggunakan kumpulan data khusus. [Ini menerima kumpulan data yang berisi petunjuk, respons dasar, dan respons penantang, kemudian menggunakan model Nova Judge untuk memberikan metrik tingkat kemenangan berdasarkan probabilitas Bradley-Terry melalui perbandingan berpasangan.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) Format resep:`xxx_llm_judge_eval.yaml`.
**Persyaratan set data Nova LLM**
Format berkas:
+ `llm_judge.jsonl`File tunggal yang berisi contoh evaluasi. Nama file harus tepat`llm_judge.jsonl`.
+ Anda harus mengunggah kumpulan data Anda ke lokasi S3 tempat pekerjaan pelatihan SageMaker AI dapat diakses.
+ File harus mengikuti format skema yang diperlukan untuk `llm_judge` kumpulan data.
+ Dataset input harus memastikan semua catatan berada di bawah panjang konteks 12 k.
Format skema - Setiap baris dalam `.jsonl` file harus objek JSON dengan bidang berikut.
+ Bidang yang diperlukan.
`prompt`: String yang berisi prompt untuk respons yang dihasilkan.
`response_A`: String yang berisi respons dasar.
`response_B`: String yang berisi respons alternatif dibandingkan dengan respons dasar.
Entri contoh
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
Untuk menggunakan kumpulan data kustom Anda, ubah resep evaluasi Anda dengan bidang wajib berikut, jangan ubah konten apa pun:
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
**Batasan**
+ Hanya satu `.jsonl` file yang diizinkan per evaluasi.
+ File harus benar-benar mengikuti skema yang ditentukan.
+ Model Nova Judge sama di seluruh spesifikasi mikro/lite/pro.
+ Model juri khusus saat ini tidak didukung.
##### Nova LLM sebagai Hakim untuk resep benchmark multi-modal (gambar)
Nova LLM Judge for multi-modal (image), kependekan dari Nova MM\$1LLM Judge, adalah fitur evaluasi model yang memungkinkan Anda membandingkan kualitas respons dari satu model dengan respons model dasar menggunakan kumpulan data khusus. [Ini menerima kumpulan data yang berisi petunjuk, respons dasar, dan respons penantang, dan gambar dalam bentuk string yang dikodekan Base64, kemudian menggunakan model Nova Judge untuk memberikan metrik tingkat kemenangan berdasarkan probabilitas Bradley-Terry melalui perbandingan berpasangan.](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) Format resep:`xxx_mm_llm_judge_eval.yaml`.
**Persyaratan set data Nova LLM**
Format berkas:
+ `mm_llm_judge.jsonl`File tunggal yang berisi contoh evaluasi. Nama file harus persis`llm_judge.jsonl`.
+ Anda harus mengunggah kumpulan data Anda ke lokasi S3 tempat pekerjaan pelatihan SageMaker AI dapat mengaksesnya.
+ File harus mengikuti format skema yang diperlukan untuk `mm_llm_judge` kumpulan data.
+ Dataset input harus memastikan semua catatan berada di bawah panjang konteks 12 k, tidak termasuk atribut gambar.
Format skema - Setiap baris dalam `.jsonl` file harus objek JSON dengan bidang berikut.
+ Bidang yang diperlukan.
`prompt`: String yang berisi prompt untuk respons yang dihasilkan.
`images`: Array yang berisi daftar objek dengan atribut data (nilainya adalah string gambar yang dikodekan Base64).
`response_A`: String yang berisi respons dasar.
`response_B`: String yang berisi respons alternatif dibandingkan dengan respons dasar.
Entri contoh
Untuk keterbacaan, contoh berikut mencakup baris dan lekukan baru, tetapi dalam kumpulan data yang sebenarnya, setiap catatan harus berada pada satu baris.
```
{
"prompt": "What is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "How many animals are in each of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal"
}
```
Untuk menggunakan kumpulan data kustom Anda, ubah resep evaluasi Anda dengan bidang wajib berikut, jangan ubah konten apa pun:
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Batasan**
+ Hanya satu `.jsonl` file yang diizinkan per evaluasi.
+ File harus benar-benar mengikuti skema yang ditentukan.
+ Model Nova MM Judge hanya mendukung referensi gambar.
+ Model Nova MM Judge sama di seluruh spesifikasi Amazon Nova Micro, Amazon Nova Lite, dan Amazon Nova Pro.
+ Model juri khusus saat ini tidak didukung.
+ URI gambar Amazon S3 tidak didukung.
+ Dataset input harus memastikan semua catatan berada di bawah panjang konteks 12 k, tidak termasuk atribut gambar.
#### Mengevaluasi Pos Pemeriksaan CPT (Pra-Pelatihan Berkelanjutan)
Evaluasi model CPT (terus menerus pra-terlatih) dapat menjadi tantangan daripada model yang telah mengalami SFT (penyetelan halus yang diawasi) karena model CPT secara teratur tidak memiliki kemampuan untuk mengikuti instruksi. Alih-alih mengikuti instruksi, model CPT akan beroperasi sebagai model penyelesaian, yang berarti mereka hanya akan mencoba untuk melanjutkan pola yang disediakan dengan urutan token input. Mengingat keterbatasan ini, kumpulan data evaluasi tipikal mungkin tidak berfungsi dengan benar karena format input “Tanya Jawab” — alih-alih menjawab pertanyaan, model hanya akan mencoba melanjutkan pertanyaan yang sama. Namun, dengan memformat kumpulan data dengan cara tertentu untuk meminta model dalam gaya penyelesaian, kita bisa mendapatkan pemahaman tentang bagaimana kinerja model.
Ikuti langkah-langkah di bawah ini untuk memahami cara melakukan evaluasi pada model pra-pelatihan berkelanjutan menggunakan alur kerja evaluasi Nova Forge.
##### Persiapan dan Pemformatan Dataset
Mengevaluasi model CPT memanfaatkan alur kerja [Bring Your Own Dataset](#nova-model-evaluation-config-byo) yang sudah ada yang sudah disediakan dalam pengalaman evaluasi model Nova Forge. Namun, kueri dalam kumpulan data harus diformat dalam format “penyelesaian” murni karena model CPT tidak akan menanggapi permintaan gaya pertanyaan standar dengan cara yang sama seperti model SFT.
Keterbatasan penting lainnya dari model yang telah mengalami CPT semata-mata adalah ketidakmampuan mereka untuk menghasilkan STOP atau akhir token urutan — ini berarti bahwa model akan terus menghasilkan token sampai dihentikan secara paksa (seperti dengan parameter max\$1new\$1tokens). Mengingat keterbatasan ini, praktik terbaik adalah mengevaluasi model menggunakan respons token tunggal (seperti pilihan ganda) untuk memastikan model tidak terus menghasilkan keluaran sampah yang tidak diperlukan setelah diminta.
Misalnya, kumpulan data evaluasi tipikal (seperti MMLU, GPQA, MATH, dll), mungkin meminta model dengan pertanyaan seperti:
```
Early settlements and high population density along coastlines and rivers are
best attributed to which of the following?
A: "Poor climate conditions"
B: "Limited forest cover"
C: "Cars"
D: "Access to trade routes"
(Expected answer is D.)
```
Namun, model CPT tidak akan mengerti bagaimana menanggapi pertanyaan ini dengan benar karena kurangnya fine tuning pada instruksi berikut. Oleh karena itu, model CPT harus diminta dalam gaya penyelesaian, seperti:
```
Early settlements and high population density along coastlines and rivers
are best attributed to which of the following?
A: Poor climate conditions
B: Limited forest cover
C: Cars
D: Access to trade routes
The correct answer to this question is option
(Expected answer is D.)
```
Setelah pemeriksaan inferensi, logprobs keluaran yang dihasilkan oleh model akan memberikan rincian apakah model memproses input dengan benar dan menghasilkan respons yang benar. Tidak dijamin bahwa model akan selalu menghasilkan respons yang tepat (dalam hal ini, huruf D) yang diharapkan, namun, itu harus ada dalam logprobs jika model berfungsi dengan benar.
Contoh prompt gaya penyelesaian non-pilihan ganda lainnya:
```
The capital of France is
(Expected answer of Paris)
```
Kami mengharapkan model untuk menghasilkan respons “Paris” atau melihat token yang sesuai dengan “Paris” di suatu tempat dalam output logprobs.
##### Pemformatan Dataset
Evaluasi CPT memanfaatkan alur kerja [Bring Your Own Dataset](#nova-model-evaluation-config-byo) yang ada. Data harus diformat dalam format “respons kueri” dalam file JSONL yang dipisahkan oleh baris baru.
Contoh dataset dengan 4 entri di dalamnya:
```
{"query": "The capital of France is", "response": "Paris"}
{"query": "2 + 2 =", "response": "4"}
{"query": "The mitochondria is the powerhouse of the", "response": "cell"}
{"query": "What is the largest planet?\nA: Mars\nB: Jupiter\nC: Saturn\nD: Earth\nAnswer:", "response": "B"}
```
Setiap baris harus berisi:
+ `query`: Teks prompt untuk penyelesaian
+ `response`: Penyelesaian yang diharapkan (kebenaran dasar)
Model akan menerima input teks mentah tanpa pemformatan obrolan. Model CPT biasanya belum dilatih pada token khusus dan tidak akan merespons templat obrolan dengan benar, jadi saat meminta model HANYA string yang disediakan dalam kueri akan dikirim ke model (dengan `[BOS]` token tambahan ditambahkan secara otomatis.)
##### Konfigurasi Resep
Berikut adalah contoh resep yang dikonfigurasi untuk mengevaluasi model CPT:
```
run:
name: cpt_eval_job
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: s3://bucket/path/to/cpt-checkpoint/
evaluation:
task: gen_qa # Required for CPT - bring your own dataset
strategy: gen_qa
metric: all # Returns rouge1, rouge2, rougeL, exact_match, f1_score, bleu
inference:
checkpoint_is_instruction_tuned: "false" # Required for CPT checkpoints
top_logprobs: 5 # Change to desired amount of logprobs to calculate
max_new_tokens: 1 # Keep low for completion tasks
temperature: 0.0
```
Perubahan utama untuk evaluasi CPT:
+ `checkpoint_is_instruction_tuned: "false"`
Ini adalah parameter baru yang ditambahkan secara khusus untuk mendukung evaluasi berjalan di pos pemeriksaan CPT. Menyetel checkpoint\$1is\$1instruction\$1tuned ke false akan **menonaktifkan** template obrolan Amazon Nova default yang biasanya membungkus prompt input.
+ `top_logprobs: 5`
Probabilitas log (logprobs) mengungkapkan distribusi kepercayaan model di seluruh kemungkinan token berikutnya, membantu Anda menilai apakah model telah mempelajari penyelesaian yang diharapkan selama pra-pelatihan. Biasanya, jika model berkinerja sebagaimana dimaksud, kita akan melihat respons yang diharapkan (yaitu, “A”, “B”, dll) sebagai token keluaran yang dihasilkan atau token di logprobs.
+ `max_new_tokens: 1`
Model CPT biasanya belum dilatih untuk menghasilkan token “stop” atau “end of sequence” khusus yang belum memberi sinyal kapan harus menghentikan inferensi. Ini berarti model biasanya akan terus menghasilkan token baru sampai panjang token maks tertentu tercapai sehingga menghasilkan inferensi yang tidak perlu. Biasanya membatasi max\$1new\$1tokens ke 1 dan memberikan prompt yang dapat mengevaluasi model pada satu respons (seperti pertanyaan pilihan ganda) adalah cara paling efisien untuk meminta model. Menyetel max\$1new\$1tokens ke 1 memastikan bahwa token sampah tambahan tidak dihasilkan.
##### Parameter Kunci
+ **checkpoint\$1is\$1instruction\$1tuned: Harus disetel** ke (atau sebagai boolean) untuk menonaktifkan templat obrolan `"false"` `false`
+ **top\$1logprobs**: 5, direkomendasikan untuk melihat bagaimana model belajar selama CPT
+ **tugas**: Harus `gen_qa` - Model CPT tidak dapat menggunakan tolok ukur mengikuti instruksi seperti MMLU atau MATH
+ **Strategi**: Harus `gen_qa`
+ **max\$1new\$1tokens**: Direkomendasikan untuk tetap rendah (1-5) karena model CPT melakukan penyelesaian, bukan pembuatan
## Menjalankan pekerjaan pelatihan evaluasi
Mulai pekerjaan pelatihan menggunakan contoh notebook berikut. Silakan lihat buku catatan di bawah ini sebagai contoh untuk menjalankan pekerjaan pelatihan evaluasi. Untuk informasi selengkapnya, lihat [Menggunakan estimator SageMaker AI untuk menjalankan pekerjaan pelatihan](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html).
### Tabel referensi
Sebelum menjalankan buku catatan, lihat tabel referensi berikut untuk memilih URI gambar dan konfigurasi instance.
**Memilih URI gambar**
| Resep | URI citra |
| --- | --- |
| URI gambar evaluasi | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest |
**Memilih jenis dan hitungan instans**
| Model | Jenis Tugas | Tipe instans | Jumlah instans yang disarankan | Jumlah instans yang diizinkan |
| --- | --- | --- | --- | --- |
| Amazon Nova Mikro | Evaluasi (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Lite | Evaluasi (SFT/DPO) | g5.12xlarge | 1 | 1 - 16 |
| Amazon Nova Pro | Evaluasi (SFT/DPO) | p5.48xlarge | 1 | 1 - 16 |
### Notebook sampel
Contoh notebook berikut menunjukkan bagaimana menjalankan pekerjaan pelatihan evaluasi.
```
# install python SDK
# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes
!pip install sagemaker==2.254.1
import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`
# Populate parameters
# input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type" # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "" # optional, leave blank for Amazon managed encryption
# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)
estimator = PyTorch(
output_path=output_s3_uri,
base_job_name=job_name,
role=role,
instance_type=instance_type,
instance_count=instance_count,
training_recipe=recipe_path,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key
)
estimator.fit()
# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})
```
## Menilai dan menganalisis hasil evaluasi
Setelah pekerjaan evaluasi Anda selesai dengan sukses, Anda dapat menilai dan menganalisis hasilnya menggunakan langkah-langkah berikut.
**Untuk menilai dan menganalisis hasil, ikuti langkah-langkah ini.**
1. Memahami struktur lokasi output. Hasil disimpan di lokasi keluaran Amazon S3 yang Anda tentukan sebagai file terkompresi:
```
s3://your-bucket/output/benchmark-name/
└── job_name/
└── output/
└── output.tar.gz
```
1. Unduh `output.tar.gz` file dari ember Anda. Ekstrak konten untuk mengungkapkan.
```
run_name/
├── eval_results/
| └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
| └── details/
| └── model/
| └── /
| └──details__#_.parquet
└── tensorboard_results/
└── eval/
└── events.out.tfevents.[timestamp]
```
+ `results_[timestamp].json`- Keluaran metrik file JSON
+ `details__#_.parquet`- File keluaran inferensi (kecuali untuk`strong_reject`)
+ `events.out.tfevents.[timestamp]`- Berkas TensorBoard keluaran
+ `inference_output.jsonl`- File output inferensi dibersihkan (hanya untuk `gen_qa` tugas)
1. Lihat hasil di TensorBoard. Untuk memvisualisasikan metrik evaluasi Anda:
1. Unggah folder yang diekstrak ke bucket S3
1. Arahkan ke SageMaker AI TensorBoard
1. Pilih “folder S3" Anda
1. Tambahkan jalur folder S3
1. Tunggu sinkronisasi selesai
1. Menganalisis output inferensi. Semua tugas evaluasi, kecuali `llm_judge` dan`strong_reject`, akan memiliki bidang berikut untuk analisis dalam output inferensi.
+ `full_prompt`- Permintaan pengguna penuh dikirim ke model yang digunakan untuk tugas evaluasi.
+ `gold`- Bidang yang berisi jawaban yang benar seperti yang ditentukan oleh dataset.
+ `metrics`- Bidang yang berisi metrik yang dievaluasi pada inferensi individu. Nilai yang membutuhkan agregasi tidak akan memiliki nilai pada output inferensi individu.
+ `predictions`- Bidang yang berisi daftar output model untuk prompt yang diberikan.
+ `pred_logits`- Bidang yang berisi token keluaran yang dipertimbangkan dan probabilitas log dari setiap token keluaran yang dikembalikan dalam konten pesan.
Dengan melihat bidang ini, Anda dapat menentukan penyebab perbedaan metrik dan memahami perilaku model yang disesuaikan.
Untuk`llm_judge`, file keluaran inferensi berisi bidang berikut di bawah bidang metrik per pasangan evaluasi.
+ `forward_output`- Preferensi mentah hakim saat mengevaluasi secara berurutan (Response\$1a, response\$1b).
+ `backward_output`- Preferensi mentah hakim saat mengevaluasi dalam urutan terbalik (Response\$1b, response\$1a).
+ `Pairwise metrics`- Metrik yang dihitung per pasang evaluasi maju dan mundur termasuk`a_scores`,, `b_scores``ties`, `inference-score` dan. `score`
**catatan**
Metrik agregat seperti hanya `winrate` tersedia di file hasil ringkasan, bukan per penilaian individu.
Untuk`gen_qa`, `inference_output.jsonl` file berisi bidang berikut untuk setiap objek JSON:
+ prompt - Prompt akhir yang dikirimkan ke model
+ inferensi - Output inferensi mentah dari model
+ gold - Respon target dari dataset input
+ metadata - String metadata dari dataset input jika disediakan
## Evaluasi praktik terbaik dan pemecahan masalah
### Praktik terbaik
Berikut ini mencantumkan beberapa praktik terbaik untuk proses evaluasi.
+ Jaga jalur keluaran Anda diatur berdasarkan model dan tipe benchmark.
+ Pertahankan konvensi penamaan yang konsisten untuk memudahkan pelacakan.
+ Simpan hasil yang diekstraksi di lokasi yang aman.
+ Pantau status TensorBoard sinkronisasi untuk pemuatan data yang berhasil.
### Pemecahan masalah
Anda dapat menggunakan grup CloudWatch log `/aws/sagemaker/TrainingJobs` untuk melatih log kesalahan pekerjaan.
#### Kegagalan inti mesin
**Masalah:**
Jika Anda melihat:
```
RuntimeError: Engine core initialization failed.
```
**Penyebab:**
Meskipun ini adalah kesalahan umum yang dapat memiliki banyak penyebab, biasanya terjadi ketika ada ketidakcocokan antara pos pemeriksaan model yang Anda coba muat dan jenis model yang ditentukan. Misalnya Anda ingin mengevaluasi pos pemeriksaan model Nova 2.0 lite yang disetel dengan baik tetapi tipe model yang Anda berikan adalah tipe model 1.0. misalnya `amazon.nova-micro-v1:0:128k`
Pemetaan yang benar harus
```
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
```
**Pencegahan**:
Periksa kembali apakah `model_name_or_path` dipetakan ke kanan `model_type` sebelum mengirimkan pekerjaan evaluasi.
## Subtugas yang tersedia
Berikut daftar subtugas yang tersedia untuk evaluasi model di beberapa domain termasuk MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH, dan MMMU (Massive Multitask Multimodal Understanding). Subtugas ini memungkinkan Anda menilai kinerja model Anda pada kemampuan dan bidang pengetahuan tertentu.
**MMLU**
```
MMLU_SUBTASKS = [
"abstract_algebra",
"anatomy",
"astronomy",
"business_ethics",
"clinical_knowledge",
"college_biology",
"college_chemistry",
"college_computer_science",
"college_mathematics",
"college_medicine",
"college_physics",
"computer_security",
"conceptual_physics",
"econometrics",
"electrical_engineering",
"elementary_mathematics",
"formal_logic",
"global_facts",
"high_school_biology",
"high_school_chemistry",
"high_school_computer_science",
"high_school_european_history",
"high_school_geography",
"high_school_government_and_politics",
"high_school_macroeconomics",
"high_school_mathematics",
"high_school_microeconomics",
"high_school_physics",
"high_school_psychology",
"high_school_statistics",
"high_school_us_history",
"high_school_world_history",
"human_aging",
"human_sexuality",
"international_law",
"jurisprudence",
"logical_fallacies",
"machine_learning",
"management",
"marketing",
"medical_genetics",
"miscellaneous",
"moral_disputes",
"moral_scenarios",
"nutrition",
"philosophy",
"prehistory",
"professional_accounting",
"professional_law",
"professional_medicine",
"professional_psychology",
"public_relations",
"security_studies",
"sociology",
"us_foreign_policy",
"virology",
"world_religions"
]
```
**BBH**
```
BBH_SUBTASKS = [
"boolean_expressions",
"causal_judgement",
"date_understanding",
"disambiguation_qa",
"dyck_languages",
"formal_fallacies",
"geometric_shapes",
"hyperbaton",
"logical_deduction_five_objects",
"logical_deduction_seven_objects",
"logical_deduction_three_objects",
"movie_recommendation",
"multistep_arithmetic_two",
"navigate",
"object_counting",
"penguins_in_a_table",
"reasoning_about_colored_objects",
"ruin_names",
"salient_translation_error_detection",
"snarks",
"sports_understanding",
"temporal_sequences",
"tracking_shuffled_objects_five_objects",
"tracking_shuffled_objects_seven_objects",
"tracking_shuffled_objects_three_objects",
"web_of_lies",
"word_sorting"
]
```
**Matematika**
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
```
**MMMU**
```
MATH_SUBTASKS = [
"Accounting",
"Agriculture",
"Architecture_and_Engineering",
"Art",
"Art_Theory",
"Basic_Medical_Science",
"Biology",
"Chemistry",
"Clinical_Medicine",
"Computer_Science",
"Design",
"Diagnostics_and_Laboratory_Medicine",
"Economics",
"Electronics",
"Energy_and_Power",
"Finance",
"Geography",
"History",
"Literature",
"Manage",
"Marketing",
"Materials",
"Math",
"Mechanical_Engineering",
"Music",
"Pharmacy",
"Physics",
"Psychology",
"Public_Health",
"Sociology",
```
Evaluasi model Nova Anda yang disesuaikan menggunakan berbagai metode dan metrik evaluasi.
**Topics**
+ [Prasyarat](#nova-model-evaluation-prerequisites)
+ [Tugas benchmark yang tersedia](#nova-model-evaluation-benchmark)
+ [Evaluasi konfigurasi spesifik](#nova-model-evaluation-config)
+ [Menjalankan pekerjaan pelatihan evaluasi](#nova-model-evaluation-notebook)
+ [Menilai dan menganalisis hasil evaluasi](#nova-model-evaluation-assess)
+ [Evaluasi praktik terbaik dan pemecahan masalah](#nova-model-evaluation-best-practices)
+ [Subtugas yang tersedia](#nova-model-evaluation-subtasks)
+ [Evaluasi model penalaran](nova-reasoning-model-evaluation.md)
+ [Evaluasi RFT](nova-rft-evaluation.md)
+ [Menerapkan fungsi hadiah](nova-implementing-reward-functions.md)
# Evaluasi model penalaran
## Ikhtisar
Dukungan model penalaran memungkinkan evaluasi dengan model Nova berkemampuan penalaran yang melakukan penalaran internal eksplisit sebelum menghasilkan tanggapan akhir. Fitur ini menggunakan kontrol tingkat API melalui `reasoning_effort` parameter untuk mengaktifkan atau menonaktifkan fungsionalitas penalaran secara dinamis, berpotensi meningkatkan kualitas respons untuk tugas analitis yang kompleks.
**Model yang didukung**
+ amazon.nova-2-lite-v 1:0:256 k
## Konfigurasi resep
Aktifkan penalaran dengan menambahkan `reasoning_effort` parameter ke `inference` bagian resep Anda:
```
run:
name: reasoning-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: zs_cot # [MODIFIABLE] Evaluation strategy
metric: accuracy # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/high or null to disable
max_new_tokens: 32768 # [MODIFIABLE] Maximum tokens to generate, recommended value when reasoning_effort set to high
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
## Menggunakan parameter reasing\$1effort
`reasoning_effort`Parameter mengontrol perilaku penalaran untuk model berkemampuan penalaran.
### Prasyarat
+ **Kompatibilitas model** - Set `reasoning_effort` hanya ketika `model_type` menentukan model berkemampuan penalaran (saat ini) `amazon.nova-2-lite-v1:0:256k`
+ **Penanganan kesalahan** - Menggunakan `reasoning_effort` dengan model yang tidak didukung akan gagal dengan `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
### Pilihan yang tersedia
| Opsi | Perilaku | Batas token | Kasus penggunaan |
| --- | --- | --- | --- |
| null (default) | Menonaktifkan mode penalaran | N/A | Evaluasi standar tanpa overhead penalaran |
| rendah | Memungkinkan penalaran dengan kendala | 4.000 token untuk penalaran internal | Skenario yang membutuhkan penalaran ringkas; mengoptimalkan kecepatan dan biaya |
| tinggi | Memungkinkan penalaran tanpa kendala | Tidak ada batasan token pada penalaran internal | Masalah kompleks yang membutuhkan analisis dan step-by-step penalaran ekstensif |
| Metode pelatihan | Pilihan yang tersedia | Cara mengkonfigurasi |
| --- | --- | --- |
| SFT (Penyetelan Penyesuaian yang Diawasi) | Tinggi atau Mati saja | Gunakan reasing\$1enabled: true (high) atau reasoning\$1enabled: false (off) |
| RFT (Penguatan Fine-Tuning) | Rendah, Tinggi, atau Mati | Gunakan reasing\$1effort: low atau reasing\$1effort: high. Hilangkan bidang untuk menonaktifkan. |
| Evaluasi | Rendah, Tinggi, atau Mati | Gunakan reasing\$1effort: low atau reasing\$1effort: high. Gunakan null untuk menonaktifkan. |
### Kapan mengaktifkan penalaran
**Gunakan mode penalaran (`low`atau`high`) untuk**
+ Tugas pemecahan masalah yang kompleks (matematika, teka-teki logika, pengkodean)
+ Pertanyaan analitis multi-langkah yang membutuhkan penalaran menengah
+ Tugas di mana penjelasan atau step-by-step pemikiran terperinci meningkatkan akurasi
+ Skenario di mana kualitas respons diprioritaskan daripada kecepatan
**Gunakan mode non-penalaran (`null`atau hilangkan parameter) untuk**
+ Tanya Jawab sederhana atau pertanyaan faktual
+ Tugas menulis kreatif
+ Ketika waktu respons yang lebih cepat sangat penting
+ Pembandingan kinerja di mana overhead penalaran harus dikecualikan
+ Optimalisasi biaya saat penalaran tidak meningkatkan kinerja tugas
### Pemecahan masalah
**Kesalahan: “Mode penalaran diaktifkan tetapi model tidak mendukung penalaran”**
**Penyebab**: `reasoning_effort` Parameter disetel ke nilai non-null, tetapi yang ditentukan `model_type` tidak mendukung penalaran.
**Resolusi**:
+ Verifikasi jenis model Anda `amazon.nova-2-lite-v1:0:256k`
+ Jika menggunakan model yang berbeda, beralihlah ke model berkemampuan penalaran atau hapus `reasoning_effort` parameter dari resep Anda
# Evaluasi RFT
## Apa itu evaluasi RFT?
Evaluasi RFT memungkinkan Anda menilai kinerja model Anda menggunakan fungsi hadiah khusus sebelum, selama, atau setelah pelatihan pembelajaran penguatan. Tidak seperti evaluasi standar yang menggunakan metrik yang telah ditentukan sebelumnya, Evaluasi RFT memungkinkan Anda menentukan kriteria keberhasilan Anda sendiri melalui fungsi Lambda yang menilai output model berdasarkan kebutuhan spesifik Anda.
## Mengapa mengevaluasi dengan RFT?
Evaluasi sangat penting untuk menentukan apakah proses fine-tuning RL memiliki:
+ Penyelarasan model yang ditingkatkan dengan kasus penggunaan spesifik dan nilai-nilai kemanusiaan Anda
+ Mempertahankan atau meningkatkan kemampuan model pada tugas-tugas utama
+ Menghindari efek samping yang tidak diinginkan seperti berkurangnya faktualitas, peningkatan verbositas, atau penurunan kinerja pada tugas-tugas lain
+ Memenuhi kriteria keberhasilan khusus Anda seperti yang ditentukan oleh fungsi hadiah Anda
## Kapan menggunakan evaluasi RFT
Gunakan Evaluasi RFT dalam skenario ini:
+ Sebelum Pelatihan RFT: Tetapkan metrik dasar pada kumpulan data evaluasi Anda
+ Selama Pelatihan RFT: Pantau kemajuan pelatihan dengan pos pemeriksaan menengah
+ Setelah Pelatihan RFT: Validasi bahwa model akhir memenuhi kebutuhan Anda
+ Membandingkan Model: Mengevaluasi beberapa versi model menggunakan kriteria hadiah yang konsisten
**catatan**
Gunakan Evaluasi RFT saat Anda membutuhkan metrik khusus domain khusus. Untuk evaluasi tujuan umum (akurasi, kebingungan, BLEU), gunakan metode evaluasi standar.
## Persyaratan format data
### Struktur data masukan
Data input evaluasi RFT harus mengikuti format Fine-Tuning Penguatan OpenAI. Setiap contoh adalah objek JSON yang berisi:
+ `messages`— Array giliran percakapan dengan `system` dan peran `user`
+ `reference_answer`— Output yang diharapkan atau data kebenaran dasar yang digunakan oleh fungsi hadiah Anda untuk penilaian
### Contoh format data
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### Keterbatasan saat ini
+ Hanya teks: Tidak ada input multimodal (gambar, audio, video) yang didukung
+ Percakapan satu putaran: Hanya mendukung pesan pengguna tunggal (tidak ada dialog multi-putaran)
+ Format JSON: Data input harus dalam format JSONL (satu objek JSON per baris)
+ Output model: Evaluasi dilakukan pada penyelesaian yang dihasilkan dari model yang ditentukan
## Mempersiapkan resep evaluasi Anda
### Contoh notebook
Untuk contoh lengkap, lihat [Buku catatan evaluasi](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook).
### Contoh konfigurasi resep
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in sagemaker python SDK
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## Fungsi hadiah preset
Dua fungsi hadiah preset (`prime_code`dan`prime_math`) tersedia sebagai lapisan Lambda untuk memudahkan integrasi dengan fungsi Lambda RFT Anda.
### Ikhtisar
Fungsi preset ini memberikan kemampuan out-of-the-box evaluasi untuk:
+ `prime_code`— Pembuatan kode dan evaluasi kebenaran
+ `prime_math`— Penalaran matematis dan evaluasi pemecahan masalah
### Pengaturan cepat
1. [Unduh layer Lambda dari rilis. nova-custom-eval-sdk ](https://github.com/aws/nova-custom-eval-sdk/releases)
1. Publikasikan lapisan Lambda menggunakan AWS Command Line Interface ()AWS CLI:
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. Tambahkan layer ke fungsi Lambda Anda di AWS Management Console (Pilih layer preset-function-layer dari kustom dan tambahkan juga AWSSDKPandas-Python 312 untuk dependensi numpy).
1. Impor dan gunakan dalam kode Lambda Anda:
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
### fungsi prime\$1code
Mengevaluasi tugas pembuatan kode Python dengan mengeksekusi kode terhadap kasus uji dan mengukur kebenaran.
**Contoh format dataset masukan**
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**Fitur utama**
+ Ekstraksi kode otomatis dari blok kode penurunan harga
+ Deteksi fungsi dan pengujian berbasis panggilan
+ Eksekusi kasus uji dengan perlindungan batas waktu
+ Validasi sintaks dan pemeriksaan kompilasi
+ Pelaporan kesalahan terperinci dengan traceback
### fungsi prime\$1math
Mengevaluasi penalaran matematika dan kemampuan pemecahan masalah dengan dukungan matematika simbolis.
**Format masukan**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**Fitur utama**
+ Evaluasi matematika simbolik menggunakan SymPy
+ Beberapa format jawaban (LaTeX, teks biasa, simbolik)
+ Pemeriksaan kesetaraan matematika
+ Normalisasi dan penyederhanaan ekspresi
### Persyaratan format data
**Untuk evaluasi kode**
+ Input: Array argumen fungsi (tipe yang tepat: bilangan bulat, string, dll.)
+ Output: Array nilai pengembalian yang diharapkan (tipe yang tepat: boolean, angka, dll.)
+ Kode: Harus menggunakan Python dengan definisi fungsi yang jelas
**Untuk evaluasi matematika**
+ Jawaban referensi: Ekspresi matematika atau nilai numerik
+ Tanggapan: Bisa LaTe X, teks biasa, atau notasi simbolik
+ Kesetaraan: Diperiksa secara simbolis, bukan hanya pencocokan string
### Praktik terbaik
+ Gunakan tipe data yang tepat dalam kasus uji (bilangan bulat vs string, boolean vs “True”)
+ Berikan tanda tangan fungsi yang jelas dalam masalah kode
+ Sertakan kasus tepi dalam input pengujian (nol, angka negatif, input kosong)
+ Format ekspresi matematika secara konsisten dalam jawaban referensi
+ Uji fungsi reward Anda dengan data sampel sebelum penerapan
### Penanganan kesalahan
Kedua fungsi tersebut mencakup penanganan kesalahan yang kuat untuk:
+ Kesalahan kompilasi dalam kode yang dihasilkan
+ Pengecualian runtime selama eksekusi
+ Data masukan cacat
+ Skenario batas waktu untuk loop tak terbatas
+ Ekspresi matematika tidak valid
## Membuat fungsi hadiah Anda
### Persyaratan Lambda ARN
Lambda ARN Anda harus mengikuti format ini:
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
Jika Lambda tidak memiliki skema penamaan ini, pekerjaan akan gagal dengan kesalahan ini:
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
### Format permintaan Lambda
Fungsi Lambda Anda menerima data dalam format ini:
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**catatan**
Struktur pesan mencakup `content` array bersarang, cocok dengan format data input. Pesan terakhir dengan peran `nova_assistant` berisi respons yang dihasilkan model.
### Format respons Lambda
Fungsi Lambda Anda harus mengembalikan data dalam format ini:
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**Bidang respons**
+ `id`— Harus cocok dengan ID sampel input
+ `aggregate_reward_score`— Skor keseluruhan (biasanya 0,0 hingga 1,0)
+ `metrics_list`— Array metrik individu dengan:
+ `name`— Pengidentifikasi metrik (misalnya, “akurasi”, “kelancaran”)
+ `value`— Skor metrik (biasanya 0,0 hingga 1,0)
+ `type`— Baik “Metrik” (untuk pelaporan) atau “Hadiah” (digunakan dalam pelatihan)
## Izin IAM
### Izin yang diperlukan
Peran SageMaker eksekusi Anda harus memiliki izin untuk menjalankan fungsi Lambda Anda. Tambahkan kebijakan ini ke peran SageMaker eksekusi Anda:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Peran pelaksanaan Lambda
Peran eksekusi fungsi Lambda Anda memerlukan izin eksekusi Lambda dasar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Jika fungsi Lambda Anda mengakses AWS layanan lain (misalnya, S3 untuk data referensi, DynamoDB untuk logging), tambahkan izin tersebut ke peran eksekusi Lambda.
## Melaksanakan pekerjaan evaluasi
1. **Siapkan data Anda** - Format data evaluasi Anda sesuai dengan persyaratan format data dan unggah file JSONL Anda ke S3: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Konfigurasikan resep Anda** — Perbarui resep sampel dengan konfigurasi Anda:
+ Setel `model_name_or_path` ke lokasi model Anda
+ Atur `lambda_arn` ke ARN fungsi reward Anda
+ Setel `output_s3_path` ke lokasi keluaran yang Anda inginkan
+ Sesuaikan `inference` parameter sesuai kebutuhan
Simpan resepnya sebagai `rft_eval_recipe.yaml`
1. **Jalankan evaluasi** - Jalankan pekerjaan evaluasi menggunakan buku catatan yang disediakan: Buku [catatan evaluasi](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Pantau kemajuan** — Pantau pekerjaan evaluasi Anda melalui:
+ SageMaker Konsol: Periksa status pekerjaan dan log
+ CloudWatch Log: Lihat log eksekusi terperinci
+ Lambda Logs: Masalah fungsi hadiah debug
## Memahami hasil evaluasi
### Format output
Pekerjaan evaluasi menghasilkan hasil ke lokasi S3 yang Anda tentukan dalam format JSONL. Setiap baris berisi hasil evaluasi untuk satu sampel:
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**catatan**
Output Pekerjaan Evaluasi RFT identik dengan format Respons Lambda. Layanan evaluasi melewati respons fungsi Lambda Anda tanpa modifikasi, memastikan konsistensi antara perhitungan hadiah Anda dan hasil akhir.
### Menafsirkan hasil
**Skor hadiah agregat**
+ Rentang: Biasanya 0,0 (terburuk) hingga 1,0 (terbaik), tetapi tergantung pada implementasi Anda
+ Tujuan: Angka tunggal yang merangkum kinerja keseluruhan
+ Penggunaan: Bandingkan model, lacak peningkatan selama pelatihan
**Metrik individu**
+ Jenis Metrik: Metrik informasi untuk analisis
+ Jenis Hadiah: Metrik yang digunakan selama pelatihan RFT
+ Interpretasi: Nilai yang lebih tinggi umumnya menunjukkan kinerja yang lebih baik (kecuali jika Anda merancang metrik terbalik)
### Tolok ukur kinerja
Apa yang dimaksud dengan kinerja “baik” tergantung pada kasus penggunaan Anda:
| Rentang skor | Interpretasi | Tindakan |
| --- | --- | --- |
| 0,8 - 1,0 | Sangat baik | Model siap untuk penyebaran |
| 0,6 - 0,8 | Baik | Perbaikan kecil mungkin bermanfaat |
| 0,4 - 0,6 | Adil | Diperlukan peningkatan yang signifikan |
| 0,0 - 0,4 | Miskin | Tinjau data pelatihan dan fungsi hadiah |
**penting**
Ini adalah pedoman umum. Tentukan ambang batas Anda sendiri berdasarkan persyaratan bisnis, kinerja model dasar, kendala khusus domain, dan analisis biaya-manfaat pelatihan lebih lanjut.
## Pemecahan masalah
### Masalah umum
| Isu | Penyebab | Solusi |
| --- | --- | --- |
| Batas waktu Lambda | Perhitungan hadiah yang kompleks | Tingkatkan batas waktu Lambda atau optimalkan fungsi |
| Izin ditolak | Izin IAM tidak ada | Verifikasi SageMaker peran dapat memanggil Lambda |
| Skor tidak konsisten | Fungsi hadiah non-deterministik | Gunakan benih tetap atau logika deterministik |
| Hasil yang hilang | Kesalahan Lambda tidak tertangkap | Tambahkan penanganan kesalahan komprehensif di Lambda |
### Daftar periksa debug
+ Verifikasi data input mengikuti format yang benar dengan array konten bersarang
+ Konfirmasikan Lambda ARN sudah benar dan fungsinya diterapkan
+ Periksa izin IAM untuk → Pemanggilan SageMaker Lambda
+ Tinjau CloudWatch log untuk kesalahan Lambda
+ Validasi respons Lambda sesuai dengan format yang diharapkan
## Praktik terbaik
+ Mulai Sederhana: Mulailah dengan fungsi imbalan dasar dan ulangi
+ Uji Lambda Secara Terpisah: Gunakan acara uji Lambda sebelum evaluasi penuh
+ Validasi pada Dataset Kecil: Jalankan evaluasi pada subset sebelum dataset lengkap
+ Kontrol Versi: Lacak versi fungsi hadiah bersama versi model
+ Biaya Monitor: Pemanggilan Lambda dan waktu komputasi memengaruhi biaya
+ Log Ekstensif: Gunakan pernyataan cetak di Lambda untuk debugging
+ Atur Timeout dengan Tepat: Seimbangkan antara kesabaran dan biaya
+ Metrik Dokumen: Tentukan dengan jelas apa yang diukur setiap metrik
## Langkah selanjutnya
Setelah menyelesaikan evaluasi RFT:
+ Jika hasilnya memuaskan: Terapkan model ke produksi
+ Jika perbaikan diperlukan:
+ Sesuaikan fungsi hadiah
+ Kumpulkan lebih banyak data pelatihan
+ Ubah hiperparameter pelatihan
+ Jalankan iterasi pelatihan RFT tambahan
+ Pemantauan berkelanjutan: Evaluasi ulang secara berkala dengan data baru
# Menerapkan fungsi hadiah
## Ikhtisar
Fungsi hadiah (juga disebut pencetak gol atau grader) adalah komponen inti yang mengevaluasi respons model dan memberikan sinyal umpan balik untuk pelatihan. Ini harus diimplementasikan sebagai fungsi Lambda yang menerima respons model dan mengembalikan skor hadiah.
## Format antarmuka
Fungsi reward Anda harus menerima dan mengembalikan data dalam format berikut:
**Sampel sampel masukan untuk pelatihan**
```
{
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Contoh payload untuk hadiah lambda**
Kontainer secara otomatis mengubah data Anda sebelum mengirimnya ke fungsi Lambda Anda dengan:
1. Menghasilkan respons model untuk setiap prompt
1. Menambahkan giliran asisten (respons yang dihasilkan) ke array pesan
1. Menambahkan `id` bidang unik untuk melacak
Fungsi Lambda Anda akan menerima data dalam format yang diubah ini:
```
{
"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..."
}
],
# Following section will be same as your training dataset sample
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Hadiah kontrak Lambda**
```
def lambda_handler(event, context):
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
"""
Args:
samples: List of dictionaries in OpenAI format
Example input:
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Company, I don nott have a dedicated security team..."
}
],
# This section will be same as your training dataset
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
Returns:
List of dictionaries with reward scores:
{
"id": str, # Same id as input sample
"aggregate_reward_score": float, # Overall score for the sample
"metrics_list": [ # OPTIONAL: Component scores
{
"name": str, # Name of the component score
"value": float, # Value of the component score
"type": str # "Reward" or "Metric"
}
]
}
"""
```
## Bidang input dan output
### Bidang input
| Bidang | Deskripsi | Catatan tambahan |
| --- | --- | --- |
| id | Pengidentifikasi unik untuk sampel | Bergema kembali dalam output. Format string |
| pesan | Riwayat obrolan yang dipesan dalam format OpenAI | Array objek pesan |
| pesan [] .role | Pembicara pesan | Nilai umum: “pengguna”, “asisten”, “sistem” |
| pesan [] .content | Konten teks pesan | Tali polos |
| \$1\$1metadata | Informasi bentuk bebas untuk membantu penilaian | Objek; bidang opsional yang dilewatkan dari data pelatihan |
### Bidang output
| Bidang | Deskripsi | Catatan tambahan |
| --- | --- | --- |
| id | Pengidentifikasi yang sama dengan sampel input | Harus cocok dengan masukan |
| aggregate\$1reward\$1score | Skor keseluruhan untuk sampel | Float (misalnya, 0,0—1,0 atau rentang yang ditentukan tugas) |
| metrics\$1list | Skor komponen yang membentuk agregat | Array objek metrik |
## Kendala teknis
+ **Batas batas waktu** - 15 menit waktu eksekusi maksimum per pemanggilan Lambda
+ **Konkurensi** - Harus menangani permintaan `rollout_worker_replicas * 64` bersamaan
+ **Keandalan** - Harus menerapkan penanganan kesalahan yang tepat dan mengembalikan skor yang valid secara konsisten
+ **Kinerja** - Optimalkan untuk eksekusi cepat (detik, bukan menit) untuk memungkinkan pelatihan yang efisien
**Praktik terbaik**
+ Minimalkan panggilan API eksternal
+ Gunakan algoritma dan struktur data yang efisien
+ Menerapkan logika coba lagi untuk kegagalan sementara
+ Cache perhitungan yang dapat digunakan kembali
+ Uji secara menyeluruh sebelum pelatihan untuk memastikan eksekusi bebas bug
## Menggunakan fungsi hadiah khusus
Menerapkan fungsi hadiah khusus ketika Anda memiliki kriteria evaluasi khusus tugas:
+ **Tentukan kriteria evaluasi** - Tentukan apa yang membuat respons yang baik untuk tugas Anda
+ **Menerapkan fungsi Lambda** - Buat fungsi Lambda mengikuti format antarmuka
+ **Uji secara lokal** - Validasi fungsi Anda mengembalikan skor yang benar untuk input sampel
+ **Terapkan ke AWS** — Menyebarkan Lambda Anda dan perhatikan ARN
+ **Konfigurasikan resep** — Tambahkan Lambda ARN ke bidang resep Anda `reward_lambda_arn`
+ **Uji dengan dataset kecil** — Jalankan RFT dengan data minimal untuk memverifikasi integrasi
## Izin IAM
### Izin yang diperlukan
Peran SageMaker eksekusi Anda harus memiliki izin untuk menjalankan fungsi Lambda Anda. Tambahkan kebijakan ini ke peran SageMaker eksekusi Anda:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Peran pelaksanaan Lambda
Peran eksekusi fungsi Lambda Anda memerlukan izin eksekusi Lambda dasar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
Izin tambahan: Jika fungsi Lambda Anda mengakses layanan AWS lain (misalnya, S3 untuk data referensi, DynamoDB untuk logging), tambahkan izin tersebut ke peran eksekusi Lambda.
## Contoh: LLM Sebagai fungsi hadiah Hakim
Contoh ini menunjukkan penggunaan model Amazon Bedrock sebagai juri untuk mengevaluasi respons model dengan membandingkannya dengan jawaban referensi. Template Lambda ini menyediakan kerangka kerja bagi pelanggan untuk mengimplementasikan panggilan ke Amazon Bedrock untuk permintaan inferensi guna memproses evaluasi penilaian. Fungsi Lambda mempertahankan input/output kontrak yang sama dengan fungsi hadiah lainnya.
### Implementasi
Fungsi Lambda ini mengimplementasikan proses evaluasi dua tahap: `lambda_handler` mengekstrak respons model dan jawaban referensi dari sampel yang masuk, kemudian fungsi tersebut `lambda_graded` memanggil Amazon Bedrock untuk menilai kesamaan semantik di antara mereka. Implementasinya mencakup penanganan kesalahan yang kuat dengan percobaan ulang otomatis untuk kegagalan sementara dan mendukung format jawaban referensi yang fleksibel (baik format string dan kamus terstruktur).
**Detail implementasi:**
+ **Coba Ulang Logika**: Menerapkan backoff eksponensial (1s, 2s, 4s) untuk pengecualian pembatasan guna menangani batas laju API Bedrock
+ **Penanganan Kesalahan**: Mengembalikan skor 0,0 untuk evaluasi yang gagal daripada menaikkan pengecualian
+ **Penilaian Deterministik**: Menggunakan suhu = 0,0 untuk memastikan skor yang konsisten di seluruh evaluasi
+ **Format Referensi Fleksibel**: Secara otomatis menangani jawaban referensi string dan kamus
+ **Penjepitan Skor**: Memastikan semua skor berada dalam kisaran [0,0, 1,0] yang valid
+ **Model Agnostik**: Ubah JUDGE\$1MODEL\$1ID untuk menggunakan model Amazon Bedrock apa pun (Nova, Llama, Mistral, dll.)
```
"""
LLM Judge Lambda POC - Working implementation using Amazon Bedrock
"""
import json
import time
import boto3
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')
JUDGE_MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
SYSTEM_PROMPT = "You must output ONLY a number between 0.0 and 1.0. No explanations, no text, just the number."
JUDGE_PROMPT_TEMPLATE = """Compare the following two responses and rate how similar they are on a scale of 0.0 to 1.0, where:
- 1.0 means the responses are semantically equivalent (same meaning, even if worded differently)
- 0.5 means the responses are partially similar
- 0.0 means the responses are completely different or contradictory
Response A: {response_a}
Response B: {response_b}
Output ONLY a number between 0.0 and 1.0. No explanations."""
def lambda_graded(response_a: str, response_b: str, max_retries: int = 3) -> float:
"""Call Bedrock to compare responses and return similarity score."""
prompt = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, response_b=response_b)
for attempt in range(max_retries):
try:
response = bedrock_runtime.converse(
modelId=JUDGE_MODEL_ID,
messages=[{"role": "user", "content": [{"text": prompt}]}],
system=[{"text": SYSTEM_PROMPT}],
inferenceConfig={"temperature": 0.0, "maxTokens": 10}
)
print(f"Bedrock call successful: {response}")
output = response['output']['message']['content'][0]['text'].strip()
score = float(output)
print(f"Score parsed: {score}")
return max(0.0, min(1.0, score))
except Exception as e:
if "ThrottlingException" in str(e) and attempt < max_retries - 1:
time.sleep(2 ** attempt)
else:
print(f"Bedrock call failed: {e}")
return None
return None
def lambda_handler(event, context):
"""AWS Lambda handler - processes samples from RFTEvalInvoker."""
try:
samples = event if isinstance(event, list) else [event]
results = []
for sample in samples:
sample_id = sample.get("id", "unknown")
messages = sample.get("messages", [])
# Extract assistant response (response A)
response_a = ""
for msg in messages:
if msg.get("role") in ["assistant", "nova_assistant"]:
response_a = msg.get("content", "")
break
# Extract reference answer from root level (no longer in metadata)
reference_answer = sample.get("reference_answer", "")
# Handle both string and dict reference_answer formats
if isinstance(reference_answer, dict):
# If reference_answer is a dict, extract the explanation or compliant field
response_b = reference_answer.get("explanation", reference_answer.get("compliant", ""))
else:
response_b = reference_answer
if not response_a or not response_b:
results.append({
"id": sample_id,
"aggregate_reward_score": 0.0,
"metrics_list": [{"name": "similarity_score", "value": 0.0, "type": "Metric"}]
})
continue
# Get similarity score
score = lambda_graded(response_a, response_b)
results.append({
"id": sample_id,
"aggregate_reward_score": score,
"metrics_list": [
{
"name": "similarity_score",
"value": score,
"type": "Metric"
}
]
})
return {"statusCode": 200, "body": json.dumps(results)}
except Exception as e:
print(f"Error: {e}")
return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
```
### Format input
Lambda menerima format input yang sama dengan fungsi reward lainnya:
```
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don't have a dedicated security team..."
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_custom_field": "custom_value"
}
```
### Format output
```
{
"id": "sample-001",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "similarity_score",
"value": 0.85,
"type": "Metric"
}
]
}
```
### Pertimbangan deployment
Anda mungkin juga perlu menyesuaikan template prompt dan parameter inferensi berdasarkan kemampuan model dan format API yang Anda pilih.
+ **Izin IAM: Peran** eksekusi Lambda harus memiliki `bedrock:InvokeModel` izin untuk model yang Anda pilih
+ **Timeout**: Setel batas waktu Lambda setidaknya 60 detik untuk mengakomodasi latensi API Bedrock dan percobaan ulang
+ **Wilayah**: Terapkan di wilayah tempat model Bedrock pilihan Anda tersedia
+ **Biaya**: Pantau penggunaan API Bedrock karena setiap evaluasi membuat satu panggilan API per sampel
+ **Throughput**: Untuk evaluasi skala besar, mintalah peningkatan kuota Bedrock untuk menghindari pembatasan
**Meningkatkan Throughput Batuan Dasar**
Jika Anda mengalami pelambatan selama evaluasi, tingkatkan kuota model Bedrock Anda:
+ Arahkan ke konsol AWS Service Quotas
+ Cari “Bedrock” dan pilih wilayah Anda
+ Temukan kuota untuk model yang Anda pilih (misalnya, “Doa per menit untuk Claude 3.5 Soneta”)
+ Klik “Minta peningkatan kuota” dan tentukan throughput yang Anda inginkan
+ Berikan pembenaran untuk kenaikan (misalnya, “beban kerja evaluasi RFT”)
Logika coba ulang bawaan Lambda menangani pelambatan sesekali, tetapi evaluasi volume tinggi yang berkelanjutan memerlukan peningkatan kuota yang sesuai.
**Kebijakan IAM yang Diperlukan:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:*::foundation-model/*"
}
]
}
```
# Pelatihan berulang
Pelatihan berulang adalah pendekatan sistematis untuk menyempurnakan model melalui beberapa siklus pelatihan, di mana setiap putaran dibangun di atas pos pemeriksaan sebelumnya dengan mengatasi kelemahan spesifik yang ditemukan melalui evaluasi. Metode ini memungkinkan peningkatan yang ditargetkan untuk memodelkan kinerja dengan memasukkan contoh yang dikuratori yang membahas mode kegagalan, beradaptasi dengan perubahan persyaratan, dan memvalidasi peningkatan secara bertahap daripada berkomitmen pada satu pelatihan jangka panjang. Prosesnya biasanya mengikuti pola seperti SFT (Supervised Fine-Tuning) diikuti oleh RFT (Reward-based Fine-Tuning), dengan pos pemeriksaan yang disimpan dalam bucket S3 escrow yang AWS dikelola yang dapat direferensikan untuk iterasi pelatihan berikutnya sambil mempertahankan konsistensi dalam jenis model dan teknik pelatihan di seluruh pipeline.
Untuk detail selengkapnya, lihat [Pelatihan Iteratif](nova-iterative-training.md).