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 le RFT** Utilisez 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 : + Tâches où la qualité est subjective ou multidimensionnelle (écriture créative, optimisation du code, raisonnement complexe) + Scénarios comportant plusieurs solutions valides où certaines sont clairement meilleures que d'autres + Applications nécessitant une amélioration itérative, une personnalisation ou le respect de règles métier complexes + Cas où la collecte d'exemples étiquetés de haute qualité est coûteuse ou peu pratique **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 : + Résolution de problèmes mathématiques et génération de code + Raisonnement scientifique et analyse de données structurées + Tâches nécessitant un step-by-step raisonnement ou une résolution de problèmes en plusieurs étapes + Applications équilibrant plusieurs objectifs (précision, efficacité, style) + Scénarios dans lesquels le succès peut être vérifié par programmation par le biais de résultats d'exécution ou de mesures de performance **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.](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input) Chaque exemple d'entraînement est un objet JSON contenant : + Un `messages` tableau de tournants, d'utilisations `system` et `user` de rôles conversationnels + Un `reference_answer` champ contenant le résultat attendu ou les critères d'évaluation pour le calcul de la récompense **Limitations actuelles** + Texte uniquement ### 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** + Minimum de 100 exemples de formation + Minimum de 100 exemples d'évaluation **Approche axée sur l'évaluation** Avant d'investir dans une formation RFT à grande échelle, évaluez les performances de base de votre modèle : + **Haute performance (récompense supérieure à 95 %)** — Le RFT n'est peut-être pas nécessaire : votre modèle fonctionne déjà bien + **Très mauvaise performance (0 % de récompense)** — Passez d'abord à SFT pour établir les fonctionnalités de base + **Performances modérées** — le RFT est probablement approprié Commencer par un petit jeu de données vous permet de : + Validez que votre fonction de récompense est exempte de bogues + Confirmez que RFT est la bonne approche pour votre cas d'utilisation + Identifiez et corrigez les problèmes à un stade précoce + Testez le flux de travail avant de le mettre à l'échelle 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 : + Formatage incohérent + Étiquettes ou instructions contradictoires + Des instructions ambiguës + Réponses de référence contradictoires 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 : + Différents formats d'entrée et boîtiers + Cartographiez les modèles d'utilisation réels de la production à partir des journaux et des analyses des utilisateurs + Échantillonner selon les types d'utilisateurs, les régions géographiques et les variations saisonnières + Incluez des niveaux de difficulté allant des problèmes simples aux problèmes complexes **Considérations relatives aux fonctions de récompense** Concevez votre fonction de récompense pour un entraînement efficace : + Exécuter en quelques secondes (et non en quelques minutes) + Parallélisez efficacement avec Lambda + Obtenez des scores cohérents et fiables + Gérez les différents types de sorties de modèles avec élégance 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 (`messages`et`reference_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. **Note** Vous n'avez pas besoin de le configurer dans votre recette : le format de données prend en charge des champs supplémentaires par nature. Incluez-les simplement dans le JSON de vos données d'entraînement, et elles seront transmises à votre fonction de récompense `metadata` sur le terrain. **Propriétés supplémentaires communes** Exemples de champs de métadonnées : + `task_id`— Identifiant unique pour le suivi + `difficulty_level`— Indicateur de complexité du problème + `domain`— Domaine ou catégorie + `expected_reasoning_steps`— Nombre d'étapes de la solution **Exemple avec des 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:/// # 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) ``` ## 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** + none — Aucun raisonnement (omettez le champ reasoning\$1effort) + faible — Frais de raisonnement minimaux + high — Capacité de raisonnement maximale (par défaut lorsque reasoning\$1effort est spécifié) **Note** Il n'existe pas d'option moyenne pour le RFT. Si le champ reasoning\$1effort est absent de votre configuration, le raisonnement est désactivé. Lorsque le raisonnement est activé, vous devez le définir sur 32768 `max_new_tokens` pour prendre en compte les résultats de raisonnement étendus. **Quand utiliser chaque mode** Utilisez un raisonnement raisonné pour : + Tâches analytiques complexes + Résolution de problèmes mathématiques + Déduction logique en plusieurs étapes + Tâches où la step-by-step réflexion apporte une valeur ajoutée Utilisez none (omettez reasoning\$1effort) ou un raisonnement faible pour : + Des requêtes factuelles simples + Classifications directes + Optimisation de la vitesse et des coûts + Réponse simple aux questions **Compromis en termes de coûts et de performances** Les modes de raisonnement supérieurs augmentent : + Durée et coût de la formation + Latence et coût des inférences + Capacité de modélisation pour les tâches de raisonnement complexes ### 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 : + Mesurer les taux d'accord entre le juge LLM et les évaluateurs humains sur des échantillons représentatifs de votre tâche + Veiller à ce que l'accord du LLM avec les humains atteigne ou dépasse les taux de concordance interhumains + Identifier les biais potentiels dans le modèle de juge + Renforcer l'assurance que le signal de récompense oriente votre modèle dans la direction prévue 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 :** | Configuration | Exigence | Détails | | --- | --- | --- | | Débit d'Amazon Bedrock | Quota suffisant | Assurez-vous que votre quota de débit pour le modèle Amazon Bedrock utilisé est suffisant pour votre charge de travail de formation | | délai d’expiration Lambda | Délai d'attente prolongé | Configurez le délai d'expiration de votre fonction Lambda jusqu'à 15 minutes maximum. Le paramètre par défaut est de 3 secondes, ce qui est insuffisant pour les réponses du modèle Amazon Bedrock | | Simultanéité Lambda | Concurrence accrue | Le Lambda est invoqué en parallèle pendant l'entraînement. Augmentez la simultanéité pour optimiser le débit disponible | | Configuration de la recette | Correspond aux paramètres Lambda | La limite de simultanéité doit être configurée dans votre recette | ## Création et gestion d'emplois **Démarrage d'un poste de formation** Utilisez le modèle de carnet de tâches de SageMaker formation : [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) **Exigences relatives à l'instance** Le conteneur prend en charge à la fois les formations Full-Rank et LoRa : + **Entraînement LoRa — instances** 2/4/6/8 × p5.48xlarge ou p5en.48xlarge + **Entraînement complet :** 2/4/6/8 × instances p5.48xlarge (obligatoire) ## Formation en matière de surveillance Les journaux d'entraînement incluent des mesures complètes à chaque étape. Principales catégories de mesures : **Métriques de récompenses** + `critic/rewards/mean`,`critic/rewards/max`, `critic/rewards/min` — Distribution de récompenses + `val-score/rewards/mean@1`— Récompenses de validation **Comportement du modèle** + `actor/entropy`— Variation des politiques (plus élevée = plus exploratoire) **Santé de l'entraînement** + `actor/pg_loss`— Perte liée au gradient de politique + `actor/pg_clipfrac`— Fréquence des mises à jour découpées + `actor/grad_norm`— Ampleur du gradient **Caractéristiques de la réponse** + `prompt_length/mean`,`prompt_length/max`, `prompt_length/min` — Statistiques des jetons d'entrée + `response_length/mean`,`response_length/max`, `response_length/min` — Statistiques des jetons de sortie + `response/aborted_ratio`— Taux de génération incomplète (0 = tout est terminé) **Performances** + `perf/throughput`— Débit de formation + `perf/time_per_step`— Durée par étape d'entraînement + `timing_per_token_ms/*`— Délais de traitement par jeton **Utilisation des ressources** + `perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` — Mémoire GPU + `perf/cpu_memory_used_gb`— Mémoire du processeur ## 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 : + Journaux d'entraînement + `manifest.json`fichier dans l'emplacement de sortie Amazon S3 (défini par `output_s3_uri` dans votre bloc-notes) ## Limites et meilleures pratiques **Limites** + **Délai Lambda : les** fonctions de récompense doivent être terminées dans les 15 minutes (pour éviter les processus incontrôlables et gérer les coûts) + **Un tour uniquement** — Les conversations à plusieurs tours ne sont pas prises en charge + **Exigences en matière de données** — Nécessite une diversité suffisante ; peine à obtenir de maigres récompenses (< 5 % d'exemples positifs) + **Coût de calcul** : plus coûteux que le réglage fin supervisé + **Aucune donnée multimodale** : seul le type de données texte est pris en charge **Bonnes pratiques** **Commencez petit** + Commencez par 100 à 200 exemples + Valider l'exactitude de la fonction de récompense + Échelle progressive en fonction des résultats **Évaluation préalable à la formation** + Testez les performances du modèle de référence avant RFT + Si les récompenses sont toujours de 0 %, utilisez d'abord SFT pour établir les capacités de base + Si les récompenses sont supérieures à 95 %, le RFT peut être inutile **Surveiller l'entraînement** + Suivez les scores moyens des récompenses et leur distribution + Attention au surajustement (les récompenses d'entraînement augmentent tandis que les récompenses de validation diminuent) + Recherchez des modèles inquiétants : + Plafond des récompenses inférieur à 0,15 + Variation croissante des récompenses au fil du temps + Baisse des performances de validation **Optimisez les fonctions de récompense** + Exécuter en quelques secondes (et non en quelques minutes) + Minimiser les appels d'API externes + Utilisez des algorithmes efficaces + Mettre en œuvre une gestion appropriée des erreurs + Profitez de la mise à l'échelle parallèle de Lambda **Stratégie d'itération** Si les récompenses ne s'améliorent pas : + Ajuster le design des fonctions de récompense + Augmenter la diversité des jeux de données + Ajoutez des exemples plus représentatifs + Vérifiez que les signaux de récompense sont clairs et cohérents ## 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 : + Support de conversation à plusieurs tours + Fonctions de récompense avec un temps d'exécution supérieur à 15 minutes + Algorithmes et options de réglage supplémentaires + Modifications de recettes d'entraînement personnalisées + State-of-the-art Techniques d'IA Nova Forge fonctionne SageMaker HyperPod et est conçu pour aider les entreprises clientes à créer leurs propres modèles de pointe. ## Commandes et astuces utiles Une collection de [scripts d'observabilité](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring) est disponible pour aider à suivre l'état et la progression des tâches de formation. Les scripts disponibles sont les suivants : + Activation des notifications par e-mail pour les mises à jour du statut des tâches de formation + Obtenir des estimations du temps de formation en fonction de la configuration des tâches + Obtenir des estimations de la durée prévue de la formation pour les tâches en cours **Installation** **Note** Veillez à actualiser vos AWS informations d'identification avant d'utiliser l'un des scripts suivants. ``` 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](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md) pour plus de détails et d'exemples.