As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Envio de trabalhos de treinamento

Lançamento de trabalhos de treinamento

Depois que seu agente for implantado e seu conjunto de dados estiver no S3, crie um trabalho de treinamento usando um dos métodos a seguir.

SageMaker Estúdio AI

SageMaker SDK AI para Python

Descubra os modelos compatíveis

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 seu ambiente de agente

Opção 1: tempo de execução do Bedrock AgentCore

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

Opção 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 seu conjunto de dados (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}")

Crie um grupo restrito de pacotes de modelos para Nova (opcional)

Se você estiver escolhendo o modelo Nova (nova-textgeneration-lite-v2), crie opcionalmente o Restricted Model Package Group antes de enviar um trabalho de treinamento (próxima etapa). Se você pular essa etapa, o SDK criará automaticamente uma para você.

O Restricted Model Package Group (RMPG) é um grupo de pacotes de modelos com ManagedStorageType: Restricted. É necessário para modelos de código fechado, como o Nova, em que os pesos do modelo são gerenciados pelo cliente AWS e não estão diretamente acessíveis ao cliente.

O esquema de trabalho do RFT requer dois MPGs restritos separados:

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)

Depois que o grupo de pacotes do modelo for criado, passe os grupos na próxima etapa ao enviar um trabalho de treinamento.

Envie um trabalho de treinamento com a 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}")

Envie um trabalho de treinamento com um 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}")

Envie um trabalho de treinamento com o grupo de pacotes Restricted Model para Nova

Consulte a etapa acima (Create Restricted Model Package Group for Nova) para saber como criar um grupo de Restricted Model Package.

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

Crie um trabalho de treinamento usando a CreateJob API. Você especifica a configuração do agente, a localização dos dados de treinamento, o modelo básico e as configurações de saída noJobConfigDocument.

Para recuperar o 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"

Crie emprego com o 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

Crie um trabalho com um 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

Crie emprego com o 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']}")

Crie um trabalho com um 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']}")

Treinamento de monitoramento

Monitore seu Training Job

Use a DescribeJob API para verificar o status atual do seu trabalho a qualquer momento. O status do trabalho passa porInProgress, e depois paraCompleted, Failed ouStopped.

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

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

Monitore o treinamento no MLflow

SageMaker A IA se integra automaticamente ao MLflow gerenciado para monitorar o progresso, as métricas e os artefatos do seu trabalho de treinamento. Para habilitar o rastreamento do MLflow, inclua um MlflowConfig em seu trabalho: OutputDataConfig

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

Pré-requisitos

O que é registrado

Referência detalhada de métricas de treinamento

As métricas a seguir são registradas em cada etapa do treinamento.

Contadores de etapas e taxa de transferência () training/

Durações de fase () timing_s/

Distribuição de recompensas (rollout/reward/)

Contagens de turnos (rollout/turns/)

Comprimentos de token () rollout/tokens/

Log-probability saúde (rollout/logprob/)

Distribuição de vantagens (rollout/advantage/)

Batch-quality classificação (analysis/)

Recompensa de avaliação e aprovação @k (val/reward/)

Emitido na linha de base (etapa 0), em cada val_every intervalo e na etapa final. Inclui as mesmas métricas de distribuição, rollout/reward além das métricas de recompensa de grupo agregadas por prompt.

Distribuição:

Group-reward (agregação por prompt):

Pass @k e a contabilidade do sucesso:

Contagens de turnos de avaliação (val/turns/)

Comprimentos do token de avaliação () val/tokens/

Avaliação da saúde log-probabilística () val/logprob/

Acessando a interface do usuário do MLflow

Acesse a interface do usuário do MLflow por meio de um URL pré-assinado:

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 o AuthorizedUrl da saída para o seu navegador.

Trajetórias e traços do agente

Durante o treinamento, a SageMaker IA registra cada interação entre seu agente e o modelo de política como uma trajetória — o registro completo de uma implementação. Cada trajetória captura cada solicitação enviada ao modelo, cada resposta gerada, cada chamada de ferramenta feita e a recompensa final. As trajetórias são publicadas em seu experimento MLflow como traços estruturados.

Rastrear conteúdo

Visualizando trajetórias na interface do usuário do MLflow

Acesse a interface do usuário do MLflow por meio de um URL pré-assinado:

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 o AuthorizedUrl da saída para o seu navegador.

Abra a interface do usuário do MLflow usando o URL pré-assinado acima. Navegue até a execução do seu experimento e selecione a guia Traços. Cada rastreamento representa uma implantação concluída e mostra:

Use trajetórias para depurar baixas pontuações de recompensa

Obtenha resultados de treinamento

Quando um trabalho de treinamento é concluído, os pesos do modelo treinado são armazenados como um SageMaker AI Model Package. Esta seção explica como encontrar seus resultados, entender os tipos de pontos de verificação produzidos durante o treinamento e usá-los para implantação ou treinamento contínuo.

Como os resultados são armazenados

SageMaker A IA armazena os resultados do treinamento como Pacotes de Modelos versionados e imutáveis dentro dos Model Package Groups. Multi-turn O RL usa dois grupos separados, que você especifica ao criar um trabalho:

Configure os dois grupos em seu 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 pontos de verificação

O treinamento produz dois tipos de pontos de verificação, salvos em cada etapa do treinamento:

Ponto de verificação do modelo (somente pesos)

Ponto de verificação retomável (estado completo)

Ciclo de vida do ponto de verificação

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 seu modelo treinado

Quando um trabalho é concluído com êxito, o modelo final é salvo como um Model Package no Output Model Package Group. O OutputModelPackageArn campo no registro do trabalho contém o ARN.

Verifique a conclusão do trabalho e recupere o ARN do modelo de saída:

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

Procure OutputModelPackageArn na resposta. Use-o para descrever o Model Package e obter a localização S3 dos pesos:

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

Se um trabalho falhar ou for interrompido antes da conclusão, o último ponto de verificação intermediário será promovido para o Output Model Package Group com base no melhor esforço. Verifique OutputModelPackageArn da mesma forma.

Para monitorar a criação de pontos de verificação durante o treinamento, observe os ModelCheckpoint campos ResumableCheckpoint e na DescribeJob saída.

Retomar um trabalho interrompido

Se um trabalho falhar ou for interrompido no meio do treinamento, você pode começar um novo trabalho que continue exatamente na etapa em que parou. A plataforma restaura todo o estado de treinamento — pesos, impulso do otimizador e contador de passos — a partir do ponto de verificação retomável.

Especifique um ponto de verificação retomável do Intermediate Checkpoint Model Package Group 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"
}

Eles InputModelPackageArn devem apontar para um ponto de verificação retomável (um com IsCheckpoint=true metadados do Model Package). O treinamento é retomado a partir da etapa após o ponto de verificação — por exemplo, se o ponto de verificação foi salvo na etapa 4, o treinamento continua a partir da etapa 5.

O seguinte deve permanecer o mesmo entre o trabalho original e o trabalho retomado:

Continue treinando em um novo emprego (treinamento iterativo)

O treinamento iterativo permite que você desenvolva um modelo previamente treinado com um conjunto de dados diferente, hiperparâmetros diferentes ou uma função de recompensa refinada. Ao contrário da retomada, isso inicia uma nova corrida de treinamento - o otimizador é reiniciado, o contador de passos é redefinido para 0 e apenas os pesos LoRa treinados são transferidos.

Especifique um ponto de verificação do modelo do 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"
}

O que você pode mudar entre as iterações:

O que deve permanecer o mesmo:

Padrões comuns para treinamento iterativo:

Melhores práticas do Checkpoint