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
+ Navigieren Sie im Navigationsbereich zu Modelle und wählen Sie JumpStart Basismodelle aus.
+ Wählen Sie ein Modell aus, das Multiturn-RL unterstützt (siehe Tabelle mit unterstützten Modellen), und wählen Sie dann Modell anpassen und anschließend Mit UI anpassen aus.
+ Wählen Sie Multi-Turn Reinforcement Learning als Anpassungstechnik aus.
+ Konfigurieren Sie Ihre Agentenumgebung — wählen Sie Ihre AgentCore Bedrock-Laufzeit aus oder geben Sie Ihren Lambda-Forwarder-ARN an.
+ Geben Sie Ihren Trainingsdatensatz als S3-URI oder als registrierten Datensatz an.
+ Passen Sie die Hyperparameter nach Bedarf an.
+ Überprüfen Sie Ihre Konfiguration und wählen Sie Senden.
### 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:
+ Ausgabe-MPG — speichert das endgültige, fein abgestimmte Modellpaket
+ Intermediate Checkpoint MPG — reserviert für Trainings-Checkpoints für Fortgeschrittene (muss sich vom Output-MPG unterscheiden)
```
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 an`JobConfigDocument`.
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` oder`Stopped`.
```
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**
+ Erstellen Sie eine verwaltete MLflow App in Ihrem Konto. Anweisungen zur Einrichtung finden Sie unter MLflow App Setup.
+ Stellen Sie sicher, dass Ihre SageMaker AI-Ausführungsrolle berechtigt ist, in die MLflow App zu schreiben (`sagemaker-mlflow:*`Aktionen).
+ Nehmen Sie das `MlflowResourceArn` in Ihre Jobkonfiguration auf.
**Was wird protokolliert**
| \# | Kategorie | Was wird protokolliert | Wo in der MLflow-Benutzeroberfläche |
| --- | --- | --- | --- |
| 1 | Trainingsmetriken | Per-step Zähler, Durchsatz, Datums- und Tokenabrechnung, Gesamtdauer jeder Phase eines Schritts, Zusammenfassung des Rollout-Batches mit Zusammenfassung der Trajektorien und Verteilung der Anzahl an Runden pro Trajektorie | Registerkarte „Metriken“ (Zeitreihendiagramme) |
| 2 | Trajektorienspuren | Vollständige Multi-Turn-Konversationen mit Tool-Calls und Prämien | Registerkarte „Spuren“ |
#### Detaillierte Referenz zu Trainingsmetriken
Die folgenden Messwerte werden bei jedem Trainingsschritt protokolliert.
**Schrittzähler und Durchsatz () `training/`**
| Metrik | Description |
| --- | --- |
| training/epoch | Aktuelle Epochennummer |
| training/global\_step | Globaler Trainingsschrittzähler |
| training/num\_groups | Trajektoriegruppen in diesem Schritt |
| training/num\_trajectories | Gesamtzahl der in diesem Schritt verarbeiteten Trajektorien |
| training/total\_tokens | In diesem Schritt wurden die Tokens für alle Mikrobatches summiert |
| training/num\_datums | Aus Trajektorien gebildete Trainingsdaten |
| training/datums\_per\_trajectory | Durchschnittliche Daten, die pro Trajektorie ausgegeben wurden |
| training/action\_tokens\_mean | Durchschnittliche Aktions-Token (Antwort-Token) pro Trajektorie |
| training/obs\_tokens\_mean | Durchschnittliche Beobachtungs- (Aufforderung-) Tokens pro Trajektorie |
| training/trainable\_token\_positions | Gesamtzahl der trainierbaren Zielpositionen in diesem Schritt |
| training/nontrainable\_token\_positions | Gesamtzahl der in diesem Schritt nicht trainierbaren Zielpositionen |
| training/trainable\_token\_ratio | Verhältnis: Token-Positionen trainable / (trainable \+ nontrainable) |
**Dauer der Phasen () `timing_s/`**
| Metrik | Description |
| --- | --- |
| timing\_s/step | Gesamtzeit für den vollständigen Schritt |
| timing\_s/training | Zeit für forward/backward Durchläufe und Optimierungsschritt |
| timing\_s/policy\_update | Zeitersparnis bei aktualisierten Gewichten für den Sampler |
| timing\_s/save\_checkpoint | Zeitersparnis an einem Checkpoint (nur bei Checkpoint-Schritten) |
| timing\_s/eval | Zeitaufwändige Evaluierung (nur bei Evaluierungsschritten) |
**Verteilung der Prämien (`rollout/reward/`)**
| Metrik | Description |
| --- | --- |
| rollout/reward/mean | Durchschnittliche Belohnung für den weiteren Verlauf aller Gruppen |
| rollout/reward/valid\_mean | Durchschnittliche Belohnung nur für die gültigen Gruppen (ohne Vorteil); entspricht dem Wert, wenn keine Filterung vorgenommen wurde mean |
| rollout/reward/std | Standardabweichung der Trajektorieprämien |
| rollout/reward/min | Minimale Belohnung für die Flugbahn |
| rollout/reward/max | Maximale Belohnung für die Flugbahn |
| rollout/reward/zero\_frac | Bruchteil der Flugbahnen mit einer Gesamtbelohnung von genau 0,0 |
**Runde zählt () `rollout/turns/`**
| Metrik | Description |
| --- | --- |
| rollout/turns/mean | Durchschnittliche Kurven (Übergänge) pro Trajektorie |
| rollout/turns/min | Minimale Anzahl an Kurven zwischen Trajektorien |
| rollout/turns/max | Maximale Anzahl an Kurven über Trajektorien |
**Token-Längen () `rollout/tokens/`**
| Metrik | Description |
| --- | --- |
| rollout/tokens/prompt\_mean | Durchschnittliche Anzahl von Prompt-Tokens pro Übergang |
| rollout/tokens/response\_mean | Durchschnittliche Anzahl von Antwort-Token pro Übergang |
| rollout/tokens/response\_std | Standardabweichung der Anzahl der Antwort-Token |
| rollout/tokens/response\_min | Minimale Anzahl von Antwort-Token |
| rollout/tokens/response\_max | Maximale Anzahl an Antwort-Token (achten Sie auf Clustering untersampling\_max\_tokens) |
**Log-probability Gesundheit () `rollout/logprob/`**
| Metrik | Description |
| --- | --- |
| rollout/logprob/zero\_count | Gesamtzahl der Zero-Logprob-Token |
| rollout/logprob/zero\_frac | Bruchteil aller Logprobs, die genau 0,0 sind |
| rollout/logprob/zero\_per\_group | Durchschnittlich null Logprobs pro Trajektoriengruppe |
| rollout/logprob/nz\_mean | Mittelwert der Logprobs ungleich Null |
| rollout/logprob/nz\_std | Standardabweichung von Logprobs ungleich Null |
| rollout/logprob/nz\_min | Minimaler Logprob ungleich Null |
| rollout/logprob/nz\_max | Maximaler Logprob-Wert ungleich Null |
**Verteilung der Vorteile () `rollout/advantage/`**
| Metrik | Description |
| --- | --- |
| rollout/advantage/mean | Mittlerer Wert des Vorteils bei allen Übergängen |
| rollout/advantage/std | Standardabweichung der Vorteile |
| rollout/advantage/min | Minimaler Vorteil |
| rollout/advantage/max | Maximaler Vorteil |
| rollout/advantage/n\_positive | Übergänge mit positivem Vorteil |
| rollout/advantage/n\_negative | Übergänge mit negativem Vorteil |
**Batch-quality Einstufung (`analysis/`)**
| Metrik | Description |
| --- | --- |
| analysis/batch\_completion\_ratio | total\_completed / batch\_size— Bruchteil der erwarteten Gruppen, die eingetroffen sind |
| analysis/batch\_valid\_ratio | valid\_count / batch\_size— Gruppen, für die kein Vorteil besteht, im Vergleich zur gesamten Charge |
| analysis/zero\_adv\_groups | Gruppen, bei denen alle Übergänge fast keinen Vorteil haben |
| analysis/zero\_adv\_nonzero\_reward | Zero-advantage Gruppen, bei denen mindestens ein Übergang eine Belohnung ungleich 0 hat (völlig korrekter Fall für binäre Prämien) |
| analysis/zero\_adv\_zero\_reward | Zero-advantage Gruppen, bei denen alle Belohnungen 0 sind (völlig falscher Fall) |
| analysis/reward\_variance\_across\_groups | Varianz der durchschnittlichen Prämien pro Gruppe (hoch = unterschiedliche Charge) |
| analysis/mean\_group\_reward\_spread | Durchschnittliche Verteilung der Prämien innerhalb der Gruppe max - min |
**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:**
| Metrik | Description |
| --- | --- |
| val/reward/mean | Durchschnittliche Belohnung im Vergleich zum Bewertungssatz |
| val/reward/std | Belohnen Sie std dev |
| val/reward/min | Minimale Belohnung |
| val/reward/max | Maximale Belohnung |
| val/reward/zero\_frac | Bruchteil der Trajektorien ohne Belohnung |
**Group-reward (Aggregation pro Aufforderung):**
| Metrik | Description |
| --- | --- |
| val/reward/min\_within\_groups | Durchschnittliche Mindestvergütung pro Aufforderung |
| val/reward/mean\_within\_groups | Durchschnittliche durchschnittliche Belohnung pro Aufforderung |
| val/reward/max\_within\_groups | Durchschnittliche maximale Belohnung pro Aufforderung |
| val/reward/std\_within\_groups | Durchschnittliche Standardbelohnung pro Aufforderung (Konsistenz) |
| val/reward/rollouts\_per\_prompt | Durchschnittliche Anzahl von Rollouts (n) über mehrere Eingabeaufforderungen |
| val/reward/num\_prompts | Verschiedene Eingabeaufforderungen wurden ausgewertet |
**Pass @k und Erfolgsrechnung:**
| Metrik | Description |
| --- | --- |
| val/reward/succeeded\_rollouts | Gesamtzahl der Rollouts mit Prämie ≥ success\_threshold |
| val/reward/failed\_rollouts | Gesamtzahl der Rollouts mit Belohnung < success\_threshold |
| val/reward/success\_threshold | Verwendeter Schwellenwert (aus Gründen der Übersichtlichkeit wiedergegeben) |
| val/reward/pass\_at\_{k} | Die Wahrscheinlichkeit liegt bei ≥1 von k Stichproben |
| val/reward/pass\_power\_{k} | Wahrscheinlichkeit, dass alle k Stichproben erfolgreich sind (Zuverlässigkeit) |
**Die Auswertung zählt (`val/turns/`)**
| Metrik | Description |
| --- | --- |
| val/turns/mean | Durchschnittliche Anzahl an Umdrehungen pro Berechnungsbahn |
| val/turns/min | Minimale Anzahl an Kurven |
| val/turns/max | Maximale Anzahl an Umdrehungen |
**Längen der Evaluierungstoken (`val/tokens/`)**
| Metrik | Description |
| --- | --- |
| val/tokens/prompt\_mean | Durchschnittliche Anzahl von Prompt-Tokens pro Übergang |
| val/tokens/response\_mean | Durchschnittlicher Wert der Antwort-Token pro Übergang |
| val/tokens/response\_std | Standardabweichung der Antwort-Token |
| val/tokens/response\_min | Minimale Anzahl von Antwort-Token |
| val/tokens/response\_max | Maximale Anzahl an Antwort-Token |
**Bewertung des Zustands anhand von Log-Wahrscheinlichkeitsdaten () `val/logprob/`**
| Metrik | Description |
| --- | --- |
| val/logprob/zero\_count | Gesamtzahl der Null-Logprob-Token |
| val/logprob/zero\_frac | Bruchteil von null Logprobs |
| val/logprob/zero\_per\_group | Null Logprobs pro Gruppe |
| val/logprob/nz\_mean | Mittelwert von Logprobs ungleich Null |
| val/logprob/nz\_std | Standardabweichung von Logprobs ungleich Null |
| val/logprob/nz\_min | Minimaler Logprob ungleich Null |
| val/logprob/nz\_max | Maximaler Logprob-Wert ungleich Null |
**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**
+ Die Eingabeaufforderung aus Ihrem Trainingsdatensatz
+ Jede Inferenzrunde des Modells (Daten auf Prompt-, Antwort- und Token-Ebene)
+ Tool-Aufrufe und ihre Ergebnisse, falls Ihr Agent Tools verwendet
+ Die endgültige Prämienpunktzahl
+ Informationen zum Zeitplan für jede Runde
**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:
+ Die Systemaufforderung und die Benutzeraufforderung
+ Jede Antwort des Assistenten (mit thinking/reasoning , falls zutreffend)
+ Die Nutzungsdauer der Tools zeigt an, welche Tools aufgerufen wurden und welche Ergebnisse sie erzielt haben
+ Die der Trajektorie zugewiesene Belohnungspunktzahl
**Verwenden Sie Trajektorien, um niedrige Belohnungswerte zu debuggen**
| Symptom | Worauf zu achten ist |
| --- | --- |
| Niedrige Belohnung bei den meisten Rollouts | Sind die Antworten der Modelle kohärent? Ist das Format der Aufforderung korrekt? |
| Tool-related Misserfolge | Sind Tool-Aufrufe erfolgreich? Sind Eingaben und Ausgaben wohlgeformt? |
| Endlosschleife für Agenten | Wiederholt der Agent dieselben Aktionen, ohne Fortschritte zu machen? |
| Verkürzte Antworten | Werden Antworten durch das MaxToken-Limit abgeschnitten? |
## 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:
| Group (Gruppieren) | Zweck | Inhalt |
| --- | --- | --- |
| Paketgruppe „Ausgabemodell“ | Endgültiges trainiertes Modell | HuggingFace-compatible Gewichte des LoRa-Adapters (adapter\_config.json \+ adapter\_model.safetensors) |
| Paketgruppe „Intermediate Checkpoint Model“ | Zustand des Trainings wieder aufnehmbar | Gewichte des LoRa-Adapters \+ Optimizer-Status \+ Metadaten für Trainingsschritte |
**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)**
+ In der Ausgabemodell-Paketgruppe gespeichert
+ Enthält die Gewichte des HuggingFace-compatible LoRa-Adapters im Format SafeTensors
+ Verwenden Sie es für Rückschlüsse, für die Implementierung oder als Ausgangspunkt für einen neuen Schulungsjob
+ Wird bei jedem Schritt, bei Abschluss eines Jobs und wenn ein Job beendet wird, erstellt
**Prüfpunkt, der wieder aufgenommen werden kann (vollständiger Status)**
+ In der Intermediate Checkpoint Model Package Group gespeichert
+ Enthält LoRa-Adaptergewichte, Optimizer-Status und Metadaten für Trainingsschritte pro GPU
+ Wird verwendet, um einen unterbrochenen Job genau in dem Schritt fortzusetzen, in dem er gestoppt wurde
+ Internes Format — nicht direkt für Inferenzen nutzbar
### 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:
+ Basismodell
+ LoRa-Konfiguration (Rang und Alpha)
+ Hyperparameter (Lernrate, Batchgröße usw.)
+ Datensatz
### 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 als`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"
}
```
**Was Sie zwischen den Iterationen ändern können:**
+ Hyperparameter (Lernrate, Batchgröße, max\_steps, group\_size usw.)
+ Datensatz (verschiedene Eingabeaufforderungen oder Datenverteilung)
+ Belohnungsfunktion
+ Konfiguration des Agenten
**Was muss gleich bleiben:**
+ Basismodell — Der LoRa-Adapter ist an die Architektur des Basismodells gebunden
Übliche Muster für iteratives Training:
+ **Lernen im Lehrplan** — zuerst an einfacheren Problemen trainieren, dann an schwierigeren weitermachen
+ **Verfeinerung der Belohnung** — beginnen Sie mit einer einfachen Belohnungsfunktion und wiederholen Sie diese dann mit einer differenzierteren
+ **Anpassung der Hyperparameter** — Erhöhen Sie die Chargengröße oder passen Sie die Lernrate an, nachdem Sie die anfängliche Trainingsdynamik beobachtet haben
### Bewährte Methoden bei Checkpoint
+ **Überwachen Sie die Erstellung von Checkpoints**. Verwenden Sie DescribeJob es, um während des `ModelCheckpoint` Trainings nachzuverfolgen `ResumableCheckpoint` und zu erfassen, damit Sie wissen, was verfügbar ist, falls Sie das Training fortsetzen müssen.
+ **Planen Sie Ausfälle bei langen Aufträgen ein.** Wenn ein Job aus vielen Schritten besteht, sollten Sie Ihren Arbeitsablauf so gestalten, dass er von Checkpoints aus wieder aufgenommen wird, anstatt von vorne neu zu beginnen.