Exécution d'évaluations et interprétation des résultats - Amazon SageMaker AI
Exécution du travail d'évaluationComprendre les résultats de l'évaluationRésolution des problèmesBonnes pratiquesÉtapes suivantesFonctions de récompense prédéfinies

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.

Exécution d'évaluations et interprétation des résultats

Exécution du travail d'évaluation

Étape 1 : Préparez vos données

  • Formatez vos données d'évaluation conformément aux exigences relatives au format des données

  • Téléchargez votre fichier JSONL sur S3 : s3://your-bucket/eval-data/eval_data.jsonl

Étape 2 : Configurez votre recette

Mettez à jour l'exemple de recette avec votre configuration :

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

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

  • Réglez output_s3_path sur l'emplacement de sortie souhaité

  • Ajustez inference les paramètres selon les besoins

Enregistrez la recette sous rft_eval_recipe.yaml

Étape 3 : Exécuter l'évaluation

Exécutez le travail d'évaluation à l'aide du bloc-notes fourni : Carnets d'évaluation

Conteneur d'évaluation

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest

Étape 4 : suivre les progrès

Suivez 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 : résolution des problèmes liés à la fonction de récompense

Comprendre les résultats de l'évaluation

Format de sortie

La tâche d'évaluation produit les résultats vers l'emplacement S3 que vous avez spécifié au format JSONL. Chaque ligne contient les résultats de l'évaluation pour 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 du Job d'évaluation RFT est identique au format Lambda Response. Le service d'évaluation passe en revue 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 agrégé

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

  • Objectif : numéro unique résumant les performances globales

  • Utilisation : comparer les modèles, suivre les améliorations au fil de 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 :

Fourchette de scores Interprétation Action
0,8 - 1,0 Excellente Modèle prêt pour le déploiement
0,6 - 0,8 Bon Des améliorations mineures peuvent être bénéfiques
0,4 - 0,6 équitable 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 de :

  • Besoins commerciaux

  • Performances du modèle de référence

  • Contraintes spécifiques au domaine

  • Analyse coûts-avantages de la formation continue

Analyse des résultats

Calculer des statistiques récapitulatives

import json  
import numpy as np  
scores = []  
with open('evaluation_results.jsonl', 'r') as f:  
    for line in f:  
        result = json.loads(line)  
        scores.append(result['aggregate_reward_score'])  
  
print(f"Mean: {np.mean(scores):.3f}")  
print(f"Median: {np.median(scores):.3f}")  
print(f"Std Dev: {np.std(scores):.3f}")  
print(f"Min: {np.min(scores):.3f}")  
print(f"Max: {np.max(scores):.3f}")

  • Identifiez les cas de défaillance : passez en revue les échantillons présentant de faibles scores pour comprendre les faiblesses

  • Comparez les métriques : analysez la corrélation entre les différentes métriques pour identifier les compromis

  • Suivi dans le temps : comparez les résultats d'évaluation entre les itérations de formation

Résolution des problèmes

Problèmes courants

Problème Cause Solution
délai d’expiration Lambda Calcul complexe des récompenses Augmenter le délai Lambda ou optimiser la fonction
Autorisation refusée Autorisations IAM manquantes Vérifier que SageMaker le rôle peut invoquer Lambda
Scores incohérents Fonction de récompense non déterministe Utilisez 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 pour le débogage

  • Vérifiez que les données d'entrée suivent le format correct 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

  • Vérifiez 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 répétez

  • 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 l'évaluation sur le sous-ensemble avant le jeu de données complet

  • Contrôle des versions : suivez les versions des fonctions de récompense parallèlement aux versions des modèles

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

  • Enregistrez intensivement : utilisez des instructions d'impression dans Lambda pour le débogage

  • Définissez les délais de manière appropriée : équilibre entre patience et coût

  • Métriques du document : 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 de formation RFT supplémentaires

  • Surveillance continue : réévaluez périodiquement avec de nouvelles données

Fonctions de récompense prédéfinies

Deux fonctions de récompense prédéfinies (prime_code, prime_math) de la bibliothèque open source verl sont disponibles dans une couche Lambda que vous pouvez associer à votre RFT Lambda.

Présentation de

Ces fonctions prédéfinies fournissent des capacités out-of-the-box d'évaluation pour :

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

  • prime_math — Évaluation du raisonnement mathématique et de la résolution de problèmes

Configuration rapide

  1. Téléchargez la couche Lambda depuis les versions nova-custom-eval-sdk

  2. Publiez une couche Lambda à l'aide de : 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 personnalisée à preset-function-layer partir de la couche personnalisée et ajoutez également AWSSDKPandas-Python 312 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

Objectif : É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 d'entrée issu de l'évaluation

{"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 du code à partir de blocs de code Markdown

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

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

  • Validation de syntaxe et contrôles de compilation

  • Signalement détaillé des erreurs avec retraçage

fonction prime_math

Objectif : É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éponse 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 pour la correspondance des chaînes

Bonnes pratiques

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

  • Fournir des signatures de fonction claires en cas de problèmes de code

  • Inclure les cas extrêmes 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 avec des 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