Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Esegui lavori TensorFlow di formazione con SageMaker Training Compiler Puoi utilizzare qualsiasi interfaccia SageMaker AI per eseguire un processo di formazione con SageMaker Training Compiler: Amazon SageMaker Studio Classic, AWS SDK per Python (Boto3) Amazon SageMaker Notebook Instances e. AWS Command Line Interface **Topics** + [Usare l' SageMaker SDK Python](#training-compiler-enable-tensorflow-pysdk) + [Utilizzo dell'SDK SageMaker AI Python e dell'estensione dei contenitori di Deep Learning di SageMaker AI Framework](#training-compiler-enable-tensorflow-sdk-extend-container) + [Abilita SageMaker Training Compiler utilizzando l'operazione SageMaker API AI `CreateTrainingJob`](#training-compiler-enable-tensorflow-api) ## Usare l' SageMaker SDK Python Per attivare SageMaker Training Compiler, aggiungi il `compiler_config` parametro allo stimatore SageMaker AI TensorFlow o Hugging Face. Importa la classe `TrainingCompilerConfig` e passa un'istanza al parametro `compiler_config`. I seguenti esempi di codice mostrano la struttura delle classi di stima SageMaker AI con SageMaker Training Compiler attivato. **Suggerimento** Per iniziare con i modelli predefiniti forniti dalle librerie TensorFlow e Transformers, prova a utilizzare le dimensioni dei batch fornite nella tabella di riferimento all'indirizzo. [Modelli testati](training-compiler-support.md#training-compiler-tested-models) **Nota** SageMaker Training Compiler for TensorFlow è disponibile tramite gli estimatori del SageMaker framework AI [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)e [Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator). Per informazioni adatte al tuo caso d'uso, consulta una delle seguenti opzioni. ### Per l’addestramento su una singola 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() ``` Per preparare lo script di addestramento, consulta le pagine seguenti. + [Per l’addestramento su una singola GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-keras-single-gpu)di un modello costruito utilizzando TensorFlow Keras (). `tf.keras.*` + [Per l’addestramento su una singola GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-no-keras-single-gpu)di un modello costruito utilizzando TensorFlow moduli (`tf.*`esclusi i moduli TensorFlow Keras). ------ #### [ 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() ``` Per preparare lo script di addestramento, consulta le pagine seguenti. + [Per l’addestramento su una singola GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-single-gpu)di un modello TensorFlow Keras con Hugging Face Transformers + [Per l’addestramento su una singola GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-single-gpu)di un TensorFlow modello con Hugging Face Transformers ------ ### Per l’addestramento distribuito ------ #### [ 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() ``` **Suggerimento** Per preparare lo script di addestramento, consulta le pagine seguenti. [Per l’addestramento distribuito](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-distributed)di un modello TensorFlow Keras con Hugging Face Transformers [Per l’addestramento distribuito](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-distributed)di un TensorFlow modello con Hugging Face Transformers ------ L'elenco seguente è l'insieme minimo di parametri richiesti per eseguire un processo di SageMaker formazione con il compilatore. **Nota** Quando si utilizza lo stimatore SageMaker AI Hugging Face, è necessario specificare i `compiler_config` parametri, `transformers_version` `tensorflow_version``hyperparameters`, e per abilitare Training Compiler. SageMaker Non è possibile utilizzare `image_uri` per specificare manualmente i Deep Learning Containers integrati nel compilatore Addestramento elencati in [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks). + `entry_point` (str) — Obbligatorio. Specifica il nome del file dello script di addestramento. + `instance_count` (int) — Obbligatorio. Specifica il numero di istanze. + `instance_type` (str) — Obbligatorio. Specifica il tipo di istanza. + `transformers_version`(str) — Richiesto solo quando si utilizza lo stimatore SageMaker AI Hugging Face. Specificate la versione della libreria Hugging Face Transformers supportata da Training Compiler. SageMaker Per trovare le versioni disponibili, consulta [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks). + `framework_version` o `tensorflow_version` (str) — Obbligatorio. Specificate la TensorFlow versione supportata da Training Compiler. SageMaker Per trovare le versioni disponibili, consulta [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks). **Nota** Quando si utilizza lo TensorFlow stimatore SageMaker AI, è necessario specificare. `framework_version` Quando si utilizza lo stimatore SageMaker AI Hugging Face, è necessario specificare entrambi e. `transformers_version` `tensorflow_version` + `hyperparameters` (dict) — Facoltativo. Specifica gli iperparametri per il processo di addestramento, ad esempio `n_gpus``batch_size`, e `learning_rate`. Quando abiliti SageMaker Training Compiler, prova batch di dimensioni maggiori e regola il tasso di apprendimento di conseguenza. Per trovare casi di studio sull'uso del compilatore e sulle dimensioni dei batch modificate per migliorare la velocità di addestramento, consulta [Modelli testati](training-compiler-support.md#training-compiler-tested-models) e [SageMaker Taccuini e blog di esempio per Training Compiler](training-compiler-examples-and-blogs.md). + `compiler_config`(TrainingCompilerConfig oggetto) — Obbligatorio. Includi questo parametro per attivare SageMaker Training Compiler. I seguenti sono parametri per la classe `TrainingCompilerConfig`. + `enabled` (bool) — Facoltativo. `False`Specificare `True` o attivare o disattivare SageMaker Training Compiler. Il valore predefinito è `True`. + `debug` (bool) — Facoltativo. Per ricevere log di addestramento più dettagliati relativi ai processi di addestramento accelerati dal compilatore, modificalo in `True`. Tuttavia, la registrazione aggiuntiva potrebbe aumentare il sovraccarico e rallentare il processo di addestramento compilato. Il valore predefinito è `False`. **avvertimento** Se attivi SageMaker Debugger, ciò potrebbe influire sulle prestazioni di Training Compiler. SageMaker Ti consigliamo di disattivare Debugger durante l'esecuzione di SageMaker Training Compiler per assicurarti che non ci sia alcun impatto sulle prestazioni. Per ulteriori informazioni, consulta [Considerazioni](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Per disattivare le funzionalità di Debugger, aggiungi i seguenti due argomenti allo strumento di valutazione: ``` disable_profiler=True, debugger_hook_config=False ``` Se il processo di addestramento con il compilatore viene avviato correttamente, durante la fase di inizializzazione del processo vengono ricevuti i seguenti log: + Con `TrainingCompilerConfig(debug=False)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... ``` + Con `TrainingCompilerConfig(debug=True)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... Training Compiler set to debug mode ``` ## Utilizzo dell'SDK SageMaker AI Python e dell'estensione dei contenitori di Deep Learning di SageMaker AI Framework AWS Deep Learning Containers (DLC) per TensorFlow l'uso, versioni adattate TensorFlow che includono modifiche al framework open source TensorFlow . I [Deep Learning Containers di SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) sono ottimizzati per l' AWS infrastruttura sottostante e Amazon SageMaker AI. Con il vantaggio dell'utilizzo di DLCs, l'integrazione di SageMaker Training Compiler aggiunge ulteriori miglioramenti delle prestazioni rispetto a quella nativa TensorFlow. Inoltre, puoi creare un container di addestramento personalizzato estendendo l'immagine DLC. **Nota** Questa funzionalità di personalizzazione Docker è attualmente disponibile solo per. TensorFlow Per estendere e personalizzare l' SageMaker IA TensorFlow DLCs per il tuo caso d'uso, usa le seguenti istruzioni. ### Crea un Dockerfile. Utilizza il seguente modello Dockerfile per estendere il DLC AI. SageMaker TensorFlow Devi usare l'immagine SageMaker AI TensorFlow DLC come immagine di base del tuo contenitore Docker. [Per trovare l'immagine del TensorFlow DLC SageMaker AI URIs, consulta 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 ... ``` Per ulteriori informazioni, consulta [Fase 2: creare e caricare gli script di addestramento Dockerfile e Python](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step2). Considerate le seguenti insidie quando estendete AI Framework: SageMaker DLCs + Non disinstallate o modificate in modo esplicito la versione dei TensorFlow pacchetti nei SageMaker contenitori AI. In questo modo i TensorFlow pacchetti AWS ottimizzati vengono sovrascritti da TensorFlow pacchetti open source, il che potrebbe comportare un peggioramento delle prestazioni. + Fai attenzione ai pacchetti che hanno una TensorFlow versione o un tipo particolare come dipendenza. Questi pacchetti potrebbero disinstallare implicitamente i pacchetti AWS ottimizzati TensorFlow e installare pacchetti open source TensorFlow . [Ad esempio, è noto che le librerie [tensorflow/models e [tensorflow/text](https://github.com/tensorflow/text)](https://github.com/tensorflow/models) tentano sempre di reinstallare l'open source. TensorFlow](https://github.com/tensorflow/models/issues/9267) Se devi installare queste librerie per scegliere una versione specifica per il tuo caso d'uso, ti consigliamo di esaminare i Dockerfiles DLC AI per la versione 2.9 o successiva. SageMaker TensorFlow I percorsi dei Dockerfile sono in genere nel seguente formato: `tensorflow/training/docker//py3//Dockerfile.gpu`. Nei Dockerfile, dovresti trovare le righe di codice per reinstallare il TensorFlow binario AWS gestito (specificato nella variabile di `TF_URL` ambiente) e altre dipendenze in ordine. La sezione di reinstallazione sarà simile all'esempio seguente: ``` # 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 ``` ### Crea e invia a ECR Per creare e inviare il tuo container Docker ad Amazon ECR, segui le istruzioni nei seguenti link: + [Fase 3: costruire il container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step3) + [Fase 4: test del container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step4) + [Fase 5: inviare il container ad Amazon ECR](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5) ### Esegui utilizzando SageMaker Python SDK Estimator Usa lo stimatore del TensorFlow framework SageMaker AI come al solito. Devi specificare `image_uri` per utilizzare il nuovo container ospitato in Amazon ECR. ``` 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() ``` ## Abilita SageMaker Training Compiler utilizzando l'operazione SageMaker API AI `CreateTrainingJob` SageMaker [Le opzioni di configurazione di Training Compiler devono essere specificate tramite il `HyperParameters` campo `AlgorithmSpecification` and nella sintassi della richiesta per l'`CreateTrainingJob`operazione API.](https://amazonaws.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) ``` "AlgorithmSpecification": { "TrainingImage": "" }, "HyperParameters": { "sagemaker_training_compiler_enabled": "true", "sagemaker_training_compiler_debug_mode": "false" } ``` Per trovare un elenco completo delle immagini del contenitore di deep learning su URIs cui è implementato SageMaker Training Compiler, consulta. [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks)