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 PyTorch di formazione con SageMaker Training Compiler **Importante** **Avviso di deprecazione: ** SageMaker Training Compiler non è supportato in Python SDK v3. SageMaker Se attualmente stai utilizzando Training Compiler, continua a utilizzare Python SDK v2. SageMaker Per i nuovi progetti, considera l'utilizzo della classe unificata con i framework supportati`ModelTrainer`. Consulta la documentazione di [ SageMaker Python SDK per indicazioni sulla migrazione. ](https://sagemaker.readthedocs.io/en/stable/) Puoi utilizzare qualsiasi interfaccia SageMaker AI per eseguire un lavoro di formazione con SageMaker Training Compiler: Amazon SageMaker Studio Classic, istanze Amazon SageMaker Notebook e. AWS SDK per Python (Boto3) AWS Command Line Interface **Topics** + [Usare l'SDK Python SageMaker](#training-compiler-enable-pytorch-pysdk) + [Utilizzo dell'API AI Operation SageMaker `CreateTrainingJob`](#training-compiler-enable-pytorch-api) ## Usare l'SDK Python SageMaker SageMaker Training Compiler for PyTorch è disponibile tramite le classi SageMaker AI [`PyTorch`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) e [`HuggingFace`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) framework estimator. Per attivare SageMaker Training Compiler, aggiungi il `compiler_config` parametro agli stimatori AI SageMaker . Importa la classe `TrainingCompilerConfig` e passa un'istanza al parametro `compiler_config`. I seguenti esempi di codice mostrano la struttura delle classi di stimatori SageMaker AI con SageMaker Training Compiler attivato. **Suggerimento** Per iniziare con i modelli predefiniti forniti da PyTorch o 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** Il PyTorch supporto nativo è disponibile in SageMaker Python SDK v2.121.0 e versioni successive. Assicurati di aggiornare l'SDK Python di conseguenza. SageMaker **Nota** A partire dalla PyTorch v1.12.0, sono disponibili i contenitori SageMaker Training Compiler per. PyTorch Nota che i contenitori SageMaker Training Compiler per non PyTorch sono preconfezionati con Hugging Face Transformers. Se devi installare la libreria nel container, assicurati di aggiungere il file `requirements.txt` nella directory di origine quando invii un processo di addestramento. Per la PyTorch versione 1.11.0 e precedenti, usa le versioni precedenti dei contenitori Training Compiler per Hugging Face e. SageMaker PyTorch Per un elenco completo delle versioni del framework e le informazioni sui container corrispondenti, consulta [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks). Per informazioni adatte al tuo caso d'uso, consulta una delle seguenti opzioni. ### Per l’addestramento su una singola GPU ------ #### [ PyTorch v1.12.0 and later ] Per compilare e addestrare un PyTorch modello, configura uno PyTorch stimatore SageMaker AI con SageMaker Training Compiler come mostrato nel seguente esempio di codice. **Nota** Questo PyTorch supporto nativo è disponibile in SageMaker AI Python SDK v2.120.0 e versioni successive. Assicurati di aggiornare l'AI Python SDK. 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 ] Per compilare e addestrare un modello di trasformatore con PyTorch, configura uno stimatore SageMaker AI Hugging Face con SageMaker Training Compiler, come mostrato nel seguente esempio di codice. ``` 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() ``` Per preparare lo script di addestramento, consulta le pagine seguenti. + [Per l’addestramento su una singola GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-single-gpu)di un PyTorch modello che utilizza l'API Trainer di Hugging Face Transformers [https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer) + [Per l’addestramento su una singola GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-single-gpu)di un PyTorch modello senza l'API Trainer di Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) Per trovare esempi end-to-end, consulta i seguenti notebook: + [Compila e addestra un modello di trainer Hugging Face Transformers per domande e risposte con il set di dati SQuAD](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/albert-base-v2/albert-base-v2.html) + [Compila e addestra un modello Hugging Face `BERT` Transformer con il set di dati SST utilizzando Training Compiler 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) + [Compila e addestra un modello di addestramento per la classificazione binaria con il set di dati SST2 per l'addestramento 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) ------ ### Per l’addestramento distribuito ------ #### [ PyTorch v1.12 ] Per la PyTorch versione 1.12, è possibile eseguire l'addestramento distribuito con SageMaker Training Compiler aggiungendo l'`pytorch_xla`opzione specificata al parametro della classe AI estimator. `distribution` SageMaker PyTorch **Nota** Questo PyTorch supporto nativo è disponibile in SageMaker AI Python SDK v2.121.0 e versioni successive. Assicurati di aggiornare l'AI Python SDK. SageMaker ``` 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() ``` **Suggerimento** Per preparare lo script di addestramento, vedi [PyTorch](training-compiler-pytorch-models.md) ------ #### [ Transformers v4.21 with PyTorch v1.11 ] Per la PyTorch versione 1.11 e successive, SageMaker Training Compiler è disponibile per l'addestramento distribuito con l'`pytorch_xla`opzione specificata nel parametro. `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() ``` **Suggerimento** Per preparare lo script di addestramento, consulta le pagine seguenti. [Per l’addestramento distribuito](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)di un PyTorch modello che utilizza l'API Trainer di Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) [Per l’addestramento distribuito](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)di un PyTorch modello senza l'API Trainer di 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 ] Per la versione supportata della PyTorch v1.10.2 e precedenti, SageMaker Training Compiler richiede un meccanismo alternativo per l'avvio di un processo di formazione distribuito. Per eseguire l'addestramento distribuito, SageMaker Training Compiler richiede di passare uno script di avvio del training distribuito SageMaker AI all'argomento e di passare lo script di addestramento all'`entry_point`argomento. `hyperparameters` Il seguente esempio di codice mostra come configurare uno stimatore SageMaker AI Hugging Face applicando le modifiche richieste. ``` 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() ``` Lo script di avvio avrà un aspetto simile al seguente. Racchiude lo script di addestramento e configura l'ambiente di addestramento distribuito in base alla dimensione dell'istanza di addestramento scelta. ``` # 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) ``` **Suggerimento** Per preparare lo script di addestramento, consulta le pagine seguenti. [Per l’addestramento distribuito](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)di un PyTorch modello che utilizza l'API Trainer di Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) [Per l’addestramento distribuito](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)di un PyTorch modello senza l'API Trainer di Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) **Suggerimento** Per trovare esempi end-to-end, consulta i seguenti notebook: [Compila e addestra il modello GPT2 utilizzando l'API Transformers Trainer con il set di dati SST2 per l'addestramento 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) [Compila e addestra il modello GPT2 utilizzando l'API Transformers Trainer con il set di dati SST2 per l'addestramento 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) ------ L'elenco seguente è il set minimo di parametri necessari per eseguire un processo di formazione con il compilatore. SageMaker **Nota** Quando si utilizza lo stimatore SageMaker AI Hugging Face, è necessario specificare i `compiler_config` parametri`transformers_version`, `pytorch_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. **Nota** Per eseguire un training distribuito con SageMaker Training Compiler e PyTorch v1.10.2 e versioni precedenti, specifica il nome del file di uno script di avvio con questo parametro. Lo script di avvio deve essere preparato per completare lo script di addestramento e configurare l'ambiente di addestramento distribuito. Per maggiori informazioni, vedi i seguenti notebook di esempio: [Compila e addestra il modello GPT2 utilizzando l'API Transformers Trainer con il set di dati SST2 per la formazione 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) [Compila e addestra il modello GPT2 utilizzando l'API Transformers Trainer con il set di dati SST2 per l'addestramento 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) — Facoltativo. Aggiungilo se hai bisogno di installare pacchetti aggiuntivi. Per installare i pacchetti, è necessario preparare un file `requirements.txt` in questa directory. + `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 AI Hugging Face. SageMaker Specifica 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 `pytorch_version` (str) — Obbligatorio. Specifica la PyTorch 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 stimatore SageMaker AI Hugging Face, è necessario specificare sia che. `transformers_version` `pytorch_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 la velocità 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 di Training Compiler](training-compiler-examples-and-blogs.md). **Nota** Per eseguire un training distribuito con SageMaker Training Compiler e PyTorch v1.10.2 e versioni precedenti, è necessario aggiungere un parametro aggiuntivo, per specificare lo script di training`"training_script"`, come mostrato nell'esempio di codice precedente. + `compiler_config`(TrainingCompilerConfig oggetto) — Necessario per attivare Training Compiler. SageMaker Includi questo parametro per attivare SageMaker Training Compiler. I seguenti sono parametri per la classe `TrainingCompilerConfig`. + `enabled` (bool) — Facoltativo. Specifica `True` o `False` per 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`. + `distribution` (dict) — Facoltativo. Per eseguire un processo di formazione distribuito con SageMaker Training Compiler, aggiungi. `distribution = { 'pytorchxla' : { 'enabled': True }}` **avvertimento** Se si attiva SageMaker Debugger, ciò potrebbe influire sulle prestazioni di SageMaker Training Compiler. Ti consigliamo di disattivare Debugger durante l'esecuzione di SageMaker Training Compiler per assicurarti che non vi 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'API AI Operation SageMaker `CreateTrainingJob` SageMaker Le opzioni di configurazione del Training Compiler devono essere specificate tramite il `HyperParameters` campo `AlgorithmSpecification` and nella sintassi della richiesta per il funzionamento dell'[`CreateTrainingJob`API. ](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 } ``` Per trovare un elenco completo degli URI di immagini dei contenitori di deep learning in cui è implementato SageMaker Training Compiler, consulta. [Framework supportati](training-compiler-support.md#training-compiler-supported-frameworks)