Créez et gérez des tâches de réglage précis pour les modèles Amazon Nova - Amazon Bedrock
Conditions préalablesCréez votre job RFTSurveillez votre travail de formation RFTConfigurer l'inférence

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.

Créez et gérez des tâches de réglage précis pour les modèles Amazon Nova

Vous pouvez créer une tâche de réglage fin du renforcement (RFT) à l'aide de la console ou de l'API Amazon Bedrock. Le travail RFT peut prendre quelques heures en fonction de la taille de vos données d'entraînement, du nombre d'époques et de la complexité de vos fonctions de récompense.

Conditions préalables

  • Créez un rôle de service IAM avec les autorisations requises. Pour obtenir des informations complètes sur la sécurité et les autorisations, y compris les autorisations spécifiques à RFT, consultez. Accès et sécurité pour les modèles Amazon Nova

  • (Facultatif) Chiffrez les données d'entrée et de sortie, votre tâche RFT ou les demandes d'inférence adressées à des modèles personnalisés. Pour plus d'informations, consultez la section Chiffrement des modèles personnalisés.

Créez votre job RFT

Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :

Console

Pour soumettre une tâche RFT dans la console, procédez comme suit :

  1. Ouvrez la console Amazon Bedrock et accédez à Modèles personnalisés sous Tune.

  2. Choisissez Créer, puis Créer une tâche de réglage précis du renforcement.

  3. Dans la section Détails du modèle, choisissez Amazon Nova 2 Lite comme modèle de base.

  4. Dans la section Détails de la personnalisation, entrez le nom de la personnalisation.

  5. Dans la section Données d'entraînement, choisissez votre source de données. Choisissez parmi vos journaux d'appel disponibles stockés dans Amazon S3, sélectionnez l'emplacement Amazon S3 de votre ensemble de données d'entraînement ou téléchargez un fichier directement depuis votre appareil.

    Note

    Votre ensemble de données d'entraînement doit être au format de données OpenAI Chat Completions. Si vous fournissez des journaux d'invocation au format Amazon Bedrock invoke ou converse, Amazon Bedrock les convertit automatiquement au format Chat Completions.

  6. Dans la section Fonction de récompense, configurez votre mécanisme de récompense :

    • Modéliser en tant que juge (RLAIF) - Sélectionnez un modèle de base hébergé par Bedrock comme juge et configurez les instructions d'évaluation. Utilisez-le pour des tâches subjectives telles que la modération du contenu.

      Note

      L'option Model as judge de la console convertit automatiquement votre configuration en fonction Lambda pendant l'entraînement.

    • Code personnalisé (RLVR) - Créez des fonctions de récompense personnalisées à l'aide du code Python exécuté via des fonctions Lambda. Utilisez-le pour des tâches objectives telles que la génération de code.

    Pour de plus amples informations, veuillez consulter Configuration des fonctions de récompense pour les modèles Amazon Nova.

  7. (Facultatif) Dans la section Hyperparamètres, ajustez les paramètres d'entraînement ou utilisez les valeurs par défaut.

  8. Dans la section Données de sortie, entrez l'emplacement Amazon S3 où Amazon Bedrock doit enregistrer les résultats des tâches.

  9. Dans la section Configuration des rôles, choisissez un rôle existant dans la liste déroulante ou entrez un nom pour le rôle de service à créer.

  10. (Facultatif) Dans la section Configuration supplémentaire, configurez les données de validation en pointant vers un compartiment Amazon S3, les paramètres de chiffrement KMS et les balises de tâche et de modèle.

  11. Choisissez Créer une tâche de réglage précis du renforcement pour commencer la tâche.

API

Envoyez une CreateModelCustomizationJob demande avec customizationType set toREINFORCEMENT_FINE_TUNING.

Champs obligatoires : roleArnbaseModelIdentifier,customModelName,jobName,trainingDataConfig,outputDataConfig, rftConfig

Exemple de demande :

{
    "roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
    "baseModelIdentifier": "amazon.nova-2.0",
    "customModelName": "my-rft-model",
    "jobName": "my-rft-job",
    "customizationType": "REINFORCEMENT_FINE_TUNING",
    "trainingDataConfig": {
        "s3Uri": "s3://my-bucket/training-data.jsonl"
    },
    "customizationConfig": {
        "rftConfig" : {
            "graderConfig": {
                "lambdaGrader": {
                    "lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
                }
            },
            "hyperParameters": {
                "batchSize": 64,
                "epochCount": 2,
                "evalInterval": 10,
                "inferenceMaxTokens": 8192,
                "learningRate": 0.00001,
                "maxPromptLength": 4096,
                "reasoningEffort": "high",
                "trainingSamplePerPrompt": 4
            }
        }
    },
    "outputDataConfig": {
        "s3Uri": "s3://my-bucket/rft-output/"
    }
}

Exemple de demande d'API Python :

import boto3

bedrock = boto3.client(service_name='bedrock')
    
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"

customizationConfig = {
    'rftConfig' : {
        'graderConfig': {
            'lambdaGrader': {
                'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
            }
        },
        'hyperParameters': {
            'batchSize': 64,
            'epochCount': 2,
            'evalInterval': 10,
            'inferenceMaxTokens': 8192,
            'learningRate':0.00001,
            'maxPromptLength': 4096,
            'reasoningEffort': 'high',
            'trainingSamplePerPrompt':4
        }
    }
}

trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}

# Create job
response_ft = bedrock.create_model_customization_job(
    jobName=jobName, 
    customModelName=customModelName,
    roleArn=roleArn,
    baseModelIdentifier=baseModelIdentifier,
    customizationConfig=customizationConfig,
    trainingDataConfig=trainingDataConfig,
    outputDataConfig=outputDataConfig,
    customizationType=customizationType
)

jobArn = response_ft['jobArn']

Surveillez votre travail de formation RFT

Amazon Bedrock fournit une surveillance en temps réel à l'aide de graphiques visuels et de mesures pendant la formation RFT. Ces indicateurs vous aident à comprendre si le modèle converge correctement et si la fonction de récompense guide efficacement le processus d'apprentissage.

Suivi de l'état des emplois

Vous pouvez suivre le statut de votre poste RFT pendant les phases de validation et de formation dans la console Amazon Bedrock.

Indicateurs d'achèvement :

  • Le statut du job passe à Terminé lorsque la formation est terminée avec succès

  • Le modèle d'ARN personnalisé devient disponible pour le déploiement

  • Les indicateurs de formation atteignent les seuils de convergence

Indicateurs d'entraînement en temps réel

Amazon Bedrock fournit une surveillance en temps réel pendant la formation RFT avec des graphiques visuels affichant les mesures de formation et de validation.

Indicateurs d'entraînement de base

  • Perte d'entraînement : mesure dans quelle mesure le modèle apprend à partir des données d'entraînement

  • Statistiques sur les récompenses d'entraînement - Affiche les scores de récompenses attribués par vos fonctions de récompense

  • Marge de récompense : mesure la différence entre les récompenses pour bonnes et mauvaises réponses

  • Précision des ensembles d'entraînement et de validation : affiche les performances du modèle à la fois sur les données d'entraînement et sur les données maintenues

Catégories métriques détaillées

  • Indicateurs de récompenses — critic/rewards/meancritic/rewards/max,, critic/rewards/min (distribution des récompenses) et val-score/rewards/mean@1 (récompenses de validation)

  • Comportement du modèle — actor/entropy (variation des politiques ; une valeur plus élevée correspond à une approche plus exploratoire)

  • État de la formation : actor/pg_loss (perte du gradient des politiques), actor/pg_clipfrac (fréquence des mises à jour découpées) et actor/grad_norm (amplitude du gradient)

  • Caractéristiques de réponse —prompt_length/mean,prompt_length/max, prompt_length/min (statistiques des jetons d'entrée),response_length/mean,response_length/max, response_length/min (statistiques des jetons de sortie) et response/aborted_ratio (taux de génération incomplet ; 0 est égal à tout terminé)

  • Performances : perf/throughput (débit d'entraînement), perf/time_per_step (temps par étape d'entraînement) et timing_per_token_ms/* (temps de traitement par jeton)

  • Utilisation des ressources —perf/max_memory_allocated_gb, perf/max_memory_reserved_gb (mémoire GPU) et perf/cpu_memory_used_gb (mémoire CPU)

Visualisation des progrès de l'entraînement

La console affiche des graphiques interactifs qui sont mis à jour en temps réel au fur et à mesure de l'avancement de votre tâche RFT. Ces visualisations peuvent vous aider à :

  • Suivez la convergence vers des performances optimales

  • Identifiez rapidement les problèmes de formation potentiels

  • Déterminer les points d'arrêt optimaux

  • Comparez les performances à différentes époques

Configurer l'inférence

Une fois le travail terminé, déployez le modèle RFT pour une inférence à la demande ou utilisez le débit provisionné pour des performances constantes. Pour configurer l'inférence, voirConfiguration de l’inférence pour un modèle personnalisé.

Utilisez Test in Playground pour évaluer et comparer les réponses avec le modèle de base. Pour évaluer votre modèle RFT terminé, consultezÉvaluez votre modèle RFT.