PyTorch - Amazon SageMaker AI
Modelli PyTorch con Hugging Face Transformers

PyTorch

Porta il tuo modello PyTorch in SageMaker AI ed esegui il job di addestramento con il Compilatore SageMaker per l’addestramento.

Modelli PyTorch con Hugging Face Transformers

I modelli PyTorch con Hugging Face Transformers si basano sull'API torch.nn.Module di PyTorch. Hugging Face Transformers fornisce anche classi di modelli Trainer e pre-addestrate per PyTorch per aiutare a ridurre lo sforzo di configurazione dei modelli di elaborazione del linguaggio naturale (NLP). Dopo aver preparato lo script di addestramento, è possibile avviare un job di addestramento utilizzando lo strumento di stima PyTorch o HuggingFace di SageMaker AI con la configurazione del Compilatore SageMaker per l’addestramento procedendo all’argomento successivo in Abilitare Amazon 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 Trainer Hugging Face Transformers

Se utilizzi la classe Trainer della libreria Transformers, non è necessario apportare ulteriori modifiche allo script di addestramento. SageMaker Training Compiler compila automaticamente il modello di addestramento se lo abiliti tramite la classe dello strumento di valutazione. Il codice seguente mostra la forma base di uno script di addestramento PyTorch 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 l’addestramento distribuito con il Compilatore di addestramento di SageMaker, devi aggiungere la seguente funzione _mp_fn() nello script di addestramento e completare la funzione main(). Reindirizza le chiamate della funzione _mp_fn(index) dal runtime distribuito di SageMaker AI per PyTorch (pytorchxla) alla funzione main() 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.

Per Transformers v4.17 e precedenti con PyTorch v1.10.2 e precedenti

Il Compilatore di addestramento di SageMaker utilizza un meccanismo alternativo per avviare un processo di addestramento distribuito e non è necessario apportare alcuna modifica allo script di addestramento. Invece, il Compilatore SageMaker per l’addestramento richiede di inoltrare uno script di avvio dell’addestramento distribuito di SageMaker AI all’argomento entry_point e di passare lo script di addestramento all’argomento hyperparameters nello strumento di stima Hugging Face di SageMaker AI.

Best practice per utilizzare SageMaker Training Compiler con Trainer

  • Assicurati di utilizzare gli ottimizzatori SyncFree impostando l'argomento optim su adamw_torch_xla durante la configurazione di transformers.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 gli argomenti dataloader_num_workers e preprocessing_num_workers della classe Transformers.TrainingArgument 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 processi di addestramento PyTorch con il compilatore Addestramento SageMaker.

Modelli linguistici di grandi dimensioni che utilizzano direttamente PyTorch (senza l'API Hugging Face Transformers Trainer)

Se disponi di uno script di addestramento che utilizza direttamente PyTorch, devi apportare ulteriori modifiche allo script di addestramento PyTorch per implementare PyTorch/XLA. Segui le istruzioni per modificare lo script per configurare correttamente le primative PyTorch/XLA.

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 utilizzi Automatic Mixed Precision (AMP) di PyTorch, procedi nel seguente modo:

    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, esegui il wrapping del tuo dataloader nella classe ParallelLoader di PyTorch/XLA:

    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 eseguire il checkpoint del tuo addestramento, usa il metodo di checkpoint del modello di PyTorch/XLA:

    xm.save(model.state_dict(), path_to_save)

Dopo aver completato l'adattamento dello script di addestramento, procedi con Esegui processi di addestramento PyTorch con il compilatore Addestramento SageMaker.

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)

    Le funzioni train_device_loader come un normale caricatore PyTorch 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 un addestramento distribuito con qualsiasi modello PyTorch 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 successive

    Per eseguire l’addestramento distribuito con il Compilatore di addestramento di SageMaker, devi aggiungere la seguente funzione _mp_fn() nello script di addestramento e completare la funzione main(). Reindirizza le chiamate della funzione _mp_fn(index) dal runtime distribuito di SageMaker AI per PyTorch (pytorchxla) alla funzione main() 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.

    Per Transformers v4.17 e precedenti con PyTorch v1.10.2 e precedenti

    Il Compilatore SageMaker per l’addestramento utilizza un meccanismo alternativo per avviare un job di addestramento distribuito e richiede di passare uno script di avvio dell’addestramento distribuito di SageMaker AI all’argomento entry_point e di passare lo script di addestramento all’argomento hyperparameters nello strumento di stima Hugging Face di SageMaker AI.

Dopo aver completato l'adattamento dello script di addestramento, procedi con Esegui processi di addestramento PyTorch con il compilatore Addestramento SageMaker.

Best practice per utilizzare il Compilatore di addestramento di SageMaker con Pytorch/XLA.

Se desideri sfruttare il Compilatore di addestramento di SageMaker sul tuo script di addestramento PyTorch nativo, ti consigliamo di acquisire prima familiarità con PyTorch sui dispositivi XLA. Le sezioni seguenti elencano alcune best practice per abilitare XLA per PyTorch.

Nota

Questa sezione per le 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à lazy in PyTorch/XLA

Una differenza significativa tra PyTorch/XLA e PyTorch nativo è che il sistema PyTorch/XLA funziona in modalità lazy mentre il PyTorch nativo 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 sistema PyTorch/XLA crea il grafico di calcolo al volo quando si chiamano le API PyTorch 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 compilazioni ed esecuzioni utilizzando 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à lazy 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'addestramento in modalità Automatic Mixed Precision (AMP) accelera notevolmente la velocità di addestramento sfruttando i core Tensor delle GPU NVIDIA. Il Compilatore di addestramento di SageMaker fornisce ottimizzatori syncfreeottimizzati 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 da PyTorch 1.13.1, il Compilatore di addestramento di SageMaker migliora le prestazioni permettendo a PyTorch/XLA di sovrascrivere automaticamente gli ottimizzatori (come SGD, Adam, AdamW) in torch.optim o transformers.optimization con le loro versioni syncfree in torch_xla.amp.syncfree (come 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.