Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Rinforzo Fine-Tuning (RFT) con modelli Amazon Nova

Panoramica di

Che cos'è RFT?

Il Reinforcement Fine-Tuning (RFT) migliora le prestazioni del modello addestrandosi sui segnali di feedback (punteggi misurabili o premi che indicano le prestazioni del modello) anziché sulle risposte esatte e corrette. A differenza della regolazione fine supervisionata (SFT), che apprende dalle coppie input-output, RFT utilizza funzioni di ricompensa per valutare le risposte del modello e ottimizza iterativamente il modello per massimizzare tali ricompense. Questo approccio eccelle quando è difficile definire l'output esatto e corretto, ma è possibile misurare in modo affidabile la qualità della risposta.

Quando usare RFT

Utilizza RFT quando puoi definire criteri di successo chiari e misurabili, ma è difficile fornire risultati esatti e corretti per la formazione. RFT è ideale per:

I migliori casi d'uso

RFT eccelle nei settori in cui la qualità dell'output può essere misurata oggettivamente, ma le risposte ottimali sono difficili da definire in anticipo:

Modelli supportati

Nova Lite 2.0

Panoramica del formato dei dati

I dati di addestramento RFT devono seguire il formato OpenAI Fine-Tuning Reinforcement. Ogni esempio di addestramento è un oggetto JSON contenente:

Limitazioni attuali

Esempi di formati di dati

Ogni esempio deve essere su una sola riga del file JSONL, con un oggetto JSON per riga.

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

Il reference_answer campo contiene l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare la qualità.

Consigli sulle dimensioni dei set di dati

Punto di partenza

Evaluation-first approccio

Prima di investire nella formazione RFT su larga scala, valuta le prestazioni di base del tuo modello:

Iniziare con un set di dati di piccole dimensioni consente di:

Una volta convalidato, puoi espanderlo a set di dati più grandi per migliorare ulteriormente le prestazioni.

Caratteristiche dei dati di allenamento efficaci

Chiarezza e coerenza

I buoni esempi RFT richiedono dati di input chiari e inequivocabili che consentano un calcolo accurato della ricompensa tra i diversi output del modello. Evita il rumore nei tuoi dati, tra cui:

Qualsiasi ambiguità indurrà in errore il processo di formazione e indurrà il modello ad apprendere comportamenti non intenzionali.

Diversità

Il tuo set di dati dovrebbe catturare l'intera diversità dei casi d'uso di produzione per garantire solide prestazioni nel mondo reale. Include:

Considerazioni sulla funzione di ricompensa

Progetta la tua funzione di ricompensa per un allenamento efficiente:

Le funzioni di ricompensa veloci e scalabili consentono un'iterazione rapida e una sperimentazione conveniente.

Proprietà aggiuntive

Il formato di dati RFT supporta campi personalizzati oltre ai requisiti di base dello schema (e). messages reference_answer Questa flessibilità consente di aggiungere tutti i dati aggiuntivi necessari alla funzione di ricompensa per una corretta valutazione.

Proprietà aggiuntive comuni

Campi di metadati di esempio:

Esempio con proprietà aggiuntive

{
  "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
}

Questi campi aggiuntivi vengono passati alla funzione di ricompensa durante la valutazione, abilitando una sofisticata logica di punteggio personalizzata in base al caso d'uso specifico.

Configurazione di addestramento

Ricetta di esempio

# 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).

Formazione RFT utilizzando LLM come giudice

Panoramica di

I modelli linguistici di grandi dimensioni (LLM) vengono sempre più utilizzati come giudici nei flussi di lavoro di reinforcement fine-tuning (RFT), che forniscono segnali di ricompensa automatici che guidano l'ottimizzazione dei modelli. In questo approccio, un LLM valuta i risultati del modello in base a criteri specifici, che si tratti di valutare la correttezza, la qualità, l'aderenza allo stile o l'equivalenza semantica, e assegna premi che guidano il processo di reinforcement learning.

Ciò è particolarmente utile per le attività in cui le funzioni di ricompensa tradizionali sono difficili da definire programmaticamente, come determinare se rappresentazioni diverse (come "1/3«, «0,333" e «un terzo») sono semanticamente equivalenti o valutare qualità sfumate come coerenza e pertinenza. Utilizzando LLM-based i giudici come funzioni di ricompensa, puoi scalare RFT su domini complessi senza richiedere ampie annotazioni umane, consentendo una rapida iterazione e il miglioramento continuo dei tuoi modelli in diversi casi d'uso oltre ai tradizionali problemi di allineamento.

Selezione della modalità di ragionamento

Modalità disponibili

Quando usare ciascuna modalità

Usa un ragionamento elevato per:

Usa none (ometti reasoning_effort) o low reasoning per:

Compromessi in termini di costi e prestazioni

Aumentano le modalità di ragionamento più elevate:

Convalida del tuo giudice LLM

Prima di implementarne uno LLM-as-a-judge in produzione, verifica che le valutazioni del modello arbitrale siano in linea con il giudizio umano. Questa operazione prevede:

Questa fase di convalida aiuta a garantire che il processo di valutazione automatizzato produca modelli che soddisfino i criteri di qualità della produzione.

Configurazione Lambda per LLM judge

L'utilizzo di un LLM come giudice è un'estensione dell'utilizzo delle funzioni Lambda per il Reinforcement Learning with Verifiable Rewards (RLVR). All'interno della funzione Lambda, effettui una chiamata a uno dei modelli ospitati in Amazon Bedrock.

Requisiti di configurazione importanti:

Creazione ed esecuzione di lavori

Avvio di un lavoro di formazione

Usa il modello di taccuino per i lavori di SageMaker formazione: https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook

Requisiti dell'ist

Il contenitore supporta sia Full-Rank la formazione LoRa che:

Monitoraggio della formazione

I registri di formazione includono metriche complete per ogni fase. Categorie metriche chiave:

Metriche sulle ricompense

Comportamento del modello

Formazione e salute

Caratteristiche di risposta

Prestazioni

utilizzo delle risorse

Utilizzo di modelli ottimizzati

Al termine dell'addestramento, il checkpoint finale del modello viene salvato nella posizione di output specificata. Il percorso del checkpoint è disponibile in:

Limitazioni e best practice

Limitazioni

Best practice

Inizia in piccolo

Pre-training valutazione

Monitora la formazione

Ottimizza le funzioni di ricompensa

Strategia di iterazione

Se le ricompense non migliorano:

Apprendimento adattivo del curriculum

L'apprendimento adattivo del curriculum è una funzionalità opzionale che seleziona dinamicamente quali istruzioni di formazione presentare al modello durante la RFT. Invece di allenarsi in modo uniforme su tutte le istruzioni, il formatore utilizza il modello stesso per prevedere la difficoltà immediata e seleziona i suggerimenti nell'intervallo di difficoltà produttivo, in cui il modello a volte ha successo e talvolta fallisce. Ciò massimizza la varianza dei risultati all'interno di ciascun gruppo di implementazione GRPO, producendo un segnale di vantaggio più elevato, una convergenza più rapida e una migliore stabilità dell'allenamento RL riducendo i rumorosi aggiornamenti del gradiente da richieste troppo facili o troppo difficili.

Come funziona il curriculum adattivo

Quando il curriculum adattivo è abilitato, il ciclo di formazione aggiunge una fase di previsione e selezione prima di ogni fase di implementazione:

Quando usare un curriculum adattivo

Il curriculum adattivo è più efficace nei seguenti scenari:

Configurazione del curriculum adattivo

Aggiungi il adaptive_curriculum blocco sotto trainer alla tua ricetta per abilitare l'apprendimento adattivo del curriculum:

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.

La tabella seguente descrive ogni parametro adattivo del curriculum:

Consigli per set di dati a lungo contesto

Il curriculum adattivo funziona eseguendo un leggero predittore del tasso di successo su un pool di richieste dei candidati e selezionando il batch più produttivo da implementare. Quando max_prompt_length è breve (qualche migliaio di token o meno), il predittore viene eseguito in pochi secondi per ogni passaggio di screening e le spese generali relative al curriculum sono trascurabili. Quando la lunghezza del prompt aumenta, il tempo di inferenza del predittore aumenta all'incirca in modo quadratico (l'attenzione è O (n²) nella lunghezza della sequenza), quindi lo screening può dominare la fase temporale sui set di dati in cui i prompt superano circa 8.000 token.

Le impostazioni seguenti mantengono il curriculum adattivo utilizzabile ed economico su set di dati a lungo termine. Applicatele insieme; riguardano diverse componenti dei costi di screening.

Esempio di configurazione ottimizzata per un set di dati a contesto lungo (circa 24-32K token prompt):

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

Preparazione dei dati per un curriculum adattivo

Quando si utilizza un curriculum adattivo, i dati di allenamento devono includere un predictor_prompt campo (o il nome del campo specificato inpredictor_prompt_column) contenente una versione concisa del testo del problema. Questo campo viene utilizzato dal pass-rate predittore per valutare rapidamente la difficoltà immediata senza elaborare l'intero contesto della conversazione.

Esempio di immissione JSONL con prompt predittivo:

{
  "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?"
}

Se il predictor_prompt campo non è presente, il sistema torna a utilizzare il prompt completo del campo. messages

Esempio completo di ricetta con curriculum adattivo

L'esempio seguente mostra una ricetta LoRa RFT completa con curriculum adattivo abilitato:

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

Monitoraggio del curriculum adattivo

Quando il curriculum adattivo è abilitato, vengono registrate metriche aggiuntive in ogni fase della formazione:

Funzionalità avanzate: Nova Forge

Per gli utenti che richiedono funzionalità avanzate oltre ai limiti RFT standard, Nova Forge è disponibile come servizio di abbonamento a pagamento che offre:

Nova Forge funziona SageMaker HyperPod ed è progettata per supportare i clienti aziendali nella creazione dei propri modelli di frontiera.

Comandi e suggerimenti utili

È disponibile una raccolta di script di osservabilità per aiutare a monitorare lo stato e l'avanzamento dei lavori di formazione.

Gli script disponibili sono:

Installazione

pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/

Utilizzo di base

# 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

Per ulteriori dettagli ed esempi, consulta questa pagina.