View a markdown version of this page

Évaluation RFT - Amazon Nova

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.

Évaluation RFT

Qu'est-ce que l'évaluation RFT ?

L'évaluation RFT vous permet d'évaluer les performances de votre modèle à l'aide de fonctions de récompense personnalisées avant, pendant ou après l'entraînement par apprentissage par renforcement. Contrairement aux évaluations standard qui utilisent des mesures prédéfinies, l'évaluation RFT vous permet de définir vos propres critères de réussite grâce à une fonction Lambda qui note les résultats du modèle en fonction de vos besoins spécifiques.

Pourquoi évaluer avec RFT ?

L'évaluation est cruciale pour déterminer si le processus d'ajustement du RL a :

  • Alignement amélioré du modèle avec votre cas d'utilisation spécifique et vos valeurs humaines

  • Capacités du modèle maintenues ou améliorées pour les tâches clés

  • Effets secondaires imprévus évités tels qu'une réduction de la factualité, une augmentation de la verbosité ou une dégradation des performances sur d'autres tâches

  • Répond à vos critères de réussite personnalisés tels que définis par votre fonction de récompense

Quand utiliser l'évaluation RFT

Utilisez l'évaluation RFT dans les scénarios suivants :

  • Avant la formation RFT : établissez des mesures de base sur votre ensemble de données d'évaluation

  • Pendant la formation RFT : surveillez la progression de l'entraînement à l'aide de points de contrôle intermédiaires

  • Après la formation RFT : vérifiez que le modèle final répond à vos exigences

  • Comparaison de modèles : évaluez plusieurs versions de modèles en utilisant des critères de récompense cohérents

Note

Utilisez RFT Evaluation lorsque vous avez besoin de métriques personnalisées et spécifiques à un domaine. Pour une évaluation générale (précision, perplexité, BLEU), utilisez des méthodes d'évaluation standard.

Exigences de format de données

Structure des données d'entrée

Les données d'entrée de l'évaluation RFT doivent suivre le format OpenAI Fine-Tuning Reinforcment. Chaque exemple est un objet JSON contenant :

  • messages— Éventail de tournants de conversation avec system et de rôles user

  • reference_answer— Résultats attendus ou données de base utilisées par votre fonction de récompense pour la notation

Exemple de format de données

{ "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Solve for x. Return only JSON like {\"x\": <number>}. Equation: 2x + 5 = 13" } ] } ], "reference_answer": { "x": 4 } }

Limitations actuelles

  • Texte uniquement : aucune entrée multimodale (images, audio, vidéo) n'est prise en charge

  • Single-turn conversations : ne prend en charge que les messages d'un seul utilisateur (pas de dialogues à plusieurs tours)

  • Format JSON : les données d'entrée doivent être au format JSONL (un objet JSON par ligne)

  • Sorties du modèle : l'évaluation est effectuée sur les complétions générées à partir du modèle spécifié

Préparation de votre recette d'évaluation

Exemple de bloc-notes

Pour un exemple complet, voir Carnets https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook d'évaluation.

Exemple de configuration de recette

run: name: nova-lite-rft-eval-job model_type: amazon.nova-lite-v1:0:300k model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in SageMaker Python SDK output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results evaluation: task: rft_eval # [FIXED] Do not modify strategy: rft_eval # [FIXED] Do not modify metric: all # [FIXED] Do not modify # Inference Configuration inference: max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate top_k: -1 # [MODIFIABLE] Top-k sampling parameter top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic) top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output # ============================================================================= # Bring Your Own Reinforcement Learning Environment # ============================================================================= rl_env: reward_lambda_arn: arn:aws:lambda:<region>:<account_id>:function:<reward-function-name>

Fonctions de récompense prédéfinies

Deux fonctions de récompense prédéfinies (prime_codeetprime_math) sont disponibles sous forme de couche Lambda pour une intégration facile avec vos fonctions Lambda RFT.

Vue d’ensemble

Ces fonctions prédéfinies fournissent des fonctionnalités d'évaluation prêtes à l'emploi pour :

  • prime_code— Génération de code et évaluation de l'exactitude

  • prime_math— Raisonnement mathématique et évaluation de la résolution de problèmes

Configuration rapide

  1. Téléchargez la couche Lambda à partir des versions de nova-custom-eval-sdk.

  2. Publiez la couche Lambda à l'aide de l'interface de ligne de AWS commande (AWS CLI) :

    aws lambda publish-layer-version \ --layer-name preset-function-layer \ --description "Preset reward function layer with dependencies" \ --zip-file fileb://universal_reward_layer.zip \ --compatible-runtimes python3.9 python3.10 python3.11 python3.12 \ --compatible-architectures x86_64 arm64
  3. Ajoutez la couche à votre fonction Lambda dans AWS Management Console (sélectionnez la couche de fonction prédéfinie dans la couche personnalisée et AWSSDKPandas-Python312 ajoutez-la également pour les dépendances numpy).

  4. Importez et utilisez dans votre code Lambda :

    from prime_code import compute_score # For code evaluation from prime_math import compute_score # For math evaluation

fonction prime_code

Évalue les tâches de génération de code Python en exécutant le code par rapport à des cas de test et en mesurant l'exactitude.

Exemple de format de jeu de données en entrée

{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}} {"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}

Fonctions principales

  • Extraction automatique de code à partir de blocs de code Markdown

  • Détection des fonctions et tests basés sur les appels

  • Exécution de scénarios de test avec protection contre le délai d'attente

  • Validation de la syntaxe et contrôles de compilation

  • Rapports d'erreurs détaillés avec traçabilité

fonction prime_math

Évalue les capacités de raisonnement mathématique et de résolution de problèmes à l'aide d'un support mathématique symbolique.

Format d'entrée

{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}

Fonctions principales

  • Évaluation mathématique symbolique à l'aide de SymPy

  • Formats de réponses multiples (LaTeX, texte brut, symbolique)

  • Vérification de l'équivalence mathématique

  • Normalisation et simplification des expressions

Exigences de format de données

Pour l'évaluation du code

  • Entrées : tableau d'arguments de fonction (types appropriés : entiers, chaînes, etc.)

  • Sorties : tableau des valeurs de retour attendues (types appropriés : booléens, nombres, etc.)

  • Code : Doit être en Python avec des définitions de fonctions claires

Pour l'évaluation des mathématiques

  • Réponse de référence : expression mathématique ou valeur numérique

  • Réponse : Il peut s'agir d'un LaTe X, d'un texte brut ou d'une notation symbolique

  • Équivalence : vérifiée symboliquement, pas seulement une correspondance de chaînes

Bonnes pratiques

  • Utilisez les types de données appropriés dans les cas de test (entiers contre chaînes, booléens contre « True »)

  • Fournir des signatures de fonction claires dans les problèmes de code

  • Inclure des cas limites dans les entrées de test (zéro, nombres négatifs, entrées vides)

  • Formater les expressions mathématiques de manière cohérente dans les réponses de référence

  • Testez votre fonction de récompense à l'aide d'exemples de données avant le déploiement

Gestion des erreurs

Les deux fonctions incluent une gestion robuste des erreurs pour :

  • Erreurs de compilation dans le code généré

  • Exceptions d'exécution pendant l'exécution

  • Données d'entrée mal formées

  • Scénarios de temporisation pour des boucles infinies

  • Expressions mathématiques non valides

Création de votre fonction de récompense

Exigences relatives à l'ARN Lambda

Votre ARN Lambda doit suivre le format suivant :

"arn:aws:lambda:*:*:function:*SageMaker*"

Si le Lambda ne possède pas ce schéma de dénomination, la tâche échouera avec l'erreur suivante :

[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)

Format de requête Lambda

Votre fonction Lambda reçoit des données au format suivant :

[ { "id": "sample-001", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Do you have a dedicated security team?" } ] }, { "role": "nova_assistant", "content": [ { "type": "text", "text": "As an AI developed by Company, I don't have a dedicated security team..." } ] } ], "reference_answer": { "compliant": "No", "explanation": "As an AI developed by Company, I do not have a traditional security team..." } } ]
Note

La structure du message inclut le content tableau imbriqué, correspondant au format des données d'entrée. Le dernier message avec rôle nova_assistant contient la réponse générée par le modèle.

Format de réponse Lambda

Votre fonction Lambda doit renvoyer des données au format suivant :

[ { "id": "sample-001", "aggregate_reward_score": 0.75, "metrics_list": [ { "name": "accuracy", "value": 0.85, "type": "Metric" }, { "name": "fluency", "value": 0.90, "type": "Reward" } ] } ]

Champs de réponse

  • id— Doit correspondre à l'identifiant de l'échantillon d'entrée

  • aggregate_reward_score— Note globale (généralement de 0,0 à 1,0)

  • metrics_list— Tableau de mesures individuelles avec :

    • name— Identifiant métrique (par exemple, « précision », « fluidité »)

    • value— Score métrique (généralement de 0,0 à 1,0)

    • type— Soit « Métrique » (pour les rapports) soit « Récompense » (utilisée lors de la formation)

Autorisations IAM

Autorisations requises

Votre rôle SageMaker d'exécution doit être autorisé à invoquer votre fonction Lambda. Ajoutez cette politique à votre rôle SageMaker d'exécution :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "arn:aws:lambda:region:account-id:function:function-name" } ] }

Rôle d’exécution Lambda

Le rôle d'exécution de votre fonction Lambda nécessite des autorisations d'exécution Lambda de base :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": "arn:aws:logs:*:*:*" } ] }

Si votre fonction Lambda accède à d'autres AWS services (par exemple, S3 pour les données de référence, DynamoDB pour la journalisation), ajoutez ces autorisations au rôle d'exécution Lambda.

Exécution de la tâche d'évaluation

  1. Préparez vos données — Formatez vos données d'évaluation conformément aux exigences en matière de format de données et téléchargez votre fichier JSONL sur S3 : s3://your-bucket/eval-data/eval_data.jsonl

  2. Configurez votre recette — Mettez à jour l'exemple de recette en fonction de votre configuration :

    • Réglez model_name_or_path en fonction de l'emplacement de votre modèle

    • Réglez lambda_arn sur l'ARN de votre fonction de récompense

    • output_s3_pathRéglez sur l'emplacement de sortie souhaité

    • Ajustez inference les paramètres selon les besoins

    Enregistrez la recette sous rft_eval_recipe.yaml

  3. Exécuter l'évaluation — Exécutez la tâche d'évaluation à l'aide du bloc-notes fourni : Carnets d'évaluation

  4. Suivez les progrès — Surveillez votre travail d'évaluation grâce à :

    • SageMaker Console : vérifier l'état des tâches et les journaux

    • CloudWatch Journaux : Afficher les journaux d'exécution détaillés

    • Lambda Logs : problèmes liés à la fonction de récompense de débogage

Comprendre les résultats de l'évaluation

Format de sortie

La tâche d'évaluation génère les résultats vers l'emplacement S3 que vous avez spécifié au format JSONL. Chaque ligne contient les résultats de l'évaluation d'un échantillon :

{ "id": "sample-001", "aggregate_reward_score": 0.75, "metrics_list": [ { "name": "accuracy", "value": 0.85, "type": "Metric" }, { "name": "fluency", "value": 0.90, "type": "Reward" } ] }
Note

La sortie de la tâche d'évaluation RFT est identique au format de réponse Lambda. Le service d'évaluation transmet la réponse de votre fonction Lambda sans modification, garantissant ainsi la cohérence entre vos calculs de récompenses et les résultats finaux.

Interprétation des résultats

Score de récompense global

  • Plage : généralement 0,0 (pire) à 1,0 (meilleur), mais cela dépend de votre implémentation

  • Objectif : Chiffre unique résumant la performance globale

  • Utilisation : comparer les modèles, suivre les améliorations par rapport à la formation

Métriques individuelles

  • Type de métrique : métriques informatives pour l'analyse

  • Type de récompense : mesures utilisées lors de l'entraînement RFT

  • Interprétation : des valeurs plus élevées indiquent généralement de meilleures performances (sauf si vous concevez des métriques inverses)

Critères de performance

Ce qui constitue une « bonne » performance dépend de votre cas d'utilisation :

Échelle de scores Interprétation Action
0,8 à 1,0 Excellent Modèle prêt à être déployé
0,6 à 0,8 Bon Des améliorations mineures peuvent être bénéfiques
0,4 à 0,6 Juste Une amélioration significative est nécessaire
0,0 à 0,4 Pauvre Passez en revue les données d'entraînement et la fonction de récompense
Important

Il s'agit de directives générales. Définissez vos propres seuils en fonction des exigences de l'entreprise, des performances du modèle de référence, des contraintes spécifiques au domaine et de l'analyse coûts-avantages de la formation continue.

Résolution des problèmes

Problèmes courants

Problème Cause Solution
délai d’expiration Lambda Calcul complexe des récompenses Augmentez le délai Lambda ou optimisez la fonction
Autorisation refusée Autorisations IAM manquantes Vérifier que SageMaker le rôle peut invoquer Lambda
Scores incohérents Non-deterministic fonction de récompense Utiliser des graines fixes ou une logique déterministe
Résultats manquants Erreurs Lambda non détectées Ajoutez une gestion complète des erreurs dans Lambda

Liste de contrôle de débogage

  • Vérifiez que les données d'entrée suivent le bon format avec des tableaux de contenu imbriqués

  • Vérifiez que l'ARN Lambda est correct et que la fonction est déployée

  • Vérifiez les autorisations IAM pour SageMaker → Invocation Lambda

  • Consulter CloudWatch les journaux pour détecter les erreurs Lambda

  • Valider que la réponse Lambda correspond au format attendu

Bonnes pratiques

  • Commencez simplement : commencez par les fonctions de récompense de base et itérez

  • Testez Lambda séparément : utilisez les événements de test Lambda avant l'évaluation complète

  • Valider sur un petit ensemble de données : exécuter une évaluation sur un sous-ensemble avant l'ensemble de données complet

  • Contrôle de version : suivez les versions de la fonction de récompense en même temps que les versions des modèles

  • Surveillez les coûts : les appels Lambda et le temps de calcul ont une incidence sur les coûts

  • Journalisez de manière approfondie : utilisez les instructions print dans Lambda pour le débogage

  • Réglez les délais d'attente de manière appropriée : équilibre entre patience et coût

  • Métriques des documents : définissez clairement ce que mesure chaque métrique

Étapes suivantes

Après avoir terminé l'évaluation RFT :

  • Si les résultats sont satisfaisants : déployer le modèle en production

  • Si des améliorations sont nécessaires :

    • Ajuster la fonction de récompense

    • Collectez davantage de données d'entraînement

    • Modifier les hyperparamètres d'entraînement

    • Exécutez des itérations d'entraînement RFT supplémentaires

  • Surveillance continue : Re-evaluate périodiquement avec de nouvelles données