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 SageMaker Training Compiler ausführen **Wichtig** **Hinweis zur Veralterung: Der ** SageMaker Training Compiler wird in SageMaker Python SDK v3 nicht unterstützt. Wenn Sie derzeit den Training Compiler verwenden, verwenden SageMaker Sie weiterhin Python SDK v2. Für neue Projekte sollten Sie erwägen, die einheitliche `ModelTrainer` Klasse mit unterstützten Frameworks zu verwenden. Eine Anleitung [ zur Migration finden Sie in der ](https://sagemaker.readthedocs.io/en/stable/) SageMaker Python-SDK-Dokumentation. 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 der SageMaker AI-API-Operation `CreateTrainingJob`](#training-compiler-enable-pytorch-api) ## Verwenden des SageMaker Python-SDK SageMaker Training Compiler für PyTorch ist in den Klassen SageMaker AI [`PyTorch`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) und [`HuggingFace`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) 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 KI-Schätzerklassen bei aktiviertem SageMaker Training Compiler. **Tipp** Um mit den von PyTorch oder Transformers bereitgestellten vorgefertigten Modellen zu beginnen, versuchen Sie, die in der Referenztabelle unter angegebenen Chargengröß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 KI-Schätzer mit dem 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 AI Python SDK aktualisieren. SageMaker ``` 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-Schätzer mit dem 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](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 die Trainer-API von Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) End-to-End-Beispiele finden Sie in den folgenden Notebooks: + [Kompilieren und trainieren Sie mit dem SQuad-Datensatz ein Transformers-Trainer-Modell für Fragen und Antworten mit dem Hugging Face Transformers Trainer-Modell](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 des Training Compilers SageMaker ](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 Training Single-Node Single-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 ] Für PyTorch Version 1.12 können Sie verteiltes Training mit dem SageMaker Training Compiler ausführen, indem Sie die angegebene `pytorch_xla` Option zum `distribution` Parameter der SageMaker AI-Schätzerklasse 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 im `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](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 die Trainer-API von Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](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 der SageMaker Training Compiler einen alternativen Mechanismus, um einen verteilten Trainingsjob zu starten. Um verteiltes Training auszuführen, müssen Sie beim SageMaker Training Compiler ein von SageMaker KI verteiltes Launcher-Skript für das `entry_point` Argument und Ihr Trainingsskript an das Argument übergeben. `hyperparameters` Das folgende Codebeispiel zeigt, wie ein SageMaker AI Hugging Face Estimator konfiguriert wird, der die erforderlichen Änderungen vornimmt. ``` 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](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 die Trainer-API von Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) **Tipp** End-to-End-Beispiele finden Sie in den folgenden Notebooks: [Kompilieren und trainieren Sie das GPT2-Modell mithilfe der Transformers Trainer API mit dem SST2-Datensatz für das Training Single-Node Multi-GPU ](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 das Training Multi-Node Multi-GPU ](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 den Mindestsatz an Parametern, der für die Ausführung eines SageMaker Trainingsauftrags mit dem Compiler erforderlich ist. **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üher durchzuführen, geben Sie den Dateinamen eines Launcher-Skripts für diesen Parameter 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 das Training Single-Node Multi-GPU ](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 das Training Multi-Node Multi-GPU ](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 vom Training Compiler unterstützte Hugging Face Transformers-Bibliotheksversion an. SageMaker 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 den SageMaker Training Compiler aktivieren, probieren Sie größere Chargen 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 Notizbücher und Blogs zum Beispiel für den 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üher auszufü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. Schließen Sie diesen Parameter ein, um den SageMaker Training Compiler einzuschalten. Nachfolgend sind die Parameter für die Klasse `TrainingCompilerConfig` aufgeführt. + `enabled` (bool) – Optional. Geben Sie an `True``False`, ob der SageMaker Training Compiler ein- oder ausgeschaltet werden soll. 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 dem SageMaker Training Compiler auszuführen, fügen Sie Folgendes hinzu. `distribution = { 'pytorchxla' : { 'enabled': True }}` **Warnung** Wenn Sie den SageMaker Debugger einschalten, kann sich dies auf die Leistung des SageMaker Training Compilers auswirken. Wir empfehlen, den Debugger auszuschalten, wenn Sie den SageMaker Training Compiler ausführen, um sicherzustellen, dass dies keine Auswirkungen auf die Leistung hat. 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 der SageMaker AI-API-Operation `CreateTrainingJob` SageMaker Die Konfigurationsoptionen für den Training Compiler müssen in der Anforderungssyntax für den [`CreateTrainingJob` API-Vorgang über das `HyperParameters` Feld `AlgorithmSpecification` und angegeben werden. ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) ``` "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-Image-URIs, für die der SageMaker Training Compiler implementiert ist, finden Sie unter. [Unterstützte Frameworks](training-compiler-support.md#training-compiler-supported-frameworks)