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. # PyTorch Trainingsjobs mit dem SageMaker Training Compiler ausführen Sie können jede der SageMaker KI-Schnittstellen verwenden, um einen Trainingsjob mit SageMaker Training Compiler auszuführen: Amazon SageMaker Studio Classic, Amazon SageMaker Notebook-Instances und AWS Command Line Interface. AWS SDK für Python (Boto3) **Topics** + [Verwenden des SageMaker Python-SDK](#training-compiler-enable-pytorch-pysdk) + [Verwendung des SageMaker `CreateTrainingJob` AI-API-Vorgangs](#training-compiler-enable-pytorch-api) ## Verwenden des SageMaker Python-SDK SageMaker Training Compiler for PyTorch ist in den Klassen SageMaker AI [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)und [https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator)Framework Estimator verfügbar. Um den SageMaker Training Compiler zu aktivieren, fügen Sie den `compiler_config` Parameter zu den SageMaker AI-Schätzern hinzu. Importieren Sie die `TrainingCompilerConfig`-Klasse und übergeben Sie eine Instance davon an den `compiler_config`-Parameter. Die folgenden Codebeispiele zeigen die Struktur von SageMaker AI-Estimator-Klassen mit aktiviertem SageMaker Training Compiler. **Tipp** Um mit vorgefertigten Modellen von PyTorch oder Transformers zu beginnen, versuchen Sie, die in der Referenztabelle unter angegebenen Batchgrößen zu verwenden. [Getestete Modelle](training-compiler-support.md#training-compiler-tested-models) **Anmerkung** Die native PyTorch Unterstützung ist im SageMaker Python SDK v2.121.0 und höher verfügbar. Stellen Sie sicher, dass Sie das SageMaker Python-SDK entsprechend aktualisieren. **Anmerkung** Ab PyTorch Version 1.12.0 sind SageMaker Training Compiler-Container für PyTorch verfügbar. Beachten Sie, dass die SageMaker Training Compiler-Container für nicht im Lieferumfang von Hugging Face Transformers enthalten PyTorch sind. Wenn Sie die Bibliothek im Container installieren müssen, stellen Sie sicher, dass Sie die `requirements.txt` Datei im Quellverzeichnis hinzufügen, wenn Sie einen Trainingsjob einreichen. Verwenden Sie für PyTorch Version 1.11.0 und früher die vorherigen Versionen der SageMaker Training Compiler-Container für Hugging Face und. PyTorch Eine vollständige Liste der Framework-Versionen und der entsprechenden Container-Informationen finden Sie unter [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks). Weitere Informationen, die zu Ihrem Anwendungsfall passen, finden Sie unter einer der folgenden Optionen. ### Für das Training mit einer einzelnen GPU ------ #### [ PyTorch v1.12.0 and later ] Um ein PyTorch Modell zu kompilieren und zu trainieren, konfigurieren Sie einen SageMaker PyTorch AI-Schätzer mit SageMaker Training Compiler, wie im folgenden Codebeispiel gezeigt. **Anmerkung** Diese native PyTorch Unterstützung ist im SageMaker AI Python SDK v2.120.0 und höher verfügbar. Stellen Sie sicher, dass Sie das SageMaker AI Python SDK aktualisieren. ``` from sagemaker.pytorch import PyTorch, TrainingCompilerConfig # the original max batch size that can fit into GPU memory without compiler batch_size_native=12 learning_rate_native=float('5e-5') # an updated max batch size that can fit into GPU memory with compiler batch_size=64 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_estimator=PyTorch( entry_point='train.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=1, instance_type='ml.p3.2xlarge', framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` ------ #### [ Hugging Face Transformers with PyTorch v1.11.0 and before ] Um ein Transformer-Modell mit zu kompilieren und zu trainieren PyTorch, konfigurieren Sie einen SageMaker AI Hugging Face Estimator mit SageMaker Training Compiler, wie im folgenden Codebeispiel gezeigt. ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # the original max batch size that can fit into GPU memory without compiler batch_size_native=12 learning_rate_native=float('5e-5') # an updated max batch size that can fit into GPU memory with compiler batch_size=64 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_huggingface_estimator=HuggingFace( entry_point='train.py', instance_count=1, instance_type='ml.p3.2xlarge', transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. + [Für das Training mit einer einzelnen GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-single-gpu)[eines PyTorch Modells, das die Trainer-API von Hugging Face Transformers verwendet](https://huggingface.co/docs/transformers/main_classes/trainer) + [Für das Training mit einer einzelnen GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-single-gpu)[eines PyTorch Modells ohne Hugging Face Transformers' Trainer API](https://huggingface.co/transformers/main_classes/trainer.html) end-to-endBeispiele finden Sie in den folgenden Notizbüchern: + [Kompilieren und trainieren Sie mit dem AD-Datensatz ein Transformers-Trainermodell für Fragen und Antworten mit dem Hugging Face Transformers Trainer-Modell SQu](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/albert-base-v2/albert-base-v2.html) + [Kompilieren und trainieren Sie ein Hugging Face `BERT` Transformer-Modell mit dem SST-Datensatz mithilfe SageMaker des Training Compilers](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/bert-base-cased/bert-base-cased-single-node-single-gpu.html) + [Kompilieren und trainieren Sie ein binäres Klassifikationstrainer-Modell mit dem SST2 Datensatz für das Single-Node-Training mit einer GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/roberta-base/roberta-base.html) ------ ### Für verteiltes Training ------ #### [ PyTorch v1.12 ] In PyTorch Version 1.12 können Sie verteiltes Training mit dem SageMaker Training Compiler ausführen, indem Sie die angegebene `pytorch_xla` Option dem `distribution` Parameter der SageMaker AI-Estimator-Klasse hinzufügen. PyTorch **Anmerkung** Diese native PyTorch Unterstützung ist im SageMaker AI Python SDK v2.121.0 und höher verfügbar. Stellen Sie sicher, dass Sie das SageMaker AI Python SDK aktualisieren. ``` from sagemaker.pytorch import PyTorch, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_estimator=PyTorch( entry_point='your_training_script.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=instance_count, instance_type=instance_type, framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` **Tipp** Informationen zur Vorbereitung Ihres Trainingsskripts finden Sie unter [PyTorch](training-compiler-pytorch-models.md) ------ #### [ Transformers v4.21 with PyTorch v1.11 ] Für PyTorch Version 1.11 und höher ist der SageMaker Training Compiler für verteiltes Training mit der für den `pytorch_xla` Parameter angegebenen Option verfügbar. `distribution` ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_huggingface_estimator=HuggingFace( entry_point='your_training_script.py', instance_count=instance_count, instance_type=instance_type, transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` **Tipp** Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. [Für verteiltes Training](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)[eines PyTorch Modells, das die Trainer-API von Hugging Face Transformers verwendet](https://huggingface.co/transformers/main_classes/trainer.html) [Für verteiltes Training](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)[eines PyTorch Modells ohne Hugging Face Transformers' Trainer API](https://huggingface.co/transformers/main_classes/trainer.html) ------ #### [ Transformers v4.17 with PyTorch v1.10.2 and before ] Für die unterstützte Version von PyTorch v1.10.2 und früher benötigt SageMaker Training Compiler einen alternativen Mechanismus zum Starten eines verteilten Trainingsjobs. Um verteilte Schulungen ausführen zu können, müssen Sie beim SageMaker Training Compiler dem Argument ein Skript für den Start von verteiltem Training von SageMaker KI übergeben und Ihr Trainingsskript an das `entry_point` Argument übergeben. `hyperparameters` Das folgende Codebeispiel zeigt, wie ein SageMaker AI Hugging Face Face-Schätzer konfiguriert wird, indem die erforderlichen Änderungen angewendet werden. ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count training_script="your_training_script.py" hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate, "training_script": training_script # Specify the file name of your training script. } pytorch_huggingface_estimator=HuggingFace( entry_point='distributed_training_launcher.py', # Specify the distributed training launcher script. instance_count=instance_count, instance_type=instance_type, transformers_version='4.17.0', pytorch_version='1.10.2', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` Das Startskript sollte wie folgt aussehen. Es umschließt Ihr Trainingsskript und konfiguriert die verteilte Trainingsumgebung in Abhängigkeit von der Größe der Trainings-Instance Ihrer Wahl. ``` # distributed_training_launcher.py #!/bin/python import subprocess import sys if __name__ == "__main__": arguments_command = " ".join([arg for arg in sys.argv[1:]]) """ The following line takes care of setting up an inter-node communication as well as managing intra-node workers for each GPU. """ subprocess.check_call("python -m torch_xla.distributed.sm_dist " + arguments_command, shell=True) ``` **Tipp** Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. [Für verteiltes Training](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)[eines PyTorch Modells, das die Trainer-API von Hugging Face Transformers verwendet](https://huggingface.co/transformers/main_classes/trainer.html) [Für verteiltes Training](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)[eines PyTorch Modells ohne Hugging Face Transformers' Trainer API](https://huggingface.co/transformers/main_classes/trainer.html) **Tipp** end-to-endBeispiele finden Sie in den folgenden Notizbüchern: [Kompilieren und trainieren Sie das GPT2 Modell mithilfe der Transformers Trainer-API mit dem SST2 Datensatz für Einzelknoten-Training mit mehreren GPUs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Kompilieren und trainieren Sie das GPT2 Modell mithilfe der Transformers Trainer-API mit dem SST2 Datensatz für Multi-Node-Multi-GPU-Training](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) ------ Die folgende Liste enthält die Mindestanzahl von Parametern, die für die Ausführung eines SageMaker Trainingsjobs mit dem Compiler erforderlich sind. **Anmerkung** Wenn Sie den SageMaker AI Hugging Face Estimator verwenden, müssen Sie die `compiler_config` Parameter,, und angeben `transformers_version` `pytorch_version``hyperparameters`, um den Training Compiler zu aktivieren SageMaker . Sie können `image_uri` nicht verwenden, um die unter [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks) aufgelisteten integrierten Deep-Learning-Container für den Trainingscompiler manuell anzugeben. + `entry_point` (str) – Erforderlich. Geben Sie den Dateinamen Ihres Trainingsskripts an. **Anmerkung** Um ein verteiltes Training mit SageMaker Training Compiler und PyTorch Version 1.10.2 und früheren Versionen auszuführen, geben Sie für diesen Parameter den Dateinamen eines Launcher-Skripts an. Das Launcher-Skript sollte so vorbereitet sein, dass es Ihr Trainingsskript umschließt und die verteilte Trainingsumgebung konfiguriert. Weitere Informationen finden Sie in den folgenden Notebook-Beispielen: [Kompilieren und trainieren Sie das GPT2 Modell mithilfe der Transformers Trainer-API mit dem SST2 Datensatz für Einzelknoten-Training mit mehreren GPUs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Kompilieren und trainieren Sie das GPT2 Modell mithilfe der Transformers Trainer-API mit dem SST2 Datensatz für Multi-Node-Multi-GPU-Training](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) + `source_dir` (str) – Optional. Fügen Sie dies hinzu, wenn Sie zusätzliche Pakete installieren müssen. Um Pakete zu installieren, müssen Sie eine `requirements.txt` Datei in diesem Verzeichnis vorbereiten. + `instance_count` (int) – Erforderlich. Geben Sie die Anzahl der Instances an. + `instance_type` (str) – Erforderlich. Geben Sie den Instance-Typ an. + `transformers_version`(str) — Nur erforderlich, wenn der SageMaker AI Hugging Face Estimator verwendet wird. Geben Sie die Hugging Face Transformers-Bibliotheksversion an, die vom SageMaker Training Compiler unterstützt wird. Die verfügbaren Versionen finden Sie unter [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks). + `framework_version` oder `pytorch_version` (str) – Erforderlich. Geben Sie die vom Training PyTorch Compiler unterstützte SageMaker Version an. Die verfügbaren Versionen finden Sie unter [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks). **Anmerkung** Wenn Sie den SageMaker AI Hugging Face Estimator verwenden, müssen Sie sowohl als auch angeben. `transformers_version` `pytorch_version` + `hyperparameters` (dict) – Optional. Geben Sie Hyperparameter für den Trainingsjob an, z. B. `n_gpus``batch_size`, und `learning_rate`. Wenn Sie SageMaker Training Compiler aktivieren, probieren Sie größere Batchgrößen aus und passen Sie die Lernrate entsprechend an. Fallstudien zur Verwendung des Compilers und zur Anpassung der Batchgrößen zur Verbesserung der Trainingsgeschwindigkeit finden Sie unter [Getestete Modelle](training-compiler-support.md#training-compiler-tested-models) und [SageMaker Beispiel für Notizbücher und Blogs zum Training Compiler](training-compiler-examples-and-blogs.md). **Anmerkung** Um ein verteiltes Training mit SageMaker Training Compiler und PyTorch Version 1.10.2 und früheren Versionen durchzuführen, müssen Sie einen zusätzlichen Parameter hinzufügen`"training_script"`, um Ihr Trainingsskript zu spezifizieren, wie im vorherigen Codebeispiel gezeigt. + `compiler_config`(TrainingCompilerConfig Objekt) — Erforderlich, um den SageMaker Training Compiler zu aktivieren. Fügen Sie diesen Parameter hinzu, um den SageMaker Training Compiler zu aktivieren. Nachfolgend sind die Parameter für die Klasse `TrainingCompilerConfig` aufgeführt. + `enabled` (bool) – Optional. Geben Sie `True` oder an`False`, um den SageMaker Training Compiler ein- oder auszuschalten. Der Standardwert ist `True`. + `debug` (bool) – Optional. Um detailliertere Trainingsprotokolle von Ihren Compiler-beschleunigten Trainingsaufträgen zu erhalten, ändern Sie es zu `True`. Die zusätzliche Protokollierung kann jedoch den Aufwand erhöhen und den kompilierten Trainingsjob verlangsamen. Der Standardwert ist `False`. + `distribution` (dict) – Fakultativ. Um einen verteilten Trainingsjob mit SageMaker Training Compiler auszuführen, fügen Sie hinzu. `distribution = { 'pytorchxla' : { 'enabled': True }}` **Warnung** Wenn Sie den SageMaker Debugger aktivieren, kann dies die Leistung von SageMaker Training Compiler beeinträchtigen. Es wird empfohlen, den Debugger zu deaktivieren, wenn SageMaker Training Compiler ausgeführt wird, um sicherzustellen, dass die Leistung nicht beeinträchtigt wird. Weitere Informationen finden Sie unter [Überlegungen](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Um die Debugger-Funktionen auszuschalten, fügen Sie dem Schätzer die folgenden beiden Argumente hinzu: ``` disable_profiler=True, debugger_hook_config=False ``` Wenn der Trainingsjob mit dem Compiler erfolgreich gestartet wurde, erhalten Sie während der Job-Initialisierungsphase die folgenden Protokolle: + Mit `TrainingCompilerConfig(debug=False)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... ``` + Mit `TrainingCompilerConfig(debug=True)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... Training Compiler set to debug mode ``` ## Verwendung des SageMaker `CreateTrainingJob` AI-API-Vorgangs SageMaker Die Konfigurationsoptionen des Training Compilers müssen im `HyperParameters` Feld `AlgorithmSpecification` und in der Anforderungssyntax für den [`CreateTrainingJob`API-Vorgang](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) angegeben werden. ``` "AlgorithmSpecification": { "TrainingImage": "" }, "HyperParameters": { "sagemaker_training_compiler_enabled": "true", "sagemaker_training_compiler_debug_mode": "false", "sagemaker_pytorch_xla_multi_worker_enabled": "false" // set to "true" for distributed training } ``` Eine vollständige Liste der Deep-Learning-Container-Images URIs , für die SageMaker Training Compiler implementiert wurde, finden Sie unter. [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks)