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.

# Nutzung von Ausbildungsplänen für SageMaker Ausbildungsjobs
<a name="training-plan-utilization-for-training-jobs"></a>

Sie können einen SageMaker Trainingsplan für Ihre Schulungsjobs verwenden, indem Sie bei der Erstellung eines Schulungsjobs den Plan Ihrer Wahl angeben.

**Anmerkung**  
Der Schulungsplan muss den `Active` Status `Scheduled` oder haben, damit er für einen Trainingsjob verwendet werden kann.

Wenn die erforderliche Kapazität für eine Ausbildungsstelle nicht sofort verfügbar ist, wartet die Stelle, bis sie verfügbar ist, oder bis die Kapazität erreicht `StoppingCondition` ist oder die Stelle `Pending` seit 2 Tagen ausgelastet ist, je nachdem, was zuerst eintritt. Wenn die Abbruchbedingung erfüllt ist, wird der Job gestoppt. Wenn ein Job seit 2 Tagen aussteht, wird er mit einem beendet`InsufficientCapacityError`.

**Wichtig**  
**Kündigungsprozess für reservierte Kapazität:** Sie haben bis 30 Minuten vor Ablauf der Endzeit der reservierten Kapazität vollen Zugriff auf alle Reserved Instances. Wenn Ihre reservierte Kapazität noch 30 Minuten beträgt, beginnen die SageMaker Schulungspläne damit, alle laufenden Instances innerhalb dieser reservierten Kapazität zu beenden.  
Um sicherzustellen, dass Sie aufgrund dieser Kündigungen keine Fortschritte verlieren, empfehlen wir Ihnen, Ihre Trainingsjobs zu überprüfen.

## Überprüfe deinen Ausbildungsjob
<a name="training-jobs-checkpointing"></a>

Wenn Sie SageMaker Trainingspläne für Ihre SageMaker Trainingsaufgaben verwenden, achten Sie darauf, Checkpointing in Ihrem Schulungsskript zu implementieren. Auf diese Weise können Sie Ihren Trainingsfortschritt speichern, bevor eine reservierte Kapazität abläuft. Checkpointing ist besonders wichtig, wenn Sie mit reservierten Kapazitäten arbeiten, da Sie so das Training am zuletzt gespeicherten Punkt fortsetzen können, falls Ihre Arbeit zwischen zwei reservierten Kapazitäten unterbrochen wird oder wenn Ihr Trainingsplan sein Enddatum erreicht.

Um dies zu erreichen, können Sie die `SAGEMAKER_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP`-Umgebungsvariable verwenden. Diese Variable hilft zu bestimmen, wann der Checkpoint-Prozess eingeleitet werden soll. Indem Sie diese Logik in Ihr Trainingsskript integrieren, stellen Sie sicher, dass der Fortschritt Ihres Modells in angemessenen Intervallen gespeichert wird.

Hier ist ein Beispiel dafür, wie Sie diese Checkpoint-Logik in Ihrem Python-Trainingsskript implementieren können:

```
import os
import time
from datetime import datetime, timedelta

def is_close_to_expiration(threshold_minutes=30):
    # Retrieve the expiration timestamp from the environment variable
    expiration_time_str = os.environ.get('SAGEMAKER_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP', '0')
    
    # If the timestamp is not set (default '0'), return False
    if expiration_time_str == '0':
        return False
    
    # Convert the timestamp string (in milliseconds) to a datetime object
    expiration_time = datetime(1970, 1, 1) + timedelta(milliseconds=int(expiration_time_str))
    
    # Calculate the time difference between now and the expiration time
    time_difference = expiration_time - datetime.now()
    
    # Return True if we're within the threshold time of expiration
    return time_difference < timedelta(minutes=threshold_minutes)

def start_checkpointing():
    # Placeholder function for checkpointing logic
    print("Starting checkpointing process...")
    # TODO: Implement actual checkpointing logic here
    # For example:
    # - Save model state
    # - Save optimizer state
    # - Save current epoch and iteration numbers
    # - Save any other relevant training state

# Main training loop
num_epochs = 100
final_checkpointing_done = False
for epoch in range(num_epochs):
    # TODO: Replace this with your actual training code
    # For example:
    # - Load a batch of data
    # - Forward pass
    # - Calculate loss
    # - Backward pass
    # - Update model parameters
    
    # Check if we're close to capacity expiration and haven't done final checkpointing
    if not final_checkpointing_done and is_close_to_expiration():
        start_checkpointing()
        final_checkpointing_done = True
    
    # Simulate some training time (remove this in actual implementation)
    time.sleep(1)
print("Training completed.")
```

**Anmerkung**  
Die Bereitstellung von Trainingsjobs folgt einer First-In-First-Out (FIFO-) Reihenfolge, aber einem kleineren Cluster-Job, der später erstellt wurde, kann Kapazität zugewiesen werden, bevor ein größerer Cluster-Job erstellt wurde, wenn der größere Job nicht ausgeführt werden kann.
SageMaker Das trainingsverwaltete Warmbecken ist mit Trainingsplänen kompatibel. SageMaker Für die Wiederverwendung von Clustern müssen Sie in nachfolgenden `CreateTrainingJob` Anfragen identische `TrainingPlanArn` Werte angeben, um denselben Cluster wiederzuverwenden.

**Topics**
+ [Überprüfe deinen Ausbildungsjob](#training-jobs-checkpointing)
+ [Erstellen Sie mit der KI-Konsole einen Trainingsjob SageMaker](use-training-plan-for-training-jobs-using-console.md)
+ [Erstellen Sie einen Trainingsjob mithilfe der API AWS CLI, SageMaker SDK](use-training-plan-for-training-jobs-using-api-cli-sdk.md)

# Erstellen Sie mit der KI-Konsole einen Trainingsjob SageMaker
<a name="use-training-plan-for-training-jobs-using-console"></a>

Mithilfe der SageMaker KI-Benutzeroberfläche können Sie SageMaker Trainingspläne für Ihre Trainingsjobs verwenden. Beim Erstellen eines Trainingsjobs werden Ihnen die verfügbaren Pläne vorgeschlagen, sofern Ihre Instance-Auswahl und Region mit den verfügbaren Plänen übereinstimmen.

Um einen Trainingsjob mithilfe der reservierten Kapazität eines Trainingsplans in der SageMaker Konsole zu erstellen:

1. Navigieren Sie zur SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Wählen Sie im linken Navigationsbereich **Training** und dann **Trainingsjobs** aus.

1. Wählen Sie **Trainingsjob erstellen** aus.

1. Achten Sie bei der Konfiguration der Ressourcen für Ihren Trainingsjob auf den Abschnitt **Instance-Kapazität**. Wenn Pläne verfügbar sind, die dem ausgewählten Instance-Typ und der Region entsprechen, werden diese hier angezeigt. Wählen Sie einen Trainingsplan aus, der Ihren Rechenkapazitätsanforderungen entspricht.

   Wenn keine geeigneten Pläne verfügbar sind, können Sie entweder Ihren Instance-Typ oder Ihre Region anpassen oder ohne einen Trainingsplan fortfahren.

1. Nachdem Sie einen Trainingsplan ausgewählt haben (oder sich entschieden haben, ohne einen Plan fortzufahren), schließen Sie die restliche Konfiguration Ihrer Trainingsjobs ab und wählen Sie **Trainingsjob erstellen**, um den Vorgang zu starten.

![\[SageMaker KI-Konsolenseite zum Erstellen eines neuen Schulungsjobs. Auf der Seite werden verschiedene Konfigurationsoptionen angezeigt, darunter Jobeinstellungen, Algorithmusoptionen, Ressourcenkonfiguration, Auswahl des Trainingsplans und Abbruchbedingungen.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/training-plans/tp-create-training-job.png)


Überprüfen und starten Sie Ihren Job. Ihr Job beginnt zu laufen, sobald der Schulungsplan die `Active` Kapazität aussteht.

# Erstellen Sie einen Trainingsjob mithilfe der API AWS CLI, SageMaker SDK
<a name="use-training-plan-for-training-jobs-using-api-cli-sdk"></a>

Um SageMaker Trainingspläne für Ihren SageMaker Trainingsjob zu verwenden, geben Sie `ResourceConfig` beim Aufrufen der [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API-Operation den `TrainingPlanArn` Parameter des gewünschten Plans an. Es kann genau ein Plan pro Job verwenden.

**Wichtig**  
Das im `ResourceConfig` Abschnitt der `CreateTrainingJob` Anfrage angegebene `InstanceType` Feld muss mit dem `InstanceType` Ihres Trainingsplans übereinstimmen.

## Führen Sie mithilfe der CLI einen Trainingsjob für einen Plan aus
<a name="training-job-cli"></a>

Das folgende Beispiel zeigt, wie Sie mithilfe des `TrainingPlanArn` Attributs im `create-training-job` AWS CLI Befehl einen SageMaker Schulungsjob erstellen und ihn mit einem bereitgestellten Schulungsplan verknüpfen. 

Weitere Informationen zum Erstellen einer Ausbildungsstelle mithilfe des AWS CLI [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)Befehls finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-training-job.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-training-job.html).

```
# Create a training job
aws sagemaker create-training-job \
  --training-job-name training-job-name \
  ...
    
  --resource-config '{
        "InstanceType": "ml.p5.48xlarge",
        "InstanceCount": 8,
        "VolumeSizeInGB": 10,
        "TrainingPlanArn": "training-plan-arn"
        }
    }' \
    ...
```

Mit diesem AWS CLI Beispielbefehl wird ein neuer Trainingsjob in SageMaker KI erstellt, der einen Trainingsplan im `--resource-config` Argument erfüllt.

```
aws sagemaker create-training-job \
  --training-job-name job-name \
  --role-arn arn:aws:iam::111122223333:role/DataAndAPIAccessRole \
  --algorithm-specification '{"TrainingInputMode": "File","TrainingImage": "111122223333.dkr.ecr.us-east-1.amazonaws.com/algo-image:tag", "ContainerArguments": [" "]}' \
  --input-data-config '[{"ChannelName":"training","DataSource":{"S3DataSource":{"S3DataType":"S3Prefix","S3Uri":"s3://bucketname/input","S3DataDistributionType":"ShardedByS3Key"}}}]' \
  --output-data-config '{"S3OutputPath": "s3://bucketname/output"}' \
  --resource-config '{"VolumeSizeInGB":10,"InstanceCount":4,"InstanceType":"ml.p5.48xlarge", "TrainingPlanArn" : "arn:aws:sagemaker:us-east-1:111122223333:training-plan/plan-name"}' \
  --stopping-condition '{"MaxRuntimeInSeconds": 1800}' \
  --region us-east-1
```

Nachdem Sie den Trainingsjob erstellt haben, können Sie überprüfen, ob er dem Trainingsplan ordnungsgemäß zugewiesen wurde, indem Sie die `DescribeTrainingJob` API aufrufen.

```
aws sagemaker describe-training-job --training-job-name training-job-name
```

## Führen Sie mithilfe des SageMaker AI Python SDK einen Trainingsjob auf einem Plan aus
<a name="training-job-sdk"></a>

Alternativ können Sie mit dem [SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) einen Trainingsjob erstellen, der mit einem Trainingsplan verknüpft ist.

Wenn Sie das SageMaker Python-SDK JupyterLab in Studio verwenden, um einen Trainingsjob zu erstellen, stellen Sie sicher, dass die Ausführungsrolle, die von dem Bereich verwendet wird, in dem Ihre JupyterLab Anwendung ausgeführt wird, über die erforderlichen Berechtigungen zur Verwendung von SageMaker Trainingsplänen verfügt. Informationen zu den erforderlichen Berechtigungen für die Verwendung von SageMaker Trainingsplänen finden Sie unter[IAM für SageMaker Schulungspläne](training-plan-iam-permissions.md).

Das folgende Beispiel zeigt, wie Sie einen SageMaker Trainingsjob erstellen und ihn mit einem bereitgestellten Trainingsplan verknüpfen, indem Sie das `training_plan` Attribut im `Estimator` Objekt verwenden, wenn Sie das SageMaker Python-SDK verwenden.

Weitere Informationen zum SageMaker Estimator finden Sie unter [Verwenden eines SageMaker Schätzers zur Ausführung eines Trainingsjobs](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html).

```
import sagemaker
import boto3
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

# Set up the session and SageMaker client
session = boto3.Session()
region = session.region_name
sagemaker_session = session.client('sagemaker')

# Get the execution role for the training job
role = get_execution_role()

# Define the input data configuration
trainingInput = TrainingInput(
    s3_data='s3://input-path',
    distribution='ShardedByS3Key',
    s3_data_type='S3Prefix'
)

estimator = Estimator(
    entry_point='train.py',
    image_uri="123456789123.dkr.ecr.{}.amazonaws.com/image:tag",
    role=role,
    instance_count=4,
    instance_type='ml.p5.48xlarge',
    training_plan="training-plan-arn",
    volume_size=20,
    max_run=3600,
    sagemaker_session=sagemaker_session,
    output_path="s3://output-path"
)

# Create the training job
estimator.fit(inputs=trainingInput, job_name=job_name)
```

Nachdem Sie den Trainingsjob erstellt haben, können Sie überprüfen, ob er dem Trainingsplan ordnungsgemäß zugewiesen wurde, indem Sie die `DescribeTrainingJob` API aufrufen.

```
# Check job details
sagemaker_session.describe_training_job(TrainingJobName=job_name)
```