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à.
# PyTorch
Porta il tuo PyTorch modello all' SageMaker intelligenza artificiale ed esegui il processo di formazione con Training Compiler SageMaker .
**Topics**
+ [PyTorch Modelli con Hugging Face Transformers](#training-compiler-pytorch-models-transformers)
## PyTorch Modelli con Hugging Face Transformers
PyTorch i modelli con [ Hugging Face ](https://huggingface.co/docs/transformers/index) Transformers si basano sull'API torch.nn.Module. PyTorch [https://pytorch.org/docs/stable/nn.html#torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) Hugging Face Transformers fornisce anche classi di modelli [ Trainer ](https://huggingface.co/docs/transformers/main_classes/trainer) e preaddestrati per PyTorch contribuire a ridurre lo sforzo di configurazione dei modelli di elaborazione del linguaggio naturale (NLP). Dopo aver preparato lo script di formazione, puoi avviare un processo di formazione utilizzando l' SageMaker IA `PyTorch` o `HuggingFace` ModelTrainer con la configurazione del SageMaker Training Compiler quando passerai all'argomento successivo all'indirizzo. [Abilita SageMaker Training Compiler](training-compiler-enable.md)
**Suggerimento**
Quando si crea un tokenizzatore per un modello NLP utilizzando Transformers nello script di addestramento, assicurarsi di utilizzare una forma di tensore di input statica specificando `padding='max_length'`. Non utilizzare `padding='longest'`, in quanto il padding sulla sequenza più lunga del batch può modificare la forma del tensore per ogni batch di addestramento. La forma di input dinamica può attivare la ricompilazione del modello e aumentare il tempo totale di addestramento. Per ulteriori informazioni sulle opzioni di riempimento dei tokenizzatori Transformers, vedere [Padding and troncation](https://huggingface.co/docs/transformers/pad_truncation) nella *documentazione di Hugging Face Transformers*.
**Topics**
+ [Modelli linguistici di grandi dimensioni che utilizzano la classe Hugging Face Transformers Trainer ``](#training-compiler-pytorch-models-transformers-trainer)
+ [Modelli linguistici di grandi dimensioni che utilizzano PyTorch direttamente (senza l'API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### Modelli linguistici di grandi dimensioni che utilizzano la classe Hugging Face Transformers Trainer ``
Se si utilizza la classe Trainer della libreria Transformers, non è necessario apportare ulteriori modifiche allo script di training. SageMaker Training Compiler compila automaticamente il modello Trainer se lo abiliti tramite la classe. ModelTrainer Il codice seguente mostra la forma base di uno script di PyTorch allenamento con l'API Hugging Face Trainer.
```
from transformers import Trainer, TrainingArguments
training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)
```
**Topics**
+ [Per l’addestramento su una singola GPU](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [Per l’addestramento distribuito](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [Procedure consigliate per utilizzare SageMaker Training Compiler con Trainer ``](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Per l’addestramento su una singola GPU
Non è necessario modificare il codice quando utilizzi la classe [`transformers.Trainer`](https://huggingface.co/docs/transformers/main_classes/trainer).
#### Per l’addestramento distribuito
**PyTorch v1.11.0 e versioni successive **
Per eseguire un training distribuito con SageMaker Training Compiler, è necessario aggiungere la seguente `_mp_fn()` funzione nello script di training e racchiudere la funzione. `main()` Reindirizza le chiamate di `_mp_fn(index)` funzione dal runtime distribuito SageMaker AI for PyTorch (`pytorchxla`) alla `main()` funzione dello script di training.
```
def _mp_fn(index):
main()
```
Questa funzione accetta l'argomento `index` per indicare la classe della GPU corrente nel cluster per l'addestramento distribuito. Per trovare altri script di esempio, vedi gli [script di esempio di modellazione del linguaggio Hugging Face Transformers](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Per Transformers v4.17 e versioni precedenti con v1.10.2 e versioni precedenti PyTorch **
SageMaker Training Compiler utilizza un meccanismo alternativo per l'avvio di un processo di formazione distribuito e non è necessario apportare alcuna modifica allo script di formazione. SageMaker Training Compiler richiede invece di passare uno script di avvio di addestramento distribuito dall' SageMaker IA all'`entry_point`argomento e di passare lo script di addestramento all'`hyperparameters`argomento in AI Hugging Face. SageMaker ModelTrainer
#### Procedure consigliate per utilizzare SageMaker Training Compiler con Trainer ``
+ Assicurati di utilizzare gli SyncFree ottimizzatori impostando l'`optim`argomento su `adamw_torch_xla` durante l'impostazione dei trasformatori. [ TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Vedi anche [Ottimizzatore](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) nella *documentazione di Hugging Face Transformers*.
+ Assicurati che il throughput della pipeline di elaborazione dei dati sia superiore al throughput di addestramento. Puoi modificare `preprocessing_num_workers` gli argomenti `dataloader_num_workers` e gli argomenti dei [ trasformatori. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)classe per raggiungere questo obiettivo. In genere, questi devono essere maggiori o uguali al numero di GPU ma inferiori al numero di CPU.
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esegui lavori PyTorch di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
### Modelli linguistici di grandi dimensioni che utilizzano PyTorch direttamente (senza l'API Hugging Face Transformers Trainer)
Se disponi di uno script di formazione che utilizza PyTorch direttamente, devi apportare ulteriori modifiche allo script di formazione per implementarlo PyTorch . PyTorch/XLA Segui le istruzioni per modificare lo script per impostare correttamente le PyTorch/XLA primative.
**Topics**
+ [Per l’addestramento su una singola GPU](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [Per l’addestramento distribuito](#training-compiler-pytorch-models-non-trainer-distributed)
+ [Procedure consigliate per utilizzare Training Compiler con SageMaker PyTorch/XLA](#training-compiler-pytorch-models-best-practices)
#### Per l’addestramento su una singola GPU
1. Importa le librerie di ottimizzazione.
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. Cambia il dispositivo di destinazione in XLA anziché `torch.device("cuda")`
```
device=xm.xla_device()
```
1. Se stai usando PyTorch [ Automatic Mixed Precision ](https://pytorch.org/docs/stable/amp.html) (AMP), procedi come segue:
1. Sostituisci `torch.cuda.amp` con i seguenti:
```
import torch_xla.amp
```
1. Sostituisci `torch.optim.SGD` e `torch.optim.Adam` con una delle seguenti opzioni:
```
import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD
```
1. Sostituisci `torch.cuda.amp.GradScaler` con i seguenti:
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Se non utilizzi AMP, sostituisci `optimizer.step()` con quanto segue:
```
xm.optimizer_step(optimizer)
```
1. Se stai usando un dataloader distribuito, racchiudi il tuo dataloader nella classe's: PyTorch/XLA `ParallelLoader`
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. Aggiungi `mark_step` alla fine del ciclo di addestramento quando non utilizzi `parallel_loader`:
```
xm.mark_step()
```
1. Per verificare il tuo allenamento, usa il metodo di checkpoint del PyTorch/XLA modello:
```
xm.save(model.state_dict(), path_to_save)
```
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esegui lavori PyTorch di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Per l’addestramento distribuito
Oltre alle modifiche elencate nella sezione [Per l’addestramento su una singola GPU](#training-compiler-pytorch-models-non-trainer-single-gpu) precedente, aggiungi le seguenti modifiche per distribuire correttamente il carico di lavoro tra le GPU.
1. Se utilizzi AMP, aggiungi `all_reduce` dopo `scaler.scale(loss).backward()`:
```
gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())
```
1. Se devi impostare variabili per `local_ranks` e `world_size`, usa un codice simile al seguente:
```
local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()
```
1. Per qualsiasi valore `world_size` (`num_gpus_per_node*num_nodes`) maggiore di `1`, devi definire un campionatore di addestramento che dovrebbe essere simile al seguente:
```
import torch_xla.core.xla_model as xm
if xm.xrt_world_size() > 1:
train_sampler=torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
train_loader=torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler,
drop_last=args.drop_last,
shuffle=False if train_sampler else True,
num_workers=args.num_workers
)
```
1. Apporta le seguenti modifiche per assicurarti di utilizzare il `parallel_loader` fornito dal modulo `torch_xla distributed`.
```
import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)
```
`train_device_loader`Funziona come un normale PyTorch caricatore come segue:
```
for step, (data, target) in enumerate(train_device_loader):
optimizer.zero_grad()
output=model(data)
loss=torch.nn.NLLLoss(output, target)
loss.backward()
```
Con tutte queste modifiche, dovresti essere in grado di avviare un training distribuito con qualsiasi PyTorch modello senza l'API Transformer Trainer. Tieni presente che queste istruzioni possono essere utilizzate sia per GPU multi-nodo che per GPU multi-nodo.
1. **Per PyTorch v1.11.0 e versioni successive **
Per eseguire un training distribuito con SageMaker Training Compiler, è necessario aggiungere la seguente `_mp_fn()` funzione nello script di training e racchiudere la funzione. `main()` Reindirizza le chiamate di `_mp_fn(index)` funzione dal runtime distribuito SageMaker AI for PyTorch (`pytorchxla`) alla `main()` funzione dello script di training.
```
def _mp_fn(index):
main()
```
Questa funzione accetta l'argomento `index` per indicare la classe della GPU corrente nel cluster per l'addestramento distribuito. Per trovare altri script di esempio, vedi gli [script di esempio di modellazione del linguaggio Hugging Face Transformers](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Per Transformers v4.17 e versioni precedenti con v1.10.2 e versioni precedenti PyTorch **
SageMaker Training Compiler utilizza un meccanismo alternativo per l'avvio di un processo di formazione distribuito e richiede di passare uno script di avvio di formazione distribuito SageMaker AI all'argomento e di passare lo script di addestramento all'`entry_point`argomento in AI Hugging Face. `hyperparameters` SageMaker ModelTrainer
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esegui lavori PyTorch di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Procedure consigliate per utilizzare Training Compiler con SageMaker PyTorch/XLA
Se desideri sfruttare il SageMaker Training Compiler sul tuo script di PyTorch formazione nativo, potresti prima familiarizzare con [ PyTorch i dispositivi XLA. ](https://pytorch.org/xla/release/1.9/index.html) Le sezioni seguenti elencano alcune best practice per abilitare XLA per. PyTorch
**Nota**
Questa sezione dedicata alle best practice presuppone l'utilizzo dei seguenti moduli: PyTorch/XLA
```
import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
```
##### Comprendi la modalità pigra in PyTorch/XLA
Una differenza significativa tra PyTorch/XLA e native PyTorch è che il PyTorch/XLA sistema funziona in modalità lazy mentre il nativo PyTorch funziona in modalità eager. I tensori in modalità lazy sono segnaposto per la creazione del grafico di calcolo fino a quando non vengono materializzati dopo il completamento della compilazione e della valutazione. Il PyTorch/XLA sistema crea il grafico computazionale al volo quando si chiamano le PyTorch API per creare il calcolo utilizzando tensori e operatori. Il grafico di calcolo viene compilato ed eseguito quando `xm.mark_step()` viene chiamato esplicitamente o implicitamente da `pl.MpDeviceLoader/pl.ParallelLoader`, o quando richiedi esplicitamente il valore di un tensore, ad esempio chiamando `loss.item()` o `print(loss)`.
##### Riduci al minimo il numero di *compilazione ed esecuzioni* usando pl. `MpDeviceLoader/pl.ParallelLoader`e `xm.step_closure`
Per ottenere prestazioni ottimali, è necessario tenere presente i modi possibili per avviare *compilazioni ed esecuzioni* come descritto in [Comprendi la modalità pigra in PyTorch/XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) e cercare di ridurre al minimo il numero di compilazioni ed esecuzioni. Idealmente, è necessaria una sola compilazione ed esecuzione per iterazione di addestramento e viene avviata automaticamente da `pl.MpDeviceLoader/pl.ParallelLoader`. `MpDeviceLoader` è ottimizzato per XLA e dovrebbe essere sempre utilizzato, se possibile, per ottenere le migliori prestazioni. Durante l'addestramento, potresti voler esaminare alcuni risultati intermedi come i valori di perdita. In tal caso, la stampa di tensori pigri dovrebbe essere inserita utilizzando `xm.add_step_closure()` per evitare compilazioni ed esecuzioni non necessarie.
##### Usa gli ottimizzatori AMP e syncfree ``
L'allenamento in modalità Automatic Mixed Precision (AMP) accelera notevolmente la velocità di allenamento sfruttando i core Tensor delle GPU NVIDIA. SageMaker Training Compiler fornisce `syncfree` ottimizzatori ottimizzati per XLA per migliorare le prestazioni AMP. Attualmente sono disponibili i seguenti tre ottimizzatori `syncfree` che dovrebbero essere utilizzati se possibile per ottenere le migliori prestazioni.
```
torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW
```
Questi `syncfree` ottimizzatori devono essere abbinati a for gradient. `torch_xla.amp.GradScaler` scaling/unscaling
**Suggerimento**
A partire dalla PyTorch versione 1.13.1, SageMaker Training Compiler migliora le prestazioni consentendo di PyTorch/XLA sovrascrivere automaticamente gli ottimizzatori (come SGD, Adam, AdamW) presenti `torch.optim` o `transformers.optimization` con le loro versioni syncfree (come,,). `torch_xla.amp.syncfree` `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Non è necessario modificare le righe di codice in cui si definiscono gli ottimizzatori nello script di addestramento.