Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Presentación de trabajos de formación

Lanzamiento de trabajos de formación

Una vez que el agente esté desplegado y el conjunto de datos esté en S3, cree un trabajo de formación mediante uno de los siguientes métodos.

SageMaker AI Studio

SageMaker SDK de Python para IA

Descubra los modelos compatibles

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

Configure su entorno de agentes

Opción 1: tiempo de ejecución de Bedrock AgentCore

# List available runtimes
runtimes = MultiTurnRLTrainer.list_bedrock_agentcore_runtimes()
for rt in runtimes:
    print(f"  - {rt['name']} ({rt['status']}) → {rt['arn']}")

Opción 2: agente Lambda personalizado

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")

Registre su conjunto de datos (opcional)

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

Crear un grupo de paquetes de modelos restringidos para Nova (opcional)

Si elige el modelo Nova (nova-textgeneration-lite-v2), puede crear opcionalmente un grupo de paquetes de modelos restringidos antes de enviar un trabajo de formación (siguiente paso). Si te saltas este paso, el SDK creará uno automáticamente para ti.

Restricted Model Package Group (RMPG) es un grupo de paquetes modelo con ManagedStorageType: Restricted. Es obligatorio para los modelos de código cerrado, como Nova, donde los pesos de los modelos son gestionados por el cliente AWS y el cliente no puede acceder directamente a ellos.

El esquema de tareas de RFT requiere dos MPG restringidos independientes:

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)

Una vez creado el grupo de paquetes modelo, pase los grupos al siguiente paso al enviar un trabajo de formación.

Envíe un trabajo de formación con 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}")

Envíe un trabajo de formación con un agente Lambda personalizado

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

Envíe un trabajo de formación con el grupo de paquetes de modelos restringidos para Nova

Consulte el paso anterior (Crear un grupo de paquetes de modelos restringidos para Nova) sobre cómo crear un grupo de paquetes de modelos restringidos.

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 CLI

Cree un trabajo de formación mediante la CreateJob API. La configuración del agente, la ubicación de los datos de entrenamiento, el modelo base y los ajustes de salida se especifican enJobConfigDocument.

Para recuperar el JobConfigDocument esquema completo:

aws sagemaker list-job-schema-versions --job-category AgentRFT
aws sagemaker describe-job-schema-version --job-category AgentRFT --version "1.0.0"

Cree un trabajo con 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

Cree un trabajo con un agente Lambda personalizado

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

Cree un trabajo con 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']}")

Cree un trabajo con un agente Lambda personalizado

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']}")

Capacitación sobre monitoreo

Supervise su trabajo de formación

Usa la DescribeJob API para comprobar el estado actual de tu trabajo en cualquier momento. El estado del trabajo pasa de un lado a otro yInProgress, despuésCompleted, a Failed oStopped.

aws sagemaker describe-job \
  --job-name "my-agent-rft-job" \
  --job-category AgentRFT \
  --region us-west-2

Usa el 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}")

Supervise la formación en MLflow

SageMaker La IA se integra automáticamente con el MLflow gestionado para realizar un seguimiento del progreso, las métricas y los artefactos de su trabajo de formación. Para habilitar el seguimiento de MLflow, incluye uno de los siguientes MlflowConfig elementos en tu trabajo: OutputDataConfig

"OutputDataConfig": {
    "S3OutputPath": "s3://your-bucket/output/",
    "MlflowConfig": {
        "MlflowResourceArn": "arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/my-rft-mlflow-app"
    }
}

Requisitos previos

¿Qué se registra

Referencia detallada de las métricas de entrenamiento

Las siguientes métricas se registran en cada paso del entrenamiento.

Contadores de pasos y rendimiento () training/

Duraciones de fase () timing_s/

Distribución de recompensas (rollout/reward/)

El turno cuenta () rollout/turns/

Longitudes de los tokens () rollout/tokens/

Log-probability salud () rollout/logprob/

Distribución de ventajas () rollout/advantage/

Batch-quality clasificación (analysis/)

Recompensa y pase de evaluación @k () val/reward/

Se emite al inicio (paso 0), en cada val_every intervalo y en el paso final. Incluye las mismas métricas de distribución, rollout/reward además de las métricas de recompensas grupales agregadas por solicitud.

Distribución:

Group-reward (agregación por mensaje):

Pass @k y la contabilidad del éxito:

El número de turnos de evaluación cuenta (val/turns/)

Longitudes de los tokens de evaluación (val/tokens/)

Estado de probabilidad logarítmica de evaluación () val/logprob/

Acceso a la interfaz de usuario de MLflow

Acceda a la interfaz de usuario de MLflow a través de una URL prefirmada:

aws sagemaker create-presigned-mlflow-app-url \
  --arn arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id \
  --region us-west-2

Copie el AuthorizedUrl archivo de salida a su navegador.

Trayectorias y trazas de los agentes

Durante la formación, la SageMaker IA registra todas las interacciones entre el agente y el modelo de política como una trayectoria, es decir, el registro completo de una implementación. Cada trayectoria captura cada solicitud enviada al modelo, cada respuesta generada, cada llamada de herramienta realizada y la recompensa final. Las trayectorias se publican en su experimento de MLflow como trazas estructuradas.

Rastrea el contenido

Visualización de las trayectorias en la interfaz de usuario de MLflow

Acceda a la interfaz de usuario de MLflow a través de una URL prefirmada:

aws sagemaker create-presigned-mlflow-app-url \
  --arn arn:aws:sagemaker:us-west-2:123456789012:mlflow-app/mlflow-app-id \
  --region us-west-2

Copie el AuthorizedUrl archivo de salida a su navegador.

Abra la interfaz de usuario de MLflow con la URL prefirmada de arriba. Navega hasta la ejecución del experimento y selecciona la pestaña Rastros. Cada traza representa una implementación completada y muestra lo siguiente:

Usa las trayectorias para depurar las puntuaciones de recompensa bajas

Obtenga los resultados de la capacitación

Cuando se completa un trabajo de entrenamiento, las pesas del modelo entrenado se almacenan como un SageMaker AI Model Package. En esta sección se explica cómo encontrar los resultados, comprender los tipos de puntos de control que se generan durante el entrenamiento y utilizarlos para el despliegue o la formación continua.

¿Cómo se almacenan los resultados

SageMaker La IA almacena los resultados del entrenamiento como paquetes de modelos versionados e inmutables dentro de los grupos de paquetes de modelos. Multi-turn RL usa dos grupos separados, que se especifican al crear un trabajo:

Configura ambos grupos en tu: 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"
}

Tipos de puntos de control

La formación produce dos tipos de puntos de control, que se guardan en cada paso de la formación:

Punto de control modelo (solo pesos)

Punto de control reanudable (estado completo)

Ciclo de vida de los puntos

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

Recupere su modelo entrenado

Cuando un trabajo se completa correctamente, el modelo final se guarda como paquete de modelos en el grupo de paquetes de modelos de salida. El OutputModelPackageArn campo del registro de trabajo contiene el ARN.

Compruebe la finalización del trabajo y recupere el ARN del modelo de salida:

aws sagemaker describe-job \
--job-name "my-agent-rft-job" \
--job-category AgentRFT \
--region us-west-2

Busque OutputModelPackageArn en la respuesta. Úselo para describir el Model Package y obtener la ubicación S3 de las pesas:

aws sagemaker describe-model-package \
--model-package-name "arn:aws:sagemaker:us-west-2:123456789012:model-package/my-final-models/5"

Si un trabajo falla o se detiene antes de completarse, el último punto de control intermedio pasa al Output Model Package Group haciendo todo lo posible. Compruébelo OutputModelPackageArn de la misma manera.

Para supervisar la creación de puntos de control durante el entrenamiento, observa los ModelCheckpoint campos ResumableCheckpoint y del DescribeJob resultado.

Reanude un trabajo interrumpido

Si un trabajo fracasa o se interrumpe a mitad del entrenamiento, puedes empezar un nuevo trabajo retomando el mismo paso en el que lo dejaste. La plataforma restaura el estado completo del entrenamiento (pesas, optimizador de impulso y contador de pasos) desde el punto de control que se puede reanudar.

Especifique un punto de control reanudable del grupo de paquetes del modelo de punto de control intermedio como: 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"
}

InputModelPackageArnDebe apuntar a un punto de control reanudable (uno que figure IsCheckpoint=true en sus metadatos del Model Package). El entrenamiento se reanuda desde el paso posterior al punto de control; por ejemplo, si el punto de control se guardó en el paso 4, el entrenamiento continúa desde el paso 5.

Lo siguiente debe permanecer igual entre el trabajo original y el trabajo reanudado:

Continuar formándose para un nuevo trabajo (formación iterativa)

El entrenamiento iterativo te permite basarte en un modelo previamente entrenado con un conjunto de datos diferente, diferentes hiperparámetros o una función de recompensa refinada. A diferencia de la reanudación, esto inicia una nueva sesión de entrenamiento: el optimizador se restablece, el contador de pasos se restablece a 0 y solo se transfieren las pesas LoRa entrenadas.

Especifique un punto de control de modelo del grupo Output Model Package Group comoInputModelPackageArn:

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

Qué puede cambiar entre iteraciones:

Qué debe permanecer igual:

Patrones comunes para el entrenamiento iterativo:

Mejores prácticas de Checkpoint