Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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.