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. # TensorFlow 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-tensorflow-pysdk) + [Verwenden Sie das SageMaker AI Python SDK und erweitern Sie die SageMaker Deep-Learning-Container des AI Frameworks](#training-compiler-enable-tensorflow-sdk-extend-container) + [Aktivieren Sie den SageMaker Training Compiler mithilfe der SageMaker AI-API-Operation `CreateTrainingJob`](#training-compiler-enable-tensorflow-api) ## Verwenden des SageMaker Python-SDK Um den SageMaker Training Compiler zu aktivieren, fügen Sie den `compiler_config` Parameter dem SageMaker AI TensorFlow - oder Hugging Face-Schätzer hinzu. Importieren Sie die `TrainingCompilerConfig`-Klasse und übergeben Sie eine Instance davon an den `compiler_config`-Parameter. Die folgenden Codebeispiele zeigen die Struktur der SageMaker AI-Schätzerklassen bei aktiviertem SageMaker Training Compiler. **Tipp** Um mit den vorgefertigten Modellen zu beginnen, die von den Bibliotheken TensorFlow und Transformers bereitgestellt werden, versuchen Sie, die in der Referenztabelle unter angegebenen Batchgrößen zu verwenden. [Getestete Modelle](training-compiler-support.md#training-compiler-tested-models) **Anmerkung** SageMaker Training Compiler für TensorFlow ist über die Framework-Schätzer SageMaker AI [ TensorFlow ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) und [ Hugging Face verfügbar. ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) Weitere Informationen, die zu Ihrem Anwendungsfall passen, finden Sie unter einer der folgenden Optionen. ### Für das Training mit einer einzelnen GPU ------ #### [ TensorFlow ] ``` from sagemaker.tensorflow import TensorFlow, 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 the global learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } tensorflow_estimator=TensorFlow( entry_point='{{train.py}}', instance_count=1, instance_type='{{ml.p3.2xlarge}}', framework_version='{{2.9.1}}', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) tensorflow_estimator.fit() ``` Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. + [Für das Training mit einer einzelnen GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-keras-single-gpu)eines Modells, das mit TensorFlow Keras () konstruiert wurde. `tf.keras.*` + [Für das Training mit einer einzelnen GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-no-keras-single-gpu)eines Modells, das mithilfe von TensorFlow Modulen konstruiert wurde (mit `tf.*` Ausnahme der TensorFlow Keras-Module). ------ #### [ Hugging Face Estimator with TensorFlow ] ``` 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 the global learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } tensorflow_huggingface_estimator=HuggingFace( entry_point='{{train.py}}', instance_count=1, instance_type='{{ml.p3.2xlarge}}', transformers_version='4.21.1', tensorflow_version='2.6.3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) tensorflow_huggingface_estimator.fit() ``` Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. + [Für das Training mit einer einzelnen GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-single-gpu)eines TensorFlow Keras-Modells mit Hugging Face Transformers + [Für das Training mit einer einzelnen GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-single-gpu)eines TensorFlow Modells mit Hugging Face Transformers ------ ### Für verteiltes Training ------ #### [ Hugging Face Estimator with TensorFlow ] ``` 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 } tensorflow_huggingface_estimator=HuggingFace( entry_point='{{train.py}}', instance_count=instance_count, instance_type=instance_type, transformers_version='4.21.1', tensorflow_version='2.6.3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) tensorflow_huggingface_estimator.fit() ``` **Tipp** Informationen zum Erstellen Ihres Trainingsskripts finden Sie auf den folgenden Seiten. [Für verteiltes Training](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-distributed)eines TensorFlow Keras-Modells mit Hugging Face Transformers [Für verteiltes Training](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-distributed)eines TensorFlow Modells mit Hugging Face Transformers ------ 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` `tensorflow_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. + `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 Sie den SageMaker AI Hugging Face Estimator verwenden. 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 `tensorflow_version` (str) – Erforderlich. Geben Sie die vom Training TensorFlow 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 TensorFlow AI-Schätzer verwenden, müssen Sie Folgendes angeben. `framework_version` Wenn Sie den SageMaker AI Hugging Face Estimator verwenden, müssen Sie sowohl als auch angeben. `transformers_version` `tensorflow_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). + `compiler_config`(TrainingCompilerConfig Objekt) — Erforderlich. Schließen Sie diesen Parameter ein, um den SageMaker Training Compiler zu aktivieren. 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`. **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 ``` ## Verwenden Sie das SageMaker AI Python SDK und erweitern Sie die SageMaker Deep-Learning-Container des AI Frameworks AWS Deep-Learning-Container (DLC) zur TensorFlow Verwendung, angepasste Versionen TensorFlow davon enthalten Änderungen, die das Open-Source-Framework ergänzen TensorFlow . Die Deep Learning-Container des [ SageMaker KI-Frameworks ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) sind für die zugrunde liegende AWS Infrastruktur und Amazon SageMaker AI optimiert. Mit dem Vorteil der Verwendung der DLCs bietet die SageMaker Training Compiler-Integration weitere Leistungsverbesserungen gegenüber der nativen Version. TensorFlow Darüber hinaus können Sie einen benutzerdefinierten Trainingscontainer erstellen, indem Sie das DLC-Image erweitern. **Anmerkung** Diese Docker-Anpassungsfunktion ist derzeit nur für verfügbar. TensorFlow Verwenden Sie die folgenden Anweisungen, um die SageMaker TensorFlow AI-DLCs für Ihren Anwendungsfall zu erweitern und anzupassen. ### Erstellen einer Docker-Datei Verwende die folgende Dockerfile-Vorlage, um den AI-DLC zu erweitern. SageMaker TensorFlow Sie müssen das SageMaker TensorFlow AI-DLC-Image als Basisimage Ihres Docker-Containers verwenden. Die SageMaker TensorFlow AI-DLC-Image-URIs finden Sie unter Unterstützte Frameworks. [https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-frameworks) ``` # SageMaker AI TensorFlow Deep Learning Container image FROM 763104351884.dkr.ecr.{{}}.amazonaws.com/tensorflow-training:{{}} ENV PATH="/opt/ml/code:${PATH}" # This environment variable is used by the SageMaker AI container # to determine user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code # Add more code lines to customize for your use-case ... ``` Weitere Informationen finden Sie unter [Schritt 2: Dockerfile- und Python-Trainingsskripts erstellen und hochladen](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step2). Beachten Sie bei der Erweiterung der SageMaker AI Framework-DLCs die folgenden Fallstricke: + Deinstallieren oder ändern Sie die Version von TensorFlow Paketen in SageMaker AI-Containern nicht explizit. Dadurch werden die AWS optimierten TensorFlow Pakete durch TensorFlow Open-Source-Pakete überschrieben, was zu Leistungseinbußen führen kann. + Achten Sie auf Pakete, die eine bestimmte TensorFlow Version oder Variante als Abhängigkeit haben. Diese Pakete könnten implizit die AWS optimierten Pakete deinstallieren TensorFlow und TensorFlow Open-Source-Pakete installieren. Es gibt beispielsweise ein bekanntes Problem, dass die [ tensorflow/models ](https://github.com/tensorflow/models) und [ tensorflow/text ](https://github.com/tensorflow/text) -Bibliotheken immer versuchen, Open Source [ neu zu installieren. TensorFlow ](https://github.com/tensorflow/models/issues/9267) Wenn Sie diese Bibliotheken installieren müssen, um eine bestimmte Version für Ihren Anwendungsfall auszuwählen, empfehlen wir Ihnen, sich die SageMaker TensorFlow AI-DLC-Dockerfiles für Version 2.9 oder höher anzusehen. Die Pfade zu den Dockerfiles haben normalerweise das folgende Format: `tensorflow/training/docker//py3//Dockerfile.gpu`. In den Dockerfiles solltest du die Codezeilen finden, um die AWS verwaltete TensorFlow Binärdatei (in der `TF_URL` Umgebungsvariablen angegeben) und andere Abhängigkeiten der Reihe nach neu zu installieren. Der Abschnitt für die Neuinstallation sollte wie das folgende Beispiel aussehen: ``` # tf-models does not respect existing installations of TensorFlow # and always installs open source TensorFlow RUN pip3 install --no-cache-dir -U \ tf-models-official=={{x.y.z}} RUN pip3 uninstall -y tensorflow tensorflow-gpu \ ; pip3 install --no-cache-dir -U \ ${TF_URL} \ tensorflow-io=={{x.y.z}} \ tensorflow-datasets=={{x.y.z}} ``` ### Erstellen und auf ECR übertragen Folgen Sie den Anweisungen unter den folgenden Links, um Ihren Docker-Container zu erstellen und auf Amazon ECR zu übertragen: + [Schritt 3: Erstellen des Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step3) + [Schritt 4: Testen der Behälter](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step4) + [Schritt 5: Pushen Sie den Container zu Amazon ECR](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5) ### Führen Sie es mit dem SageMaker Python SDK Estimator aus Verwenden Sie den SageMaker TensorFlow AI-Framework-Schätzer wie gewohnt. Sie müssen `image_uri` angeben, dass Sie den neuen Container verwenden möchten, den Sie in Amazon ECR gehostet haben. ``` import sagemaker, boto3 from sagemaker import get_execution_role from sagemaker.tensorflow import TensorFlow, TrainingCompilerConfig account_id = boto3.client('sts').get_caller_identity().get('Account') ecr_repository = {{'tf-custom-container-test'}} tag = {{':latest'}} region = boto3.session.Session().region_name uri_suffix = 'amazonaws.com' byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format( account_id, region, uri_suffix, ecr_repository + tag ) byoc_image_uri # This should return something like # 111122223333.dkr.ecr.us-east-2.amazonaws.com/tf-custom-container-test:latest estimator = TensorFlow( image_uri=image_uri, role=get_execution_role(), base_job_name='{{tf-custom-container-test-job}}', instance_count=1, instance_type='{{ml.p3.8xlarge}}' compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) # Start training estimator.fit() ``` ## Aktivieren Sie den SageMaker Training Compiler mithilfe 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://amazonaws.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) ``` "AlgorithmSpecification": { "TrainingImage": "{{}}" }, "HyperParameters": { "sagemaker_training_compiler_enabled": "true", "sagemaker_training_compiler_debug_mode": "false" } ``` 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)