Présentation de Vue d'ensemble des formats de données Recommandations relatives à la taille des jeux Caractéristiques des données d'entraînement efficaces Propriétés supplémentaires Configuration d’entraînement Formation RFT utilisant le LLM en tant que juge Création et gestion d'emplois Formation en matière de surveillance Utilisation de modèles affinés Limites et meilleures pratiques Curriculum d'apprentissage adaptatif Capacités avancées : Nova Forge Commandes et astuces utiles

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

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 (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.

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://<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).

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

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.jsonfichier 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 :

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.
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.
Formation — La formation GRPO standard se poursuit selon les instructions sélectionnées.
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é danspredictor_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://<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

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é 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 pour plus de détails et d'exemples.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Préparation des données pour un réglage multimodal précis

Suivi des progrès au fil des itérations