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.
# Formation pour les modèles Amazon Nova
L'entraînement des modèles Amazon Nova SageMaker HyperPod prend en charge plusieurs techniques, notamment la pré-formation continue (CPT), le réglage fin supervisé (SFT) et le réglage fin par renforcement (RFT). Chaque technique répond à des besoins de personnalisation différents et peut être appliquée à différentes versions de modèles Amazon Nova.
**Topics**
+ [Pré-entraînement continu (CPT)](nova-cpt.md)
+ [Peaufinage supervisé (SFT)](nova-fine-tune.md)
+ [Réglage précis du renforcement (RFT) activé SageMaker HyperPod](nova-hp-rft.md)
# Pré-entraînement continu (CPT)
La pré-formation continue (CPT) est une technique de formation qui prolonge la phase de pré-formation d'un modèle de base en l'exposant à du texte supplémentaire non étiqueté provenant de domaines ou de corpus spécifiques. Contrairement au réglage fin supervisé, qui nécessite des paires d'entrées-sorties étiquetées, le CPT s'entraîne sur des documents bruts pour aider le modèle à acquérir une connaissance plus approfondie de nouveaux domaines, à apprendre la terminologie et les modèles d'écriture spécifiques à un domaine, et à s'adapter à des types de contenu ou à des domaines particuliers.
Cette approche est particulièrement utile lorsque vous disposez de volumes importants (des dizaines de milliards de jetons) de données textuelles spécifiques à un domaine, telles que des documents juridiques, de la littérature médicale, de la documentation technique ou du contenu commercial propriétaire, et que vous souhaitez que le modèle développe une fluidité native dans ce domaine. Généralement, après la phase CPT, le modèle doit subir des étapes supplémentaires de réglage des instructions pour lui permettre d'utiliser les connaissances nouvellement acquises et d'effectuer des tâches utiles.
**Modèles pris en charge**
Le CPT est disponible pour les modèles Amazon Nova suivants :
+ Nova 1.0 (Micro, Lite, Pro)
+ Nova 2.0 (Lite)
**Quand utiliser Nova 1.0 par rapport à Nova 2.0**
La gamme de modèles Amazon Nova offre plusieurs points de fonctionnement en termes de rapport prix/performances afin d'optimiser la précision, la vitesse et le coût.
Choisissez Nova 2.0 lorsque vous avez besoin des éléments suivants :
+ Capacités de raisonnement avancées pour les tâches analytiques complexes
+ Performances supérieures en matière de codage, de mathématiques et de résolution de problèmes scientifiques
+ Support d'une plus longue durée de contexte
+ De meilleures performances multilingues
**Note**
Le modèle le plus grand n'est pas toujours meilleur. Tenez compte du compromis coût-performance et des exigences spécifiques de votre entreprise lorsque vous choisissez entre les modèles Nova 1.0 et Nova 2.0.
# CPT sur Nova 2.0
Amazon Nova Lite 2.0 est un modèle de raisonnement conçu sur des ensembles de données plus volumineux et plus diversifiés que Nova Lite 1.0. Bien qu'il s'agisse d'un modèle plus grand, Nova Lite 2.0 permet une inférence plus rapide que Nova Lite 1.0 tout en offrant des capacités de raisonnement améliorées, des longueurs de contexte plus longues et des performances multilingues améliorées.
CPT on Nova 2.0 vous permet d'étendre ces fonctionnalités avancées avec les données spécifiques à votre domaine, ce qui permet au modèle de développer une expertise approfondie dans des domaines spécialisés tout en conservant ses capacités de raisonnement et d'analyse supérieures.
## Exemple de recette CPT
Voici un exemple de recette pour le CPT. Vous pouvez trouver cette recette et d'autres dans le référentiel de [recettes](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/training/nova).
```
# Note:
# This recipe can run on p5.48xlarge
# Run config
run:
name: "my-cpt-run" # A descriptive name for your training job
model_type: "amazon.nova-2-lite-v1:0:256k" # Model variant specification, do not change
model_name_or_path: "nova-lite-2/prod" # Base model path, do not change
replicas: 8 # Number of compute instances for training, allowed values are 4, 8, 16, 32
data_s3_path: "" # Customer data paths
validation_data_s3_path: "" # Customer validation data paths
output_s3_path: "" # Output artifact path, job-specific configuration - not compatible with standard SageMaker Training Jobs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-cpt-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-cpt-run" # Optional for MLFlow. Note: leave this field non-empty
## Training specific configs
training_config:
task_type: cpt
max_length: 8192 # Maximum context window size (tokens)
global_batch_size: 256 # Global batch size, allowed values are 32, 64, 128, 256.
trainer:
max_steps: 10 # The number of training steps to run total
val_check_interval: 10 # The number of steps between running validation. Integer count or float percentage
limit_val_batches: 2 # Batches of the validation set to use each trigger
model:
hidden_dropout: 0.0 # Dropout for hidden states, must be between 0.0 and 1.0
attention_dropout: 0.0 # Dropout for attention weights, must be between 0.0 and 1.0
optim:
optimizer: adam
lr: 1e-5 # Learning rate
name: distributed_fused_adam # Optimizer algorithm, do not change
adam_w_mode: true # Enable AdamW mode
eps: 1e-06 # Epsilon for numerical stability
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Beta1 for Adam optimizer
adam_beta2: 0.95 # Beta2 for Adam optimizer
sched:
warmup_steps: 10 # Learning rate warmup steps
constant_steps: 0 # Steps at constant learning rate
min_lr: 1e-6 # Minimum learning rate, must be lower than lr
```
## Préparation des données pour le CPT on 2.0
**Exigences de format de données**
Les ensembles de données de formation et de validation doivent être des fichiers JSONL au format illustré ci-dessous, où chaque ligne contient un objet JSON représentant une conversation avec les champs et la structure requis. Voici un exemple :
```
{"text": "AWS stands for Amazon Web Services"}
{"text": "Amazon SageMaker is a fully managed machine learning service"}
{"text": "Amazon Bedrock is a fully managed service for foundation models"}
```
Les entrées de texte doivent contenir un contenu naturellement fluide et de haute qualité qui représente le domaine cible.
Vérifiez que les données peuvent être converties [au format Arrow](https://huggingface.co/docs/datasets/en/about_arrow). Utilisez le script python ci-dessous pour vous aider. Assurez-vous que la `datasets==2.18.0` version minimale est utilisée :
```
from datasets import load_dataset, load_from_disk
from pathlib import Path
input_path = Path("")
output_path = Path("")
dataset = load_dataset("json", data_files=str(input_path), split="train")
dataset.save_to_disk(str(output_path), max_shard_size="1GB")
try:
test_dataset = datasets.load_from_disk(output_dir)
print(f"Dataset loaded successfully ✅! Contains {len(test_dataset)} samples")
except Exception as e:
print(e)
```
Il devrait imprimer le même nombre de lignes que dans le fichier JSONL.
Lorsque vous utilisez le mixage de données, exécutez la première tâche avec. `max_steps=2` Cela permettra de créer des optimisations dans le cluster pour l'accès aux données et de vérifier que tous les mélanges de données sont disponibles.
**Comment préparer les données pour le CPT**
Les données d'entraînement sont le facteur déterminant le plus crucial pour le succès de la pré-formation continue. Bien que les données du CPT soient souvent décrites comme « non étiquetées », la réalité est bien plus nuancée. La manière dont les données sont structurées, formatées et présentées détermine si le modèle va acquérir les connaissances et les compétences requises pour le cas d'utilisation métier.
### Préparation d'ensembles de données métiers structurés pour le CPT
Il s'agit d'un défi courant pour les entreprises et les organisations qui élaborent des modèles de base spécialisés dans leur domaine. La plupart des entreprises possèdent de riches référentiels de données structurées : catalogues de produits, profils utilisateurs, journaux de transactions, soumissions de formulaires, appels d'API et métadonnées opérationnelles. À première vue, cela semble très différent du texte Web non structuré généralement utilisé dans le cadre de la pré-formation standard.
Pour tirer des leçons efficaces des données commerciales structurées, réfléchissez bien aux tâches en aval et concevez la présentation des données de manière à obliger le modèle à apprendre les bonnes relations prédictives.
Pour exploiter tout le potentiel de la pré-formation continue, pensez à :
+ Quelles tâches le modèle doit effectuer au moment de l'inférence
+ Quelles sont les informations présentes dans les données brutes
+ Comment structurer ces données afin que le modèle apprenne à les extraire et à les manipuler correctement
Le simple fait de transférer des données structurées dans la formation n'apprendra pas au modèle à raisonner à ce sujet. Donnez une forme active à la présentation des données afin de guider ce que le modèle apprend.
Dans les sections suivantes, une revue de la littérature démontre l'importance de l'augmentation des données et fournit des exemples de stratégies d'augmentation pour les données commerciales structurées qui donneront des idées utiles sur la façon de traiter et d'organiser un ensemble de données commerciales pour le CPT.
**Données structurées pour le CPT dans la littérature**
Le CPT peut intégrer les faits du domaine dans le modèle, mais échoue souvent à les rendre récupérables et manipulables lorsque les entrées ou les tâches changent. Des expériences contrôlées montrent que, sans augmentation variable pendant le préentraînement, les modèles mémorisent des faits de manière fragile qui restent difficiles à extraire même après un réglage ultérieur des instructions, et ils recommandent d'injecter des instructions sous forme de signaux au début de l'entraînement. Pour les données semi-structurées, la sérialisation aléatoire et d'autres augmentations réduisent le surajustement du schéma. C'est pourquoi le CPT doit être entrelacé avec des tâches de type instruction plutôt que d'être exécuté d'abord et IFT plus tard. Des travaux axés sur la finance révèlent en outre que le mélange conjoint des données CPT et des données d'instructions par lots améliore la généralisation et réduit l'oubli par rapport à la recette séquentielle. Le rapport technique de Qwen converge sur le même schéma en intégrant des données d'enseignement de haute qualité dans la préformation elle-même, ce qui stimule l'apprentissage contextuel et préserve le suivi des instructions tout en acquérant de nouvelles connaissances dans le domaine.
L'augmentation des données pour les corpus semi-structurés est un levier clé. Le CPT sensible aux graphes synthétiques étend les petits ensembles de domaines en corpus liés à des entités qui enseignent explicitement les relations et les composés en les extrayant au moment de l'inférence. Le mixage conjoint du CPT et des instructions surpasse les pipelines séquentiels dans le domaine de la finance et l'équilibre entre le domaine des données générales réduit la dégradation des compétences générales. Le CPT dans un domaine à très grande échelle peut également conserver une large capacité et même permettre des compromis grâce à la fusion de modèles, tout en indiquant que le réglage des instructions est la prochaine étape essentielle, renforçant ainsi l'intérêt de l'introduction de signaux d'instructions pendant le CPT.
**Insuffler de la diversité par le biais de la randomisation et du remaniement**
Une stratégie générale qui permet d'enseigner efficacement le modèle à partir des ensembles de données structurés et semi-structurés consiste à modifier l'ordre des champs dans les ensembles de données, voire à supprimer certaines clés de manière aléatoire.
Le remaniement des champs oblige le modèle à lire la signification de chaque valeur plutôt que l'endroit où elle apparaît et à apprendre les relations entre tous les champs. Par exemple, dans le cas d'un jeu vidéo publié sur Amazon Store, lorsque « Titre », « Plateforme », « Prix », « État » et « Édition » arrivent sous différentes formes, le modèle ne peut pas se fier au « troisième emplacement est la plateforme » ; il doit lier les étiquettes aux valeurs et connaître les relations bilatérales entre les attributs : titre, plateforme, prix, condition, prix. Ainsi, il peut, par exemple, déduire une plateforme probable à partir du nom d'un jeu et d'un prix observé, ou estimer une fourchette de prix plausible en fonction d'un titre et d'une plateforme.
La suppression aléatoire de clés lors de la sérialisation agit comme une suppression de fonctionnalités : elle empêche la co-adaptation sur un champ donné et oblige le modèle à récupérer les informations manquantes à partir des preuves restantes. Si le terme « Plateforme » est absent, le modèle doit le trouver dans la chaîne de titre ou dans le texte de compatibilité ; si le terme « Prix » est masqué, il doit être triangulé en fonction de la plate-forme, de l'édition et de l'état. Cela renforce la symétrie (A→B et B→A), la robustesse face aux listes compliquées du monde réel et l'invariance du schéma lorsque des champs sont manquants, renommés ou réorganisés.
Un exemple de style shopping le concrétise. Sérialisez le même article de plusieurs manières : « Titre : 'Elden Ring' \$1 Plateforme : PlayStation 5 \$1 État : usagé, comme neuf \$1 Prix : 34,99\$1 » et une permutation telle que « Prix : 34,99\$1 \$1 Titre : 'Elden Ring' \$1 État : usagé, comme neuf \$1 Plateforme : 5 ». Parfois, supprimez « Plateforme » tout en laissant « Compatible avec » dans la description. PlayStation PS5 Définissez des objectifs complémentaires tels que la prévision de la plateforme à partir de \$1title, price\$1 et la prédiction d'une tranche de prix à partir de \$1title, platform\$1. Étant donné que l'ordre et même la présence des clés varient, la seule stratégie stable consiste à apprendre les véritables relations entre les attributs plutôt que de mémoriser un modèle.
### La façon dont les données sont présentées est importante
LLMs apprenez en prédisant le jeton suivant à partir de ce qu'ils ont déjà vu. Ainsi, l'ordre des champs et des événements affichés pendant l'entraînement détermine ce que le modèle peut apprendre. Si le format d'entraînement correspond à la tâche réelle, la perte se répercute sur les jetons de décision exacts. Si les champs sont mélangés sans structure, le modèle apprend les raccourcis ou mémorise la popularité, puis échoue lorsqu'on lui demande de choisir parmi les options.
Montrez d'abord la situation, puis les options, puis la décision. Si le modèle doit également en apprendre davantage sur les résultats ou les explications, placez-les après la décision.
### Échantillons d'emballage pour CPT
**Qu'est-ce que l'emballage ?**
Cela signifie simplement de remplir chaque fenêtre de séquence des données d'entraînement avec plusieurs exemples complets afin que la fenêtre soit dense avec de vrais jetons, et non avec du remplissage.
**Pourquoi est-ce important ?**
Pendant l'entraînement, une longueur de contexte maximale est définie, par exemple 8 192 jetons. Les lots sont mis en forme selon [taille du lot × longueur du contexte]. Si un exemple d'entraînement est plus court que la durée du contexte, les positions restantes sont rembourrées. Le rembourrage passe toujours par l'attention et les noyaux MLP, même si la perte est masquée. Le calcul est donc payé pour des jetons qui ne transmettent aucun signal d'apprentissage.
**Comment emballer ?**
Pour regrouper plusieurs échantillons, concaténez plusieurs échantillons d'apprentissage avec un ` [DOC] ` séparateur entre les deux (notez l'espace avant et après le [DOC]) de telle sorte que la longueur totale des échantillons soit inférieure à la longueur de contexte souhaitée.
Voici un exemple de document compressé :
```
{"text": "training sample 1 [DOC] training sample 2 [DOC] training sample 3"}
```
### Paramètres de réglage CPT
Les paramètres disponibles pour un réglage précis avec le CPT sont les suivants :
**Configuration d'exécution**
+ **nom : nom** descriptif de votre poste de formation. Cela permet d'identifier votre tâche dans la console AWS de gestion.
+ **model\$1type** : variante du modèle Amazon Nova à utiliser. Les options disponibles sont les `amazon.nova-2-lite-v1:0:256k` suivantes :
+ **model\$1name\$1or\$1path : chemin vers** le modèle de base à utiliser pour votre entraînement. Les options disponibles sont`nova-lite-2/prod`, ou le chemin S3 pour le point de contrôle post-entraînement ()`s3://customer-escrow-bucket-unique_id/training_run_name`.
+ **répliques** : nombre d'instances de calcul à utiliser pour la formation distribuée. Les valeurs disponibles varient en fonction du modèle que vous choisissez. Amazon Nova Lite 2.0 prend en charge 4, 8, 16 ou 32 répliques.
+ **data\$1s3\$1path** : emplacement S3 du jeu de données d'entraînement, qui est un fichier JSONL. Ce fichier doit résider dans le même AWS compte et dans la même région que le cluster. Tous les emplacements S3 fournis doivent se trouver dans le même compte et la même région.
+ **validation\$1data\$1s3\$1path** : (Facultatif) L'emplacement S3 du jeu de données de validation, qui est un fichier JSONL. Ce fichier doit résider dans le même compte et la même région que le cluster. Tous les emplacements S3 fournis doivent se trouver dans le même compte et la même région.
+ **output\$1s3\$1path** : emplacement S3 où le manifeste et les journaux sont stockés. TensorBoard Tous les emplacements S3 fournis doivent se trouver dans le même AWS compte et dans la même AWS région.
+ **mlflow\$1tracking\$1uri** : l'ARN de l'application à utiliser pour la journalisation MLFlow MLFlow
+ **mlflow\$1experiment\$1name** : nom de l'expérience MLFlow
+ **mlflow\$1run\$1name : nom de l'exécution** MLFlow
**Configuration de la formation**
+ **max\$1length : longueur** de séquence maximale en jetons. Détermine la taille de la fenêtre contextuelle pour l’entraînement. La valeur maximale prise en charge est de 8 192 jetons pour le CPT.
Des séquences plus longues amélioreront l’efficacité de l’entraînement au prix d’une augmentation des exigences de mémoire. Nous vous recommandons de faire correspondre le paramètre max\$1length à la distribution de vos données.
+ **global\$1batch\$1size** : nombre total d'échantillons d'entraînement traités ensemble en un seul passage en avant ou en arrière sur tous les appareils et tous les travailleurs.
Cette valeur multiplie la taille du lot par appareil et le nombre d’appareils. Cela affecte la stabilité de l’entraînement et le débit. Nous vous recommandons de commencer par une taille de lot adaptée à la mémoire, puis d’augmenter verticalement à partir de là. Pour les données spécifiques à un domaine, des lots plus importants peuvent trop lisser les gradients.
**Paramètres de l'entraîneur**
+ **max\$1steps** : le nombre d'étapes d'entraînement à exécuter. Chaque étape entraînera le modèle avec le `global_batch_size` nombre d'éléments
**Réglages du modèle**
+ **hidden\$1dropout** : probabilité de supprimer les sorties d'état masquées. Augmentez cette valeur d’environ 0,0-0,2 pour réduire les surajustements sur de plus petits jeux de données. Les valeurs valides sont comprises entre 0 et 1 inclus.
+ **attention\$1dropout : probabilité de** perdre du poids d'attention. Ce paramètre peut faciliter la généralisation. Les valeurs valides sont comprises entre 0 et 1 inclus.
**Configuration de l'optimiseur**
+ **lr** : le taux d'apprentissage, qui contrôle la taille des étapes lors de l'optimisation. Nous recommandons des valeurs comprises entre 1e-6 et 1e-4 pour de bonnes performances. Les valeurs valides sont comprises entre 0 et 1 inclus.
+ **nom** : L'algorithme de l'optimiseur. Actuellement, seul `distributed_fused_adam` est pris en charge.
+ **weight\$1decay** : La force de régularisation L2. Des valeurs plus élevées (entre 0,01 et 0,1) augmentent la régularisation.
+ **warmup\$1steps** : nombre d'étapes pour augmenter progressivement le taux d'apprentissage. Cela améliore la stabilité de l’entraînement. Les valeurs valides sont comprises entre 1 et 20 inclus.
+ **min\$1lr** : Le taux d'apprentissage minimum à la fin de la décadence. Les valeurs valides sont comprises entre 0 et 1 inclus, mais doivent être inférieures au taux d’apprentissage.
# Peaufinage supervisé (SFT)
Le processus de formation SFT comprend deux étapes principales :
+ **Préparation des données** : suivez les directives établies pour créer, nettoyer ou reformater les ensembles de données selon la structure requise. Assurez-vous que les entrées, les sorties et les informations auxiliaires (telles que les traces de raisonnement ou les métadonnées) sont correctement alignées et formatées.
+ **Configuration de l'entraînement** : définissez la manière dont le modèle sera entraîné. Lors de l'utilisation, cette configuration est écrite dans un fichier de recette YAML qui inclut :
+ Chemins des sources de données (ensembles de données de formation et de validation)
+ Hyperparamètres clés (époques, taux d'apprentissage, taille du lot)
+ Composants optionnels (paramètres d'entraînement distribués, etc.)
## Comparaison et sélection des modèles Nova
Amazon Nova 2.0 est un modèle formé sur un ensemble de données plus vaste et plus diversifié qu'Amazon Nova 1.0. Les améliorations clés comprennent les suivantes :
+ **Capacités de raisonnement améliorées** avec prise en charge du mode de raisonnement explicite
+ **Performances multilingues étendues** dans d'autres langues
+ **Performances améliorées pour les tâches complexes**, notamment le codage et l'utilisation des outils
+ **Gestion étendue du contexte** avec une précision et une stabilité accrues à des longueurs de contexte plus longues
## Quand utiliser Nova 1.0 ou Nova 2.0
Choisissez Amazon Nova 2.0 lorsque :
+ Des performances supérieures associées à des capacités de raisonnement avancées sont nécessaires
+ Un support multilingue ou une gestion de tâches complexes sont nécessaires
+ De meilleurs résultats en matière de codage, d'appel d'outils ou de tâches analytiques sont nécessaires
# SFT sur Nova 2.0
Amazon Nova Lite 2.0 apporte des fonctionnalités améliorées pour un réglage précis supervisé, notamment un mode de raisonnement avancé, une meilleure compréhension multimodale et une gestion étendue du contexte. SFT on Nova 2.0 vous permet d'adapter ces puissantes fonctionnalités à vos cas d'utilisation spécifiques tout en maintenant les performances supérieures du modèle pour les tâches complexes.
Les principales fonctionnalités de SFT on Nova 2.0 incluent :
+ **Support du mode raisonnement** : entraînez des modèles pour générer des traces de raisonnement explicites avant les réponses finales pour des capacités analytiques améliorées.
+ **Formation multimodale avancée** : affinez la compréhension des documents (PDF), la compréhension vidéo et les tâches basées sur des images avec une précision accrue.
+ **Capacités d'appel d'outils** : entraînez les modèles à utiliser efficacement des outils externes et des fonctions nécessitant des flux de travail complexes.
+ **Support contextuel étendu** : tirez parti de fenêtres contextuelles plus longues avec une stabilité et une précision accrues pour les applications gourmandes en documents.
**Note**
Pour plus d'informations sur les images de conteneurs ou les exemples de recettes à utiliser, consultez les [recettes Amazon Nova](nova-model-recipes.md).
**Topics**
+ [Sélection du mode de raisonnement (Nova 2.0 uniquement)](#nova-sft-2-reasoning-mode)
+ [Format des données d'appel de l'outil](#nova-sft-2-tool-calling)
+ [Document comprenant le format des données](#nova-sft-2-document-understanding)
+ [Compréhension vidéo pour SFT](#nova-sft-2-video-understanding)
+ [Instructions de téléchargement des données](#nova-sft-2-data-upload)
+ [Création d'un Job de peaufinage](#nova-sft-2-creating-job)
+ [Paramètres de réglage SFT](#nova-sft-2-tuning-parameters)
+ [Guidage des hyperparamètres](#nova-sft-2-hyperparameters)
## Exemple de recette SFT
Vous trouverez ci-dessous un exemple de recette pour SFT. Vous pouvez trouver cette recette et d'autres dans le référentiel de [recettes](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova).
```
run:
name: my-full-rank-sft-run
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3://my-bucket-name/train.jsonl # only and not compatible with SageMaker Training Jobs
replicas: 4 # Number of compute instances for training, allowed values are 4, 8, 16, 32
output_s3_path: s3://my-bucket-name/outputs/ # Output artifact path (HyperPod job-specific; not compatible with standard SageMaker Training Jobs)
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-full-rank-sft-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-full-rank-sft-run" # Optional for MLFlow. Note: leave this field non-empty
training_config:
max_steps: 100 # Maximum training steps. Minimal is 4.
save_steps: ${oc.select:training_config.max_steps} # How many training steps the checkpoint will be saved
save_top_k: 5 # Keep top K best checkpoints. Note supported only for jobs. Minimal is 1.
max_length: 32768 # Sequence length (options: 8192, 16384, 32768 [default], 65536)
global_batch_size: 32 # Global batch size (options: 32, 64, 128)
reasoning_enabled: true # If data has reasoningContent, set to true; otherwise False
lr_scheduler:
warmup_steps: 15 # Learning rate warmup steps. Recommend 15% of max_steps
min_lr: 1e-6 # Minimum learning rate, must be between 0.0 and 1.0
optim_config: # Optimizer settings
lr: 1e-5 # Learning rate, must be between 0.0 and 1.0
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Exponential decay rate for first-moment estimates
adam_beta2: 0.95 # Exponential decay rate for second-moment estimates
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "null" # Disable LoRA for PEFT
```
## Sélection du mode de raisonnement (Nova 2.0 uniquement)
Amazon Nova 2.0 prend en charge le mode raisonnement pour des capacités analytiques améliorées :
+ **Mode de raisonnement (activé)** :
+ `reasoning_enabled: true`Paramétré dans la configuration d'entraînement
+ Modélisez des trains pour générer des traces de raisonnement avant les réponses finales
+ Améliore les performances lors de tâches de raisonnement complexes
+ **Mode sans raisonnement (désactivé)** :
+ Définir `reasoning_enabled: false` ou omettre le paramètre (par défaut)
+ SFT standard sans raisonnement explicite
+ Convient aux tâches qui ne bénéficient pas du step-by-step raisonnement
**Note**
Lorsque le raisonnement est activé, il fonctionne avec un effort de raisonnement élevé. Il n'existe pas d'option de faible raisonnement pour SFT.
Le contenu du raisonnement multimodal n'est pas pris en charge pour SFT. Le mode de raisonnement s'applique aux entrées contenant uniquement du texte.
### Utilisation du mode raisonnement avec des ensembles de données non raisonnés
L'entraînement d'Amazon Nova sur un ensemble de données non raisonné avec `reasoning_enabled: true` est autorisé. Cela risque toutefois de faire perdre au modèle ses capacités de raisonnement, car Amazon Nova apprend principalement à générer les réponses présentées dans les données sans appliquer de raisonnement.
Si vous entraînez Amazon Nova sur un ensemble de données non raisonné mais que vous souhaitez tout de même utiliser le raisonnement lors de l'inférence :
1. Désactiver le raisonnement pendant l'entraînement (`reasoning_enabled: false`)
1. Permettre le raisonnement ultérieurement lors de l'inférence
Bien que cette approche permette de raisonner au moment de l'inférence, elle ne garantit pas une amélioration des performances par rapport à l'inférence sans raisonnement.
**Bonne pratique :** activez le raisonnement à la fois pour l'entraînement et pour l'inférence lorsque vous utilisez des ensembles de données de raisonnement, et désactivez-le pour les deux lorsque vous utilisez des ensembles de données sans raisonnement.
**Note**
Pour plus d'informations sur les images de conteneurs ou les exemples de recettes à utiliser, consultez les [recettes Amazon Nova](nova-model-recipes.md).
## Format des données d'appel de l'outil
SFT prend en charge les modèles de formation à l'utilisation des outils (appel de fonctions). Vous trouverez ci-dessous un exemple de format de saisie pour l'appel d'outils :
**Exemple de saisie :**
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are an expert in composing function calls."
}
],
"toolConfig": {
"tools": [
{
"toolSpec": {
"name": "getItemCost",
"description": "Retrieve the cost of an item from the catalog",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"item_name": {
"type": "string",
"description": "The name of the item to retrieve cost for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to retrieve cost for"
}
},
"required": [
"item_id"
]
}
}
}
},
{
"toolSpec": {
"name": "getItemAvailability",
"description": "Retrieve whether an item is available in a given location",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"zipcode": {
"type": "string",
"description": "The zipcode of the location to check in"
},
"quantity": {
"type": "integer",
"description": "The number of items to check availability for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to check availability for"
}
},
"required": [
"item_id", "zipcode"
]
}
}
}
}
]
},
"messages": [
{
"role": "user",
"content": [
{
"text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"
}
}
},
{
"toolUse": {
"toolUseId": "getItemAvailability_0",
"name": "getItemAvailability",
"input": {
"zipcode": "94086",
"quantity": 20,
"item_id": "id-123"
}
}
}
]
},
{
"role": "user",
"content": [
{
"toolResult": {
"toolUseId": "getItemAvailability_0",
"content": [
{
"text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"
}
]
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"
}
]
}
]
}
```
Considérations importantes concernant les données relatives aux appels d'outils :
+ ToolUse doit apparaître uniquement dans les virages d'assistant
+ ToolResult doit apparaître uniquement au tour de l'utilisateur
+ ToolResult doit être uniquement en texte ou en JSON ; les autres modalités ne sont actuellement pas prises en charge pour les modèles Amazon Nova
+ L'InputSchema du ToolSpec doit être un objet de schéma JSON valide
+ Chacun ToolResult doit faire référence toolUseId à un assistant précédent valide ToolUse, toolUseId utilisé exactement une fois par conversation
**Note**
Pour plus d'informations sur les images de conteneurs ou les exemples de recettes à utiliser, consultez les [recettes Amazon Nova](nova-model-recipes.md).
## Document comprenant le format des données
SFT prend en charge les modèles de formation sur les tâches de compréhension des documents. Vous trouverez ci-dessous un exemple de format de saisie :
**Exemple d'entrée**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"document": {
"format": "pdf",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
],
"reasoning_content": [
{
"text": "I need to find the relevant section in the document to answer the question.",
"type": "text"
}
]
}
]
}
```
Considérations importantes pour la compréhension des documents :
+ Seuls les fichiers PDF sont pris en charge
+ La taille maximale du document est de 10 Mo
+ Un échantillon peut contenir des documents et du texte, mais ne peut pas mélanger des documents avec d'autres modalités (telles que des images ou des vidéos)
**Note**
Pour plus d'informations sur les images de conteneurs ou les exemples de recettes à utiliser, consultez les [recettes Amazon Nova](nova-model-recipes.md).
## Compréhension vidéo pour SFT
SFT prend en charge le réglage précis des modèles pour les tâches de compréhension vidéo. Vous trouverez ci-dessous un exemple de format de saisie :
**Exemple d'entrée**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
],
"reasoning_content": [
{
"text": "I need to find the relevant section in the video to answer the question.",
"type": "text"
}
]
}
]
}
```
Considérations importantes pour la compréhension de la vidéo :
+ Les vidéos peuvent atteindre un maximum de 50 Mo
+ Les vidéos peuvent durer jusqu'à 15 minutes
+ Une seule vidéo est autorisée par échantillon ; les vidéos multiples dans le même échantillon ne sont pas prises en charge
+ Un échantillon peut contenir de la vidéo et du texte, mais ne peut pas mélanger la vidéo avec d'autres modalités (telles que des images ou des documents)
**Note**
Pour plus d'informations sur les images de conteneurs ou les exemples de recettes à utiliser, consultez les [recettes Amazon Nova](nova-model-recipes.md).
## Instructions de téléchargement des données
Téléchargez des ensembles de données de formation et de validation dans un compartiment S3. Spécifiez les emplacements suivants dans le `run` bloc de la recette :
```
## Run config
run:
...
data_s3_path: "s3:////.jsonl"
```
**Remarque** : remplacez``,``, ````, et `` par des chemins S3 réels.
**Remarque** : Les ensembles de données de validation ne sont actuellement pas pris en charge pour SFT avec Amazon Nova 2.0. Si un ensemble de données de validation est fourni, il sera ignoré.
## Création d'un Job de peaufinage
Définissez le modèle de base à l'aide `model_name_or_path` des champs `model_type` et du `run` bloc :
```
## Run config
run:
...
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
...
```
## Paramètres de réglage SFT
Les paramètres disponibles pour le réglage avec SFT sont les suivants :
**Configuration d'exécution**
+ **nom : nom** descriptif de votre poste de formation. Cela permet d'identifier votre tâche dans la console AWS de gestion.
+ **model\$1type** : variante du modèle Amazon Nova à utiliser. Les options disponibles sont les `amazon.nova-2-lite-v1:0:256k` suivantes :
+ **model\$1name\$1or\$1path : chemin vers** le modèle de base à utiliser pour votre entraînement. Les options disponibles sont`nova-lite-2/prod`, ou le chemin S3 pour le point de contrôle post-entraînement ()`s3://customer-escrow-bucket-unique_id/training_run_name`.
+ **répliques** : nombre d'instances de calcul à utiliser pour la formation distribuée. Les valeurs disponibles varient en fonction du modèle que vous choisissez. Amazon Nova Lite 2.0 prend en charge 4, 8, 16 ou 32 répliques.
+ **data\$1s3\$1path** : emplacement S3 du jeu de données d'entraînement, qui est un fichier JSONL. Ce fichier doit résider dans le même AWS compte et dans la même région que le cluster. Tous les emplacements S3 fournis doivent se trouver dans le même compte et la même région.
+ **validation\$1data\$1s3\$1path** : (Facultatif) L'emplacement S3 du jeu de données de validation, qui est un fichier JSONL. Ce fichier doit résider dans le même compte et la même région que le cluster. Tous les emplacements S3 fournis doivent se trouver dans le même compte et la même région.
+ **output\$1s3\$1path** : emplacement S3 où le manifeste et les journaux sont stockés. TensorBoard Tous les emplacements S3 fournis doivent se trouver dans le même AWS compte et dans la même AWS région.
+ **mlflow\$1tracking\$1uri** : l'ARN de l'application à utiliser pour MLFlow la journalisation. MLFlow
+ **mlflow\$1experiment\$1name** : nom de l'expérience. MLFlow
+ **mlflow\$1run\$1name : nom de l'exécution**. MLFlow
**Configuration de la formation**
+ **max\$1steps** : le nombre d'étapes d'entraînement à exécuter. Chaque étape entraînera le modèle avec un `global_batch_size` certain nombre d'éléments.
+ **save\$1steps** : fréquence (en étapes) à laquelle enregistrer les points de contrôle du modèle pendant l'entraînement.
+ **save\$1top\$1k** : Le nombre maximum de meilleurs points de contrôle à conserver en fonction des métriques de validation.
+ **max\$1length : longueur** de séquence maximale en jetons. Détermine la taille de la fenêtre contextuelle pour l’entraînement. La valeur maximale prise en charge est de 32 768 jetons pour SFT.
Des séquences plus longues amélioreront l’efficacité de l’entraînement au prix d’une augmentation des exigences de mémoire. Nous vous recommandons de faire correspondre le paramètre max\$1length à la distribution de vos données.
+ **global\$1batch\$1size** : nombre total d'échantillons d'entraînement traités ensemble en un seul passage en avant ou en arrière sur tous les appareils et tous les travailleurs.
Cette valeur multiplie la taille du lot par appareil et le nombre d’appareils. Cela affecte la stabilité de l’entraînement et le débit. Nous vous recommandons de commencer par une taille de lot adaptée à la mémoire, puis d’augmenter verticalement à partir de là. Pour les données spécifiques à un domaine, des lots plus importants peuvent trop lisser les gradients.
+ **reasoning\$1enabled** : indicateur booléen pour activer les capacités de raisonnement pendant l'entraînement.
**Planificateur de taux d'apprentissage**
+ **warmup\$1steps** : nombre d'étapes pour augmenter progressivement le taux d'apprentissage. Cela améliore la stabilité de l’entraînement.
+ **min\$1lr** : Le taux d'apprentissage minimum à la fin de la décadence. Les valeurs valides sont comprises entre 0 et 1 inclus, mais doivent être inférieures au taux d’apprentissage.
**Configuration de l'optimiseur**
+ **lr** : le taux d'apprentissage, qui contrôle la taille des étapes lors de l'optimisation. Nous recommandons des valeurs comprises entre 1e-6 et 1e-4 pour de bonnes performances. Les valeurs valides sont comprises entre 0 et 1 inclus.
+ **weight\$1decay** : La force de régularisation L2. Des valeurs plus élevées (entre 0,01 et 0,1) augmentent la régularisation.
+ **adam\$1beta1** : Le taux de décroissance exponentiel pour les premières estimations dans l'optimiseur Adam. La valeur par défaut est 0,9.
+ **adam\$1beta2** : Le taux de décroissance exponentiel pour le deuxième instant est estimé dans l'optimiseur Adam. La valeur par défaut est 0,95.
**Configuration PEFT**
+ **peft\$1scheme : schéma de réglage** fin efficace en termes de paramètres à utiliser. Les options concernent `'null'` un réglage précis du rang complet ou un réglage précis basé sur `lora` LoRA.
**Réglage LoRa (lorsque peft\$1scheme est « lora »)**
+ **alpha** : paramètre de mise à l'échelle LoRa. Contrôle l'amplitude de l'adaptation de rang inférieur. Les valeurs typiques sont comprises entre 8 et 128.
+ **lora\$1plus\$1lr\$1ratio : taux** d'apprentissage pour l'optimisation LoRa\$1. Ce multiplicateur ajuste le taux d'apprentissage spécifiquement pour les paramètres LoRa.
## Guidage des hyperparamètres
Utilisez les hyperparamètres recommandés suivants en fonction de l'approche d'entraînement :
**Entraînement complet**
+ **Époques** : 1
+ **Taux d'apprentissage (lr)** : 1e-5
+ **Taux d'apprentissage minimal (min\$1lr)** : 1e-6
**LoRa (adaptation de bas rang)**
+ **Époques** : 2
+ **Taux d'apprentissage (lr)** : 5e-5
+ **Taux d'apprentissage minimal (min\$1lr)** : 1e-6
**Remarque** : ajustez ces valeurs en fonction de la taille du jeu de données et des performances de validation. Surveillez les indicateurs d'entraînement pour éviter le surajustement.
# Réglage précis du renforcement (RFT) activé SageMaker HyperPod
Le réglage fin par renforcement (RFT) est une technique d'apprentissage automatique qui améliore les performances des modèles grâce à des signaux de feedback (scores mesurables ou récompenses indiquant la qualité des réponses) plutôt qu'à une supervision directe avec des réponses exactes. Contrairement au réglage fin supervisé traditionnel 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 est particulièrement efficace pour les tâches où il est difficile de définir le résultat exact correct, mais vous pouvez mesurer de manière fiable la qualité de réponse. Le RFT permet aux modèles d'apprendre des comportements et des préférences complexes par le biais d'essais et de commentaires, ce qui le rend idéal pour les applications nécessitant une prise de décision nuancée, une résolution créative des problèmes ou le respect de critères de qualité spécifiques pouvant être évalués par programmation.
**Quand utiliser RFT**
Utilisez la RFT lorsque vous pouvez définir des critères de réussite clairs et mesurables, mais que vous avez du mal à fournir des résultats exacts pour la formation. Il est idéal pour les tâches où la qualité est subjective ou multidimensionnelle, telles que l'écriture créative, l'optimisation du code ou le raisonnement complexe, pour lesquelles plusieurs solutions valides existent, mais certaines sont clairement meilleures que d'autres.
Le RFT fonctionne mieux lorsque vous disposez des éléments suivants :
+ Une fonction de récompense fiable qui peut évaluer les résultats du modèle de manière programmatique
+ Nécessité d'aligner le comportement du modèle sur des préférences ou des contraintes spécifiques
+ Situations dans lesquelles le réglage minutieux supervisé traditionnel ne suffit pas parce que la collecte d'exemples étiquetés de haute qualité est coûteuse ou peu pratique
Envisagez le RFT pour les applications nécessitant une amélioration itérative, une personnalisation ou le respect de règles métier complexes pouvant être codées sous forme de signaux de récompense.
**À quoi convient le mieux le RFT**
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** : exactitude vérifiable avec plusieurs voies de résolution
+ **Génération et optimisation du code** : résultats d'exécution et indicateurs de performance testables
+ **Tâches de raisonnement scientifique** : cohérence logique et exactitude factuelle
+ **Analyse de données structurées** : résultats vérifiables par programmation
+ **Raisonnement en plusieurs étapes** : tâches nécessitant une progression step-by-step logique
+ **Utilisation des outils et appels d'API** : succès mesurable par les résultats d'exécution
+ **Flux de travail complexes** : respect de contraintes et de règles commerciales spécifiques
La RFT fonctionne exceptionnellement bien lorsque vous devez équilibrer plusieurs objectifs concurrents tels que la précision, l'efficacité et le style.
**Quand utiliser le mode raisonnement pour l'entraînement RFT**
Amazon Nova 2.0 prend en charge le mode raisonnement pendant l'entraînement RFT. Les modes suivants sont disponibles :
+ **none : aucun** raisonnement (omettez le champ reasoning\$1effort)
+ **faible** : surcharge de raisonnement minimale
+ **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é.
Utilisez un raisonnement raisonné pour ce qui suit :
+ 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 un raisonnement nul (omettez reasoning\$1effort) ou un raisonnement bas pour ce qui suit :
+ Des requêtes factuelles simples
+ Classifications directes
+ Optimisation de la vitesse et des coûts
+ Réponse simple aux questions
**Important**
Les modes de raisonnement avancés augmentent le temps et les coûts de formation, la latence et le coût des inférences, mais augmentent également la capacité du modèle à effectuer des tâches de raisonnement complexes.
**Modèles pris en charge**
RFT est onSageMaker HyperPod compatible avec Amazon Nova Lite 2.0 (amazon.nova-2-lite-v 1:0:256 k).
**Étapes majeures**
Le processus RFT comprend quatre phases clés :
+ **Implémentation d'un évaluateur** : créez une fonction de récompense pour évaluer de manière programmatique les réponses du modèle en fonction de vos critères de qualité.
+ Instructions de **téléchargement : préparez et téléchargez les** données d'entraînement dans le format conversationnel spécifié avec des données de référence à des fins d'évaluation.
+ **Démarrage d'une tâche** : lancez le processus de réglage précis du renforcement avec les paramètres que vous avez configurés.
+ **Surveillance** : suivez les progrès de la formation à l'aide de tableaux de bord de mesures pour garantir que le modèle apprend efficacement.
Chaque étape s'appuie sur la précédente, l'évaluateur servant de base qui guide l'ensemble du processus de formation en fournissant des signaux de feedback cohérents.
**Topics**
+ [RFT sur Nova 2.0](nova-hp-rft-nova2.md)
# RFT sur Nova 2.0
Les données d'entraînement RFT suivent le format conversationnel OpenAI. Chaque exemple de formation est un objet JSON contenant des messages, des réponses de référence et des définitions d'outils facultatives. Cette section fournit des conseils sur la préparation de données d'entraînement efficaces pour RFT sur Nova 2.0.
**Topics**
+ [Format et structure des données](#nova-hp-rft-data-format)
+ [Descriptions des champs](#nova-hp-rft-field-descriptions)
+ [Guidage des hyperparamètres](#nova-hp-rft-monitoring-hyperparams)
+ [Propriétés supplémentaires](#nova-hp-rft-additional-properties)
+ [Recommandations relatives à la taille des jeux](#nova-hp-rft-dataset-size)
+ [Caractéristiques des données d'entraînement efficaces](#nova-hp-rft-effective-data)
+ [Surveillance de la formation RFT](nova-hp-rft-monitoring.md)
## Format et structure des données
Chaque exemple d'entraînement est un objet JSON contenant les éléments suivants :
+ **messages** : un ensemble de tournants conversationnels utilisant les rôles système, utilisateur et éventuellement assistant
+ **reference\$1answer** : Résultat attendu ou critères d'évaluation pour le calcul des récompenses
+ **outils** (facultatif) : tableau de définitions de fonctions disponibles pour le modèle
+ **id** (facultatif) : identifiant unique pour le suivi et la déduplication
Chaque exemple doit figurer sur une seule ligne de votre fichier JSONL, avec un objet JSON par ligne.
### Exemple 1 : problème de chimie
L'exemple suivant montre un problème de chimie avec une réponse de référence contenant des valeurs de vérité fondamentale :
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4,
"explanation": "Calculated using Lipinski's rule of five: N-H groups (2 donors), N and O atoms with lone pairs (4 acceptors)"
}
}
```
**Note**
Le reference\$1answer contient des valeurs de vérité de base calculées à l'aide de règles spécifiques au domaine. Votre fonction de récompense compare les valeurs prédites du modèle à ces valeurs de référence pour calculer un score de récompense.
### Exemple 2 : problème mathématique
L'exemple suivant montre un problème mathématique avec des étapes de résolution :
```
{
"id": "math-001",
"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"]
}
}
```
### Exemple 3 : utilisation de l'outil
L'exemple suivant montre l'utilisation de l'outil avec le comportement attendu :
```
{
"id": "tool-001",
"messages": [
{
"role": "system",
"content": "You are a helpful game master assistant"
},
{
"role": "user",
"content": "Generate a strength stat for a warrior character. Apply a +2 racial bonus modifier."
}
],
"tools": [
{
"type": "function",
"function": {
"name": "StatRollAPI",
"description": "Generates character stats by rolling 4d6, dropping the lowest die result, and applying a modifier.",
"parameters": {
"type": "object",
"properties": {
"modifier": {
"description": "An integer representing the modifier to apply to the total of the stat roll.",
"type": "integer"
}
},
"required": ["modifier"]
}
}
}
],
"reference_answer": {
"tool_called": "StatRollAPI",
"tool_parameters": {
"modifier": 2
},
"expected_behavior": "Call StatRollAPI with modifier=2 and return the calculated stat value"
}
}
```
## Descriptions des champs
| Champ | Description | Informations complémentaires | Obligatoire |
| --- |--- |--- |--- |
| id | Identifiant unique pour cet exemple de RFT | Chaîne (par exemple, « sample-001 »). Utile pour le suivi et la déduplication. | Non |
| messages | Liste ordonnée des messages de chat qui définissent l'invite et le contexte | Tableau d'objets . Le mannequin les voit dans l'ordre. Commence généralement par un message système, puis par un message utilisateur. | Oui |
| messages [] .role | Qui parle dans le message | Valeurs communes : « système », « utilisateur » (parfois « assistant » dans d'autres contextes) | Non |
| messages [] .content | Le contenu textuel du message | Corde simple. Pour le système, il s'agit d'instructions, pour l'utilisateur, de la tâche ou de l'entrée. | Non |
| outils | Spécifications de l'outil disponibles pour le modèle dans cet exemple | Matrice. Chaque élément définit l'interface et les métadonnées d'un outil. Les types peuvent inclure « fonction » ou « interne ». | Non |
| réponse\$1référence | La sortie du modèle attendue pour cet exemple | Chaîne ou objet en fonction de la tâche. Utilisé comme cible pour l'évaluation ou la formation. | Non |
**Note**
Tous les champs personnalisés supplémentaires (par exemple, task\$1id, difficulty\$1level, context\$1data) ne sont pas validés et seront transmis à votre fonction de récompense sous forme de métadonnées.
## Guidage des hyperparamètres
Utilisez les hyperparamètres recommandés suivants en fonction de votre approche d'entraînement :
**Généralités :**
+ Époques : 1
+ Taux d'apprentissage (lr) : 1e-7
+ Nombre de générations : 8
+ Nombre maximum de nouveaux jetons : 8192
+ Taille du lot : 256
**LoRa (adaptation de bas rang) :**
+ Rang LoRa : 32
**Note**
Ajustez ces valeurs en fonction de la taille de votre jeu de données et des performances de validation. Surveillez les indicateurs d'entraînement pour éviter le surajustement.
## Propriétés supplémentaires
Le paramètre « AdditionalProperties » : true vous permet d'inclure des champs personnalisés au-delà des exigences de base du schéma, ce qui vous permet d'ajouter toutes les données dont votre fonction de récompense a besoin pour une évaluation correcte.
### Champs supplémentaires courants
Vous pouvez inclure les types de champs supplémentaires suivants :
**Métadonnées :**
+ task\$1id : identifiant unique pour le suivi
+ difficulty\$1level : indicateur de complexité du problème
+ domaine : Domaine ou catégorie
+ expected\$1reasoning\$1steps : nombre d'étapes de la solution
**Critères d'évaluation :**
+ evaluation\$1criteria : Rubriques de notation spécifiques
+ custom\$1scoring\$1weights : importance relative des différents aspects
+ context\$1data : informations générales sur le problème
+ external\$1references : liens vers la documentation ou les ressources pertinentes
### Exemple avec des propriétés supplémentaires
L'exemple suivant inclut des champs de métadonnées personnalisés :
```
{
"id": "algebra_001",
"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
}
```
## Recommandations relatives à la taille des jeux
### Point de départ
Commencez par les tailles de jeu de données minimales suivantes :
+ Minimum de 100 exemples de formation
+ Minimum de 100 exemples d'évaluation
Priorisez les données d'entrée de haute qualité et une fonction de récompense fiable qui s'exécute de manière cohérente sur les réponses du modèle.
### 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é
Cette approche axée sur l'évaluation garantit que votre fonction de récompense est exempte de bogues et détermine si la RFT est la bonne méthode pour votre cas d'utilisation. Commencer modestement vous permet de vous familiariser avec le flux de travail RFT, d'identifier et de résoudre les problèmes rapidement, de valider votre approche avant de passer à l'échelle supérieure et de tester la fiabilité de la fonction de récompense. 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 types de problèmes et niveaux de difficulté
+ Différents formats d'entrée et boîtiers
+ Échantillons représentatifs de tous les scénarios attendus
Cette diversité permet d'éviter le surajustement et garantit que le modèle gère les entrées inconnues avec élégance.
### 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 à grande échelle.
# Surveillance de la formation RFT
Surveillez les indicateurs clés pendant la formation pour garantir un apprentissage efficace et identifier rapidement les problèmes potentiels.
**Topics**
+ [Indicateurs clés à suivre](#nova-hp-rft-monitoring-metrics)
+ [Évaluation après RFT](#nova-hp-rft-monitoring-evaluation)
+ [Utilisation de modèles affinés](#nova-hp-rft-monitoring-checkpoints)
+ [Limites et meilleures pratiques](#nova-hp-rft-monitoring-limitations)
+ [Résolution des problèmes](#nova-hp-rft-monitoring-troubleshooting)
## Indicateurs clés à suivre
Surveillez les indicateurs suivants à l'aide de ces indicateurs MlFlow pendant l'entraînement :
**Indicateurs de récompenses :**
+ **Note de récompense moyenne** : qualité globale des réponses du modèle (devrait augmenter au fil du temps)
+ **Distribution des récompenses** : pourcentage de réponses recevant des récompenses élevées, moyennes et faibles
+ **Récompenses liées à la formation ou à la validation** : comparez pour détecter le surajustement
**Indicateurs de formation :**
+ **Mises à jour des politiques** : nombre de mises à jour du poids réussies
+ **Taux d'achèvement du déploiement** : pourcentage d'échantillons évalués avec succès
**En ce qui concerne les motifs :**
+ Plafond des récompenses (indique un mauvais apprentissage)
+ Les récompenses de validation diminuent tandis que les récompenses d'entraînement augmentent (surajustement)
+ La variance des récompenses augmente de manière significative au fil du temps (instabilité)
+ Pourcentage élevé d'erreurs liées à la fonction de récompense (problèmes de mise en œuvre)
**Quand arrêter l'entraînement :**
+ Les indicateurs de performance cibles sont atteints
+ Les récompenses plafonnent et ne s'améliorent plus
+ Les performances de validation se dégradent (surajustement détecté)
+ Le budget de formation maximal est atteint
## Évaluation après RFT
Une fois la formation terminée, évaluez votre modèle affiné pour évaluer les améliorations de performance :
+ **Exécuter une tâche d'évaluation RFT** : utilisez le point de contrôle de votre formation RFT comme modèle
+ **Comparaison à la base de référence** : évaluez à la fois le modèle de base et le modèle affiné sur le même ensemble de test
+ **Analyser les indicateurs** : passez en revue les indicateurs spécifiques aux tâches (précision, scores de récompense, etc.)
+ **Réaliser un examen qualitatif** : inspecter manuellement la qualité des échantillons de sortie
Pour les procédures d'évaluation détaillées, consultez la section Évaluation.
## Utilisation de modèles affinés
**Accès aux points de contrôle :**
Une fois la formation terminée, localisez votre point de contrôle :
1. Naviguez vers votre `output_path` dans S3
1. Téléchargez et extrayez `output.tar.gz`
1. Ouvrez `manifest.json`.
1. Copiez la `checkpoint_s3_bucket` valeur
**Déploiement à des fins d'inférence :**
Utilisez le chemin du point de contrôle S3 à des fins d'inférence ou de formation continue :
```
run:
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: "s3://customer-escrow--smtj-/"
```
Pour les instructions de déploiement et d'inférence, reportez-vous à la section Inférence.
## Limites et meilleures pratiques
**Limitations actuelles :**
**Restrictions relatives aux versions bêta**
+ Besoin de créer un nouveau groupe RIG pour RFT. Cette limitation sera résolue par GA.
+ Exigences relatives au type d'instance : seules les instances P5 sont prises en charge (minimum 8 instances P5.48xLarge). Prochainement : Support pour les types d'instances plus petits (ETA : mi-janvier 2025).
**Limites fonctionnelles :**
+ Délai Lambda de 15 minutes : les fonctions de récompense doivent être terminées dans les 15 minutes
+ Un tour uniquement : les conversations à plusieurs tours ne sont pas prises en charge
+ Ensembles de données de validation : non pris en charge pendant l'entraînement. Utilisez des tâches d'évaluation distinctes pour évaluer les progrès de la formation.
**Considérations relatives à la formation :**
+ Scénarios à faibles récompenses : cela peut être difficile lorsque moins de 5 % des exemples reçoivent des récompenses positives. Pensez d'abord à SFT
+ Exigences en matière de données : nécessite une diversité suffisante pour apprendre efficacement
+ Coût de calcul : plus coûteux que le réglage fin supervisé
**Nova Forge supprime certaines de ces limitations :**
+ Prend en charge les conversations à plusieurs tours
+ Permet aux fonctions de récompense de plus de 15 minutes
+ Fournit des algorithmes avancés et des options de réglage
+ Conçu pour les cas d'utilisation complexes en entreprise, spécialement conçu pour créer des modèles avant-gardistes
**Bonnes pratiques :**
**Commencez petit et agrandissez :**
+ Commencez avec un minimum d'ensembles de données (100 à 200 exemples) et peu d'époques d'entraînement
+ Validez votre approche avant de la mettre à l'échelle
+ Augmentez progressivement la taille de l'ensemble de données et les étapes d'entraînement en fonction des résultats
**Base de référence avec SFT d'abord :**
+ Si les scores de récompense sont constamment faibles (par exemple, toujours 0), effectuez SFT avant RFT
+ La RFT nécessite des performances de base raisonnables pour s'améliorer efficacement
**Concevez des fonctions de récompense efficaces :**
+ Exécuter en quelques secondes, et non en quelques minutes
+ Minimiser les appels d'API externes
+ Utiliser des algorithmes et des structures de données efficaces
+ Mettre en œuvre une gestion appropriée des erreurs
+ Faites des tests approfondis avant l'entraînement
+ Tirez parti des fonctionnalités de mise à l'échelle parallèle de Lambda
**Surveillez activement la formation :**
+ Suivez les scores de récompense moyens au fil du temps
+ Regardez la distribution des récompenses entre les échantillons
+ Comparez les récompenses de formation aux récompenses de validation
+ Recherchez les tendances inquiétantes (plateaux, surajustement, instabilité)
**Itérer en fonction des résultats :**
+ Si les récompenses ne s'améliorent pas après plusieurs itérations, ajustez le design de la fonction de récompense
+ Augmenter la diversité des ensembles de données pour fournir des signaux d'apprentissage plus clairs
+ Envisagez de passer à SFT si les récompenses restent proches de zéro
+ Expérimentez avec différents hyperparamètres (taux d'apprentissage, taille du lot)
**Optimisez la qualité des données :**
+ Garantir la diversité et la représentativité des exemples
+ Incluez des étuis de pointe et des échantillons difficiles
+ Vérifier que la fonction de récompense note correctement tous les types d'exemples
+ Supprimez ou corrigez les échantillons qui perturbent la fonction de récompense
## Résolution des problèmes
**Erreurs liées à la fonction de récompense :**
Symptômes : taux d'erreur élevé lors des appels à la fonction de récompense pendant l'entraînement
| Problème | Symptômes | Résolution |
| --- |--- |--- |
| délai d’expiration Lambda | Délais d'attente fréquents après 15 minutes | Optimisez les performances des fonctions ; considérez Nova Forge pour les évaluations complexes |
| Simultanéité insuffisante | Erreurs de régulation Lambda | Augmenter lambda\$1concurrency\$1limit ou demander une augmentation du quota |
| Format de retour non valide | L'entraînement échoue en raison d'erreurs de format | Vérifiez que la structure de retour correspond au format d'interface requis |
| Exceptions non gérées | Erreurs intermittentes | Ajoutez une gestion et une journalisation complètes des erreurs |
| Défaillances d'API externes | Notation incohérente | Mettre en œuvre une logique de nouvelle tentative et des stratégies de repli |
**Mauvaises performances d'entraînement :**
Symptômes : les récompenses ne s'améliorent pas ou plafonnent à de faibles valeurs
Résolutions :
+ **Vérifiez l'exactitude de la fonction de récompense** : testez avec des exemples connus good/bad
+ **Vérifiez les performances de référence** : évaluez le modèle de base ; si la précision est proche de zéro, effectuez d'abord le SFT
+ **Augmenter la diversité des données** : ajouter des exemples plus variés couvrant différents scénarios
+ **Ajustez les hyperparamètres** : essayez différents taux d'apprentissage ou différentes tailles de lots
+ **Vérifiez la qualité du signal de récompense** : assurez-vous que les récompenses font la différence entre les bonnes et les mauvaises réponses
**Surajustement :**
Symptômes : les récompenses d'entraînement augmentent tandis que les récompenses de validation diminuent
Résolutions :
+ **Réduisez le nombre d'étapes d'entraînement** : arrêtez l'entraînement plus tôt
+ **Augmenter la taille du jeu de données** : ajouter d'autres exemples de formation
+ **Ajouter une régularisation** : Ajuster ou `weight_decay` `entropy_coeff`
+ **Améliorez la diversité des données** : assurez-vous que le kit de formation représente une distribution complète