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

Penguatan Fine-Tuning (RFT) dengan model Amazon Nova

Ikhtisar

Apa itu RFT?

Reinforcement fine-tuning (RFT) meningkatkan kinerja model dengan melatih sinyal umpan balik — skor atau penghargaan yang dapat diukur yang menunjukkan seberapa baik kinerja model — daripada jawaban yang benar dan tepat. Tidak seperti fine-tuning yang diawasi (SFT) yang belajar dari pasangan input-output, RFT menggunakan fungsi hadiah untuk mengevaluasi respons model dan mengoptimalkan model secara iteratif untuk memaksimalkan penghargaan ini. Pendekatan ini unggul ketika mendefinisikan output yang benar secara tepat merupakan tantangan, tetapi Anda dapat mengukur kualitas respons dengan andal.

Kapan menggunakan RFT

Gunakan RFT ketika Anda dapat menentukan kriteria keberhasilan yang jelas dan terukur tetapi sulit untuk memberikan output yang tepat untuk pelatihan. RFT sangat ideal untuk:

Kasus penggunaan terbaik

RFT unggul dalam domain di mana kualitas output dapat diukur secara objektif tetapi respons optimal sulit untuk didefinisikan di muka:

Model yang didukung

Nova Lite 2.0

Ikhtisar format data

Data pelatihan RFT harus mengikuti format Penguatan OpenAI Fine-Tuning . Setiap contoh pelatihan adalah objek JSON yang berisi:

Keterbatasan saat ini

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_answerBidang 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

Evaluation-first pendekatan

Sebelum berinvestasi dalam pelatihan RFT skala besar, evaluasi kinerja dasar model Anda:

Dimulai dengan kumpulan data kecil memungkinkan Anda untuk:

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:

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:

Pertimbangan fungsi penghargaan

Rancang fungsi hadiah Anda untuk pelatihan yang efisien:

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 (messagesdanreference_answer). Fleksibilitas ini memungkinkan Anda menambahkan data tambahan apa pun yang dibutuhkan fungsi hadiah Anda untuk evaluasi yang tepat.

Properti tambahan umum

Contoh bidang metadata:

Contoh dengan properti tambahan

{
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor"
    },
    {
      "role": "user",
      "content": "Solve: 2x + 5 = 13"
    }
  ],
  "reference_answer": {
    "solution": "x = 4",
    "steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
  },
  "task_id": "algebra_001",
  "difficulty_level": "easy",
  "domain": "algebra",
  "expected_reasoning_steps": 3
}

Bidang tambahan ini diteruskan ke fungsi hadiah Anda selama evaluasi, memungkinkan logika penilaian canggih yang disesuaikan dengan kasus penggunaan spesifik Anda.

Konfigurasi pelatihan

Resep sampel

# Note:
# This recipe can run on p5.48xlarge, p5e.48xlarge, and p5en.48xlarge instance types.
run:
  name: "my-rft-run"                           # Unique run name (appears in logs and artifacts).
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data-file>      # Training dataset in JSONL format.
  replicas: 4                                   # Number of total training instances.
  generation_replicas: 2                        # Number of total instances dedicated to response generation.
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

  ## MLFlow configs
  mlflow_tracking_uri: "" # Required for MLFlow
  mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
  mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty

## SMTJ RFT training configs
training_config:
  max_length: 8192                              # Context window (tokens) for inputs and prompt.
  global_batch_size: 32                         # Total samples per optimizer step across all replicas (16/32/64/128/256).
  reasoning_effort: high                        # Reasoning mode: high, low, or null for non-reasoning.

  data:
    shuffle: true                               # Shuffle training data each epoch.

  rollout:                                      # Controls how responses are generated for advantage calculation.
    rollout_strategy:
      type: off_policy_async                    # Asynchronous rollout for higher throughput.
      age_tolerance: 2                          # Maximum policy age before regeneration.
    advantage_strategy:
      number_generation: 4                      # Samples per prompt to estimate advantages (higher = lower variance but higher cost).
    generator:
      max_new_tokens: 6000                      # Cap on tokens generated per sample.
      set_random_seed: true                     # Seed generation for reproducibility across runs.
      temperature: 1                            # Softmax temperature for sampling.
    rewards:
      preset_reward_function: null              # Preset reward functions: exact_match or null for custom.
      api_endpoint:
        lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>
        lambda_concurrency_limit: 12             # Max concurrent Lambda invocations (throughput vs. throttling).
        lambda_batch_size: 128                  # Number of samples per Lambda invocation.

  trainer:
    max_steps: 2                                # Steps to train for. One step = global_batch_size samples.
    save_steps: 5                               # Save a checkpoint every N steps.
    test_steps: 1                               # Run validation every N reference model updates.
    refit_freq: 4                               # Frequency of reference model updates.
    clip_ratio_high: 0.2                        # PPO clip ratio for policy updates.
    loss_scale: 1.0                             # Scaling factor for the policy loss.

    # RL parameters
    ent_coeff: 0.0                              # Entropy bonus added to the policy loss (higher = more exploration).
    kl_loss_coef: 0.0                           # Weight on the KL penalty between the current and reference policy.

    optim_config:                               # Optimizer settings.
        lr: 1e-6                                # Learning rate.
        weight_decay: 0.0                       # L2 regularization strength (0.0 to 1.0).
        adam_beta1: 0.9
        adam_beta2: 0.95

    peft:                                       # Parameter-efficient fine-tuning (LoRA).
        peft_scheme: "lora"                     # Enable LoRA for PEFT.
        lora_tuning:
            alpha: 64                           # LoRA scaling factor.
            lora_plus_lr_ratio: 64.0            # LoRA+ learning rate scaling factor (0.0 to 100.0).

Pelatihan RFT menggunakan LLM sebagai juri

Ikhtisar

Model bahasa besar (LLM) semakin banyak digunakan sebagai juri dalam alur kerja penyempurnaan penguatan (RFT), memberikan sinyal hadiah otomatis yang memandu pengoptimalan model. Dalam pendekatan ini, LLM mengevaluasi keluaran model terhadap kriteria yang ditentukan—apakah menilai kebenaran, kualitas, kepatuhan gaya, atau kesetaraan semantik—dan memberikan penghargaan yang mendorong proses pembelajaran penguatan.

Ini sangat berharga untuk tugas-tugas di mana fungsi hadiah tradisional sulit untuk didefinisikan secara terprogram, seperti menentukan apakah representasi yang berbeda (seperti "1/3“, “0.333", dan “sepertiga”) setara secara semantik, atau mengevaluasi kualitas bernuansa seperti koherensi dan relevansi. Dengan menggunakan LLM-based juri sebagai fungsi penghargaan, Anda dapat menskalakan RFT ke domain kompleks tanpa memerlukan anotasi manusia yang ekstensif, memungkinkan iterasi cepat dan peningkatan berkelanjutan model Anda di berbagai kasus penggunaan di luar masalah penyelarasan tradisional.

Pemilihan mode penalaran

Mode yang tersedia

Kapan menggunakan setiap mode

Gunakan penalaran tinggi untuk:

Gunakan none (hilangkan reasing_effort) atau alasan rendah untuk:

Pengorbanan biaya dan kinerja

Mode penalaran yang lebih tinggi meningkat:

Memvalidasi hakim LLM Anda

Sebelum menerapkan LLM-as-a-judge dalam produksi, validasi bahwa evaluasi model hakim selaras dengan penilaian manusia. Ini melibatkan:

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:

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

Persyaratan instans

Wadah mendukung pelatihan keduanya Full-Rank dan LoRa:

Pelatihan pemantauan

Log pelatihan mencakup metrik komprehensif di setiap langkah. Kategori metrik utama:

Metrik skor

Perilaku model

Pelatihan kesehatan

Karakteristik respons

Performa

Penggunaan sumber daya

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:

Keterbatasan dan praktik terbaik

Batasan

Praktik terbaik

Mulai dari yang kecil

Pre-training evaluasi

Pantau pelatihan

Optimalkan fungsi hadiah

Strategi iterasi

Jika hadiah tidak membaik:

Pembelajaran kurikulum adaptif

Pembelajaran kurikulum adaptif adalah fitur opsional yang secara dinamis memilih pelatihan mana yang diminta untuk disajikan kepada model selama RFT. Alih-alih melatih semua petunjuk secara seragam, pelatih menggunakan model itu sendiri untuk memprediksi kesulitan yang cepat dan memilih petunjuk dalam rentang kesulitan produktif—di mana model terkadang berhasil dan terkadang gagal. Ini memaksimalkan varians hasil dalam setiap grup peluncuran GRPO, menghasilkan sinyal keunggulan yang lebih tinggi, konvergensi yang lebih cepat, dan stabilitas pelatihan RL yang lebih baik dengan mengurangi pembaruan gradien yang bising dari petunjuk yang terlalu mudah atau terlalu sulit.

Cara kerja kurikulum adaptif

Ketika kurikulum adaptif diaktifkan, loop pelatihan menambahkan fase prediksi dan seleksi sebelum setiap langkah peluncuran:

Kapan menggunakan kurikulum adaptif

Kurikulum adaptif paling efektif dalam skenario berikut:

Mengkonfigurasi kurikulum adaptif

Tambahkan adaptive_curriculum blok trainer di bawah resep Anda untuk mengaktifkan pembelajaran kurikulum adaptif:

training_config:
  trainer:
    adaptive_curriculum:
      enable: true                               # Enable adaptive curriculum prompt selection.
      selection_pool_multiplier: 8               # Score 8 x global_batch_size candidates, keep best global_batch_size.
      prediction_mode: pass_rate                 # "pass_rate" for discrete rewards; "spread" for continuous rewards.
      exemplar_history_steps: 1                  # Previous training steps kept in the rolling exemplar history buffer.
      reinforce_coef: 0.01                       # Scale factor for the REINFORCE loss that trains the predictor (0 disables).
      predictor_prompt_column: predictor_prompt  # Dataset field with clean problem text used by the predictor.
      selection_lookahead_steps: 4               # Future training batches pre-approved per curriculum screening pass.

Tabel berikut menjelaskan setiap parameter kurikulum adaptif:

Rekomendasi untuk kumpulan data konteks panjang

Kurikulum adaptif bekerja dengan menjalankan prediktor pass-rate ringan pada kumpulan petunjuk kandidat dan memilih batch yang paling produktif untuk diluncurkan. Ketika max_prompt_length pendek (beberapa ribu token atau kurang), prediktor berjalan dalam beberapa detik per pass skrining dan overhead kurikulum dapat diabaikan. Ketika panjang prompt tumbuh, waktu inferensi prediktor tumbuh kira-kira secara kuadratis (perhatian adalah O (n²) dalam panjang urutan), sehingga penyaringan dapat mendominasi waktu langkah pada kumpulan data di mana petunjuknya melebihi sekitar 8.000 token.

Pengaturan di bawah ini menjaga kurikulum adaptif dapat digunakan dan hemat biaya pada kumpulan data konteks panjang. Terapkan bersama-sama; mereka menangani berbagai komponen biaya penyaringan.

Contoh konfigurasi yang disetel untuk kumpulan data konteks panjang (sekitar 24K — 32K petunjuk token):

training_config:
  max_length: 32768
  global_batch_size: 32

  trainer:
    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 4        # Smaller pool keeps predictor prefill bounded.
      selection_lookahead_steps: 1        # Predictor runs once per training step.
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt

Persiapan data untuk kurikulum adaptif

Saat menggunakan kurikulum adaptif, data pelatihan Anda harus menyertakan predictor_prompt bidang (atau nama bidang yang ditentukan dalampredictor_prompt_column) yang berisi versi singkat dari teks masalah. Bidang ini digunakan oleh prediktor pass-rate untuk menilai kesulitan yang cepat dengan cepat tanpa memproses konteks percakapan lengkap.

Contoh entri JSONL dengan prompt prediktor:

{
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor. Show your work step by step."
    },
    {
      "role": "user",
      "content": "A train travels 120 miles in 2 hours. If it then increases speed by 50%, how far will it travel in the next 3 hours?"
    }
  ],
  "reference_answer": "270 miles",
  "predictor_prompt": "A train travels 120 miles in 2 hours. Speed increases 50%. Distance in next 3 hours?"
}

Jika predictor_prompt bidang tidak ada, sistem akan kembali menggunakan prompt penuh dari messages bidang.

Contoh resep lengkap dengan kurikulum adaptif

Contoh berikut menunjukkan resep RFT LoRa lengkap dengan kurikulum adaptif diaktifkan:

run:
  name: "my-rft-adaptive-curriculum"
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data-file>
  replicas: 4
  generation_replicas: 2
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

training_config:
  max_length: 8192
  global_batch_size: 32
  reasoning_effort: null                        # Non-reasoning mode.

  data:
    shuffle: true

  rollout:
    rollout_strategy:
      type: off_policy_async
      age_tolerance: 2
    advantage_strategy:
      number_generation: 16                     # Higher n for better advantage estimates.
    generator:
      max_new_tokens: 6000
      temperature: 1.0
    rewards:
      preset_reward_function: exact_match       # Or null for custom Lambda reward.
      api_endpoint:
        lambda_arn: ${oc.select:run.reward_lambda_arn}   # Reuse the top-level run.reward_lambda_arn so the two stay in sync.
        lambda_concurrency_limit: 12
        lambda_batch_size: 128

  trainer:
    max_steps: 500
    save_steps: 50
    test_steps: 25
    refit_freq: 4
    clip_ratio_high: 0.2
    ent_coeff: 0.0
    kl_loss_coef: 0.0

    optim_config:
      lr: 1e-6
      weight_decay: 0.0

    peft:
      peft_scheme: "lora"
      lora_tuning:
        alpha: 64
        lora_plus_lr_ratio: 64.0

    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 8
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt

Memantau kurikulum adaptif

Saat kurikulum adaptif diaktifkan, metrik tambahan dicatat pada setiap langkah pelatihan:

Kemampuan lanjutan: Nova Forge

Untuk pengguna yang membutuhkan kemampuan canggih di luar batasan RFT standar, Nova Forge tersedia sebagai penawaran layanan berlangganan berbayar:

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 tersedia untuk membantu memantau status dan kemajuan pekerjaan pelatihan.

Skrip yang tersedia adalah:

Instalasi

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 untuk detail dan contoh tambahan.