Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Invio di un lavoro di formazione

Avvio di lavori di formazione

Dopo aver distribuito l'agente e aver installato il set di dati in S3, crea un processo di formazione utilizzando uno dei seguenti metodi.

SageMaker AI Studio

SageMaker SDK per AI per Python

Scopri i modelli supportati

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

Configura l'ambiente del tuo agente

Opzione 1: Bedrock runtime AgentCore

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

Opzione 2: agente Lambda personalizzato

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

Registra il tuo set di dati (opzionale)

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

Crea un gruppo di pacchetti di modelli con restrizioni per Nova (opzionale)

Se scegli Nova model (nova-textgeneration-lite-v2), crea facoltativamente Restricted Model Package Group prima di inviare un lavoro di formazione (passaggio successivo). Se salti questo passaggio, l'SDK ne crea automaticamente uno per te.

Restricted Model Package Group (RMPG) è un Model Package Group con ManagedStorageType: Restricted. È necessario per i modelli closed-source come Nova, in cui i pesi dei modelli sono gestiti dal cliente AWS e non sono direttamente accessibili al cliente.

Lo schema di lavoro RFT richiede due MPG con restrizioni separati:

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 volta creato il gruppo di pacchetti Model, passate i gruppi nel passaggio successivo quando inviate un lavoro di formazione.

Invia un lavoro di formazione 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}")

Invia un lavoro di formazione con un agente Lambda personalizzato

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

Invia un lavoro di formazione con il gruppo di pacchetti Restricted Model per Nova

Fai riferimento al passaggio precedente (Create Restricted Model Package Group for Nova) su come creare un gruppo 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

Crea un lavoro di formazione utilizzando l'CreateJobAPI. È possibile specificare la configurazione dell'agente, la posizione dei dati di addestramento, il modello di base e le impostazioni di output inJobConfigDocument.

Per recuperare lo JobConfigDocument schema completo:

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

Crea lavoro 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

Crea un lavoro con un agente Lambda personalizzato

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

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

Crea un lavoro con un agente Lambda personalizzato

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

Formazione sul monitoraggio

Monitora il tuo Training Job

Utilizza l'DescribeJobAPI per controllare lo stato attuale del tuo lavoro in qualsiasi momento. Lo stato del lavoro passa daInProgress, e poi aCompleted, Failed oStopped.

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

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

Monitora la formazione in MLFlow

SageMaker L'intelligenza artificiale si integra automaticamente con MLFlow gestito per tenere traccia dei progressi, delle metriche e degli artefatti del processo di formazione. Per abilitare il tracciamento MLFlow, includi nel tuo lavoro: MlflowConfig OutputDataConfig

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

Prerequisiti

Cosa viene registrato

Riferimento dettagliato alle metriche di allenamento

Le seguenti metriche vengono registrate in ogni fase dell'allenamento.

Contatori di passi e produttività () training/

Durate delle fasi () timing_s/

Distribuzione dei premi () rollout/reward/

I turni contano () rollout/turns/

Lunghezze dei token () rollout/tokens/

Log-probability salute () rollout/logprob/

Distribuzione dei vantaggi () rollout/advantage/

Batch-quality classificazione () analysis/

Premio di valutazione e pass @k () val/reward/

Emesso alla linea di base (fase 0), ad ogni val_every intervallo e nella fase finale. Include le stesse metriche di distribuzione rollout/reward più le metriche di ricompensa di gruppo aggregate per prompt.

Distribuzione:

Group-reward (aggregazione per prompt):

Pass @k e contabilità di successo:

I turni di valutazione contano (val/turns/)

Lunghezze dei token di valutazione () val/tokens/

Salute log-probabilistica di valutazione () val/logprob/

Accesso all'interfaccia utente MLFlow

Accedi all'interfaccia utente MLFlow tramite un URL predefinito:

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

Copia il file AuthorizedUrl dall'output nel tuo browser.

Tracce e traiettorie degli agenti

Durante la formazione, l' SageMaker intelligenza artificiale registra ogni interazione tra l'agente e il modello di policy come traiettoria, il record completo di un'unica implementazione. Ogni traiettoria registra ogni richiesta inviata al modello, ogni risposta generata, ogni intervento effettuato e la ricompensa finale. Le traiettorie vengono pubblicate nell'esperimento MLFlow come tracce strutturate.

Contenuti delle tracce

Visualizzazione delle traiettorie nell'interfaccia utente MLFlow

Accedi all'interfaccia utente MLFlow tramite un URL predefinito:

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

Copia il file AuthorizedUrl dall'output nel tuo browser.

Apri l'interfaccia utente MLFlow utilizzando l'URL predefinito riportato sopra. Vai all'esecuzione dell'esperimento e seleziona la scheda Traces. Ogni traccia rappresenta un'implementazione completata e mostra:

Usa le traiettorie per eseguire il debug dei punteggi di ricompensa bassi

Ottieni risultati di formazione

Al termine di un processo di formazione, i pesi del modello addestrato vengono archiviati come SageMaker AI Model Package. Questa sezione spiega come trovare i risultati, comprendere i tipi di checkpoint prodotti durante la formazione e utilizzarli per l'implementazione o la formazione continua.

Come vengono archiviati i risultati

SageMaker L'intelligenza artificiale memorizza i risultati della formazione come pacchetti modello con versioni e immutabili all'interno dei Model Package Groups. Multi-turn RL utilizza due gruppi separati, che vengono specificati durante la creazione di un lavoro:

Configura entrambi i gruppi nel tuo: 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"
}

Tipi di checkpoint

La formazione produce due tipi di checkpoint, salvati in ogni fase dell'allenamento:

Modello di checkpoint (solo pesi)

Checkpoint ripristinabile (stato completo)

Ciclo di vita di Checkpoint

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

Recupera il tuo modello addestrato

Quando un lavoro viene completato correttamente, il modello finale viene salvato come Model Package nell'Output Model Package Group. Il OutputModelPackageArn campo nel record del lavoro contiene l'ARN.

Controlla il completamento del lavoro e recupera il modello di output ARN:

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

Cerca OutputModelPackageArn nella risposta. Usalo per descrivere il Model Package e ottenere la posizione S3 dei pesi:

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

Se un job fallisce o viene interrotto prima del completamento, l'ultimo checkpoint intermedio viene promosso all'Output Model Package Group con la massima diligenza possibile. Controlla OutputModelPackageArn allo stesso modo.

Per monitorare la creazione dei checkpoint durante l'allenamento, guarda i ModelCheckpoint campi ResumableCheckpoint and in DescribeJob output.

Riprendere un lavoro interrotto

Se un lavoro fallisce o viene interrotto durante la fase di formazione, puoi iniziare un nuovo lavoro che riprende esattamente dalla fase in cui era stato interrotto. La piattaforma ripristina l'intero stato di allenamento (pesi, ottimizzatore dello slancio e contapassi) dal checkpoint riutilizzabile.

Specificare un checkpoint ripristinabile dall'Intermediate Checkpoint Model Package Group come: 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"
}

InputModelPackageArnDeve puntare a un checkpoint ripristinabile (uno con IsCheckpoint=true i metadati del Model Package). L'allenamento riprende dalla fase successiva al checkpoint: ad esempio, se il checkpoint è stato salvato nella fase 4, la formazione continua dalla fase 5.

Quanto segue deve rimanere lo stesso tra il lavoro originale e il lavoro ripreso:

Continuare la formazione su un nuovo lavoro (formazione iterativa)

La formazione iterativa consente di basarsi su un modello precedentemente addestrato con un set di dati diverso, diversi iperparametri o una funzione di ricompensa perfezionata. A differenza della ripresa, questo avvia una nuova sessione di allenamento: l'ottimizzatore si resetta, il contapassi si resetta a 0 e vengono trasferiti solo i pesi LoRa allenati.

Specificate un checkpoint del modello dall'Output Model Package Group comeInputModelPackageArn:

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

Cosa puoi cambiare tra le iterazioni:

Cosa deve rimanere uguale:

Modelli comuni per la formazione iterativa:

Le migliori pratiche di Checkpoint