PyTorch - Amazon SageMaker
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

Aggiungi il tuo PyTorch modello ed esegui SageMaker 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 Hugging Face Transformers fornisce anche classi di modelli 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 lo stimatore SageMaker PyTorch o lo HuggingFace stimatore con la configurazione 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 Trainer Hugging Face Transformers

Se utilizzate la classe Trainer della libreria transformers, non è necessario apportare ulteriori modifiche allo script di addestramento. 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)

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 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 SageMaker distribuito 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 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 SageMaker distribuito all'entry_pointargomento e di passare lo script di formazione all'hyperparametersargomento nello stimatore SageMaker Hugging Face.

Migliori pratiche per utilizzare Training Compiler con SageMaker Trainer

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 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 per configurare correttamente le primative /XLA. PyTorch

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 PyTorch 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, 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)

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

    xm.mark_step()

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

    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.

  5. 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 SageMaker distribuito 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 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 SageMaker distribuito all'entry_pointargomento e di passare lo script di formazione all'argomento nello stimatore hyperparameters Hugging Face. SageMaker

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 /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 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 native PyTorch è che il sistema PyTorch /XLA funziona in modalità pigra mentre quella nativa funziona in modalità eager. PyTorch 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 computazionale al volo quando si richiamano PyTorch le 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).

pl.MpDeviceLoader/pl.ParallelLoaderRiduci compilation-and-executionsal minimo il numero di utilizzi e xm.step_closure

Per ottenere prestazioni ottimali, è necessario tenere presente i possibili modi di avvio compilation-and-executionsdescritti in Comprendi la modalità pigra in /XLA PyTorch 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 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 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 consentendo a PyTorch /XLA di 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.