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. # Renforcement Fine-Tuning (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é (SFT) 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 qu'il est difficile de fournir des résultats exacts pour la formation. Le RFT 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 raisonnement étape par étape 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 **Evaluation-first approche** 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. Il suffit de les inclure 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 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, 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:/// # 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:::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 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:::function: 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). ``` ## Formation RFT utilisant le LLM en tant que juge ### Présentation de Les grands modèles linguistiques (LLM) 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 LLM-based des juges comme fonctions de récompense, vous pouvez adapter la 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\_effort) + faible — Frais de raisonnement minimaux + high — Capacité de raisonnement maximale (par défaut lorsque reasoning\_effort est spécifié) **Note** Il n'existe pas d'option moyenne pour le RFT. Si le champ reasoning\_effort 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 + Multi-step déduction logique + Tâches où la réflexion étape par étape ajoute de la valeur Utilisez none (omettez reasoning\_effort) 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 les deux, Full-Rank ainsi que la formation LoRa : + **Entraînement LoRa — instances** 2/4/6/8 × p5.48xlarge ou p5en.48xlarge + **Full-Rank formation** — instances 2/4/6/8 × 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 Per-token de traitement **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 achevées dans les 15 minutes (pour éviter l'emballement des processus et gérer les coûts) + **Single-turn uniquement** — Multi-turn les conversations 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 **Pre-training évaluation** + 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 ## Curriculum d'apprentissage adaptatif L'apprentissage adaptatif par cursus est une fonctionnalité optionnelle qui sélectionne de manière dynamique les instructions de formation à présenter au modèle pendant le RFT. Au lieu de s'entraîner sur toutes les instructions de manière uniforme, le formateur utilise le modèle lui-même pour prévoir la difficulté immédiate et sélectionne les instructions dans la plage de difficulté productive, où le modèle réussit parfois, parfois échoue. Cela maximise la variation des résultats au sein de chaque groupe de déploiement du GRPO, ce qui produit un signal d'avantage plus élevé, une convergence plus rapide et une meilleure stabilité de l'entraînement RL en réduisant les mises à jour bruyantes du gradient causées par des instructions trop simples ou trop difficiles. ### Comment fonctionne un programme adaptatif Lorsque le programme adaptatif est activé, la boucle de formation ajoute une phase de prédiction et de sélection avant chaque étape de déploiement : 1. **Prédiction** — Le modèle prédit le taux de réussite (ou écart de récompense) pour chaque invite de candidature à l'aide d'un format de prédiction en plusieurs étapes. Trois exemples issus de l'étape de formation précédente (un facile, un moyen, un difficile) fournissent le contexte de l'étalonnage. 1. **Sélection** — Les invites sont classées en fonction de leur niveau de difficulté prévu par rapport à l'objectif de sélection (taux de réussite par défaut : 50 %). Les meilleures instructions sont approuvées pour le déploiement ; les autres sont ignorées sans nécessiter de calculs de déploiement. 1. **Formation** — La formation GRPO standard se poursuit selon les instructions sélectionnées. 1. **Feedback** — Les taux de réussite réels issus du déploiement sont comparés aux prévisions. La cible de sélection est étalonnée automatiquement pour corriger le biais de prédiction systématique. Un gradient REINFORCE entraîne le prédicteur pour améliorer les prévisions futures. ### Quand utiliser un programme adaptatif Le programme adaptatif est particulièrement efficace dans les scénarios suivants : + Vous souhaitez améliorer la stabilité de l'entraînement RL en vous assurant que chaque lot d'entraînement contient des instructions présentant une variation significative des récompenses, afin de réduire les mises à jour bruyantes du gradient susceptibles de déstabiliser l'apprentissage. + Vous avez confirmé que le RFT de base améliore votre métrique cible. + Vous souhaitez accélérer la convergence en concentrant le calcul d'entraînement sur les instructions les plus productives. + Votre jeu de données est volumineux (plus de 5 000 invites) et contient de nombreuses instructions hors de la plage de difficulté productive qui, autrement, gaspilleraient du temps de calcul. ### Configuration d'un programme adaptatif Ajoutez le `adaptive_curriculum` bloc ci-dessous `trainer` dans votre recette pour activer l'apprentissage adaptatif par 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. ``` Le tableau suivant décrit chaque paramètre du programme adaptatif : | Paramètre | Type | Par défaut | Description | | --- | --- | --- | --- | | enable | Booléen | false | S'il faut activer la sélection rapide des programmes adaptatifs. | | selection\_pool\_multiplier | Entier (1 à 32) | 8 | Contrôle le nombre d'invites attribuées aux candidats par rapport à la taille du lot d'entraînement. Une valeur de 8 signifie que 8 global\_batch\_size instructions sont notées et que les meilleures global\_batch\_size sont sélectionnées. Des valeurs plus élevées offrent une meilleure qualité de sélection mais coûtent plus cher en termes de calcul d'inférence. | | prediction\_mode | String | pass\_rate | Mode de prédiction pour une estimation rapide de la difficulté. pass\_rateÀ utiliser pour des tâches de récompense discrètes (par exemple, vérification de l'exactitude) où le prédicteur estime la probabilité d'une bonne réponse. spreadÀ utiliser pour les tâches de récompense continues où le prédicteur estime l'écart de récompense max−min entre les déploiements. | | exemplar\_history\_steps | Entier (≥1) | 1 | Nombre d'étapes d'entraînement précédentes à conserver dans la mémoire tampon de l'historique continu pour la sélection des exemplaires. Le prédicteur utilise des exemples tirés de cet historique pour calibrer ses prédictions basées sur quelques clichés. | | reinforce\_coef | Numéro (≥0) | 0.01 | Facteur d'échelle pour la perte REINFORE qui entraîne le prédicteur du taux de réussite. Cela permet un apprentissage en boucle fermée où le prédicteur améliore sa précision au cours de l'entraînement. Réglez sur 0 pour désactiver l'entraînement des prédicteurs. | | predictor\_prompt\_column | String | predictor\_prompt | Nom du champ de l'ensemble de données contenant le texte propre du problème utilisé comme invite de prédiction. Il doit s'agir d'une version concise du problème, sans instructions ni formatage du système, afin que le prédicteur puisse rapidement évaluer la difficulté. | | selection\_lookahead\_steps | Entier (1 à 16) | 4 | Nombre de futurs lots de formation à préapprouver dans le cadre d'un seul programme de sélection par étape. Chaque réussite permet de selection\_pool\_multiplier × global\_batch\_size noter les candidats par étape ; des valeurs plus élevées de selection\_lookahead\_steps répétition sont répétées plusieurs fois pour créer une file d'instructions approuvées, ce qui réduit la surcharge des prédicteurs par étape sur les ensembles de données de courtes demandes. Pour les ensembles de données contextuels longs où le prédicteur lui-même est coûteux (voir la section des recommandations), configurez-le de 1 telle sorte que le prédicteur ne s'exécute qu'une seule fois par étape. | ### Recommandations pour les ensembles de données contextuels longs Le programme adaptatif fonctionne en exécutant un prédicteur léger du taux de réussite sur un pool d'invites de candidats et en sélectionnant le lot le plus productif à déployer. En cas `max_prompt_length` de pénurie (quelques milliers de jetons ou moins), le prédicteur s'exécute en quelques secondes par passe de dépistage et la surcharge du programme est négligeable. Lorsque la longueur de l'invite augmente, le temps d'inférence du prédicteur augmente approximativement de façon quadratique (l'attention est égale à O (n²) dans la longueur de la séquence), de sorte que le filtrage peut dominer le temps d'étape sur les ensembles de données où les invites dépassent environ 8 000 jetons. **Note** Le programme adaptatif est pris en charge pour `max_prompt_length` un maximum de 32 768 jetons (32 Ko). Son activation sur des ensembles de données dépassant cette longueur n'est pas prise en charge ; désactivez le programme adaptatif ou raccourcissez les instructions avant l'entraînement. Les paramètres ci-dessous permettent aux programmes adaptatifs d'être utilisables et rentables sur des ensembles de données contextuels longs. Appliquez-les ensemble ; ils abordent les différentes composantes du coût du dépistage. | Typique `max_prompt_length` | Paramètres de programme adaptatifs recommandés | | --- | --- | | Jusqu'à 8 000 jetons | Utiliser les valeurs par défaut :selection\_pool\_multiplier: 8,selection\_lookahead\_steps: 4. Les frais de filtrage sont faibles et ne nécessitent aucun réglage. | | Plus de 8 000 et jusqu'à 16 000 jetons | Configurez selection\_lookahead\_steps: 2. Cela réduit de moitié le nombre de passages du prédicteur par étape tout en conservant suffisamment d'instructions préapprouvées dans la file d'attente pour éviter de perdre du temps lors du déploiement. | | Plus de 16 000 et jusqu'à 24 000 jetons | Maintenez selection\_lookahead\_steps: 2 et abaissez selection\_pool\_multiplier jusqu'à4. Le plus petit pool réduit de moitié la taille du lot prédictif au détriment de la qualité de la sélection ; ensemble, ces facteurs limitent le temps de sélection par étape. | | Plus de 24 000 et jusqu'à 32 000 jetons | Utilisez selection\_pool\_multiplier: 4 avec selection\_lookahead\_steps: 1. Le prédicteur s'exécute une fois par étape d'entraînement sur un pool de taille minimale. Il s'agit du paramètre le plus agressif pris en charge ; les dépassements de 32 Ko ne sont pas pris en charge. | Exemple de configuration adaptée à un jeu de données contextuel long (environ 24 000 à 32 000 demandes de jetons) : ``` 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 ``` ### Préparation des données pour un programme adaptatif Lorsque vous utilisez un programme adaptatif, vos données d'entraînement doivent inclure un `predictor_prompt` champ (ou le nom du champ spécifié dans`predictor_prompt_column`) contenant une version concise du texte du problème. Ce champ est utilisé par le prédicteur du taux de réussite pour évaluer rapidement la difficulté rapide sans traiter le contexte complet de la conversation. Exemple d'entrée JSONL avec invite de prédiction : ``` { "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?" } ``` Si le `predictor_prompt` champ n'est pas présent, le système recommence à utiliser l'invite complète du `messages` champ. ### Exemple de recette complet avec programme adaptatif L'exemple suivant montre une recette LoRa RFT complète avec un programme adaptatif activé : ``` 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:/// replicas: 4 generation_replicas: 2 reward_lambda_arn: arn:aws:lambda:::function: 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 ``` ### Surveillance des programmes adaptatifs Lorsque le programme adaptatif est activé, des mesures supplémentaires sont enregistrées à chaque étape de la formation : + Taux de **réussite prévu par rapport au taux de réussite réel** : taux de réussite moyen prévu pour les instructions sélectionnées par rapport au taux de réussite réel observé après le déploiement. Un écart important indique que le prédicteur a besoin d'un temps d'étalonnage plus long. + **Cible de sélection : cible** de sélection calibrée automatiquement actuelle. Cela commence à 0,5 et s'ajuste en fonction de la précision des prévisions. + **Nombre de filtres de maîtrise** : nombre d'instructions exclues car le modèle les a constamment maîtrisées. **Note** Les 1 à 2 premières étapes d'apprentissage s'exécutent sans sélection adaptative (le prédicteur a besoin d'au moins une étape d'historique pour créer des exemplaires). La sélection adaptative complète commence à l'étape 3. ## 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 : + Multi-turn aide à la conversation + 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 des configurations de travail + 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.