View a markdown version of this page

PyTorch - Amazon SageMaker AI
PyTorch Modelli con Hugging Face Transformers

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 .

PyTorch Modelli con Hugging Face Transformers

PyTorch i modelli con Hugging Face Transformers 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 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

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 nella documentazione di Hugging Face Transformers.

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)

Per l’addestramento su una singola GPU

Non è necessario modificare il codice quando utilizzi la classe transformers.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.

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_pointargomento e di passare lo script di addestramento all'hyperparametersargomento in AI Hugging Face. SageMaker ModelTrainer

Procedure consigliate per utilizzare SageMaker Training Compiler con Trainer

  • Assicurati di utilizzare gli SyncFree ottimizzatori impostando l'optimargomento su adamw_torch_xla durante l'impostazione dei trasformatori. TrainingArgument. Vedi anche Ottimizzatore 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. TrainingArgumentclasse 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.

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.

Per l’addestramento su una singola GPU

  1. Importa le librerie di ottimizzazione.

    import torch_xla
import torch_xla.core.xla_model as xm

  2. Cambia il dispositivo di destinazione in XLA anziché torch.device("cuda")

    device=xm.xla_device()

  3. Se stai usando PyTorch Automatic Mixed Precision (AMP), procedi come segue:

    1. Sostituisci torch.cuda.amp con i seguenti:

      import torch_xla.amp

    2. 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

    3. Sostituisci torch.cuda.amp.GradScaler con i seguenti:

      import torch_xla.amp.GradScaler as grad_scaler

  4. Se non utilizzi AMP, sostituisci optimizer.step() con quanto segue:

    xm.optimizer_step(optimizer)

  5. 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)

  6. Aggiungi mark_step alla fine del ciclo di addestramento quando non utilizzi parallel_loader:

    xm.mark_step()

  7. 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.

Per l’addestramento distribuito

Oltre alle modifiche elencate nella sezione Per l’addestramento su una singola 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())

  2. 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()

  3. 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
)

  4. 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_loaderFunziona 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.

  5. 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.

    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_pointargomento 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.

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. 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.ParallelLoadere 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 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.