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.
# Ausführen von Trainingsjobs auf einem heterogenen Cluster
Mithilfe der Funktion für heterogene Cluster von SageMaker Training können Sie einen Trainingsjob mit mehreren Typen von ML-Instances ausführen, um die Ressourcen für verschiedene ML-Trainingsaufgaben und -zwecke besser skalieren und nutzen zu können. Wenn bei Ihrem Trainingsauftrag auf einem Cluster mit GPU-Instances beispielsweise eine geringe GPU-Auslastung und CPU-Engpässe aufgrund von CPU-intensiven Aufgaben auftreten, kann die Verwendung eines heterogenen Clusters dazu beitragen, CPU-intensive Aufgaben auszulagern, indem kostengünstigere CPU-Instance-Gruppen hinzugefügt, solche Engpässe behoben und eine bessere GPU-Auslastung erreicht werden.
**Anmerkung**
Diese Funktion ist im SageMaker Python SDK v2.98.0 und höher verfügbar.
**Anmerkung**
Diese Funktion ist in den Klassen SageMaker AI [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)und [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)Framework Estimator verfügbar. Unterstützte Frameworks sind PyTorch v1.10 oder höher und TensorFlow v2.6 oder höher.
Lesen Sie auch den Blog [Verbessern Sie das Preis-Leistungs-Verhältnis Ihres Modelltrainings mithilfe von heterogenen Amazon SageMaker AI-Clustern](https://aws.amazon.com/blogs/machine-learning/improve-price-performance-of-your-model-training-using-amazon-sagemaker-heterogeneous-clusters/).
**Topics**
+ [Konfigurieren Sie einen Schulungsjob mit einem heterogenen Cluster in Amazon AI SageMaker](train-heterogeneous-cluster-configure.md)
+ [Führen Sie verteilte Schulungen auf einem heterogenen Cluster in Amazon SageMaker AI durch](train-heterogeneous-cluster-configure-distributed.md)
+ [Ändern Ihres Trainingsskripts zum Zuweisen von Instance-Gruppen](train-heterogeneous-cluster-modify-training-script.md)
# Konfigurieren Sie einen Schulungsjob mit einem heterogenen Cluster in Amazon AI SageMaker
Dieser Abschnitt enthält Anweisungen zum Ausführen eines Trainingsauftrags mit einem heterogenen Cluster, der aus mehreren Instance-Typen besteht.
Bevor Sie beginnen, beachten Sie Folgendes.
+ Alle Instance-Gruppen verwenden dasselbe Docker-Image und dasselbe Trainingsskript. Daher sollte Ihr Trainingsskript so geändert werden, dass erkannt wird, zu welcher Instance-Gruppe es gehört, und die Ausführung entsprechend aufgeteilt werden.
+ Die Funktion für heterogene Cluster ist nicht mit dem lokalen SageMaker KI-Modus kompatibel.
+ Die CloudWatch Amazon-Protokollstreams eines heterogenen Cluster-Trainingsjobs sind nicht nach Instanzgruppen gruppiert. Sie müssen anhand der Protokolle herausfinden, welche Knoten zu welcher Gruppe gehören.
**Topics**
+ [Option 1: Verwenden des SageMaker Python-SDK](#train-heterogeneous-cluster-configure-pysdk)
+ [Option 2: Verwendung des Low-Levels SageMaker APIs](#train-heterogeneous-cluster-configure-api)
## Option 1: Verwenden des SageMaker Python-SDK
Folgen Sie den Anweisungen zur Konfiguration von Instanzgruppen für einen heterogenen Cluster mithilfe des SageMaker Python-SDK.
1. Verwenden Sie die `sagemaker.instance_group.InstanceGroup` Klasse, um Instance-Gruppen eines heterogenen Clusters für einen Trainingsauftrages zu konfigurieren. Sie können für jede Instance-Gruppe einen benutzerdefinierten Namen, den Instance-Typ und die Anzahl der Instances für jede Instance-Gruppe angeben. Weitere Informationen finden Sie unter [sagemaker.instance\$1group. InstanceGroup](https://sagemaker.readthedocs.io/en/stable/api/utility/instance_group.html)in der *SageMaker AI Python SDK-Dokumentation*.
**Anmerkung**
Weitere Informationen zu verfügbaren Instanztypen und der maximalen Anzahl von Instanzgruppen, die Sie in einem heterogenen Cluster konfigurieren können, finden Sie in der [ InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)API-Referenz.
Das folgende Codebeispiel zeigt, wie Sie zwei Instance-Gruppen einrichten, die aus zwei `ml.c5.18xlarge` reinen CPU-Instances mit Namen `instance_group_1` und einer benannten `ml.p3dn.24xlarge` GPU-Instance bestehen `instance_group_2`, wie im folgenden Diagramm dargestellt.
![\[Ein konzeptionelles Beispiel dafür, wie Daten in SageMaker Training Job zugewiesen werden können.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/HCTraining.png)
Das obige Diagramm zeigt ein konzeptionelles Beispiel dafür, wie Prozesse vor dem Training, wie z. B. die Datenvorverarbeitung, der CPU-Instance-Gruppe zugewiesen und die vorverarbeiteten Daten an die GPU-Instance-Gruppe gestreamt werden können.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 2
)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 1
)
```
1. Richten Sie mithilfe der Instanzgruppenobjekte Trainingseingabekanäle ein und weisen Sie den Kanälen mithilfe des `instance_group_names` Arguments [sagemaker.inputs Instanzgruppen zu. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)Klasse. Das `instance_group_names`-Argument akzeptiert eine Liste von Strings mit Instance-Gruppennamen.
Das folgende Beispiel zeigt, wie zwei Trainingseingangskanäle eingerichtet und die im Beispiel des vorherigen Schritts erstellten Instance-Gruppen zugewiesen werden. Sie können auch Amazon-S3-Bucket-Pfade für das `s3_data`-Argument angeben, damit die Instance-Gruppen Daten für Ihre Verwendungszwecke verarbeiten.
```
from sagemaker.inputs import TrainingInput
training_input_channel_1 = TrainingInput(
s3_data_type='S3Prefix', # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
s3_data='s3://your-training-data-storage/folder1',
distribution='FullyReplicated', # Available Options: FullyReplicated | ShardedByS3Key
input_mode='File', # Available Options: File | Pipe | FastFile
instance_groups=["instance_group_1"]
)
training_input_channel_2 = TrainingInput(
s3_data_type='S3Prefix',
s3_data='s3://your-training-data-storage/folder2',
distribution='FullyReplicated',
input_mode='File',
instance_groups=["instance_group_2"]
)
```
Weitere Informationen zu den Argumenten von `TrainingInput`, finden Sie unter den folgenden Links.
+ Die [Sagemaker.inputs. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)Klasse in der *SageMaker Python SDK-Dokumentation*
+ Die [DataSourceS3-API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html) in der *SageMaker AI-API-Referenz*
1. Konfigurieren Sie einen SageMaker AI-Schätzer mit dem `instance_groups` Argument, wie im folgenden Codebeispiel gezeigt. Das `instance_groups`-Argument akzeptiert eine Liste von `InstanceGroup`-Objekten.
**Anmerkung**
Die Funktion für heterogene Cluster ist in den Klassen SageMaker AI [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)und [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)Framework Estimator verfügbar. Unterstützte Frameworks sind PyTorch v1.10 oder höher und TensorFlow v2.6 oder höher. Eine vollständige Liste der verfügbaren Framework-Container, Framework-Versionen und Python-Versionen finden Sie unter [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) im AWS Deep Learning GitHub Container-Repository.
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 1.10.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 2.6.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
**Anmerkung**
Das `instance_type` `instance_count` Argumentpaar und das `instance_groups` Argument der SageMaker AI-Schätzerklasse schließen sich gegenseitig aus. Verwenden Sie für ein homogenes Clusterttraining das Argumentpaar `instance_type` und `instance_count`. Verwenden Sie `instance_groups` für heterogenes Clustertraining.
**Anmerkung**
Eine vollständige Liste der verfügbaren Framework-Container, Framework-Versionen und Python-Versionen finden Sie unter [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) im AWS Deep Learning GitHub Container-Repository.
1. Konfigurieren Sie die `estimator.fit` Methode mit den Trainingseingabekanälen, die mit den Instance-Gruppen konfiguriert sind, und starten Sie den Trainingsaufträge.
```
estimator.fit(
inputs={
'training': training_input_channel_1,
'dummy-input-channel': training_input_channel_2
}
)
```
## Option 2: Verwendung des Low-Levels SageMaker APIs
Wenn Sie das AWS Command Line Interface oder verwenden AWS SDK für Python (Boto3) und Low-Level SageMaker APIs verwenden möchten, um eine Trainingsanfrage mit einem heterogenen Cluster einzureichen, finden Sie weitere Informationen in den folgenden API-Referenzen.
+ [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
+ [ResourceConfig ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ResourceConfig.html)
+ [InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)
+ [S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)
# Führen Sie verteilte Schulungen auf einem heterogenen Cluster in Amazon SageMaker AI durch
Mithilfe des `distribution` Arguments der SageMaker AI-Estimator-Klasse können Sie eine bestimmte Instanzgruppe für die Durchführung verteilter Schulungen zuweisen. Nehmen wir beispielsweise an, dass Sie über die folgenden zwei Instance-Gruppe verfügen und für eine davon ein Multi-GPU-Training durchführen möchten.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup("instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup("instance_group_2", "ml.p3dn.24xlarge", 2)
```
Sie können die verteilte Trainingskonfiguration für eine der Instance-Gruppen festlegen. Die folgenden Codebeispiele zeigen beispielsweise, wie `training_group_2` mit zwei `ml.p3dn.24xlarge` Instances der verteilten Trainingskonfiguration zugewiesen wird.
**Anmerkung**
Derzeit kann nur eine Instance-Gruppe eines heterogenen Clusters für die Verteilungskonfiguration angegeben werden.
**Mit MPI**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
**Mit der SageMaker KI-Datenparallelbibliothek**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
**Anmerkung**
Wenn Sie die SageMaker AI Data Parallel Library verwenden, stellen Sie sicher, dass die Instanzgruppe aus den [von der Bibliothek unterstützten Instanztypen](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-data-parallel-support.html#distributed-data-parallel-supported-instance-types) besteht.
Weitere Informationen zur SageMaker KI-Datenparallelbibliothek finden Sie unter [SageMaker AI Data Parallel Training](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel.html).
**Mit der SageMaker AI-Modellparallelbibliothek**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
Weitere Informationen zur SageMaker AI-Modellparallelbibliothek finden Sie unter [SageMaker AI Model Parallel Training](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel.html).
# Ändern Ihres Trainingsskripts zum Zuweisen von Instance-Gruppen
Mit der heterogenen Cluster-Konfiguration in den vorherigen Abschnitten haben Sie die SageMaker Trainingsumgebung und die Instances für Ihre Trainingsaufgabe vorbereitet. Um die Instance-Gruppen weiter bestimmten Trainings- und Datenverarbeitungsaufgaben zuzuweisen, müssen Sie im nächsten Schritt Ihr Trainingsskript ändern. Standardmäßig erstellt der Trainingsauftrag einfach Trainingsskriptreplikate für alle Knoten, unabhängig von der Größe der Instance, was zu Leistungsverlusten führen kann.
Wenn Sie beispielsweise CPU-Instanzen und GPU-Instanzen in einem heterogenen Cluster mischen und gleichzeitig ein Trainingsskript für tiefe neuronale Netzwerke an das `entry_point` Argument des SageMaker AI-Estimators übergeben, wird das `entry_point` Skript auf jede Instanz repliziert. Das bedeutet, dass CPU-Instances ohne korrekte Aufgabenzuweisungen auch das gesamte Skript ausführen und den Trainingsauftrag starten, der für verteiltes Training auf GPU-Instances konzipiert ist. Daher müssen Sie Änderungen an bestimmten Verarbeitungsfunktionen vornehmen, die Sie auslagern und auf den CPU-Instances ausführen möchten. Sie können die SageMaker KI-Umgebungsvariablen verwenden, um die Informationen des heterogenen Clusters abzurufen und bestimmte Prozesse entsprechend ausführen zu lassen.
Wenn Ihr Trainingsjob gestartet wird, liest Ihr Trainingsskript Informationen zur SageMaker Trainingsumgebung, zu denen auch die heterogene Clusterkonfiguration gehört. Die Konfiguration enthält Informationen wie die aktuellen Instance-Gruppe, die aktuellen Hosts in jeder Gruppe und die Gruppe, in der sich der aktuelle Host befindet.
Sie können Instanzgruppeninformationen während der Initialisierungsphase eines SageMaker AI-Trainingsjobs auf folgende Weise abfragen.
**(Empfohlen) Lesen von Instanzgruppeninformationen mit dem SageMaker Schulungs-Toolkit**
Verwenden Sie das Python-Umgebungsmodul, das die [SageMaker Schulungstoolkit-Bibliothek](https://github.com/aws/sagemaker-training-toolkit) bereitstellt. Die Toolkit-Bibliothek ist in den [SageMaker Framework-Containern](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) für TensorFlow und vorinstalliert PyTorch, sodass Sie keinen zusätzlichen Installationsschritt benötigen, wenn Sie die vorgefertigten Container verwenden. Dies ist die empfohlene Methode, um die SageMaker KI-Umgebungsvariablen mit weniger Codeänderungen in Ihrem Trainingsskript abzurufen.
```
from sagemaker_training import environment
env = environment.Environment()
```
Umgebungsvariablen im Zusammenhang mit allgemeinem SageMaker Training und heterogenen Clustern:
+ `env.is_hetero` – Gibt ein boolesches Ergebnis zurück, unabhängig davon, ob ein heterogener Cluster konfiguriert ist oder nicht.
+ `env.current_host` – Gibt den aktuellen Host zurück.
+ `env.current_instance_type` – Gibt den Instance-Typ des aktuellen Hosts zurück.
+ `env.current_instance_group` – Gibt den Namen der aktuellen Instance-Gruppe zurück.
+ `env.current_instance_group_hosts` – Gibt eine Liste der Hosts in der aktuellen Instance-Gruppe zurück.
+ `env.instance_groups` – Gibt eine Liste von Instance-Gruppennamen zurück, die für das Training verwendet werden.
+ `env.instance_groups_dict` – Gibt die gesamte heterogene Clusterkonfiguration des Trainingsauftrages zurück.
+ `env.distribution_instance_groups`— Gibt eine Liste von Instanzgruppen zurück, die dem `distribution` Parameter der SageMaker AI-Estimator-Klasse zugewiesen sind.
+ `env.distribution_hosts`— Gibt eine Liste von Hosts zurück, die zu den Instanzgruppen gehören, die dem `distribution` Parameter der SageMaker AI-Estimator-Klasse zugewiesen sind.
Betrachten Sie zum Beispiel das folgende Beispiel für einen heterogenen Cluster, der aus zwei Instance-Gruppen besteht.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 2)
```
Die Ausgabe des `env.instance_groups_dict` heterogenen Beispielclusters sollte folgendermaßen oder ähnlich aussehen.
```
{
"instance_group_1": {
"hosts": [
"algo-2"
],
"instance_group_name": "instance_group_1",
"instance_type": "ml.c5.18xlarge"
},
"instance_group_2": {
"hosts": [
"algo-3",
"algo-1"
],
"instance_group_name": "instance_group_2",
"instance_type": "ml.p3dn.24xlarge"
}
}
```
**(Optional) Lesen von Instance-Gruppeninformationen aus der JSON-Datei mit der Ressourcenkonfiguration**
Wenn Sie die Umgebungsvariablen lieber im JSON-Format abrufen möchten, können Sie die JSON-Datei für die Ressourcenkonfiguration direkt verwenden. Die JSON-Datei in einer SageMaker Trainingsinstanz befindet sich `/opt/ml/input/config/resourceconfig.json` standardmäßig unter.
```
file_path = '/opt/ml/input/config/resourceconfig.json'
config = read_file_as_json(file_path)
print(json.dumps(config, indent=4, sort_keys=True))
```