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.

Réglage précis du renforcement (RFT) pour les modèles Amazon Nova

Présentation de

Qu'est-ce que le RFT ?

Le réglage fin par renforcement (RFT) améliore les performances du modèle en s'entraînant sur les signaux de feedback (scores mesurables ou récompenses indiquant les performances du modèle) plutôt que sur les bonnes réponses exactes. Contrairement au réglage fin supervisé qui apprend à partir de paires d'entrées-sorties, le RFT utilise des fonctions de récompense pour évaluer les réponses du modèle et optimise le modèle de manière itérative afin de maximiser ces récompenses. Cette approche excelle lorsqu'il est difficile de définir la sortie exacte correcte, mais vous pouvez mesurer de manière fiable la qualité de réponse.

Quand utiliser le RFT

Utilisez 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. C'est idéal pour :

Meilleurs cas d'utilisation

La RFT excelle dans les domaines où la qualité de sortie peut être mesurée objectivement, mais où les réponses optimales sont difficiles à définir dès le départ :

Modèles pris en charge

Amazon NovaLite 2.0

Format de données

Les données d'entraînement RFT doivent suivre le format OpenAI Reinforcement Fine-Tuning. Chaque exemple d'entraînement est un objet JSON contenant :

Exemple : problème mathématique

{
  "id": "sample-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"]
  }
}

Le reference_answer champ contient le résultat attendu ou les critères d'évaluation que votre fonction de récompense utilise pour évaluer la réponse du modèle. Il ne se limite pas aux sorties structurées : il peut contenir n'importe quel format permettant à votre fonction de récompense d'évaluer la qualité.

Recommandations relatives à la taille des jeux

Point de départ

Approche axée sur l'évaluation

Avant d'investir dans une formation RFT à grande échelle, évaluez les performances de base de votre modèle :

Commencer par un petit ensemble de données vous permet de valider que votre fonction de récompense est exempte de bogues, de confirmer que RFT est la bonne approche pour votre cas d'utilisation, d'identifier et de résoudre les problèmes rapidement, et de tester le flux de travail avant de le développer.

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 une mise en forme incohérente, des étiquettes ou des instructions contradictoires, des instructions ambiguës et des 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 des performances robustes dans le monde réel. Incluez différents formats de saisie et scénarios extrêmes, cartographiez les modèles d'utilisation réels de la production à partir des journaux et des analyses des utilisateurs, échantillonnez les types d'utilisateurs, les régions géographiques et les variations saisonnières, et incluez des niveaux de difficulté allant des problèmes les plus simples aux plus complexes.

Considérations relatives aux fonctions de récompense

Concevez votre fonction de récompense pour un entraînement efficace. Il doit s'exécuter en quelques secondes (et non en quelques minutes), se paralléliser efficacementAWS Lambda, renvoyer des scores cohérents et fiables et gérer les différents types de sorties de modèles avec élégance. Des fonctions de récompense rapides et évolutives permettent une itération rapide et une expérimentation rentable.

Propriétés supplémentaires

Le format de données RFT prend en charge les champs personnalisés au-delà des exigences de base du schéma (messagesetreference_answer). Cette flexibilité vous permet d'ajouter toutes les données supplémentaires dont votre fonction de récompense a besoin pour une évaluation correcte.

Propriétés supplémentaires communes

Ces champs supplémentaires sont transmis à votre fonction de récompense lors de l'évaluation, ce qui permet une logique de notation sophistiquée adaptée à votre cas d'utilisation spécifique.

Exemples avec des propriétés supplémentaires

Chemistry problem

{
  "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
  }
}

Le reference_answer champ contient le résultat attendu ou les critères d'évaluation que votre fonction de récompense utilise pour évaluer la réponse du modèle. Il ne se limite pas aux sorties structurées : il peut contenir n'importe quel format permettant à votre fonction de récompense d'évaluer la qualité.

Math problem with metadata

{
  "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
}

Mettre en œuvre des fonctions de récompense

Les fonctions de récompense sont implémentées sous forme de fonctions Lambda qui évaluent les réponses du modèle et renvoient des scores numériques. La fonction Lambda reçoit des messages et des informations de base au format OpenAI et doit renvoyer les scores sous forme de dictionnaire.

Autorisations IAM

Assurez-vous que votre rôle d'exécution SageMaker AI dispose InvokeFunction d'autorisations pour la fonction Lambda.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-reward-function-lambda"
    }
  ]
}

Directives de conception

Lorsque vous rédigez des fonctions de récompense, procédez comme suit :

Format d'interface

Votre fonction de récompense doit accepter et renvoyer les données dans le format suivant.

Structure d'entrée

[{
  "id": "123",
  "messages": [
    {
      "role": "user",
      "content": "Do you have a dedicated security team?"
    },
    {
      "role": "assistant",
      "content": "As an AI developed by Amazon, I don not have a dedicated security team..."
    }
  ],
  "metadata": {
    "reference_answer": {
      "compliant": "No",
      "explanation": "As an AI developed by Company, I do not have a traditional security team..."
    },
    "my_key": "sample-001"
  }
}]

Structure de sortie

[{
  "id": "123",
  "aggregate_reward_score": 0.85,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.9,
      "type": "Reward"
    },
    {
      "name": "policy_compliance",
      "value": 0.8,
      "type": "Metric"
    }
  ]
}]

Exemple de fonction Lambda

from typing import List
import json
from dataclasses import asdict, dataclass

@dataclass
class RewardOutput:
    """Reward service output."""
    id: str
    aggregate_reward_score: float

def lambda_handler(event, context):
    """Main lambda handler"""
    return lambda_grader(event)

def lambda_grader(samples: list[dict]) -> list[dict]:
    """Core grader function"""
    scores: List[RewardOutput] = []
    for sample in samples:
        idx = sample["id"]
        ground_truth = sample.get("metadata", {}).get("reference_answer")
        
        if "messages" not in sample:
            print(f"Messages is None/empty for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        if ground_truth is None:
            print(f"No answer found in ground truth for id: {idx}")
            ro = RewardOutput(id=idx, aggregate_reward_score=0.0)
            scores.append(ro)
            continue
        
        # Get model's response (last turn is assistant turn)
        last_message = sample["messages"][-1]
        assert last_message["role"] == "assistant", "Last message must be from assistant"
        model_text = last_message["content"]
        
        ground_truth_text = _extract_ground_truth_text(ground_truth)
        
        if model_text.lower() == ground_truth_text.lower():
            score = 1.0
        else:
            score = 0.0
        
        ro = RewardOutput(id=idx, aggregate_reward_score=score)
        scores.append(ro)
    
    return [asdict(score) for score in scores]

def _extract_ground_truth_text(ground_truth) -> str:
    """Turn the ground_truth field into a plain string."""
    if isinstance(ground_truth, str):
        return ground_truth
    
    if isinstance(ground_truth, dict):
        if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
            return ground_truth["explanation"]
        if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
            return ground_truth["answer"]
        return json.dumps(ground_truth, ensure_ascii=False)
    
    return str(ground_truth)

Configuration d’entraînement

Utilisez le modèle de carnet de notes SageMaker AI Training Job pour démarrer une tâche de formation. Pour plus d'informations, voir Création d'un poste de formation.

Conteneur de formation

708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-RFT-latest

Exigences relatives à l'instance

Le conteneur prend en charge à la fois les formations Full Rank et LoRa :

Sélection du mode de raisonnement

Modes disponibles

Quand utiliser chaque mode

Utilisez high le raisonnement pour les tâches analytiques complexes, la résolution de problèmes mathématiques, la déduction logique en plusieurs étapes et les tâches dans lesquelles la step-by-step réflexion apporte une valeur ajoutée.

Utilisez none (omettezreasoning_effort) ou low raisonnez pour des requêtes factuelles simples, des classifications directes, une optimisation de la vitesse et des coûts et des réponses directes aux questions.

Compromis en termes de coûts et de performances

Les modes de raisonnement avancés augmentent le temps et les coûts de formation, la latence et le coût des inférences, ainsi que les capacités de modélisation pour les tâches de raisonnement complexes.

Formation en matière de surveillance

Les journaux d'entraînement incluent des mesures complètes à chaque étape. Les principales catégories de mesures sont les suivantes :

Utilisation de modèles affinés

Une fois l'entraînement terminé, le point de contrôle final du modèle est enregistré à l'emplacement de sortie que vous avez spécifié. Le chemin du point de contrôle est disponible dans les journaux d'entraînement et le manifest.json fichier dans l'emplacement de sortie Amazon S3 (défini output_s3_uri dans votre bloc-notes).

Limites et meilleures pratiques

Limites

Bonnes pratiques