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

Parallelismo dei dati partizionati

Il parallelismo dei dati condivisi è una tecnica di addestramento distribuito che consente di risparmiare memoria che suddivide lo stato di un modello (parametri del modello, gradienti e stati dell'ottimizzatore) in un gruppo parallelo di dati. GPUs

Quando si ridimensiona il processo di formazione su un GPU cluster di grandi dimensioni, è possibile ridurre l'ingombro per GPU memoria del modello suddividendo lo stato di addestramento del modello su più livelli. GPUs Ciò offre due vantaggi: è possibile adattare modelli più grandi, che altrimenti esaurirebbero la memoria con il parallelismo dei dati standard, oppure è possibile aumentare la dimensione del batch utilizzando la memoria liberata. GPU

La tecnica standard di parallelismo dei dati replica gli stati di addestramento GPUs in tutto il gruppo parallelo di dati ed esegue l'aggregazione del gradiente in base all'operazione. AllReduce Il parallelismo dei dati partizionati modifica la procedura di addestramento distribuito standard parallelo ai dati per tenere conto della natura di partizionamento degli stati dell'ottimizzatore. Un gruppo di classificazioni sui cui gli stati del modello e dell'ottimizzatore sono partizionati viene chiamato gruppo di partizione. La tecnica di parallelismo dei dati frammentati suddivide i parametri addestrabili di un modello e i gradienti e gli stati di ottimizzazione corrispondenti all'interno del gruppo di sharding. GPUs

SageMaker L'intelligenza artificiale raggiunge il parallelismo condiviso dei dati attraverso l'implementazione di MIC, di cui si parla nel post sul blog Near-linear scaling of gigantic-model training on. AWSAWS In questa implementazione, è possibile impostare il grado di partizionamento come parametro configurabile, che deve essere inferiore al grado di parallelismo dei dati. Durante ogni passaggio in avanti e all'indietro, i MIC ricombinano temporaneamente i parametri del modello durante l'intera operazione. GPUs AllGather Dopo il passaggio in avanti o all'indietro di ogni livello, i MIC suddividono nuovamente i parametri per risparmiare memoria. GPU Durante il passaggio all'indietro, i MIC riducono i gradienti e li suddividono simultaneamente attraverso l'operazione. GPUs ReduceScatter Infine, MiCS applica i gradienti locali ridotti e partizionati alle corrispondenti partizioni di parametri locali, utilizzando le partizioni locali degli stati dell'ottimizzatore. Per ridurre il sovraccarico di comunicazione, la libreria di parallelismo dei SageMaker modelli precarica i livelli successivi nel passaggio avanti o indietro e sovrappone la comunicazione di rete al calcolo.

Lo stato di addestramento del modello viene replicato tra i gruppi di partizione. Ciò significa che prima di applicare i gradienti ai parametri, l'operazione AllReduce deve avvenire tra i gruppi di partizione, oltre all'operazione ReduceScatter che avviene all'interno del gruppo di partizione.

In effetti, il parallelismo dei dati condivisi introduce un compromesso tra il sovraccarico di comunicazione e l'efficienza della memoria. GPU L'uso del parallelismo dei dati condivisi aumenta i costi di comunicazione, ma l'ingombro di memoria per unità GPU (escluso l'utilizzo della memoria dovuto alle attivazioni) viene diviso per il grado di parallelismo dei dati frammentati, quindi è possibile inserire nel cluster modelli più grandi. GPU

Selezione del grado di parallelismo dei dati partizionati

Quando si seleziona un valore per il grado di parallelismo dei dati partizionati, il valore deve dividere equamente il grado di parallelismo dei dati. Ad esempio, per un processo di parallelismo dei dati a 8 vie, scegli 2, 4 o 8 per il grado di parallelismo dei dati partizionati. Nella scelta del grado di parallelismo dei dati partizionati, si consiglia di iniziare con un numero piccolo e di aumentarlo gradualmente fino a quando il modello non si adatta alla memoria con la dimensione del batch desiderata.

Selezione della dimensione del batch

Dopo aver impostato il parallelismo dei dati condivisi, assicurati di trovare la configurazione di addestramento più ottimale che possa essere eseguita correttamente sul cluster. GPU Per addestrare modelli linguistici di grandi dimensioni (LLM), iniziate dalla dimensione del batch 1 e aumentatela gradualmente fino a raggiungere il punto in cui si verificherà l'errore out-of-memory ()OOM. Se riscontrate l'OOMerrore anche con la dimensione del batch più piccola, applicate un grado più elevato di parallelismo dei dati suddivisi o una combinazione di parallelismo dei dati suddivisi e parallelismo tensoriale.

Come applicare il parallelismo dei dati partizionati al tuo processo di addestramento

Per iniziare con il parallelismo dei dati frammentati, applica le modifiche necessarie allo script di addestramento e configura lo stimatore con i parametri. SageMaker PyTorch sharded-data-parallelism-specific Considera anche di prendere come punto di partenza i valori di riferimento e i notebook di esempio.

PyTorch Adatta il tuo script di allenamento

Segui le istruzioni riportate nella Fase 1: Modifica uno script di PyTorch addestramento per avvolgere il modello e gli oggetti dell'ottimizzatore con i smdistributed.modelparallel.torch wrapper dei torch.nn.parallel moduli and. torch.distributed

(Facoltativo) Modifica aggiuntiva per registrare i parametri esterni del modello

Se il modello è costruito con torch.nn.Module e utilizza parametri che non sono definiti all'interno della classe del modulo, è necessario registrarli manualmente nel modulo per SMP raccogliere i parametri completi nel frattempo. Per registrare i parametri in un modulo, utilizza smp.register_parameter(module, parameter).

class Module(torch.nn.Module):
    def __init__(self, *args):
        super().__init__(self, *args)
        self.layer1 = Layer1()
        self.layer2 = Layer2()
        smp.register_parameter(self, self.layer1.weight)

    def forward(self, input):
        x = self.layer1(input)
        # self.layer1.weight is required by self.layer2.forward
        y = self.layer2(x, self.layer1.weight)
        return y

Configura lo SageMaker PyTorch stimatore

Quando configuri uno SageMaker PyTorch stimatoreFase 2: Avviare un Job di formazione utilizzando SageMaker Python SDK, aggiungi i parametri per il parallelismo dei dati suddivisi.

Per attivare il parallelismo dei dati frammentati, aggiungi il parametro all'Estimator. sharded_data_parallel_degree SageMaker PyTorch Questo parametro specifica il numero di volte in cui viene suddiviso lo stato GPUs di allenamento. Il valore di sharded_data_parallel_degree deve essere un numero intero compreso tra uno e il grado di parallelismo dei dati e deve dividere equamente il grado di parallelismo dei dati. Si noti che la libreria rileva automaticamente il numero di dati, GPUs quindi il grado di parallelità dei dati. I seguenti parametri aggiuntivi sono disponibili per configurare il parallelismo dei dati partizionati.

Il codice seguente mostra un esempio di come configurare il parallelismo dei dati partizionati.

import sagemaker
from sagemaker.pytorch import PyTorch

smp_options = {
    "enabled": True,
    "parameters": {
        # "pipeline_parallel_degree": 1,    # Optional, default is 1
        # "tensor_parallel_degree": 1,      # Optional, default is 1
        "ddp": True,
        # parameters for sharded data parallelism
        "sharded_data_parallel_degree": 2,              # Add this to activate sharded data parallelism
        "sdp_reduce_bucket_size": int(5e8),             # Optional
        "sdp_param_persistence_threshold": int(1e6),    # Optional
        "sdp_max_live_parameters": int(1e9),            # Optional
        "sdp_hierarchical_allgather": True,             # Optional
        "sdp_gradient_clipping": 1.0                    # Optional
    }
}

mpi_options = {
    "enabled" : True,                      # Required
    "processes_per_host" : 8               # Required
}

smp_estimator = PyTorch(
    entry_point="your_training_script.py", # Specify your train script
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.p3.16xlarge',
    framework_version='1.13.1',
    py_version='py3',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-job"
)

smp_estimator.fit('s3://my_bucket/my_training_data/')

Configurazioni di riferimento

Il team di formazione SageMaker distribuito fornisce le seguenti configurazioni di riferimento che è possibile utilizzare come punto di partenza. È possibile estrapolare le seguenti configurazioni per sperimentare e stimare l'utilizzo della GPU memoria per la configurazione del modello.

Parallelismo dei dati condivisi con Collectives SMDDP

Ad esempio, se aumenti la lunghezza della sequenza per un modello da 20 miliardi di parametri o aumenti le dimensioni del modello a 65 miliardi di parametri, dovresti prima provare a ridurre la dimensione del batch. Se il modello continua a non adattarsi alla dimensione del batch più piccola (la dimensione del batch pari a 1), prova ad aumentare il grado di parallelismo del modello.

Parallelismo dei dati frammentati con parallelismo tensoriale e collettivi NCCL

L'uso combinato del parallelismo dei dati frammentati e del parallelismo tensoriale è utile quando si desidera inserire un modello linguistico di grandi dimensioni (LLM) in un cluster su larga scala utilizzando dati di testo con una lunghezza di sequenza maggiore, il che porta a utilizzare un batch di dimensioni inferiori e, di conseguenza, a gestire l'utilizzo della memoria per allenarsi con sequenze di testo più lunghe. GPU LLMs Per ulteriori informazioni, consulta Parallelismo dei dati partizionati con parallelismo tensoriale.

Per case study, benchmark e altri esempi di configurazione, consulta il post sul blog Nuovi miglioramenti delle prestazioni nella libreria parallela del modello Amazon SageMaker AI.

Parallelismo condiviso dei dati con Collectives SMDDP

La libreria di parallelismo SageMaker dei dati offre primitive di comunicazione collettiva (collettive) ottimizzate per l'infrastruttura. SMDDP AWS Raggiunge l'ottimizzazione adottando un modello di all-to-all-type comunicazione utilizzando Elastic Fabric Adapter (EFA), che consente di creare collettivi ad alta velocità e meno sensibili alla latenza, affidando l'elaborazione relativa alla comunicazione su e liberando cicli per il calcolo. CPU GPU Su cluster di grandi dimensioni, Collectives può offrire miglioramenti nelle prestazioni di formazione distribuite fino al 40% rispetto SMDDP a. NCCL Per case study e risultati di benchmark, consulta il blog Nuovi miglioramenti delle prestazioni nella libreria di parallelismo dei modelli Amazon SageMaker AI.

Nel parallelismo dei dati condivisi, che è una tecnica comunemente usata nell'addestramento distribuito su larga scala, il AllGather collettivo viene utilizzato per ricostituire i parametri dello sharded layer per i calcoli dei passaggi avanti e indietro, parallelamente al calcolo. GPU Per i modelli di grandi dimensioni, eseguire l'AllGatheroperazione in modo efficiente è fondamentale per evitare problemi di collo di bottiglia e rallentare la velocità di addestramento. GPU Quando viene attivato il parallelismo dei dati condivisi, SMDDP Collectives si affida a questi collettivi fondamentali per le prestazioni, migliorando la produttività della formazione. AllGather

SMDDPAllenati con Collectives

Quando il processo di formazione ha attivato il parallelismo dei dati condivisi e soddisfa i requisitiSupported configurations, i SMDDP Collective vengono attivati automaticamente. Internamente, i SMDDP collettivi ottimizzano il AllGather collettivo per renderlo efficiente sull' AWS infrastruttura e si affidano a tutti gli altri collettivi. NCCL Inoltre, nelle configurazioni non supportate, tutti i collettivi, inclusi, utilizzano automaticamente il backend. AllGather NCCL

A partire dalla versione 1.13.0 della libreria di parallelismo dei SageMaker modelli, il parametro viene aggiunto alle opzioni. "ddp_dist_backend" modelparallel Il valore predefinito per questo parametro di configurazione è"auto", che utilizza SMDDP Collectives ogni volta che è possibile e ricorre a altrimenti. NCCL Per forzare l'uso costante della libreriaNCCL, specificate "nccl" il parametro "ddp_dist_backend" di configurazione.

Il seguente esempio di codice mostra come impostare uno PyTorch stimatore utilizzando il parallelismo dei dati frammentati con il "ddp_dist_backend" parametro, che è impostato su di default e, pertanto, facoltativo "auto" da aggiungere.

import sagemaker
from sagemaker.pytorch import PyTorch

smp_options = {
    "enabled":True,
    "parameters": {                        
        "partitions": 1,
        "ddp": True,
        "sharded_data_parallel_degree": 64
        "bf16": True,
        "ddp_dist_backend": "auto"  # Specify "nccl" to force to use NCCL.
    }
}

mpi_options = {
    "enabled" : True,                      # Required
    "processes_per_host" : 8               # Required
}

smd_mp_estimator = PyTorch(
    entry_point="your_training_script.py", # Specify your train script
    source_dir="location_to_your_script",
    role=sagemaker.get_execution_role(),
    instance_count=8,
    instance_type='ml.p4d.24xlarge',
    framework_version='1.13.1',
    py_version='py3',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-demo",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')

Configurazioni supportate

Le AllGather operazioni con SMDDP Collectives vengono attivate nei lavori di formazione quando vengono soddisfatti tutti i seguenti requisiti di configurazione.

Ottimizzazione delle prestazioni e della memoria

SMDDPI collettivi utilizzano memoria aggiuntiva. GPU Esistono due variabili di ambiente per configurare l'utilizzo della GPU memoria a seconda dei diversi casi d'uso di addestramento del modello.

Guida all'ottimizzazione delle variabili relative alla dimensione del buffer

I valori predefiniti per le variabili di ambiente dovrebbero funzionare bene per la maggior parte dei casi d'uso. Consigliamo di ottimizzare queste variabili solo se l'allenamento rileva l'errore out-of-memory (OOM).

L'elenco seguente illustra alcuni suggerimenti di ottimizzazione per ridurre l'ingombro di GPU memoria dei SMDDP Collectives, preservando al contempo il miglioramento delle prestazioni che ne derivano.

Alcuni collettivi potrebbero tornare a essere utilizzatiNCCL; pertanto, potreste non ottenere il miglioramento delle prestazioni dai collettivi ottimizzati. SMDDP Se è disponibile GPU memoria aggiuntiva da utilizzare, è possibile valutare la possibilità di aumentare i valori SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES e SMDDP_AG_SORT_BUFFER_SIZE_BYTES trarre vantaggio dall'aumento delle prestazioni.

Il codice seguente mostra come configurare le variabili di ambiente aggiungendole mpi_options nel parametro di distribuzione dello PyTorch stimatore.

import sagemaker
from sagemaker.pytorch import PyTorch

smp_options = {
    .... # All modelparallel configuration options go here
}

mpi_options = {
    "enabled" : True,                      # Required
    "processes_per_host" : 8               # Required
}

# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192" 
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"

smd_mp_estimator = PyTorch(
    entry_point="your_training_script.py", # Specify your train script
    source_dir="location_to_your_script",
    role=sagemaker.get_execution_role(),
    instance_count=8,
    instance_type='ml.p4d.24xlarge',
    framework_version='1.13.1',
    py_version='py3',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="sharded-data-parallel-demo-with-tuning",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')

Addestramento misto di precisione con parallelismo di dati partizionati

Per risparmiare ulteriormente GPU memoria con numeri in virgola mobile a semiprecisione e parallelismo di dati frammentati, potete attivare il formato a virgola mobile a 16 bit (FP16) o il formato a virgola mobile Brain () aggiungendo un parametro aggiuntivo alla configurazione di addestramento BF16 distribuito.

Per FP16 la formazione con Sharded Data Parallelism

Per eseguire l'FP16allenamento con il parallelismo dei dati condivisi, aggiungilo al dizionario di configurazione. "fp16": True" smp_options Nello script di addestramento, puoi scegliere tra le opzioni di dimensionamento delle perdite statiche e dinamiche tramite il modulo smp.DistributedOptimizer. Per ulteriori informazioni, consulta FP16Formazione con Model Parallelism.

smp_options = {
    "enabled": True,
    "parameters": {
        "ddp": True,
        "sharded_data_parallel_degree": 2,
        "fp16": True
    }
}

Per la BF16 formazione con Sharded Data Parallelism

La funzionalità di parallelismo dei dati condivisi dell' SageMaker IA supporta l'addestramento sul tipo di dati. BF16 Il tipo di BF16 dati utilizza 8 bit per rappresentare l'esponente di un numero in virgola mobile, mentre il tipo di dati utilizza 5 bit. FP16 La conservazione degli 8 bit per l'esponente consente di mantenere la stessa rappresentazione dell'esponente di un numero a virgola mobile () a precisione singola a 32 bit. FP32 Ciò semplifica la conversione da un modello all'altro FP32 ed è notevolmente meno incline a causare problemi di overflow e underflow, che spesso si presentano durante l'addestramento, specialmente quando si addestrano modelli BF16 più grandi. FP16 Sebbene entrambi i tipi di dati utilizzino 16 bit in totale, questo maggiore intervallo di rappresentazione dell'esponente nel BF16 formato va a scapito della riduzione della precisione. Per l'addestramento di modelli di grandi dimensioni, questa precisione ridotta è spesso considerata un compromesso accettabile per quanto riguarda la portata e la stabilità dell'addestramento.

Per eseguire l'BF16allenamento con il parallelismo dei dati frammentati, aggiungilo al dizionario di configurazione. "bf16": True smp_options

smp_options = {
    "enabled": True,
    "parameters": {
        "ddp": True,
        "sharded_data_parallel_degree": 2,
        "bf16": True
    }
}

Parallelismo dei dati partizionati con parallelismo tensoriale

Se utilizzi il parallelismo dei dati partizionati e devi anche ridurre la dimensione globale del batch, prendi in considerazione l'utilizzo del parallelismo tensoriale con il parallelismo dei dati partizionati. Quando si addestra un modello di grandi dimensioni con parallelismo dei dati frammentati su un cluster di elaborazione molto grande (in genere 128 nodi o più), anche un batch di dimensioni ridotte per lotto si GPU traduce in un batch globale molto grande. Potrebbe portare a problemi di convergenza o a basse prestazioni di calcolo. La riduzione della dimensione del batch per GPU volta non è possibile con il solo parallelismo dei dati frammentati, quando un singolo batch è già di grandi dimensioni e non può essere ulteriormente ridotto. In questi casi, l'utilizzo del parallelismo dei dati partizionati in combinazione con il parallelismo tensoriale aiuta a ridurre la dimensione globale del batch.

La scelta dei gradi ottimali partizionati di parallelismo dei dati e dei tensori dipende dalla scala del modello, dal tipo di istanza e dalla dimensione globale del batch che è ragionevole per la convergenza del modello. Ti consigliamo di iniziare da un grado di parallelo tensoriale basso per adattare la dimensione globale del batch al cluster di calcolo per risolvere CUDA out-of-memory gli errori e ottenere le migliori prestazioni. Guarda i due casi di esempio seguenti per scoprire come la combinazione del parallelismo tensoriale e del parallelismo dei dati frammentati ti aiuta a regolare la dimensione globale del batch raggruppando GPUs per il parallelismo del modello, con il risultato di un minor numero di repliche del modello e una dimensione globale del batch più piccola.

Esempio 1

Supponiamo di voler addestrare un modello su un cluster di 1536 GPUs (192 nodi con 8 GPUs in ciascuno), impostando il grado di parallelismo dei dati frammentati su 32 (sharded_data_parallel_degree=32) e la dimensione del batch per GPU ogni batch su 1, dove ogni batch ha una lunghezza di sequenza di 4096 token. In questo caso, ci sono 1536 repliche di modelli, la dimensione globale del batch diventa 1536 e ogni batch globale contiene circa 6 milioni di token.

(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)

L'aggiunta del parallelismo tensoriale può ridurre la dimensione globale del batch. Un esempio di configurazione può essere l'impostazione del grado parallelo del tensore su 8 e la dimensione del batch GPU per su 4. Questo forma 192 gruppi tensoriali paralleli o 192 repliche di modelli, in cui ogni replica del modello è distribuita su 8. GPUs La dimensione del batch di 4 è la quantità di dati di addestramento per iterazione e per gruppo parallelo di tensori; ovvero, ogni replica del modello consuma 4 batch per iterazione. In questo caso, la dimensione globale del batch diventa 768 e ogni batch globale contiene circa 3 milioni di token. Pertanto, la dimensione globale del batch è ridotta della metà rispetto al caso precedente con il solo parallelismo dei dati partizionati.

(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)

Esempio 2

Quando sono attivati sia il parallelismo dei dati partizionati che il parallelismo tensoriale, la libreria applica innanzitutto il parallelismo tensoriale e partiziona il modello in questa dimensione. Per ogni classificazione parallela dei tensori, il parallelismo dei dati viene applicato come per sharded_data_parallel_degree.

Ad esempio, supponiamo di voler impostare 32 GPUs con un grado di parallelo del tensore di 4 (formando gruppi di 4GPUs), un grado di parallelo dei dati frammentati di 4, finendo con un grado di replica di 2. L'assegnazione crea otto GPU gruppi in base al grado parallelo del tensore come segue(0,1,2,3):(4,5,6,7),,,(8,9,10,11),(12,13,14,15), (16,17,18,19)(20,21,22,23),(24,25,26,27). (28,29,30,31) Cioè, quattro GPUs formano un gruppo parallelo tensoriale. In questo caso, il gruppo parallelo di dati ridotto per il rango 0 GPUs dei gruppi paralleli tensoriali sarebbe. (0,4,8,12,16,20,24,28) Il gruppo parallelo di dati ridotto viene suddiviso in base al grado di parallelismo dei dati condivisi pari a 4, ottenendo due gruppi di replica per il parallelismo dei dati. GPUs(0,4,8,12)formano un gruppo di sharding, che collettivamente contiene una copia completa di tutti i parametri per lo 0th tensor parallel rank, e GPUs (16,20,24,28) formano un altro gruppo di questo tipo. Anche altre classificazioni tensoriali parallele hanno gruppi di partizioni e replica simili.

Figura 1: Gruppi di parallelismo tensoriale per (nodi, sharded data parallel degree, tensor parallel degree) = (4, 4, 4), dove ogni rettangolo rappresenta un con indici da 0 a 31. GPU Il GPUs parallelismo tensoriale della forma raggruppa TPG ₀ da a. TPG ₇ I gruppi di replica sono ({TPG₀, TPG₄}, {,} TPG₁, {, TPG₅} e {TPG₂TPG₃, TPG ₆ TPG₇}); ogni coppia di gruppi di replica condivide lo stesso colore ma è riempita in modo diverso.

Figura 2: Gruppi di parallelismo di dati frammentati per (nodi, sharded data parallel degree, tensor parallel degree) = (4, 4, 4), dove ogni rettangolo rappresenta GPU un con indici da 0 a 31. Il GPUs modulo Sharded Data Parallism raggruppa da a. SDPG ₀ SDPG ₇ I gruppi di replica sono ({SDPG₀, SDPG₄}, {,} SDPG₁, {, SDPG₅} e {SDPG₂SDPG₃, SDPG ₆ SDPG₇}); ogni coppia di gruppi di replica condivide lo stesso colore ma è riempita in modo diverso.

Come attivare il parallelismo dei dati partizionati con il parallelismo tensoriale

Per utilizzare il parallelismo dei dati frammentati con il parallelismo tensoriale, è necessario impostarli entrambi sharded_data_parallel_degree e tensor_parallel_degree nella configurazione durante la creazione di un oggetto della classe estimator. distribution SageMaker PyTorch

È inoltre necessario attivare prescaled_batch. Ciò significa che, invece di GPU leggere ciascuno il proprio batch di dati, ogni gruppo parallelo tensoriale legge collettivamente un batch combinato della dimensione del batch scelta. In effetti, invece di dividere il set di dati in parti uguali al numero di GPUs (o dimensione parallela dei datismp.dp_size()), lo divide in parti uguali al numero di GPUs diviso per tensor_parallel_degree (chiamato anche dimensione parallela dei dati ridotta). smp.rdp_size() Per maggiori dettagli sul batch prescalato, vedere Prescaled Batch nella documentazione di Python. SageMaker SDK Vedi anche lo script di addestramento di esempio train_gpt_simple.pyper GPT -2 nel repository AI Examples. SageMaker GitHub

Il seguente frammento di codice mostra un esempio di creazione di un oggetto PyTorch estimatore basato sullo scenario sopra menzionato in. Esempio 2

mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
    "ddp": True,
    "fp16": True,
    "prescaled_batch": True,
    "sharded_data_parallel_degree": 4,
    "tensor_parallel_degree": 4
}

pytorch_estimator = PyTorch(
    entry_point="your_training_script.py",
    role=role,
    instance_type="ml.p4d.24xlarge",
    volume_size=200,
    instance_count=4,
    sagemaker_session=sagemaker_session,
    py_version="py3",
    framework_version="1.13.1",
    distribution={
        "smdistributed": {
            "modelparallel": {
                "enabled": True, 
                "parameters": smp_parameters,
            }
        },
        "mpi": {
            "enabled": True,
            "processes_per_host": 8,
            "custom_mpi_options": mpi_options,
        },
    },
    source_dir="source_directory_of_your_code",
    output_path=s3_output_location
)

Suggerimenti e considerazioni per l'utilizzo del parallelismo dei dati partizionati

Considerate quanto segue quando utilizzate il parallelismo dei dati frammentati della libreria SageMaker Model Parallelism.