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
Implementa 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 Transformers](https://huggingface.co/docs/transformers/index) si basano sull'API torch.nn.Module. PyTorch](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 pre-addestrati per aiutare PyTorch 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 intelligenza artificiale `PyTorch` o lo `HuggingFace` stimatore con la configurazione 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 `Trainer` Hugging Face Transformers](#training-compiler-pytorch-models-transformers-trainer)
+ [Modelli linguistici di grandi dimensioni utilizzati PyTorch direttamente (senza l'API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### Modelli linguistici di grandi dimensioni che utilizzano la classe `Trainer` Hugging Face Transformers
Se utilizzi la classe Trainer della libreria transformers, non devi apportare ulteriori modifiche allo script di allenamento. SageMaker Training Compiler compila automaticamente il modello Trainer se lo abiliti tramite la classe estimator. Il codice seguente mostra la forma base di uno script di PyTorch formazione 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)
+ [Migliori pratiche per utilizzare Training Compiler con SageMaker `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 [https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer).
#### Per l’addestramento distribuito
**PyTorch v1.11.0 e versioni successive**
Per eseguire un addestramento distribuito con SageMaker Training Compiler, è necessario aggiungere la seguente `_mp_fn()` funzione nello script di allenamento e completare 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 addestramento.
```
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 precedenti con v1.10.2 e precedenti PyTorch **
SageMaker Training Compiler utilizza un meccanismo alternativo per avviare 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 del training distribuito basato sull' SageMaker intelligenza artificiale all'`entry_point`argomento e di passare lo script di addestramento all'`hyperparameters`argomento nello stimatore SageMaker AI Hugging Face.
#### Migliori pratiche per utilizzare Training Compiler con SageMaker `Trainer`
+ [Assicurati di utilizzare gli SyncFree ottimizzatori impostando l'`optim`argomento su `adamw_torch_xla` durante la configurazione 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 gli `preprocessing_num_workers` argomenti `dataloader_num_workers` e 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 GPUs ma inferiore al numero di CPUs.
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esecuzione PyTorch di processi di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
### Modelli linguistici di grandi dimensioni utilizzati PyTorch direttamente (senza l'API Hugging Face Transformers Trainer)
Se si dispone di uno script di formazione che utilizza PyTorch direttamente, è necessario apportare ulteriori modifiche allo script di formazione per implementare /XLA. PyTorch PyTorch Segui le istruzioni per modificare lo script in modo da configurare correttamente le primative /XLA. PyTorch
**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 /XLA SageMaker PyTorch](#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 utilizzi [Automatic PyTorch 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, inserisci il tuo dataloader nella classe /XLA PyTorch: `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 la tua formazione, usa il metodo di checkpoint del modello /XLA: PyTorch
```
xm.save(model.state_dict(), path_to_save)
```
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esecuzione PyTorch di processi di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Per l’addestramento distribuito
Oltre alle modifiche elencate nella [Per l’addestramento su una singola GPU](#training-compiler-pytorch-models-non-trainer-single-gpu) sezione precedente, aggiungi le seguenti modifiche per distribuire correttamente il carico di lavoro. GPUs
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)
```
Le `train_device_loader` funzioni, come un normale PyTorch caricatore, sono le seguenti:
```
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 la formazione distribuita 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 la versione 1.11.0 e PyTorch successive**
Per eseguire un addestramento distribuito con SageMaker Training Compiler, è necessario aggiungere la seguente `_mp_fn()` funzione nello script di allenamento e completare 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 addestramento.
```
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 precedenti con v1.10.2 e precedenti PyTorch**
SageMaker Training Compiler utilizza un meccanismo alternativo per avviare un processo di formazione distribuito e richiede di passare uno script di avvio del training distribuito SageMaker basato sull'intelligenza artificiale all'`entry_point`argomento e di passare lo script di formazione all'argomento nello stimatore AI SageMaker Hugging Face. `hyperparameters`
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Esecuzione PyTorch di processi di formazione con SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Procedure consigliate per utilizzare Training Compiler con /XLA SageMaker PyTorch
[Se desideri sfruttare il SageMaker Training Compiler sul tuo script di PyTorch formazione nativo, potresti innanzitutto prendere confidenza con i dispositivi XLA. PyTorch ](https://pytorch.org/xla/release/1.9/index.html) Nelle sezioni seguenti sono elencate 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 /XLA PyTorch
Una differenza significativa tra PyTorch/XLA e nativa PyTorch è che il PyTorch/XLA sistema funziona in modalità pigra mentre la modalità nativa 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 chiama PyTorch APIs 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 utilizzi e *compilation-and-executions*`pl.MpDeviceLoader/pl.ParallelLoader``xm.step_closure`
Per ottenere prestazioni ottimali, è necessario tenere presente i possibili modi di avvio *compilation-and-executions*descritti in [Comprendi la modalità pigra in /XLA PyTorch](#training-compiler-pytorch-models-best-practices-lazy-mode) e cercare di ridurre al minimo il numero di compilation-and-executions. Idealmente, ne compilation-and-execution è necessaria una sola per iterazione dell'allenamento 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 avvolta utilizzando per evitare che non sia necessario. `xm.add_step_closure()` compilation-and-executions
##### Usa gli ottimizzatori AMP e `syncfree`
L'allenamento in modalità Automatic Mixed Precision (AMP) accelera notevolmente la velocità di allenamento sfruttando i core Tensor di NVIDIA. GPUs 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 ottimizzatori `syncfree` devono essere abbinati con `torch_xla.amp.GradScaler` per il ridimensionamento del gradiente.
**Suggerimento**
A partire dalla PyTorch versione 1.13.1, SageMaker Training Compiler migliora le prestazioni permettendo di PyTorch/XLA sovrascrivere automaticamente gli ottimizzatori (come SGD, Adam, AdamW) in `torch.optim` o `transformers.optimization` con le loro versioni prive di sincronizzazione (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.