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à. # Esecuzione PyTorch di processi 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-pytorch-pysdk) + [Utilizzo dell'API AI Operation SageMaker `CreateTrainingJob`](#training-compiler-enable-pytorch-api) ## Usare l' SageMaker SDK Python SageMaker Training Compiler for PyTorch è disponibile tramite le classi SageMaker AI [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)e [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. Per attivare SageMaker Training Compiler, aggiungi il `compiler_config` parametro agli estimatori 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 stima 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 SageMaker Python di conseguenza. **Nota** A partire dalla PyTorch versione 1.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 SageMaker Training Compiler per Hugging Face e. 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 SageMaker AI Python SDK. ``` 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 PyTorch, configura uno SageMaker stimatore SageMaker AI Hugging Face con 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) + [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) Per trovare end-to-end esempi, consulta i seguenti taccuini: + [Compila e addestra un modello di trainer Hugging Face Transformers per domande e risposte con il set di dati AD SQu](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 trainer di classificazione binaria con il set di dati per l'addestramento a GPU singola a nodo singolo SST2 ](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, puoi 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 SageMaker AI Python SDK. ``` 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 la formazione distribuita 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) [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) ------ #### [ 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 un addestramento distribuito, SageMaker Training Compiler richiede di passare uno script di avvio del training distribuito basato sull' SageMaker intelligenza artificiale all'argomento e lo script di `entry_point` addestramento all'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) [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) **Suggerimento** Per trovare end-to-end esempi, consulta i seguenti taccuini: [Compila e addestra il GPT2 modello utilizzando l'API Transformers Trainer con il set di dati per l'addestramento multi-GPU a nodo singolo SST2 ](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 GPT2 modello utilizzando l'API Transformers Trainer con il set di dati per l'addestramento multi-nodo multi-GPU SST2 ](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 in base a 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 GPT2 modello utilizzando l'API Transformers Trainer con il set di dati per l'addestramento multi-GPU a nodo singolo SST2 ](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 GPT2 modello utilizzando l'API Transformers Trainer con il set di dati per l'addestramento multi-nodo multi-GPU SST2 ](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 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 `pytorch_version` (str) — Obbligatorio. Specificate 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 entrambi e. `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 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). **Nota** Per eseguire un corso di formazione distribuito con SageMaker Training Compiler e le PyTorch versioni 1.10.2 e precedenti, è necessario aggiungere un parametro aggiuntivo per specificare lo script di addestramento`"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. `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`. + `distribution` (dict) — Facoltativo. Per eseguire un processo di formazione distribuito con SageMaker Training Compiler, aggiungi. `distribution = { 'pytorchxla' : { 'enabled': True }}` **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'API AI Operation SageMaker `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://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 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)