Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Einreichung von Schulungsaufträgen

Ausbildungsjobs werden gestartet

Nachdem Ihr Agent bereitgestellt wurde und sich Ihr Datensatz in S3 befindet, erstellen Sie mit einer der folgenden Methoden einen Trainingsjob.

SageMaker AI Studio

SageMaker KI-Python-SDK

Entdecken Sie die unterstützten Modelle

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

Richten Sie Ihre Agentenumgebung ein

Option 1: Bedrock-Laufzeit AgentCore

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

Option 2: Benutzerdefinierter Lambda-Agent

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

Registrieren Sie Ihren Datensatz (optional)

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

Eingeschränkte Modellpaketgruppe für Nova erstellen (optional)

Wenn Sie das Nova-Modell (nova-textgeneration-lite-v2) wählen, erstellen Sie optional eine eingeschränkte Modellpaketgruppe, bevor Sie einen Schulungsjob einreichen (nächster Schritt). Wenn Sie diesen Schritt überspringen, erstellt das SDK automatisch einen für Sie.

Restricted Model Package Group (RMPG) ist eine Modellpaketgruppe mit ManagedStorageType: Eingeschränkt. Sie ist für Closed-Source-Modelle wie Nova erforderlich, bei denen die Modellgewichte vom Kunden verwaltet werden AWS und der Kunde nicht direkt darauf zugreifen kann.

Das RFT-Auftragsschema erfordert zwei separate eingeschränkte MPGs:

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)

Sobald die Modell-Paketgruppe erstellt wurde, übergeben Sie die Gruppen im nächsten Schritt, wenn Sie einen Schulungsjob einreichen.

Reichen Sie einen Schulungsjob bei Bedrock ein 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}")

Reichen Sie einen Schulungsjob mit einem benutzerdefinierten Lambda-Agenten ein

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

Reichen Sie einen Schulungsjob mit der Paketgruppe Restricted Model für Nova ein

Im obigen Schritt (Eingeschränkte Modellpaketgruppe für Nova erstellen) erfahren Sie, wie Sie eine eingeschränkte Modellpaketgruppe erstellen.

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

Erstellen Sie mithilfe der CreateJob API einen Schulungsjob. Sie geben die Agentenkonfiguration, den Speicherort der Trainingsdaten, das Basismodell und die Ausgabeeinstellungen in der anJobConfigDocument.

So rufen Sie das vollständige JobConfigDocument Schema ab:

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

Job bei Bedrock erstellen 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

Job mit benutzerdefiniertem Lambda-Agent erstellen

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

Job bei Bedrock erstellen 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']}")

Job mit benutzerdefiniertem Lambda-Agent erstellen

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

Schulung überwachen

Überwachen Sie Ihren Trainingsjob

Verwenden Sie die DescribeJob API, um den aktuellen Status Ihres Jobs jederzeit zu überprüfen. Der Jobstatus wechselt durch InProgress und dann zu Completed Failed oderStopped.

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

Verwenden Sie das 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}")

Überwachen Sie das Training in MLflow

SageMaker KI lässt sich automatisch in Managed MLflow integrieren, um den Fortschritt, die Kennzahlen und Artefakte Ihres Trainingsjobs zu verfolgen. Um das MLFlow-Tracking zu aktivieren, fügen Sie Ihrem Job Folgendes hinzu: MlflowConfig OutputDataConfig

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

Voraussetzungen

Was wird protokolliert

Detaillierte Referenz zu Trainingsmetriken

Die folgenden Messwerte werden bei jedem Trainingsschritt protokolliert.

Schrittzähler und Durchsatz () training/

Dauer der Phasen () timing_s/

Verteilung der Prämien (rollout/reward/)

Runde zählt () rollout/turns/

Token-Längen () rollout/tokens/

Log-probability Gesundheit () rollout/logprob/

Verteilung der Vorteile () rollout/advantage/

Batch-quality Einstufung (analysis/)

Bewertung belohnen und bestehen @k () val/reward/

Wird zu Beginn (Schritt 0), in jedem val_every Intervall und im letzten Schritt ausgegeben. Beinhaltet dieselben Verteilungskennzahlen wie rollout/reward plus die nach Aufforderung aggregierten Kennzahlen zur Gruppenprämie.

Verteilung:

Group-reward (Aggregation pro Aufforderung):

Pass @k und Erfolgsrechnung:

Die Auswertung zählt (val/turns/)

Längen der Evaluierungstoken (val/tokens/)

Bewertung des Zustands anhand von Log-Wahrscheinlichkeitsdaten () val/logprob/

Zugriff auf die MLflow-Benutzeroberfläche

Greifen Sie über eine vorsignierte URL auf die MLflow-Benutzeroberfläche zu:

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

Kopieren Sie das AuthorizedUrl aus der Ausgabe in Ihren Browser.

Flugbahnen und Spuren der Agenten

Während der Schulung zeichnet SageMaker KI jede Interaktion zwischen Ihrem Agenten und dem Richtlinienmodell als Verlauf auf — die vollständige Aufzeichnung eines Rollouts. Jede Trajektorie erfasst jede an das Modell gesendete Aufforderung, jede generierte Antwort, jeden Tool-Aufruf und die endgültige Belohnung. Trajektorien werden als strukturierte Spuren in Ihrem MLflow-Experiment veröffentlicht.

Inhalt der Spuren

Trajektorien in der MLflow-Benutzeroberfläche anzeigen

Greifen Sie über eine vorsignierte URL auf die MLflow-Benutzeroberfläche zu:

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

Kopieren Sie das AuthorizedUrl aus der Ausgabe in Ihren Browser.

Öffnen Sie die MLflow-Benutzeroberfläche mit der oben vorsignierten URL. Navigieren Sie zur Ausführung Ihres Experiments und wählen Sie die Registerkarte Traces aus. Jeder Trace steht für einen abgeschlossenen Rollout und zeigt:

Verwenden Sie Trajektorien, um niedrige Belohnungswerte zu debuggen

Holen Sie sich Trainingsergebnisse

Wenn ein Trainingsjob abgeschlossen ist, werden Ihre trainierten Modellgewichte als SageMaker KI-Modellpaket gespeichert. In diesem Abschnitt wird erklärt, wie Sie Ihre Ergebnisse ermitteln, die während des Trainings erstellten Checkpoint-Typen verstehen und sie für den Einsatz oder die Weiterbildung verwenden können.

Wie werden Ergebnisse gespeichert

SageMaker KI speichert die Trainingsergebnisse als versionierte, unveränderliche Modellpakete innerhalb von Modellpaketgruppen. Multi-turn RL verwendet zwei separate Gruppen, die Sie bei der Erstellung eines Jobs angeben:

Konfigurieren Sie beide Gruppen in Ihrem: 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"
}

Checkpoint-Typen

Beim Training werden zwei Arten von Checkpoints erstellt, die bei jedem Trainingsschritt gespeichert werden:

Modell-Checkpoint (nur Gewichte)

Prüfpunkt, der wieder aufgenommen werden kann (vollständiger Status)

Checkpoint-Lebenszyklus

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

Rufen Sie Ihr trainiertes Modell ab

Wenn ein Job erfolgreich abgeschlossen wurde, wird das endgültige Modell als Modellpaket in der Ausgabemodellpaketgruppe gespeichert. Das OutputModelPackageArn Feld im Jobdatensatz enthält den ARN.

Überprüfen Sie den Abschluss des Jobs und rufen Sie den ARN des Ausgabemodells ab:

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

Suchen Sie OutputModelPackageArn in der Antwort nach. Verwenden Sie es, um das Modellpaket zu beschreiben und die S3-Position der Gewichte zu ermitteln:

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

Wenn ein Job fehlschlägt oder vor Abschluss gestoppt wird, wird der letzte Zwischenprüfpunkt nach bestem Wissen in die Output Model Package Group heraufgestuft. Überprüfen Sie OutputModelPackageArn auf dieselbe Weise.

Um die Erstellung von Checkpoints während des Trainings zu überwachen, schauen Sie sich die ModelCheckpoint Felder ResumableCheckpoint und in der DescribeJob Ausgabe an.

Setzt einen unterbrochenen Job fort

Wenn ein Job fehlschlägt oder während des Trainings unterbrochen wird, können Sie einen neuen Job beginnen, der genau dort weitermacht, wo er aufgehört hat. Die Plattform stellt den gesamten Trainingsstatus — Gewichte, Optimizer-Impuls und Schrittzähler — vom Kontrollpunkt aus wieder her.

Geben Sie einen wiederaufnehmbaren Checkpoint aus der Intermediate Checkpoint Model Package Group wie folgt an: 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"
}

Der InputModelPackageArn muss auf einen wiederaufnehmbaren Prüfpunkt verweisen (einen mit Metadaten IsCheckpoint=true in den Modellpaket-Metadaten). Das Training wird mit dem Schritt nach dem Checkpoint fortgesetzt. Wenn der Checkpoint beispielsweise in Schritt 4 gespeichert wurde, wird das Training ab Schritt 5 fortgesetzt.

Folgendes muss zwischen dem ursprünglichen Job und dem wiederaufgenommenen Job gleich bleiben:

Setzen Sie das Training für einen neuen Job fort (iteratives Training)

Mit iterativem Training können Sie auf einem zuvor trainierten Modell mit einem anderen Datensatz, anderen Hyperparametern oder einer verfeinerten Belohnungsfunktion aufbauen. Im Gegensatz zur Wiederaufnahme wird damit ein neuer Trainingslauf gestartet — der Optimierer wird zurückgesetzt, der Schrittzähler wird auf 0 zurückgesetzt und nur die trainierten LoRa-Gewichte werden übernommen.

Geben Sie einen Modell-Checkpoint aus der Output Model Package Group an alsInputModelPackageArn:

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

Was Sie zwischen den Iterationen ändern können:

Was muss gleich bleiben:

Übliche Muster für iteratives Training:

Bewährte Methoden bei Checkpoint