Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Réglage fin du renforcement (RFT) avec les modèles Amazon Nova

Présentation de

Qu'est-ce que le RFT ?

Le réglage fin par renforcement (RFT) améliore les performances du modèle en s'entraînant sur les signaux de feedback (scores mesurables ou récompenses indiquant les performances du modèle) plutôt que sur les bonnes réponses exactes. Contrairement au réglage fin supervisé qui apprend à partir de paires d'entrées-sorties, le RFT utilise des fonctions de récompense pour évaluer les réponses du modèle et optimise le modèle de manière itérative afin de maximiser ces récompenses. Cette approche excelle lorsqu'il est difficile de définir la sortie exacte correcte, mais vous pouvez mesurer de manière fiable la qualité de réponse.

Quand utiliser RFT

Utilisez la RFT lorsque vous pouvez définir des critères de réussite clairs et mesurables, mais que vous avez du mal à fournir des résultats exacts pour la formation. C'est idéal pour :

Meilleurs cas d'utilisation

La RFT excelle dans les domaines où la qualité de sortie peut être mesurée objectivement, mais où les réponses optimales sont difficiles à définir dès le départ :

Modèles pris en charge

Nova Lite 2.0

Vue d'ensemble des formats de données

Les données d'entraînement RFT doivent suivre le format OpenAI Reinforcement Fine-Tuning. Chaque exemple d'entraînement est un objet JSON contenant :

Limitations actuelles

Exemples de formats de données

Chaque exemple doit figurer sur une seule ligne de votre fichier JSONL, avec un objet JSON par ligne.

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

Le reference_answer champ contient le résultat attendu ou les critères d'évaluation que votre fonction de récompense utilise pour évaluer la réponse du modèle. Il ne se limite pas aux sorties structurées : il peut contenir n'importe quel format permettant à votre fonction de récompense d'évaluer la qualité.

Recommandations relatives à la taille des jeux

Point de départ

Approche axée sur l'évaluation

Avant d'investir dans une formation RFT à grande échelle, évaluez les performances de base de votre modèle :

Commencer par un petit jeu de données vous permet de :

Une fois validé, vous pouvez l'étendre à de plus grands ensembles de données pour améliorer encore les performances.

Caractéristiques des données d'entraînement efficaces

Clarté et cohérence

Les bons exemples de RFT nécessitent des données d'entrée claires et sans ambiguïté qui permettent un calcul précis des récompenses sur les différents modèles de sortie. Évitez le bruit dans vos données, notamment :

Toute ambiguïté induira le processus de formation en erreur et incitera le modèle à apprendre des comportements involontaires.

Diversité

Votre ensemble de données doit capturer toute la diversité des cas d'utilisation en production afin de garantir de solides performances réelles. Inclure :

Considérations relatives aux fonctions de récompense

Concevez votre fonction de récompense pour un entraînement efficace :

Des fonctions de récompense rapides et évolutives permettent une itération rapide et une expérimentation rentable.

Propriétés supplémentaires

Le format de données RFT prend en charge les champs personnalisés au-delà des exigences de base du schéma (messagesetreference_answer). Cette flexibilité vous permet d'ajouter toutes les données supplémentaires dont votre fonction de récompense a besoin pour une évaluation correcte.

Propriétés supplémentaires communes

Exemples de champs de métadonnées :

Exemple avec propriétés supplémentaires

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

Ces champs supplémentaires sont transmis à votre fonction de récompense lors de l'évaluation, ce qui permet une logique de notation sophistiquée adaptée à votre cas d'utilisation spécifique.

Configuration d’entraînement

Exemple de recette

# 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://<bucket>/<data file>      # Training dataset in JSONL;  
  replicas: 4  
  reward_lambda_arn: ""  
  
## 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 reward functions built into Verl [exact_match, code_executions, math_answers]  
      api_endpoint:  
        lambda_arn: ""  
        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  
    save_top_k: 5  
      
    # 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: 7e-7                       # 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)

Formation RFT utilisant le LLM en tant que juge

Présentation de

Les grands modèles linguistiques (LLMs) sont de plus en plus utilisés comme juges dans les flux de travail de réglage fin par renforcement (RFT), fournissant des signaux de récompense automatisés qui guident l'optimisation des modèles. Dans cette approche, un LLM évalue les résultats du modèle par rapport à des critères spécifiques, qu'il s'agisse d'évaluer l'exactitude, la qualité, le respect du style ou l'équivalence sémantique, et attribue des récompenses qui stimulent le processus d'apprentissage par renforcement.

Cela est particulièrement utile pour les tâches où les fonctions de récompense traditionnelles sont difficiles à définir par programmation, par exemple pour déterminer si différentes représentations (comme « 1/3 », « 0,333 » et « un tiers ») sont sémantiquement équivalentes, ou pour évaluer des qualités nuancées telles que la cohérence et la pertinence. En utilisant des juges basés sur le LLM comme fonctions de récompense, vous pouvez adapter RFT à des domaines complexes sans nécessiter d'annotations humaines approfondies, ce qui permet une itération rapide et une amélioration continue de vos modèles dans divers cas d'utilisation, au-delà des problèmes d'alignement traditionnels.

Sélection du mode de raisonnement

Modes disponibles

Quand utiliser chaque mode

Utilisez un raisonnement poussé pour :

Utilisez none (omettez reasoning_effort) ou un raisonnement faible pour :

Compromis en termes de coûts et de performances

Les modes de raisonnement supérieurs augmentent :

Validation de votre juge LLM

Avant de déployer un modèle LLM-as-a-judge en production, vérifiez que les évaluations du modèle de juge correspondent au jugement humain. Cela implique :

Cette étape de validation permet de garantir que le processus d'évaluation automatisé produira des modèles répondant à vos critères de qualité de production.

Configuration Lambda pour LLM Judge

L'utilisation d'un LLM en tant que juge est une extension de l'utilisation des fonctions Lambda pour l'apprentissage par renforcement avec récompenses vérifiables (RLVR). Dans la fonction Lambda, vous appelez l'un des modèles hébergés sur Amazon Bedrock.

Exigences de configuration importantes :

Création et gestion d'emplois

Démarrage d'un poste de formation

Utilisez le modèle de carnet SageMaker AI Training Job : https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook

Exigences relatives à l'instance

Le conteneur prend en charge à la fois les formations Full-Rank et LoRa :

Formation au suivi

Les journaux d'entraînement incluent des mesures complètes à chaque étape. Principales catégories de mesures :

Métriques de récompenses

Comportement du modèle

Santé de l'entraînement

Caractéristiques de la réponse

Performances

Utilisation des ressources

Utilisation de modèles affinés

Une fois l'entraînement terminé, le point de contrôle final du modèle est enregistré à l'emplacement de sortie que vous avez spécifié. Le chemin du point de contrôle est disponible en :

Limites et meilleures pratiques

Limites

Bonnes pratiques

Commencez petit

Évaluation préalable à la formation

Surveiller l'entraînement

Optimisez les fonctions de récompense

Stratégie d'itération

Si les récompenses ne s'améliorent pas :

Capacités avancées : Nova Forge

Pour les utilisateurs nécessitant des fonctionnalités avancées allant au-delà des limites standard du RFT, Nova Forge est disponible sous forme de service d'abonnement payant offrant :

Nova Forge fonctionne grâce à l' SageMaker intelligence artificielle HyperPod et est conçue pour aider les entreprises clientes à créer leurs propres modèles de pointe.

Commandes et astuces utiles

Une collection de scripts d'observabilité est disponible pour aider à suivre l'état et la progression des tâches de formation.

Les scripts disponibles sont les suivants :

Installation

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

Usage de 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

Cliquez ici pour plus de détails et d'exemples.