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.
# Soumission d'un poste de formation
## Lancement d'emplois de formation
Une fois que votre agent a été déployé et que votre ensemble de données est dans S3, créez une tâche de formation en utilisant l'une des méthodes suivantes.
### SageMaker Studio d'IA
+ Accédez à Modèles dans le volet de navigation et sélectionnez Modèles JumpStart de base.
+ Sélectionnez un modèle compatible avec le RL multitour (voir le tableau des modèles pris en charge) et choisissez Personnaliser le modèle, puis Personnaliser avec l'interface utilisateur.
+ Sélectionnez l'apprentissage Multi-Turn par renforcement comme technique de personnalisation.
+ Configurez votre environnement d'agent : sélectionnez votre environnement AgentCore d'exécution Bedrock ou fournissez l'ARN de votre redirecteur Lambda.
+ Fournissez votre ensemble de données d'entraînement sous forme d'URI S3 ou d'ensemble de données enregistré.
+ Ajustez les hyperparamètres selon vos besoins.
+ Vérifiez votre configuration et choisissez Soumettre.
### SageMaker SDK Python pour IA
**Découvrez les modèles pris en charge**
```
from sagemaker.train.multi_turn_rl_trainer import MultiTurnRLTrainer
supported_models = MultiTurnRLTrainer.list_supported_models()
print(f"Supported MTRL models ({len(supported_models)}):")
for m in supported_models:
print(f" - {m}")
```
**Configurez votre environnement d'agents**
Option 1 : durée d'exécution de Bedrock AgentCore
```
# List available runtimes
runtimes = MultiTurnRLTrainer.list_bedrock_agentcore_runtimes()
for rt in runtimes:
print(f" - {rt['name']} ({rt['status']}) → {rt['arn']}")
```
Option 2 : agent Lambda personnalisé
```
from sagemaker.train.agent_lambda import AgentLambda
# Create from inline code
adapter = AgentLambda.create(
source='''
import json
def handler(event, context):
prompt = event.get("prompt", "")
return {"statusCode": 200, "body": json.dumps({"status": "ok", "agentResponse": prompt})}
''',
role="arn:aws:iam::123456789012:role/AgentLambdaRole",
)
# Create from a local file
adapter = AgentLambda.create(
source="~/my_agent_handler.py",
role="arn:aws:iam::123456789012:role/AgentLambdaRole",
)
# Create from S3
adapter = AgentLambda.create(
source="s3://my-bucket/agent_handler.py",
role="arn:aws:iam::123456789012:role/AgentLambdaRole",
)
# Wrap an existing Lambda
adapter = AgentLambda.get("arn:aws:lambda:us-west-2:123456789012:function:my-agent")
```
**Enregistrez votre jeu de données (facultatif)**
```
from sagemaker.ai_registry.dataset import DataSet
dataset = DataSet.create(
name="my-mtrl-dataset",
source="s3://my-bucket/prompts/training_prompts.parquet"
)
print(f"Dataset ARN: {dataset.arn}")
```
**Créer un groupe de packages de modèles restreint pour Nova (facultatif)**
Si vous choisissez Nova model (`nova-textgeneration-lite-v2`), créez éventuellement un groupe de packages de modèles restreints avant de soumettre une tâche de formation (étape suivante). Si vous ignorez cette étape, le SDK en crée une automatiquement pour vous.
Le groupe de packages de modèles restreint (RMPG) est un groupe de packages de modèles avec ManagedStorageType : Restreint. Cela est nécessaire pour les modèles à source fermée tels que Nova, où les poids des modèles sont gérés par le client AWS et ne sont pas directement accessibles à celui-ci.
Le schéma de travail RFT nécessite deux MPG restreints distincts :
+ Sortie MPG : enregistre le package final du modèle affiné
+ Point de contrôle intermédiaire MPG — réservé aux points de contrôle d'entraînement intermédiaires (doit être différent du MPG de sortie)
```
from sagemaker.core.resources import Job, ModelPackageGroup
from sagemaker.core.shapes import ManagedConfiguration
model_name = "nova-textgeneration-lite-v2"
# Restricted configuration
managed_config = ManagedConfiguration(managed_storage_type="Restricted")
# Output Model package group
output_mpg_name = f"{model_name}-mtrl-output-mpg"
create_kwargs = {
"model_package_group_name": output_mpg_name,
"region": "us-east-1",
"managed_configuration": managed_config
}
output_mpg = ModelPackageGroup.create(**create_kwargs)
# Intermediate Model package group
intermediate_mpg_name = f"{model_name}-mtrl-inter-mpg"
create_kwargs = {
"model_package_group_name": intermediate_mpg_name,
"region": "us-east-1",
"managed_configuration": managed_config
}
intermediate_mpg = ModelPackageGroup.create(**create_kwargs)
```
Une fois le groupe de packages Model créé, transmettez-le à l'étape suivante lors de la soumission d'une offre de formation.
**Proposez un poste de formation chez Bedrock AgentCore**
```
from sagemaker.train.multi_turn_rl_trainer import MultiTurnRLTrainer
trainer = MultiTurnRLTrainer(
model="openai-reasoning-gpt-oss-20b",
agent_env="arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent-runtime",
training_dataset="s3://my-bucket/prompts/prompts.parquet",
mlflow_app_arn="arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id",
s3_output_path="s3://my-bucket/output/",
role="arn:aws:iam::123456789012:role/SageMakerRole",
accept_eula=True,
)
# View and adjust hyperparameters
trainer.hyperparameters.get_info()
trainer.hyperparameters.max_epochs = 1
trainer.hyperparameters.global_batch_size = 32
trainer.hyperparameters.max_steps = 12
job = trainer.train(wait=True)
print(f"Job: {job.job_name}")
print(f"Status: {job.job_status}")
print(f"Output Model Package: {job.output_model_package_arn}")
```
**Soumettre une offre de formation avec un agent Lambda personnalisé**
```
trainer = MultiTurnRLTrainer(
model="openai-reasoning-gpt-oss-20b",
agent_env=adapter, # AgentLambda object or Lambda ARN string
training_dataset="s3://my-bucket/prompts/prompts.parquet",
mlflow_app_arn="arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id",
s3_output_path="s3://my-bucket/output/",
role="arn:aws:iam::123456789012:role/SageMakerRole",
accept_eula=True,
)
trainer.hyperparameters.max_epochs = 1
trainer.hyperparameters.global_batch_size = 32
trainer.hyperparameters.max_steps = 12
job = trainer.train(wait=True)
print(f"Job: {job.job_name}")
print(f"Status: {job.job_status}")
print(f"Output Model Package: {job.output_model_package_arn}")
```
**Soumettre une offre de formation avec le groupe de packages Restricted Model pour Nova**
Reportez-vous à l'étape ci-dessus (Créer un groupe de packages de modèles restreints pour Nova) pour savoir comment créer un groupe de packages de modèles restreints.
```
from sagemaker.train.multi_turn_rl_trainer import MultiTurnRLTrainer
trainer = MultiTurnRLTrainer(
model="nova-textgeneration-lite-v2",
agent_env="arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent-runtime",
training_dataset="s3://my-bucket/prompts/prompts.parquet",
mlflow_app_arn="arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id",
s3_output_path="s3://my-bucket/output/",
role="arn:aws:iam::123456789012:role/SageMakerRole",
accept_eula=True,
output_model_package_group=output_mpg,
intermediate_checkpoint_model_package_group=intermediate_mpg
)
# View and adjust hyperparameters
trainer.hyperparameters.get_info()
trainer.hyperparameters.max_epochs = 1
trainer.hyperparameters.global_batch_size = 32
trainer.hyperparameters.max_steps = 12
job = trainer.train(wait=True)
print(f"Job: {job.job_name}")
print(f"Status: {job.job_status}")
print(f"Output Model Package: {job.output_model_package_arn}")
```
### AWS INTERFACE DE LIGNE DE COMMANDE (CLI)
Créez une tâche de formation à l'aide de l'`CreateJob`API. Vous spécifiez la configuration de l'agent, l'emplacement des données d'entraînement, le modèle de base et les paramètres de sortie dans le`JobConfigDocument`.
Pour récupérer le JobConfigDocument schéma complet :
```
aws sagemaker list-job-schema-versions --job-category AgentRFT
aws sagemaker describe-job-schema-version --job-category AgentRFT --version "1.0.0"
```
**Créez un emploi avec Bedrock AgentCore**
```
aws sagemaker create-job \
--job-category AgentRFT \
--job-name "my-agent-rft-job" \
--role-arn "arn:aws:iam::123456789012:role/SageMakerFineTuningJobRole" \
--job-config-schema-version "1.0.0" \
--job-config-document '{
"AgentConfig": {
"BedrockAgentCoreConfig": {
"AgentRuntimeArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent"
}
},
"InputDataConfig": [...],
"OutputDataConfig": {...},
"ModelPackageConfig": {...},
"TrainingConfig": {...}
}' \
--region us-west-2
```
**Créez une tâche avec un agent Lambda personnalisé**
```
aws sagemaker create-job \
--job-category AgentRFT \
--job-name "my-custom-agent-rft-job" \
--role-arn "arn:aws:iam::account-id:role/SageMakerFineTuningJobRole" \
--job-config-schema-version "1.0.0" \
--job-config-document '{
"AgentConfig": {
"CustomAgentLambdaConfig": {
"LambdaArn": "arn:aws:lambda:us-west-2:account-id:function:rft-agent-forwarder"
}
},
"InputDataConfig": [...],
"OutputDataConfig": {...},
"ModelPackageConfig": {...},
"TrainingConfig": {...}
}' \
--region us-west-2
```
### boto3
**Créez un emploi avec Bedrock AgentCore**
```
import json
import boto3
sm = boto3.client("sagemaker")
response = sm.create_job(
JobName="my-agent-rft-job",
RoleArn="arn:aws:iam::123456789012:role/SageMakerFineTuningJobRole",
JobCategory="AgentRFT",
JobConfigSchemaVersion="1.0.0",
JobConfigDocument=json.dumps({
"AgentConfig": {
"BedrockAgentCoreConfig": {
"AgentRuntimeArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:runtime/my-agent"
}
},
"InputDataConfig": [...],
"OutputDataConfig": {...},
"ModelPackageConfig": {...},
"TrainingConfig": {...}
})
)
print(f"Job ARN: {response['JobArn']}")
```
**Créez une tâche avec un agent Lambda personnalisé**
```
import json
import boto3
sm = boto3.client("sagemaker")
response = sm.create_job(
JobName="my-custom-agent-rft-job",
RoleArn="arn:aws:iam::account-id:role/SageMakerFineTuningJobRole",
JobCategory="AgentRFT",
JobConfigSchemaVersion="1.0.0",
JobConfigDocument=json.dumps({
"AgentConfig": {
"CustomAgentLambdaConfig": {
"LambdaArn": "arn:aws:lambda:us-west-2:account-id:function:rft-agent-forwarder"
}
},
"InputDataConfig": [...],
"OutputDataConfig": {...},
"ModelPackageConfig": {...},
"TrainingConfig": {...}
})
)
print(f"Job ARN: {response['JobArn']}")
```
## Formation en matière de surveillance
### Surveillez votre job de formation
Utilisez l'`DescribeJob`API pour vérifier l'état actuel de votre tâche à tout moment. Le statut du poste passe par`InProgress`, puis vers`Completed`, `Failed` ou`Stopped`.
```
aws sagemaker describe-job \
--job-name "my-agent-rft-job" \
--job-category AgentRFT \
--region us-west-2
```
Utilisez le SDK :
```
# Run without blocking
job = trainer.train(wait=False)
job.wait(poll=5, timeout=3000, max_log_lines=10)
# Check status
job.refresh()
print(f"Status: {job.job_status}")
print(f"Secondary Status: {job.secondary_status}")
print(f"Output Model Package: {job.output_model_package_arn}")
print(f"MLflow Details: {job.mlflow_details}")
print(f"Billable Tokens: {job.billable_token_usage}")
# Open MLflow tracking URL
job.get_mlflow_url()
# Stop a running job
job.stop()
# Attach to an existing job from a different session
existing_job = MultiTurnRLTrainer.attach(job_name="my-existing-job-name")
print(f"Status: {existing_job.job_status}")
print(f"Output Model: {existing_job.output_model_package_arn}")
# List all completed jobs
from sagemaker.train.agent_rft_job import AgentRFTJob
for j in AgentRFTJob.get_all(status_equals="Completed"):
print(f"{j.job_name}: {j.job_status}")
```
### Surveillez l'entraînement dans MLflow
SageMaker L'IA s'intègre automatiquement à MLflow géré pour suivre la progression, les indicateurs et les artefacts de votre tâche de formation. Pour activer le suivi MLflow, incluez un `MlflowConfig` dans vos tâches : `OutputDataConfig`
```
"OutputDataConfig": {
"S3OutputPath": "s3://your-bucket/output/",
"MlflowConfig": {
"MlflowResourceArn": "arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/my-rft-mlflow-app"
}
}
```
**Conditions préalables**
+ Créez une application MLflow gérée dans votre compte. Pour les instructions de configuration, voir Configuration de l'application MLflow.
+ Assurez-vous que votre rôle d'exécution SageMaker AI est autorisé à écrire dans l'application MLflow (`sagemaker-mlflow:*`actions).
+ Incluez-les `MlflowResourceArn` dans la configuration de votre tâche.
**Qu'est-ce qui est enregistré**
| \# | Catégorie | Ce qui est enregistré | Où dans l'interface utilisateur de MLflow |
| --- | --- | --- | --- |
| 1 | Métriques d’entraînement | Per-step compteurs, débit, comptabilisation des données et des jetons, durée totale de chaque phase d'une étape, lot de déploiement récapitulatif de la trajectoire et des récompenses et distribution du nombre de tours par trajectoire | Onglet Métriques (graphiques de séries chronologiques) |
| 2 | Traces de trajectoire | Conversations complètes à plusieurs tours avec appels aux outils et récompenses | Onglet Traces |
#### Référence détaillée des indicateurs d'entraînement
Les mesures suivantes sont enregistrées à chaque étape de l'entraînement.
**Compteurs de pas et débit () `training/`**
| Métrique | Description |
| --- | --- |
| training/epoch | Numéro d'époque actuel |
| training/global\_step | Compteur de pas d'entraînement mondial |
| training/num\_groups | Groupes de trajectoires dans cette étape |
| training/num\_trajectories | Trajectoires totales traitées au cours de cette étape |
| training/total\_tokens | Les jetons ont été additionnés à tous les microlots au cours de cette étape |
| training/num\_datums | Données d'entraînement formées à partir de trajectoires |
| training/datums\_per\_trajectory | Valeurs de référence moyennes émises par trajectoire |
| training/action\_tokens\_mean | Nombre moyen de jetons d'action (réponse) par trajectoire |
| training/obs\_tokens\_mean | Nombre moyen de jetons d'observation (invite) par trajectoire |
| training/trainable\_token\_positions | Nombre total de positions cibles pouvant être entraînées au cours de cette étape |
| training/nontrainable\_token\_positions | Nombre total de positions cibles non entraînables à cette étape |
| training/trainable\_token\_ratio | Ratio : positions des trainable / (trainable \+ nontrainable) jetons |
**Durées des phases () `timing_s/`**
| Métrique | Description |
| --- | --- |
| timing\_s/step | Durée totale de l'étape |
| timing\_s/training | C'est l'heure des forward/backward passes et de l'étape d'optimisation |
| timing\_s/policy\_update | Réduction du temps consacré aux poids mis à jour pour l'échantillonneur |
| timing\_s/save\_checkpoint | Gain de temps à un point de contrôle (uniquement sur les étapes du point de contrôle) |
| timing\_s/eval | Évaluation chronologique (uniquement pour les étapes d'évaluation) |
**Distribution de récompenses (`rollout/reward/`)**
| Métrique | Description |
| --- | --- |
| rollout/reward/mean | Récompense de trajectoire moyenne dans tous les groupes |
| rollout/reward/valid\_mean | Récompense moyenne uniquement pour les groupes valides (avantage non nul) ; égale mean en l'absence de filtrage |
| rollout/reward/std | Écart type des récompenses liées à la trajectoire |
| rollout/reward/min | Récompense de trajectoire minimale |
| rollout/reward/max | Récompense maximale sur la trajectoire |
| rollout/reward/zero\_frac | Fraction de trajectoires avec récompense totale exactement 0,0 |
**Les tours comptent (`rollout/turns/`)**
| Métrique | Description |
| --- | --- |
| rollout/turns/mean | Virages moyens (transitions) par trajectoire |
| rollout/turns/min | Nombre minimal de virages sur les trajectoires |
| rollout/turns/max | Nombre maximal de virages sur les trajectoires |
**Longueurs des jetons (`rollout/tokens/`)**
| Métrique | Description |
| --- | --- |
| rollout/tokens/prompt\_mean | Nombre moyen de jetons instantanés par transition |
| rollout/tokens/response\_mean | Nombre moyen de jetons de réponse par transition |
| rollout/tokens/response\_std | Écart type du nombre de jetons de réponse |
| rollout/tokens/response\_min | Nombre minimal de jetons de réponse |
| rollout/tokens/response\_max | Nombre maximal de jetons de réponse (surveillez le clustering sursampling\_max\_tokens) |
**Log-probability santé (`rollout/logprob/`)**
| Métrique | Description |
| --- | --- |
| rollout/logprob/zero\_count | Nombre total de jetons Zero-LogProb |
| rollout/logprob/zero\_frac | Fraction de tous les logprobs dont la valeur est exactement de 0,0 |
| rollout/logprob/zero\_per\_group | Nombre moyen de probs logarithmiques nuls par groupe de trajectoires |
| rollout/logprob/nz\_mean | Moyenne de probs logarithmiques non nuls |
| rollout/logprob/nz\_std | Écart type des probs logprobs non nuls |
| rollout/logprob/nz\_min | Logprob minimal différent de zéro |
| rollout/logprob/nz\_max | Logprob maximal différent de zéro |
**Distribution des avantages (`rollout/advantage/`)**
| Métrique | Description |
| --- | --- |
| rollout/advantage/mean | Valeur d'avantage moyenne pour toutes les transitions |
| rollout/advantage/std | Écart type des avantages |
| rollout/advantage/min | Avantage minimal |
| rollout/advantage/max | Avantage maximal |
| rollout/advantage/n\_positive | Transitions présentant un avantage positif |
| rollout/advantage/n\_negative | Transitions présentant un avantage négatif |
**Batch-quality classement (`analysis/`)**
| Métrique | Description |
| --- | --- |
| analysis/batch\_completion\_ratio | total\_completed / batch\_size— fraction des groupes attendus qui sont arrivés |
| analysis/batch\_valid\_ratio | valid\_count / batch\_size— avantages non nuls par rapport au lot complet |
| analysis/zero\_adv\_groups | Groupes où toutes les transitions ont un avantage quasi nul |
| analysis/zero\_adv\_nonzero\_reward | Zero-advantage groupes où au moins une transition a une récompense différente de 0 (cas tout à fait correct pour les récompenses binaires) |
| analysis/zero\_adv\_zero\_reward | Zero-advantage groupes où toutes les récompenses sont nulles (faux cas) |
| analysis/reward\_variance\_across\_groups | Variance des récompenses moyennes par groupe (élevée = lot diversifié) |
| analysis/mean\_group\_reward\_spread | Répartition moyenne des récompenses au sein du groupe max - min |
**Récompense d'évaluation et pass @k (`val/reward/`)**
Émis à la ligne de base (étape 0), à chaque `val_every` intervalle et à l'étape finale. Inclut les mêmes indicateurs de distribution, auxquels s'`rollout/reward`ajoutent les indicateurs de récompenses de groupe agrégés par invite.
**Diffusion :**
| Métrique | Description |
| --- | --- |
| val/reward/mean | Récompense moyenne par rapport au set d'évaluation |
| val/reward/std | Récompense Std Dev |
| val/reward/min | Récompense minimale |
| val/reward/max | Récompense maximale |
| val/reward/zero\_frac | Fraction de trajectoires sans récompense |
**Group-reward (agrégation par invite) :**
| Métrique | Description |
| --- | --- |
| val/reward/min\_within\_groups | Récompense minimale moyenne par invite |
| val/reward/mean\_within\_groups | Récompense moyenne par invite |
| val/reward/max\_within\_groups | Récompense maximale moyenne par invite |
| val/reward/std\_within\_groups | Récompense moyenne par invite (cohérence) |
| val/reward/rollouts\_per\_prompt | Nombre moyen de déploiements (n) entre les invites |
| val/reward/num\_prompts | Des instructions distinctes ont été évaluées |
**Pass @k et comptabilité des réussites :**
| Métrique | Description |
| --- | --- |
| val/reward/succeeded\_rollouts | Nombre total de déploiements avec récompense ≥ success\_threshold |
| val/reward/failed\_rollouts | Nombre total de déploiements avec récompense < success\_threshold |
| val/reward/success\_threshold | Seuil utilisé (reproduit en écho pour plus de clarté) |
| val/reward/pass\_at\_{k} | Probabilité ≥ 1 de k échantillons réussis |
| val/reward/pass\_power\_{k} | Probabilité de réussite de tous les k échantillons (fiabilité) |
**Le tour d'évaluation compte (`val/turns/`)**
| Métrique | Description |
| --- | --- |
| val/turns/mean | Nombre moyen de virages par trajectoire d'évaluation |
| val/turns/min | Nombre de tours minimum |
| val/turns/max | Nombre maximum de tours |
**Longueurs des jetons d'évaluation (`val/tokens/`)**
| Métrique | Description |
| --- | --- |
| val/tokens/prompt\_mean | Nombre moyen de jetons rapides par transition |
| val/tokens/response\_mean | Nombre moyen de jetons de réponse par transition |
| val/tokens/response\_std | Écart type des jetons de réponse |
| val/tokens/response\_min | Nombre minimal de jetons de réponse |
| val/tokens/response\_max | Nombre maximal de jetons de réponse |
**Évaluation de l'état des probabilités logarithmiques () `val/logprob/`**
| Métrique | Description |
| --- | --- |
| val/logprob/zero\_count | Nombre total de jetons Zero-LogProb |
| val/logprob/zero\_frac | Fraction de zéro (logprobs) |
| val/logprob/zero\_per\_group | Zéro logprobs par groupe |
| val/logprob/nz\_mean | Moyenne de probs logarithmiques non nuls |
| val/logprob/nz\_std | Écart type des probs logprobs non nuls |
| val/logprob/nz\_min | Logprob minimal différent de zéro |
| val/logprob/nz\_max | Logprob maximal différent de zéro |
**Accès à l'interface utilisateur de MLflow**
Accédez à l'interface utilisateur de MLflow via une URL présignée :
```
aws sagemaker create-presigned-mlflow-app-url \
--arn arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id \
--region us-west-2
```
Copiez le `AuthorizedUrl` résultat dans votre navigateur.
#### Trajectoires et traces des agents
Pendant la formation, l' SageMaker IA enregistre chaque interaction entre votre agent et le modèle de politique sous forme de trajectoire, soit l'enregistrement complet d'un déploiement. Chaque trajectoire capture chaque demande envoyée au modèle, chaque réponse générée, chaque appel d'outil effectué et la récompense finale. Les trajectoires sont publiées dans votre expérience MLflow sous forme de traces structurées.
**Tracer le contenu**
+ L'invite de saisie de votre ensemble de données d'entraînement
+ Chaque tour d'inférence du modèle (données d'invite, de réponse et de niveau jeton)
+ Les appels aux outils et leurs résultats, si votre agent utilise des outils
+ Le score de récompense final
+ Informations de chronométrage pour chaque tour
**Affichage des trajectoires dans l'interface utilisateur de MLflow**
Accédez à l'interface utilisateur de MLflow via une URL présignée :
```
aws sagemaker create-presigned-mlflow-app-url \
--arn arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id \
--region us-west-2
```
Copiez le `AuthorizedUrl` résultat dans votre navigateur.
Ouvrez l'interface utilisateur MLflow à l'aide de l'URL présignée ci-dessus. Accédez à l'exécution de votre test et sélectionnez l'onglet Traces. Chaque trace représente un déploiement terminé et indique :
+ L'invite du système et l'invite de l'utilisateur
+ Chaque réponse de l'assistant (avec thinking/reasoning le cas échéant)
+ Plans d'utilisation des outils indiquant quels outils ont été appelés et leurs résultats
+ Le score de récompense attribué à la trajectoire
**Utilisez des trajectoires pour corriger les faibles scores de récompense**
| Symptôme | Ce qu’il faut rechercher |
| --- | --- |
| Faible récompense dans la plupart des déploiements | Les réponses des modèles sont-elles cohérentes ? Le format de l'invite est-il correct ? |
| Tool-related échecs | Les appels aux outils sont-ils couronnés de succès ? Les entrées et les sorties sont-elles bien formées ? |
| Agent en boucle | L'agent répète-t-il les mêmes actions sans progresser ? |
| Réponses tronquées | Les réponses sont-elles interrompues par la limite MaxTokens ? |
## Obtenez des résultats d'entraînement
À la fin d'une tâche d'entraînement, les poids de vos modèles entraînés sont stockés sous forme de package de modèles SageMaker AI. Cette section explique comment trouver vos résultats, comprendre les types de points de contrôle produits pendant la formation et les utiliser pour le déploiement ou la formation continue.
### Comment les résultats sont stockés
SageMaker L'IA stocke les résultats de formation sous forme de packages de modèles immuables et versionnés dans des groupes de packages de modèles. Multi-turn RL utilise deux groupes distincts, que vous spécifiez lors de la création d'une tâche :
| Groupe | Objectif | Table des matières |
| --- | --- | --- |
| Groupe de packages de modèles de sortie | Modèle entraîné final | HuggingFace-compatible Poids des adaptateurs LoRa (adapter\_config.json \+ adapter\_model.safetensors) |
| Groupe de packages de modèles de points de contrôle intermédiaires | État de reprise de l'entraînement | Poids de l'adaptateur LoRa \+ états de l'optimiseur \+ métadonnées des étapes d'entraînement |
**Configurez les deux groupes dans votre ModelPackageConfig :**
```
"ModelPackageConfig": {
"OutputModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-final-models",
"IntermediateCheckpointModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-intermediate-checkpoints"
}
```
### Types de points de contrôle
La formation produit deux types de points de contrôle, enregistrés à chaque étape de la formation :
**Point de contrôle du modèle (poids uniquement)**
+ Stocké dans le groupe de packages du modèle de sortie
+ Contient les poids des adaptateurs HuggingFace-compatible LoRa au format SafeTensors
+ À utiliser pour l'inférence, le déploiement ou comme point de départ pour un nouveau travail de formation
+ Créé à chaque étape, à la fin de la tâche et lorsqu'une tâche est arrêtée
**Point de contrôle réutilisable (état complet)**
+ Stocké dans le groupe de packages du modèle de point de contrôle intermédiaire
+ Contient les poids des adaptateurs LoRa, les états de l'optimiseur et les métadonnées des étapes d'entraînement par GPU
+ À utiliser pour reprendre une tâche interrompue à partir de l'étape exacte à laquelle elle s'est arrêtée
+ Format interne : non directement utilisable pour l'inférence
### Cycle de vie des points de contrôle
```
Step 1 → Intermediate Checkpoint (resumable)
Step 1 → Intermediate Checkpoint (HF-compatible)
...
Step N-1 → Intermediate Checkpoint (resumable)
Step N-1 → Intermediate Checkpoint (HF-compatible)
...
Step N (final) → Model Checkpoint (HuggingFace LoRA) → Output Model Package Group
```
### Récupérez votre modèle entraîné
Lorsqu'une tâche est terminée avec succès, le modèle final est enregistré en tant que package de modèles dans le groupe de packages de modèles de sortie. Le `OutputModelPackageArn` champ de l'enregistrement de tâche contient l'ARN.
Vérifiez l'achèvement de la tâche et récupérez l'ARN du modèle de sortie :
```
aws sagemaker describe-job \
--job-name "my-agent-rft-job" \
--job-category AgentRFT \
--region us-west-2
```
Recherchez `OutputModelPackageArn` dans la réponse. Utilisez-le pour décrire le Model Package et obtenir l'emplacement S3 des poids :
```
aws sagemaker describe-model-package \
--model-package-name "arn:aws:sagemaker:us-west-2:123456789012:model-package/my-final-models/5"
```
Si une tâche échoue ou est arrêtée avant d'être terminée, le dernier point de contrôle intermédiaire est promu au Output Model Package Group dans la mesure du possible. Vérifiez `OutputModelPackageArn` de la même manière.
Pour surveiller la création de points de contrôle pendant l'entraînement, observez les `ModelCheckpoint` champs `ResumableCheckpoint` et en DescribeJob sortie.
### Reprendre une tâche interrompue
Si une tâche échoue ou est interrompue en cours de formation, vous pouvez commencer une nouvelle tâche en reprenant exactement l'étape où elle s'était arrêtée. La plateforme rétablit l'état complet de l'entraînement (poids, optimisation de l'élan et compteur de pas) à partir du point de contrôle reprenant.
Spécifiez un point de contrôle pouvant être repris dans le groupe de packages du modèle de point de contrôle intermédiaire comme suit : `InputModelPackageArn`
```
"ModelPackageConfig": {
"OutputModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-final-models",
"IntermediateCheckpointModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-intermediate-checkpoints",
"InputModelPackageArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package/my-intermediate-checkpoints/5"
}
```
Le `InputModelPackageArn` doit pointer vers un point de contrôle révocable (un point dont les métadonnées du Model Package `IsCheckpoint=true` figurent dans ses métadonnées). L'entraînement reprend à partir de l'étape qui suit le point de contrôle. Par exemple, si le point de contrôle a été enregistré à l'étape 4, l'entraînement continue à partir de l'étape 5.
Les éléments suivants doivent rester les mêmes entre le travail d'origine et le travail repris :
+ Modèle de base
+ Configuration LoRa (rang et alpha)
+ Hyperparamètres (taux d'apprentissage, taille du lot, etc.)
+ Jeu de données
### Poursuivre la formation sur un nouvel emploi (formation itérative)
L'entraînement itératif vous permet de vous appuyer sur un modèle déjà entraîné avec un ensemble de données différent, différents hyperparamètres ou une fonction de récompense affinée. Contrairement à la reprise, cela permet de démarrer une nouvelle série d'entraînement : l'optimiseur se réinitialise, le compteur de pas est remis à 0 et seuls les poids LoRa entraînés sont reportés.
Spécifiez un point de contrôle du modèle dans le groupe de packages de modèles de sortie comme suit : `InputModelPackageArn`
```
"ModelPackageConfig": {
"OutputModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-final-models",
"IntermediateCheckpointModelPackageGroupArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package-group/my-intermediate-checkpoints",
"InputModelPackageArn": "arn:aws:sagemaker:us-west-2:123456789012:model-package/my-final-models/3"
}
```
**Ce que vous pouvez modifier entre les itérations :**
+ Hyperparamètres (taux d'apprentissage, taille du lot, max\_steps, group\_size, etc.)
+ Ensemble de données (instructions ou distribution des données différentes)
+ Fonction de récompense
+ Configuration de l'agent
**Ce qui doit rester inchangé :**
+ Modèle de base — l'adaptateur LoRa est lié à l'architecture du modèle de base
Modèles courants pour la formation itérative :
+ **Apprentissage scolaire** : entraînez-vous d'abord sur les problèmes les plus simples, puis continuez sur les plus difficiles
+ **Affinement des récompenses** : commencez par une fonction de récompense simple, puis itérez avec une fonction plus nuancée
+ **Ajustement des hyperparamètres** : augmentez la taille du lot ou ajustez le taux d'apprentissage après avoir observé la dynamique d'entraînement initiale
### Bonnes pratiques en matière de points de contrôle
+ **Surveillez la création de points de contrôle**. DescribeJob Utilisez-le pour effectuer le suivi `ResumableCheckpoint` `ModelCheckpoint` et le terrain pendant l'entraînement afin de savoir ce qui est disponible si vous devez le reprendre.
+ **Prévoyez les défaillances lors de travaux de longue durée.** Si une tâche comporte de nombreuses étapes, concevez votre flux de travail pour qu'il reprenne à partir de points de contrôle plutôt que de recommencer à zéro.